Switch from #[doc(hidden)] to pub(crate)

Switch from using `#[doc(hidden)]` to hide some internal functions to
`pub(crate)`.

The library now requires rustc 1.18.

15 files changed, 65 insertions, 122 deletions

diff --git a/src/cache/mod.rs b/src/cache/mod.rs
index b286e20..8232af0 100644
--- a/src/cache/mod.rs
+++ b/src/cache/mod.rs
@@ -683,8 +683,7 @@ impl Cache {
         self.user(id)
     }
 
-    #[doc(hidden)]
-    pub fn update_with_channel_create(&mut self, event: &ChannelCreateEvent) -> Option<Channel> {
+    pub(crate) fn update_with_channel_create(&mut self, event: &ChannelCreateEvent) -> Option<Channel> {
         match event.channel {
             Channel::Group(ref group) => {
                 let group = group.clone();
@@ -741,8 +740,7 @@ impl Cache {
         }
     }
 
-    #[doc(hidden)]
-    pub fn update_with_channel_delete(&mut self, event: &ChannelDeleteEvent) -> Option<Channel> {
+    pub(crate) fn update_with_channel_delete(&mut self, event: &ChannelDeleteEvent) -> Option<Channel> {
         match event.channel {
             Channel::Group(ref group) => {
                 self.groups.remove(&group.read().unwrap().channel_id).map(Channel::Group)
@@ -767,8 +765,8 @@ impl Cache {
         }
     }
 
-    #[doc(hidden)]
-    pub fn update_with_channel_pins_update(&mut self, event: &ChannelPinsUpdateEvent) {
+    #[allow(dead_code)]
+    pub(crate) fn update_with_channel_pins_update(&mut self, event: &ChannelPinsUpdateEvent) {
         if let Some(channel) = self.channels.get(&event.channel_id) {
             channel.write().unwrap().last_pin_timestamp = event.last_pin_timestamp;
 
@@ -787,9 +785,8 @@ impl Cache {
             return;
         }
     }
-
-    #[doc(hidden)]
-    pub fn update_with_channel_recipient_add(&mut self, event: &mut ChannelRecipientAddEvent) {
+    
+    pub(crate) fn update_with_channel_recipient_add(&mut self, event: &mut ChannelRecipientAddEvent) {
         self.update_user_entry(&event.user);
         let user = self.users[&event.user.id].clone();
 
@@ -803,15 +800,13 @@ impl Cache {
             });
     }
 
-    #[doc(hidden)]
-    pub fn update_with_channel_recipient_remove(&mut self, event: &ChannelRecipientRemoveEvent) {
+    pub(crate) fn update_with_channel_recipient_remove(&mut self, event: &ChannelRecipientRemoveEvent) {
         self.groups
             .get_mut(&event.channel_id)
             .map(|group| group.write().unwrap().recipients.remove(&event.user.id));
     }
 
-    #[doc(hidden)]
-    pub fn update_with_channel_update(&mut self, event: &ChannelUpdateEvent) {
+    pub(crate) fn update_with_channel_update(&mut self, event: &ChannelUpdateEvent) {
         match event.channel {
             Channel::Group(ref group) => {
                 let (ch_id, no_recipients) = {
@@ -864,8 +859,7 @@ impl Cache {
         }
     }
 
-    #[doc(hidden)]
-    pub fn update_with_guild_create(&mut self, event: &GuildCreateEvent) {
+    pub(crate) fn update_with_guild_create(&mut self, event: &GuildCreateEvent) {
         self.unavailable_guilds.remove(&event.guild.id);
 
         let mut guild = event.guild.clone();
@@ -881,8 +875,7 @@ impl Cache {
         self.guilds.insert(event.guild.id, Arc::new(RwLock::new(guild)));
     }
 
-    #[doc(hidden)]
-    pub fn update_with_guild_delete(&mut self, event: &GuildDeleteEvent)
+    pub(crate) fn update_with_guild_delete(&mut self, event: &GuildDeleteEvent)
         -> Option<Arc<RwLock<Guild>>> {
         // Remove channel entries for the guild if the guild is found.
         self.guilds.remove(&event.guild.id).map(|guild| {
@@ -894,15 +887,13 @@ impl Cache {
         })
     }
 
-    #[doc(hidden)]
-    pub fn update_with_guild_emojis_update(&mut self, event: &GuildEmojisUpdateEvent) {
+    pub(crate) fn update_with_guild_emojis_update(&mut self, event: &GuildEmojisUpdateEvent) {
         self.guilds
             .get_mut(&event.guild_id)
             .map(|guild| guild.write().unwrap().emojis.extend(event.emojis.clone()));
     }
 
-    #[doc(hidden)]
-    pub fn update_with_guild_member_add(&mut self, event: &mut GuildMemberAddEvent) {
+    pub(crate) fn update_with_guild_member_add(&mut self, event: &mut GuildMemberAddEvent) {
         let user_id = event.member.user.read().unwrap().id;
         self.update_user_entry(&event.member.user.read().unwrap());
 
@@ -919,8 +910,7 @@ impl Cache {
             });
     }
 
-    #[doc(hidden)]
-    pub fn update_with_guild_member_remove(&mut self, event: &GuildMemberRemoveEvent)
+    pub(crate) fn update_with_guild_member_remove(&mut self, event: &GuildMemberRemoveEvent)
         -> Option<Member> {
         self.guilds
             .get_mut(&event.guild_id)
@@ -932,8 +922,7 @@ impl Cache {
             })
     }
 
-    #[doc(hidden)]
-    pub fn update_with_guild_member_update(&mut self, event: &GuildMemberUpdateEvent)
+    pub(crate) fn update_with_guild_member_update(&mut self, event: &GuildMemberUpdateEvent)
         -> Option<Member> {
         self.update_user_entry(&event.user);
 
@@ -974,8 +963,7 @@ impl Cache {
         }
     }
 
-    #[doc(hidden)]
-    pub fn update_with_guild_members_chunk(&mut self, event: &GuildMembersChunkEvent) {
+    pub(crate) fn update_with_guild_members_chunk(&mut self, event: &GuildMembersChunkEvent) {
         for member in event.members.values() {
             self.update_user_entry(&member.user.read().unwrap());
         }
@@ -985,22 +973,19 @@ impl Cache {
             .map(|guild| guild.write().unwrap().members.extend(event.members.clone()));
     }
 
-    #[doc(hidden)]
-    pub fn update_with_guild_role_create(&mut self, event: &GuildRoleCreateEvent) {
+    pub(crate) fn update_with_guild_role_create(&mut self, event: &GuildRoleCreateEvent) {
         self.guilds
             .get_mut(&event.guild_id)
             .map(|guild| guild.write().unwrap().roles.insert(event.role.id, event.role.clone()));
     }
 
-    #[doc(hidden)]
-    pub fn update_with_guild_role_delete(&mut self, event: &GuildRoleDeleteEvent) -> Option<Role> {
+    pub(crate) fn update_with_guild_role_delete(&mut self, event: &GuildRoleDeleteEvent) -> Option<Role> {
         self.guilds
             .get_mut(&event.guild_id)
             .and_then(|guild| guild.write().unwrap().roles.remove(&event.role_id))
     }
 
-    #[doc(hidden)]
-    pub fn update_with_guild_role_update(&mut self, event: &GuildRoleUpdateEvent) -> Option<Role> {
+    pub(crate) fn update_with_guild_role_update(&mut self, event: &GuildRoleUpdateEvent) -> Option<Role> {
         self.guilds
             .get_mut(&event.guild_id)
             .and_then(|guild| {
@@ -1012,14 +997,12 @@ impl Cache {
             })
     }
 
-    #[doc(hidden)]
-    pub fn update_with_guild_unavailable(&mut self, event: &GuildUnavailableEvent) {
+    pub(crate) fn update_with_guild_unavailable(&mut self, event: &GuildUnavailableEvent) {
         self.unavailable_guilds.insert(event.guild_id);
         self.guilds.remove(&event.guild_id);
     }
 
-    #[doc(hidden)]
-    pub fn update_with_guild_update(&mut self, event: &GuildUpdateEvent) {
+    pub(crate) fn update_with_guild_update(&mut self, event: &GuildUpdateEvent) {
         self.guilds
             .get_mut(&event.guild.id)
             .map(|guild| {
@@ -1036,8 +1019,7 @@ impl Cache {
             });
     }
 
-    #[doc(hidden)]
-    pub fn update_with_presences_replace(&mut self, event: &PresencesReplaceEvent) {
+    pub(crate) fn update_with_presences_replace(&mut self, event: &PresencesReplaceEvent) {
         self.presences.extend({
             let mut p: HashMap<UserId, Presence> = HashMap::default();
 
@@ -1049,8 +1031,7 @@ impl Cache {
         });
     }
 
-    #[doc(hidden)]
-    pub fn update_with_presence_update(&mut self, event: &mut PresenceUpdateEvent) {
+    pub(crate) fn update_with_presence_update(&mut self, event: &mut PresenceUpdateEvent) {
         let user_id = event.presence.user_id;
 
         if let Some(user) = event.presence.user.as_mut() {
@@ -1076,8 +1057,7 @@ impl Cache {
         }
     }
 
-    #[doc(hidden)]
-    pub fn update_with_ready(&mut self, event: &ReadyEvent) {
+    pub(crate) fn update_with_ready(&mut self, event: &ReadyEvent) {
         let mut ready = event.ready.clone();
 
         for guild in ready.guilds {
@@ -1121,13 +1101,11 @@ impl Cache {
         self.user = ready.user;
     }
 
-    #[doc(hidden)]
-    pub fn update_with_user_update(&mut self, event: &UserUpdateEvent) -> CurrentUser {
+    pub(crate) fn update_with_user_update(&mut self, event: &UserUpdateEvent) -> CurrentUser {
         mem::replace(&mut self.user, event.current_user.clone())
     }
 
-    #[doc(hidden)]
-    pub fn update_with_voice_state_update(&mut self, event: &VoiceStateUpdateEvent) {
+    pub(crate) fn update_with_voice_state_update(&mut self, event: &VoiceStateUpdateEvent) {
         if let Some(guild_id) = event.guild_id {
             if let Some(guild) = self.guilds.get_mut(&guild_id) {
                 let mut guild = guild.write().unwrap();
diff --git a/src/client/context.rs b/src/client/context.rs
index e9b6d13..a65ffe3 100644
--- a/src/client/context.rs
+++ b/src/client/context.rs
@@ -43,14 +43,7 @@ pub struct Context {
 
 impl Context {
     /// Create a new Context to be passed to an event handler.
-    ///
-    /// There's no real reason to use this yourself. But the option is there.
-    /// Highly re-consider _not_ using this if you're tempted.
-    ///
-    /// Or don't do what I say. I'm just a comment hidden from the generated
-    /// documentation.
-    #[doc(hidden)]
-    pub fn new(shard: Arc<Mutex<Shard>>, data: Arc<Mutex<ShareMap>>) -> Context {
+    pub(crate) fn new(shard: Arc<Mutex<Shard>>, data: Arc<Mutex<ShareMap>>) -> Context {
         Context {
             data: data,
             shard: shard,
diff --git a/src/framework/buckets.rs b/src/framework/buckets.rs
index 4f24893..711c0fd 100644
--- a/src/framework/buckets.rs
+++ b/src/framework/buckets.rs
@@ -2,14 +2,12 @@ use chrono::UTC;
 use std::collections::HashMap;
 use std::default::Default;
 
-#[doc(hidden)]
-pub struct Ratelimit {
+pub(crate) struct Ratelimit {
     pub delay: i64,
     pub limit: Option<(i64, i32)>,
 }
 
-#[doc(hidden)]
-pub struct MemberRatelimit {
+pub(crate) struct MemberRatelimit {
     pub last_time: i64,
     pub set_time: i64,
     pub tickets: i32,
@@ -25,8 +23,7 @@ impl Default for MemberRatelimit {
     }
 }
 
-#[doc(hidden)]
-pub struct Bucket {
+pub(crate) struct Bucket {
     pub ratelimit: Ratelimit,
     pub users: HashMap<u64, MemberRatelimit>,
 }
diff --git a/src/framework/command.rs b/src/framework/command.rs
index 6db228f..fcf039a 100644
--- a/src/framework/command.rs
+++ b/src/framework/command.rs
@@ -9,12 +9,10 @@ pub type Exec = Fn(&mut Context, &Message, Vec<String>) -> Result<(), String> +
 pub type Help = Fn(&mut Context, &Message, HashMap<String, Arc<CommandGroup>>, &[String]) -> Result<(), String> + Send + Sync + 'static;
 pub type BeforeHook = Fn(&mut Context, &Message, &String) -> bool + Send + Sync + 'static;
 pub type AfterHook = Fn(&mut Context, &Message, &String, Result<(), String>) + Send + Sync + 'static;
-#[doc(hidden)]
-pub type InternalCommand = Arc<Command>;
+pub(crate) type InternalCommand = Arc<Command>;
 pub type PrefixCheck = Fn(&mut Context, &Message) -> Option<String> + Send + Sync + 'static;
 
-#[doc(hidden)]
-pub enum CommandOrAlias {
+pub(crate) enum CommandOrAlias {
     Alias(String),
     Command(InternalCommand),
 }
@@ -30,7 +28,7 @@ pub enum CommandType {
 #[derive(Default)]
 pub struct CommandGroup {
     pub prefix: Option<String>,
-    pub commands: HashMap<String, CommandOrAlias>,
+    pub(crate) commands: HashMap<String, CommandOrAlias>,
 }
 
 /// Command struct used to store commands internally.
@@ -64,8 +62,7 @@ pub struct Command {
     pub guild_only: bool,
     /// Whether command can only be used by owners or not.
     pub owners_only: bool,
-    #[doc(hidden)]
-    pub aliases: Vec<String>,
+    pub(crate) aliases: Vec<String>,
 }
 
 impl Command {
diff --git a/src/framework/create_group.rs b/src/framework/create_group.rs
index cc0b3bd..88aa6ba 100644
--- a/src/framework/create_group.rs
+++ b/src/framework/create_group.rs
@@ -1,4 +1,5 @@
-pub use ext::framework::command::{Command, CommandType, CommandGroup, CommandOrAlias};
+pub use ext::framework::command::{Command, CommandType, CommandGroup};
+pub(crate) use ext::framework::command::CommandOrAlias;
 pub use ext::framework::create_command::CreateCommand;
 
 use std::default::Default;
diff --git a/src/framework/mod.rs b/src/framework/mod.rs
index 43d8fe4..671771f 100644
--- a/src/framework/mod.rs
+++ b/src/framework/mod.rs
@@ -62,8 +62,9 @@ mod create_command;
 mod create_group;
 mod buckets;
 
-pub use self::buckets::{Bucket, MemberRatelimit, Ratelimit};
-pub use self::command::{Command, CommandType, CommandGroup, CommandOrAlias};
+pub(crate) use self::buckets::{Bucket, Ratelimit};
+pub use self::command::{Command, CommandType, CommandGroup};
+pub(crate) use self::command::CommandOrAlias;
 pub use self::configuration::Configuration;
 pub use self::create_command::CreateCommand;
 pub use self::create_group::CreateGroup;
@@ -450,8 +451,7 @@ impl Framework {
     }
 
     #[allow(cyclomatic_complexity)]
-    #[doc(hidden)]
-    pub fn dispatch(&mut self, mut context: Context, message: Message) {
+    pub(crate) fn dispatch(&mut self, mut context: Context, message: Message) {
         let res = command::positions(&mut context, &message, &self.configuration);
 
         let positions = match res {
@@ -798,8 +798,7 @@ impl Framework {
         self
     }
 
-    #[doc(hidden)]
-    pub fn update_current_user(&mut self, user_id: UserId, is_bot: bool) {
+    pub(crate) fn update_current_user(&mut self, user_id: UserId, is_bot: bool) {
         self.user_info = (user_id.0, is_bot);
     }
 
diff --git a/src/gateway/shard.rs b/src/gateway/shard.rs
index 44ce833..1fc7c3f 100644
--- a/src/gateway/shard.rs
+++ b/src/gateway/shard.rs
@@ -310,8 +310,7 @@ impl Shard {
     ///   shard's voice state will be updated, _if_ the `voice` feature is
     ///   enabled.
     #[allow(cyclomatic_complexity)]
-    #[doc(hidden)]
-    pub fn handle_event(&mut self, event: Result<GatewayEvent>) -> Result<Option<Event>> {
+    pub(crate) fn handle_event(&mut self, event: Result<GatewayEvent>) -> Result<Option<Event>> {
         match event {
             Ok(GatewayEvent::Dispatch(seq, event)) => {
                 self.seq = seq;
@@ -524,7 +523,6 @@ impl Shard {
 
     /// Shuts down the receiver by attempting to cleanly close the
     /// connection.
-    #[doc(hidden)]
     pub fn shutdown_clean(client: &mut WsClient) -> Result<()> {
         {
             let message = OwnedMessage::Close(Some(CloseData {
@@ -546,7 +544,6 @@ impl Shard {
     }
 
     /// Uncleanly shuts down the receiver by not sending a close code.
-    #[doc(hidden)]
     pub fn shutdown(&mut self) -> Result<()> {
         let mut stream = self.client.stream_ref().as_tcp();
 
@@ -678,8 +675,7 @@ impl Shard {
     }
 
     #[cfg(feature="voice")]
-    #[doc(hidden)]
-    pub fn cycle_voice_recv(&mut self) {
+    pub(crate) fn cycle_voice_recv(&mut self) {
         if let Ok(v) = self.manager_rx.try_recv() {
             if let Err(why) = self.client.send_json(&v) {
                 warn!("Err sending voice msg: {:?}", why);
@@ -687,8 +683,7 @@ impl Shard {
         }
     }
 
-    #[doc(hidden)]
-    pub fn heartbeat(&mut self) -> Result<()> {
+    pub(crate) fn heartbeat(&mut self) -> Result<()> {
         let map = json!({
             "d": self.seq,
             "op": OpCode::Heartbeat.num(),
@@ -718,13 +713,11 @@ impl Shard {
         }
     }
 
-    #[doc(hidden)]
-    pub fn heartbeat_interval(&self) -> i64 {
+    pub(crate) fn heartbeat_interval(&self) -> i64 {
         self.heartbeat_interval as i64
     }
 
-    #[doc(hidden)]
-    pub fn last_heartbeat_acknowledged(&self) -> bool {
+    pub(crate) fn last_heartbeat_acknowledged(&self) -> bool {
         self.last_heartbeat_acknowledged
     }
 
@@ -760,8 +753,7 @@ impl Shard {
         Err(Error::Gateway(GatewayError::ReconnectFailure))
     }
 
-    #[doc(hidden)]
-    pub fn resume(&mut self) -> Result<Event> {
+    pub(crate) fn resume(&mut self) -> Result<Event> {
         let session_id = match self.session_id.clone() {
             Some(session_id) => session_id,
             None => return Err(Error::Gateway(GatewayError::NoSessionId)),
diff --git a/src/http/mod.rs b/src/http/mod.rs
index 90869d6..b8a40ca 100644
--- a/src/http/mod.rs
+++ b/src/http/mod.rs
@@ -80,8 +80,8 @@ lazy_static! {
 
 /// Sets the token to be used across all requests which require authentication.
 ///
-/// This is really only for internal use, and if you are reading this as a user,
-/// you should _not_ use this yourself.
+/// This is intended for internal use! The only exception are webhooks.
+/// But really, please don't use this.
 #[doc(hidden)]
 pub fn set_token(token: &str) {
     TOKEN.lock().unwrap().clone_from(&token.to_owned());
@@ -1583,8 +1583,7 @@ fn request<'a, F>(route: Route, f: F) -> Result<HyperResponse>
     }
 }
 
-#[doc(hidden)]
-pub fn retry<'a, F>(f: F) -> HyperResult<HyperResponse>
+pub(crate) fn retry<'a, F>(f: F) -> HyperResult<HyperResponse>
     where F: Fn() -> RequestBuilder<'a> {
     let req = || f()
         .header(header::UserAgent(constants::USER_AGENT.to_owned()))
diff --git a/src/http/ratelimiting.rs b/src/http/ratelimiting.rs
index d290dd0..dd56d6d 100644
--- a/src/http/ratelimiting.rs
+++ b/src/http/ratelimiting.rs
@@ -340,8 +340,7 @@ pub enum Route {
     None,
 }
 
-#[doc(hidden)]
-pub fn perform<'a, F>(route: Route, f: F) -> Result<Response>
+pub(crate) fn perform<'a, F>(route: Route, f: F) -> Result<Response>
     where F: Fn() -> RequestBuilder<'a> {
     loop {
         // This will block if another thread already has the global
@@ -435,8 +434,7 @@ pub struct RateLimit {
 }
 
 impl RateLimit {
-    #[doc(hidden)]
-    pub fn pre_hook(&mut self, route: &Route) {
+    pub(crate) fn pre_hook(&mut self, route: &Route) {
         if self.limit == 0 {
             return;
         }
@@ -464,8 +462,7 @@ impl RateLimit {
         self.remaining -= 1;
     }
 
-    #[doc(hidden)]
-    pub fn post_hook(&mut self, response: &Response, route: &Route) -> Result<bool> {
+    pub(crate) fn post_hook(&mut self, response: &Response, route: &Route) -> Result<bool> {
         if let Some(limit) = parse_header(&response.headers, "x-ratelimit-limit")? {
             self.limit = limit;
         }
diff --git a/src/model/channel/message.rs b/src/model/channel/message.rs
index 930c046..15200fe 100644
--- a/src/model/channel/message.rs
+++ b/src/model/channel/message.rs
@@ -232,8 +232,7 @@ impl Message {
         }
     }
 
-    #[doc(hidden)]
-    pub fn transform_content(&mut self) {
+    pub(crate) fn transform_content(&mut self) {
         match self.kind {
             MessageType::PinsAdd => {
                 self.content = format!("{} pinned a message to this channel. See all the pins.", self.author);
@@ -497,8 +496,7 @@ impl Message {
         self.reaction_users(reaction_type, limit, after)
     }
 
-    #[doc(hidden)]
-    pub fn check_content_length(map: &JsonMap) -> Result<()> {
+    pub(crate) fn check_content_length(map: &JsonMap) -> Result<()> {
         if let Some(content) = map.get("content") {
             if let Value::String(ref content) = *content {
                 if let Some(length_over) = Message::overflow_length(content) {
@@ -510,8 +508,7 @@ impl Message {
         Ok(())
     }
 
-    #[doc(hidden)]
-    pub fn check_embed_length(map: &JsonMap) -> Result<()> {
+    pub(crate) fn check_embed_length(map: &JsonMap) -> Result<()> {
         let embed = match map.get("embed") {
             Some(&Value::Object(ref value)) => value,
             _ => return Ok(()),
diff --git a/src/model/event.rs b/src/model/event.rs
index bbb60c7..86825fa 100644
--- a/src/model/event.rs
+++ b/src/model/event.rs
@@ -2,7 +2,9 @@
 
 use chrono::{DateTime, FixedOffset};
 use serde::de::Error as DeError;
-use serde_json::{self, Error as JsonError};
+use serde_json;
+#[cfg(feature="voice")] 
+use serde_json::Error as JsonError;
 use std::collections::HashMap;
 use super::utils::deserialize_emojis;
 use super::*;
@@ -737,8 +739,8 @@ pub enum VoiceEvent {
 }
 
 impl VoiceEvent {
-    #[doc(hidden)]
-    pub fn decode(value: Value) -> Result<VoiceEvent> {
+    #[cfg(feature="voice")]
+    pub(crate) fn decode(value: Value) -> Result<VoiceEvent> {
         let mut map = JsonMap::deserialize(value)?;
 
         let op = match map.remove("op") {
diff --git a/src/voice/handler.rs b/src/voice/handler.rs
index e40c6d9..fb157e6 100644
--- a/src/voice/handler.rs
+++ b/src/voice/handler.rs
@@ -104,16 +104,8 @@ pub struct Handler {
 
 impl Handler {
     /// Creates a new Handler.
-    ///
-    /// **Note**: You should never call this yourself, and should instead use
-    /// [`Manager::join`].
-    ///
-    /// Like, really. Really do not use this. Please.
-    ///
-    /// [`Manager::join`]: struct.Manager.html#method.join
-    #[doc(hidden)]
     #[inline]
-    pub fn new(guild_id: GuildId, ws: MpscSender<Value>, user_id: UserId) -> Self {
+    pub(crate) fn new(guild_id: GuildId, ws: MpscSender<Value>, user_id: UserId) -> Self {
         Self::new_raw(guild_id, Some(ws), user_id)
     }
 
diff --git a/src/voice/manager.rs b/src/voice/manager.rs
index 67eb7b2..528efe7 100644
--- a/src/voice/manager.rs
+++ b/src/voice/manager.rs
@@ -28,8 +28,7 @@ pub struct Manager {
 }
 
 impl Manager {
-    #[doc(hidden)]
-    pub fn new(ws: MpscSender<Value>, user_id: UserId) -> Manager {
+    pub(crate) fn new(ws: MpscSender<Value>, user_id: UserId) -> Manager {
         Manager {
             handlers: HashMap::new(),
             user_id: user_id,
diff --git a/src/voice/mod.rs b/src/voice/mod.rs
index 94e3b40..4707ea8 100644
--- a/src/voice/mod.rs
+++ b/src/voice/mod.rs
@@ -20,9 +20,9 @@ use self::connection_info::ConnectionInfo;
 
 const CRYPTO_MODE: &'static str = "xsalsa20_poly1305";
 
-#[doc(hidden)]
-pub enum Status {
+pub(crate) enum Status {
     Connect(ConnectionInfo),
+    #[allow(dead_code)]
     Disconnect,
     SetReceiver(Option<Box<AudioReceiver>>),
     SetSender(Option<Box<AudioSource>>),
diff --git a/src/voice/threading.rs b/src/voice/threading.rs
index 4777231..fe0aebc 100644
--- a/src/voice/threading.rs
+++ b/src/voice/threading.rs
@@ -5,7 +5,7 @@ use super::Status;
 use ::internal::Timer;
 use ::model::GuildId;
 
-pub fn start(guild_id: GuildId, rx: MpscReceiver<Status>) {
+pub(crate) fn start(guild_id: GuildId, rx: MpscReceiver<Status>) {
     let name = format!("Serenity Voice (G{})", guild_id);
 
     ThreadBuilder::new()