diff --git a/src/api/auth/login.rs b/src/api/auth/login.rs
index 7ecc4de..2481cd6 100644
--- a/src/api/auth/login.rs
+++ b/src/api/auth/login.rs
@@ -6,7 +6,7 @@ pub mod login {
     use serde_json::{from_str, json};
 
     use crate::api::limits::LimitType;
-    use crate::errors::InstanceServerError;
+    use crate::errors::ChorusLibError;
     use crate::instance::{Instance, UserMeta};
     use crate::limit::LimitedRequester;
     use crate::types::{ErrorResponse, LoginResult, LoginSchema};
@@ -15,7 +15,7 @@ pub mod login {
         pub async fn login_account(
             &mut self,
             login_schema: &LoginSchema,
-        ) -> Result<UserMeta, InstanceServerError> {
+        ) -> Result<UserMeta, ChorusLibError> {
             let mut requester = LimitedRequester::new().await;
             let json_schema = json!(login_schema);
             let client = Client::new();
@@ -34,7 +34,7 @@ pub mod login {
                 )
                 .await;
             if response.is_err() {
-                return Err(InstanceServerError::NoResponse);
+                return Err(ChorusLibError::NoResponse);
             }
 
             let response_unwrap = response.unwrap();
@@ -49,7 +49,7 @@ pub mod login {
                         error += &(error_item.message.to_string() + " (" + &error_item.code + ")");
                     }
                 }
-                return Err(InstanceServerError::InvalidFormBodyError { error_type, error });
+                return Err(ChorusLibError::InvalidFormBodyError { error_type, error });
             }
 
             let cloned_limits = self.limits.clone();
diff --git a/src/api/auth/register.rs b/src/api/auth/register.rs
index 2c8f3f9..8ca4735 100644
--- a/src/api/auth/register.rs
+++ b/src/api/auth/register.rs
@@ -6,7 +6,7 @@ pub mod register {
 
     use crate::{
         api::limits::LimitType,
-        errors::InstanceServerError,
+        errors::ChorusLibError,
         instance::{Instance, Token, UserMeta},
         limit::LimitedRequester,
         types::{ErrorResponse, RegisterSchema},
@@ -18,12 +18,12 @@ pub mod register {
         # Arguments
         * `register_schema` - The [`RegisterSchema`] that contains all the information that is needed to register a new user.
         # Errors
-        * [`InstanceServerError`] - If the server does not respond.
+        * [`ChorusLibError`] - If the server does not respond.
          */
         pub async fn register_account(
             &mut self,
             register_schema: &RegisterSchema,
-        ) -> Result<UserMeta, InstanceServerError> {
+        ) -> Result<UserMeta, ChorusLibError> {
             let json_schema = json!(register_schema);
             let mut limited_requester = LimitedRequester::new().await;
             let client = Client::new();
@@ -42,7 +42,7 @@ pub mod register {
                 )
                 .await;
             if response.is_err() {
-                return Err(InstanceServerError::NoResponse);
+                return Err(ChorusLibError::NoResponse);
             }
 
             let response_unwrap = response.unwrap();
@@ -59,7 +59,7 @@ pub mod register {
                         error += &(error_item.message.to_string() + " (" + &error_item.code + ")");
                     }
                 }
-                return Err(InstanceServerError::InvalidFormBodyError { error_type, error });
+                return Err(ChorusLibError::InvalidFormBodyError { error_type, error });
             }
             let user_object = self.get_user(token.clone(), None).await.unwrap();
             let settings =
diff --git a/src/api/channels/channels.rs b/src/api/channels/channels.rs
index 690ec28..7ed9fc7 100644
--- a/src/api/channels/channels.rs
+++ b/src/api/channels/channels.rs
@@ -2,18 +2,14 @@ use reqwest::Client;
 use serde_json::{from_str, to_string};
 
 use crate::{
-    api::limits::Limits,
-    errors::InstanceServerError,
+    errors::ChorusLibError,
     instance::UserMeta,
     limit::LimitedRequester,
     types::{Channel, ChannelModifySchema},
 };
 
 impl Channel {
-    pub async fn get(
-        user: &mut UserMeta,
-        channel_id: &str,
-    ) -> Result<Channel, InstanceServerError> {
+    pub async fn get(user: &mut UserMeta, channel_id: &str) -> Result<Channel, ChorusLibError> {
         let mut belongs_to = user.belongs_to.borrow_mut();
         let request = Client::new()
             .get(format!(
@@ -38,7 +34,7 @@ impl Channel {
         let result_text = result.text().await.unwrap();
         match from_str::<Channel>(&result_text) {
             Ok(object) => Ok(object),
-            Err(e) => Err(InstanceServerError::RequestErrorError {
+            Err(e) => Err(ChorusLibError::RequestErrorError {
                 url: format!("{}/channels/{}/", belongs_to.urls.get_api(), channel_id),
                 error: e.to_string(),
             }),
@@ -57,8 +53,8 @@ impl Channel {
     ///
     /// # Returns
     ///
-    /// An `Option` that contains an `InstanceServerError` if an error occurred during the request, or `None` if the request was successful.
-    pub async fn delete(self, user: &mut UserMeta) -> Option<InstanceServerError> {
+    /// An `Option` that contains an `ChorusLibError` if an error occurred during the request, or `None` if the request was successful.
+    pub async fn delete(self, user: &mut UserMeta) -> Option<ChorusLibError> {
         let mut belongs_to = user.belongs_to.borrow_mut();
         let request = Client::new()
             .delete(format!(
@@ -95,12 +91,12 @@ impl Channel {
     ///
     /// # Returns
     ///
-    /// A `Result` that contains a `Channel` object if the request was successful, or an `InstanceServerError` if an error occurred during the request.
+    /// A `Result` that contains a `Channel` object if the request was successful, or an `ChorusLibError` if an error occurred during the request.
     pub async fn modify(
         modify_data: ChannelModifySchema,
         channel_id: &str,
         user: &mut UserMeta,
-    ) -> Result<Channel, InstanceServerError> {
+    ) -> Result<Channel, ChorusLibError> {
         let mut belongs_to = user.belongs_to.borrow_mut();
         let request = Client::new()
             .patch(format!(
diff --git a/src/api/channels/messages.rs b/src/api/channels/messages.rs
index a181784..d511e24 100644
--- a/src/api/channels/messages.rs
+++ b/src/api/channels/messages.rs
@@ -17,14 +17,14 @@ impl Message {
     * `limits_instance` - The [`Limits`] of the instance.
     * `requester` - The [`LimitedRequester`] that will be used to make requests to the Spacebar server.
     # Errors
-    * [`InstanceServerError`] - If the message cannot be sent.
+    * [`ChorusLibError`] - If the message cannot be sent.
      */
     pub async fn send(
         user: &mut UserMeta,
         channel_id: String,
         message: &mut MessageSendSchema,
         files: Option<Vec<PartialDiscordFileAttachment>>,
-    ) -> Result<reqwest::Response, crate::errors::InstanceServerError> {
+    ) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
         let mut belongs_to = user.belongs_to.borrow_mut();
         let url_api = belongs_to.urls.get_api();
         let mut requester = LimitedRequester::new().await;
@@ -98,14 +98,14 @@ impl UserMeta {
     * `limits_instance` - The [`Limits`] of the instance.
     * `requester` - The [`LimitedRequester`] that will be used to make requests to the Spacebar server.
     # Errors
-    * [`InstanceServerError`] - If the message cannot be sent.
+    * [`ChorusLibError`] - If the message cannot be sent.
      */
     pub async fn send_message(
         &mut self,
         message: &mut MessageSendSchema,
         channel_id: String,
         files: Option<Vec<PartialDiscordFileAttachment>>,
-    ) -> Result<reqwest::Response, crate::errors::InstanceServerError> {
+    ) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
         Message::send(self, channel_id, message, files).await
     }
 }
diff --git a/src/api/channels/reactions.rs b/src/api/channels/reactions.rs
index 0ca8e26..9bd7adc 100644
--- a/src/api/channels/reactions.rs
+++ b/src/api/channels/reactions.rs
@@ -3,7 +3,7 @@ use reqwest::Client;
 use crate::{
     instance::UserMeta,
     limit::LimitedRequester,
-    types::{self, Snowflake},
+    types::{self},
 };
 
 /**
@@ -23,7 +23,7 @@ impl ReactionMeta {
     * `user` - A mutable reference to a [`UserMeta`] instance.
 
     # Returns
-    A `Result` containing a [`reqwest::Response`] or a [`crate::errors::InstanceServerError`].
+    A `Result` containing a [`reqwest::Response`] or a [`crate::errors::ChorusLibError`].
     Fires a `Message Reaction Remove All` Gateway event.
 
     # Reference
@@ -32,7 +32,7 @@ impl ReactionMeta {
     pub async fn delete_all(
         &self,
         user: &mut UserMeta,
-    ) -> Result<reqwest::Response, crate::errors::InstanceServerError> {
+    ) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
         let mut belongs_to = user.belongs_to.borrow_mut();
         let url = format!(
             "{}/channels/{}/messages/{}/reactions/",
@@ -62,7 +62,7 @@ impl ReactionMeta {
     * `user` - A mutable reference to a [`UserMeta`] instance.
 
     # Returns
-    A `Result` containing a [`reqwest::Response`] or a [`crate::errors::InstanceServerError`].
+    A `Result` containing a [`reqwest::Response`] or a [`crate::errors::ChorusLibError`].
 
     # Reference
     See [https://discord.com/developers/docs/resources/channel#get-reactions](https://discord.com/developers/docs/resources/channel#get-reactions)
@@ -71,7 +71,7 @@ impl ReactionMeta {
         &self,
         emoji: &str,
         user: &mut UserMeta,
-    ) -> Result<reqwest::Response, crate::errors::InstanceServerError> {
+    ) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
         let mut belongs_to = user.belongs_to.borrow_mut();
         let url = format!(
             "{}/channels/{}/messages/{}/reactions/{}/",
@@ -103,7 +103,7 @@ impl ReactionMeta {
     * `user` - A mutable reference to a [`UserMeta`] instance.
 
     # Returns
-    A `Result` containing a [`reqwest::Response`] or a [`crate::errors::InstanceServerError`].
+    A `Result` containing a [`reqwest::Response`] or a [`crate::errors::ChorusLibError`].
     Fires a `Message Reaction Remove Emoji` Gateway event.
 
     # Reference
@@ -113,7 +113,7 @@ impl ReactionMeta {
         &self,
         emoji: &str,
         user: &mut UserMeta,
-    ) -> Result<reqwest::Response, crate::errors::InstanceServerError> {
+    ) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
         let mut belongs_to = user.belongs_to.borrow_mut();
         let url = format!(
             "{}/channels/{}/messages/{}/reactions/{}/",
@@ -148,7 +148,7 @@ impl ReactionMeta {
     * `user` - A mutable reference to a [`UserMeta`] instance.
 
     # Returns
-    A `Result` containing a [`reqwest::Response`] or a [`crate::errors::InstanceServerError`].
+    A `Result` containing a [`reqwest::Response`] or a [`crate::errors::ChorusLibError`].
     Returns a 204 empty response on success.
     Fires a Message Reaction Add Gateway event.
 
@@ -159,7 +159,7 @@ impl ReactionMeta {
         &self,
         emoji: &str,
         user: &mut UserMeta,
-    ) -> Result<reqwest::Response, crate::errors::InstanceServerError> {
+    ) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
         let mut belongs_to = user.belongs_to.borrow_mut();
         let url = format!(
             "{}/channels/{}/messages/{}/reactions/{}/@me/",
@@ -190,7 +190,7 @@ impl ReactionMeta {
     * `user` - A mutable reference to a [`UserMeta`] instance.
 
     # Returns
-    A `Result` containing a [`reqwest::Response`] or a [`crate::errors::InstanceServerError`].
+    A `Result` containing a [`reqwest::Response`] or a [`crate::errors::ChorusLibError`].
     Returns a 204 empty response on success.
     Fires a `Message Reaction Remove` Gateway event.
 
@@ -201,7 +201,7 @@ impl ReactionMeta {
         &self,
         emoji: &str,
         user: &mut UserMeta,
-    ) -> Result<reqwest::Response, crate::errors::InstanceServerError> {
+    ) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
         let mut belongs_to = user.belongs_to.borrow_mut();
         let url = format!(
             "{}/channels/{}/messages/{}/reactions/{}/@me/",
@@ -235,7 +235,7 @@ impl ReactionMeta {
     * `user` - A mutable reference to a [`UserMeta`] instance.
 
     # Returns
-    A `Result` containing a [`reqwest::Response`] or a [`crate::errors::InstanceServerError`].
+    A `Result` containing a [`reqwest::Response`] or a [`crate::errors::ChorusLibError`].
     Returns a 204 empty response on success.
     Fires a Message Reaction Remove Gateway event.
 
@@ -247,7 +247,7 @@ impl ReactionMeta {
         user_id: &str,
         emoji: &str,
         user: &mut UserMeta,
-    ) -> Result<reqwest::Response, crate::errors::InstanceServerError> {
+    ) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
         let mut belongs_to = user.belongs_to.borrow_mut();
         let url = format!(
             "{}/channels/{}/messages/{}/reactions/{}/{}",
diff --git a/src/api/guilds/guilds.rs b/src/api/guilds/guilds.rs
index f267e55..56912e7 100644
--- a/src/api/guilds/guilds.rs
+++ b/src/api/guilds/guilds.rs
@@ -3,7 +3,7 @@ use serde_json::from_str;
 use serde_json::to_string;
 
 use crate::api::limits::Limits;
-use crate::errors::InstanceServerError;
+use crate::errors::ChorusLibError;
 use crate::instance::UserMeta;
 use crate::limit::LimitedRequester;
 use crate::types::{Channel, ChannelCreateSchema, Guild, GuildCreateResponse, GuildCreateSchema};
@@ -23,12 +23,12 @@ impl Guild {
     ///
     /// # Errors
     ///
-    /// Returns an `InstanceServerError` if the request fails.
+    /// Returns an `ChorusLibError` if the request fails.
     ///
     pub async fn create(
         user: &mut UserMeta,
         guild_create_schema: GuildCreateSchema,
-    ) -> Result<Guild, crate::errors::InstanceServerError> {
+    ) -> Result<Guild, crate::errors::ChorusLibError> {
         let mut belongs_to = user.belongs_to.borrow_mut();
         let url = format!("{}/guilds/", belongs_to.urls.get_api());
         let request = reqwest::Client::new()
@@ -71,7 +71,7 @@ impl Guild {
     ///
     /// # Returns
     ///
-    /// An `Option` containing an `InstanceServerError` if an error occurred during the request, otherwise `None`.
+    /// An `Option` containing an `ChorusLibError` if an error occurred during the request, otherwise `None`.
     ///
     /// # Example
     ///
@@ -85,7 +85,7 @@ impl Guild {
     ///     None => println!("Guild deleted successfully"),
     /// }
     /// ```
-    pub async fn delete(user: &mut UserMeta, guild_id: &str) -> Option<InstanceServerError> {
+    pub async fn delete(user: &mut UserMeta, guild_id: &str) -> Option<ChorusLibError> {
         let mut belongs_to = user.belongs_to.borrow_mut();
         let url = format!("{}/guilds/{}/delete/", belongs_to.urls.get_api(), guild_id);
         let request = reqwest::Client::new()
@@ -119,12 +119,12 @@ impl Guild {
     ///
     /// # Returns
     ///
-    /// A `Result` containing a `reqwest::Response` if the request was successful, or an `InstanceServerError` if there was an error.
+    /// A `Result` containing a `reqwest::Response` if the request was successful, or an `ChorusLibError` if there was an error.
     pub async fn create_channel(
         &self,
         user: &mut UserMeta,
         schema: ChannelCreateSchema,
-    ) -> Result<Channel, InstanceServerError> {
+    ) -> Result<Channel, ChorusLibError> {
         let mut belongs_to = user.belongs_to.borrow_mut();
         Channel::_create(
             &user.token,
@@ -137,7 +137,7 @@ impl Guild {
         .await
     }
 
-    /// Returns a `Result` containing a vector of `Channel` structs if the request was successful, or an `InstanceServerError` if there was an error.
+    /// Returns a `Result` containing a vector of `Channel` structs if the request was successful, or an `ChorusLibError` if there was an error.
     ///
     /// # Arguments
     ///
@@ -146,7 +146,7 @@ impl Guild {
     /// * `limits_user` - A mutable reference to a `Limits` struct containing the user's rate limits.
     /// * `limits_instance` - A mutable reference to a `Limits` struct containing the instance's rate limits.
     ///
-    pub async fn channels(&self, user: &mut UserMeta) -> Result<Vec<Channel>, InstanceServerError> {
+    pub async fn channels(&self, user: &mut UserMeta) -> Result<Vec<Channel>, ChorusLibError> {
         let mut belongs_to = user.belongs_to.borrow_mut();
         let request = Client::new()
             .get(format!(
@@ -171,7 +171,7 @@ impl Guild {
         let stringed_response = match result.text().await {
             Ok(value) => value,
             Err(e) => {
-                return Err(InstanceServerError::InvalidResponseError {
+                return Err(ChorusLibError::InvalidResponseError {
                     error: e.to_string(),
                 })
             }
@@ -179,14 +179,14 @@ impl Guild {
         let _: Vec<Channel> = match from_str(&stringed_response) {
             Ok(result) => return Ok(result),
             Err(e) => {
-                return Err(InstanceServerError::InvalidResponseError {
+                return Err(ChorusLibError::InvalidResponseError {
                     error: e.to_string(),
                 })
             }
         };
     }
 
-    /// Returns a `Result` containing a `Guild` struct if the request was successful, or an `InstanceServerError` if there was an error.
+    /// Returns a `Result` containing a `Guild` struct if the request was successful, or an `ChorusLibError` if there was an error.
     ///
     /// # Arguments
     ///
@@ -196,7 +196,7 @@ impl Guild {
     /// * `limits_user` - A mutable reference to a `Limits` struct containing the user's rate limits.
     /// * `limits_instance` - A mutable reference to a `Limits` struct containing the instance's rate limits.
     ///
-    pub async fn get(user: &mut UserMeta, guild_id: &str) -> Result<Guild, InstanceServerError> {
+    pub async fn get(user: &mut UserMeta, guild_id: &str) -> Result<Guild, ChorusLibError> {
         let mut belongs_to = user.belongs_to.borrow_mut();
         Guild::_get(
             &format!("{}", belongs_to.urls.get_api()),
@@ -216,7 +216,7 @@ impl Guild {
         token: &str,
         limits_user: &mut Limits,
         limits_instance: &mut Limits,
-    ) -> Result<Guild, InstanceServerError> {
+    ) -> Result<Guild, ChorusLibError> {
         let request = Client::new()
             .get(format!("{}/guilds/{}/", url_api, guild_id))
             .bearer_auth(token);
@@ -252,12 +252,12 @@ impl Channel {
     ///
     /// # Returns
     ///
-    /// A `Result` containing a `reqwest::Response` if the request was successful, or an `InstanceServerError` if there was an error.
+    /// A `Result` containing a `reqwest::Response` if the request was successful, or an `ChorusLibError` if there was an error.
     pub async fn create(
         user: &mut UserMeta,
         guild_id: &str,
         schema: ChannelCreateSchema,
-    ) -> Result<Channel, InstanceServerError> {
+    ) -> Result<Channel, ChorusLibError> {
         let mut belongs_to = user.belongs_to.borrow_mut();
         Channel::_create(
             &user.token,
@@ -277,7 +277,7 @@ impl Channel {
         schema: ChannelCreateSchema,
         limits_user: &mut Limits,
         limits_instance: &mut Limits,
-    ) -> Result<Channel, InstanceServerError> {
+    ) -> Result<Channel, ChorusLibError> {
         let request = Client::new()
             .post(format!("{}/guilds/{}/channels/", url_api, guild_id))
             .bearer_auth(token)
@@ -297,7 +297,7 @@ impl Channel {
         };
         match from_str::<Channel>(&result.text().await.unwrap()) {
             Ok(object) => Ok(object),
-            Err(e) => Err(InstanceServerError::RequestErrorError {
+            Err(e) => Err(ChorusLibError::RequestErrorError {
                 url: format!("{}/guilds/{}/channels/", url_api, guild_id),
                 error: e.to_string(),
             }),
diff --git a/src/api/guilds/mod.rs b/src/api/guilds/mod.rs
index 7108ef7..b06487d 100644
--- a/src/api/guilds/mod.rs
+++ b/src/api/guilds/mod.rs
@@ -1 +1,5 @@
 pub mod guilds;
+pub mod roles;
+
+pub use guilds::*;
+pub use roles::*;
diff --git a/src/api/guilds/roles.rs b/src/api/guilds/roles.rs
new file mode 100644
index 0000000..482a859
--- /dev/null
+++ b/src/api/guilds/roles.rs
@@ -0,0 +1,109 @@
+use reqwest::Client;
+use serde_json::{from_str, to_string};
+
+use crate::{
+    errors::ChorusLibError,
+    instance::UserMeta,
+    limit::LimitedRequester,
+    types::{self, RoleCreateModifySchema, RoleObject},
+};
+
+impl types::RoleObject {
+    /// Retrieves all roles for a given guild.
+    ///
+    /// # Arguments
+    ///
+    /// * `user` - A mutable reference to a [`UserMeta`] instance.
+    /// * `guild_id` - The ID of the guild to retrieve roles from.
+    ///
+    /// # Returns
+    ///
+    /// An `Option` containing a `Vec` of [`RoleObject`]s if roles were found, or `None` if no roles were found.
+    ///
+    /// # Errors
+    ///
+    /// Returns a [`ChorusLibError`] if the request fails or if the response is invalid.
+    pub async fn get_all(
+        user: &mut UserMeta,
+        guild_id: &str,
+    ) -> Result<Option<Vec<RoleObject>>, crate::errors::ChorusLibError> {
+        let mut belongs_to = user.belongs_to.borrow_mut();
+        let url = format!("{}/guilds/{}/roles/", belongs_to.urls.get_api(), guild_id);
+        let request = Client::new().get(url).bearer_auth(user.token());
+        let requester = match LimitedRequester::new()
+            .await
+            .send_request(
+                request,
+                crate::api::limits::LimitType::Guild,
+                &mut belongs_to.limits,
+                &mut user.limits,
+            )
+            .await
+        {
+            Ok(request) => request,
+            Err(e) => return Err(e),
+        };
+        let roles: Vec<RoleObject> = from_str(&requester.text().await.unwrap()).unwrap();
+
+        if roles.is_empty() {
+            return Ok(None);
+        }
+
+        Ok(Some(roles))
+    }
+
+    /// Creates a new role for a given guild.
+    ///
+    /// # Arguments
+    ///
+    /// * `user` - A mutable reference to a [`UserMeta`] instance.
+    /// * `guild_id` - The ID of the guild to create the role in.
+    /// * `role_create_schema` - A [`RoleCreateModifySchema`] instance containing the properties of the role to be created.
+    ///
+    /// # Returns
+    ///
+    /// A `Result` containing the newly created [`RoleObject`] if successful, or a [`ChorusLibError`] if the request fails or if the response is invalid.
+    ///
+    /// # Errors
+    ///
+    /// Returns a [`ChorusLibError`] if the request fails or if the response is invalid.
+    pub async fn create(
+        user: &mut UserMeta,
+        guild_id: &str,
+        role_create_schema: RoleCreateModifySchema,
+    ) -> Result<RoleObject, ChorusLibError> {
+        let mut belongs_to = user.belongs_to.borrow_mut();
+        let url = format!("{}/guilds/{}/roles/", belongs_to.urls.get_api(), guild_id);
+        let body = match to_string::<RoleCreateModifySchema>(&role_create_schema) {
+            Ok(string) => string,
+            Err(e) => {
+                return Err(ChorusLibError::FormCreationError {
+                    error: e.to_string(),
+                })
+            }
+        };
+        let request = Client::new().post(url).bearer_auth(user.token()).body(body);
+        let result = match LimitedRequester::new()
+            .await
+            .send_request(
+                request,
+                crate::api::limits::LimitType::Guild,
+                &mut belongs_to.limits,
+                &mut user.limits,
+            )
+            .await
+        {
+            Ok(request) => request,
+            Err(e) => return Err(e),
+        };
+        let role: RoleObject = match from_str(&result.text().await.unwrap()) {
+            Ok(role) => role,
+            Err(e) => {
+                return Err(ChorusLibError::InvalidResponseError {
+                    error: e.to_string(),
+                })
+            }
+        };
+        Ok(role)
+    }
+}
diff --git a/src/api/policies/instance/instance.rs b/src/api/policies/instance/instance.rs
index f183e11..055568f 100644
--- a/src/api/policies/instance/instance.rs
+++ b/src/api/policies/instance/instance.rs
@@ -1,7 +1,7 @@
 use reqwest::Client;
 use serde_json::from_str;
 
-use crate::errors::InstanceServerError;
+use crate::errors::ChorusLibError;
 use crate::instance::Instance;
 use crate::types::GeneralConfiguration;
 
@@ -9,17 +9,17 @@ impl Instance {
     /**
     Gets the instance policies schema.
     # Errors
-    [`InstanceServerError`] - If the request fails.
+    [`ChorusLibError`] - If the request fails.
     */
     pub async fn general_configuration_schema(
         &self,
-    ) -> Result<GeneralConfiguration, InstanceServerError> {
+    ) -> Result<GeneralConfiguration, ChorusLibError> {
         let client = Client::new();
         let endpoint_url = self.urls.get_api().to_string() + "/policies/instance/";
         let request = match client.get(&endpoint_url).send().await {
             Ok(result) => result,
             Err(e) => {
-                return Err(InstanceServerError::RequestErrorError {
+                return Err(ChorusLibError::RequestErrorError {
                     url: endpoint_url,
                     error: e.to_string(),
                 });
@@ -27,7 +27,7 @@ impl Instance {
         };
 
         if !request.status().as_str().starts_with('2') {
-            return Err(InstanceServerError::ReceivedErrorCodeError {
+            return Err(ChorusLibError::ReceivedErrorCodeError {
                 error_code: request.status().to_string(),
             });
         }
diff --git a/src/api/users/users.rs b/src/api/users/users.rs
index 2cdaa74..ffabd3f 100644
--- a/src/api/users/users.rs
+++ b/src/api/users/users.rs
@@ -3,7 +3,7 @@ use serde_json::{from_str, to_string};
 
 use crate::{
     api::limits::Limits,
-    errors::InstanceServerError,
+    errors::ChorusLibError,
     instance::{Instance, UserMeta},
     limit::LimitedRequester,
     types::{User, UserModifySchema, UserSettings},
@@ -18,12 +18,9 @@ impl UserMeta {
     * `id` - The id of the user that will be retrieved. If this is None, the current user will be retrieved.
     * `instance_limits` - The [`Limits`] of the instance.
     # Errors
-    * [`InstanceServerError`] - If the request fails.
+    * [`ChorusLibError`] - If the request fails.
      */
-    pub async fn get(
-        user: &mut UserMeta,
-        id: Option<&String>,
-    ) -> Result<User, InstanceServerError> {
+    pub async fn get(user: &mut UserMeta, id: Option<&String>) -> Result<User, ChorusLibError> {
         User::get(user, id).await
     }
 
@@ -31,7 +28,7 @@ impl UserMeta {
         token: &String,
         url_api: &String,
         instance_limits: &mut Limits,
-    ) -> Result<UserSettings, InstanceServerError> {
+    ) -> Result<UserSettings, ChorusLibError> {
         User::get_settings(token, url_api, instance_limits).await
     }
 
@@ -43,16 +40,16 @@ impl UserMeta {
     ///
     /// # Errors
     ///
-    /// Returns an `InstanceServerError` if the request fails or if a password is required but not provided.
+    /// Returns an `ChorusLibError` if the request fails or if a password is required but not provided.
     pub async fn modify(
         &mut self,
         modify_schema: UserModifySchema,
-    ) -> Result<User, InstanceServerError> {
+    ) -> Result<User, ChorusLibError> {
         if modify_schema.new_password.is_some()
             || modify_schema.email.is_some()
             || modify_schema.code.is_some()
         {
-            return Err(InstanceServerError::PasswordRequiredError);
+            return Err(ChorusLibError::PasswordRequiredError);
         }
         let request = Client::new()
             .patch(format!(
@@ -90,8 +87,8 @@ impl UserMeta {
     ///
     /// # Returns
     ///
-    /// Returns `None` if the user was successfully deleted, or an `InstanceServerError` if an error occurred.
-    pub async fn delete(mut self) -> Option<InstanceServerError> {
+    /// Returns `None` if the user was successfully deleted, or an `ChorusLibError` if an error occurred.
+    pub async fn delete(mut self) -> Option<ChorusLibError> {
         let mut belongs_to = self.belongs_to.borrow_mut();
         let request = Client::new()
             .post(format!("{}/users/@me/delete/", belongs_to.urls.get_api()))
@@ -113,10 +110,7 @@ impl UserMeta {
 }
 
 impl User {
-    pub async fn get(
-        user: &mut UserMeta,
-        id: Option<&String>,
-    ) -> Result<User, InstanceServerError> {
+    pub async fn get(user: &mut UserMeta, id: Option<&String>) -> Result<User, ChorusLibError> {
         let mut belongs_to = user.belongs_to.borrow_mut();
         User::_get(
             &user.token(),
@@ -132,7 +126,7 @@ impl User {
         url_api: &str,
         limits_instance: &mut Limits,
         id: Option<&String>,
-    ) -> Result<User, InstanceServerError> {
+    ) -> Result<User, ChorusLibError> {
         let url: String;
         if id.is_none() {
             url = format!("{}/users/@me/", url_api);
@@ -163,7 +157,7 @@ impl User {
         token: &String,
         url_api: &String,
         instance_limits: &mut Limits,
-    ) -> Result<UserSettings, InstanceServerError> {
+    ) -> Result<UserSettings, ChorusLibError> {
         let request: reqwest::RequestBuilder = Client::new()
             .get(format!("{}/users/@me/settings/", url_api))
             .bearer_auth(token);
@@ -191,7 +185,7 @@ impl Instance {
     * `token` - A valid access token for the API.
     * `id` - The id of the user that will be retrieved. If this is None, the current user will be retrieved.
     # Errors
-    * [`InstanceServerError`] - If the request fails.
+    * [`ChorusLibError`] - If the request fails.
     # Notes
     This function is a wrapper around [`User::get`].
      */
@@ -199,7 +193,7 @@ impl Instance {
         &mut self,
         token: String,
         id: Option<&String>,
-    ) -> Result<User, InstanceServerError> {
+    ) -> Result<User, ChorusLibError> {
         User::_get(
             &token,
             &self.urls.get_api().to_string(),
diff --git a/src/errors.rs b/src/errors.rs
index a2843aa..0f65669 100644
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -11,7 +11,7 @@ custom_error! {
 
 custom_error! {
     #[derive(PartialEq, Eq)]
-    pub InstanceServerError
+    pub ChorusLibError
     NoResponse = "Did not receive a response from the Server.",
     RequestErrorError{url:String, error:String} = "An error occured while trying to GET from {url}: {error}",
     ReceivedErrorCodeError{error_code:String} = "Received the following error code while requesting from the route: {error_code}",
@@ -19,6 +19,7 @@ custom_error! {
     InvalidFormBodyError{error_type: String, error:String} = "The server responded with: {error_type}: {error}",
     RateLimited{bucket:String} = "Ratelimited on Bucket {bucket}",
     MultipartCreationError{error: String} = "Got an error whilst creating the form: {}",
+    FormCreationError{error: String} = "Got an error whilst creating the form: {}",
     TokenExpired = "Token expired, invalid or not found.",
     NoPermission = "You do not have the permissions needed to perform this action.",
     NotFound{error: String} = "The provided resource hasn't been found: {}",
diff --git a/src/instance.rs b/src/instance.rs
index ce8849d..6121c65 100644
--- a/src/instance.rs
+++ b/src/instance.rs
@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 
 use crate::api::limits::Limits;
-use crate::errors::{FieldFormatError, InstanceServerError};
+use crate::errors::{ChorusLibError, FieldFormatError};
 use crate::types::{GeneralConfiguration, User, UserSettings};
 use crate::URLBundle;
 
@@ -26,7 +26,7 @@ impl Instance {
     /// * `requester` - The [`LimitedRequester`] that will be used to make requests to the Spacebar server.
     /// # Errors
     /// * [`InstanceError`] - If the instance cannot be created.
-    pub async fn new(urls: URLBundle) -> Result<Instance, InstanceServerError> {
+    pub async fn new(urls: URLBundle) -> Result<Instance, ChorusLibError> {
         let mut instance = Instance {
             urls: urls.clone(),
             instance_info: GeneralConfiguration::new(
@@ -45,7 +45,7 @@ impl Instance {
         instance.instance_info = match instance.general_configuration_schema().await {
             Ok(schema) => schema,
             Err(e) => {
-                return Err(InstanceServerError::CantGetInfoError {
+                return Err(ChorusLibError::CantGetInfoError {
                     error: e.to_string(),
                 })
             }
diff --git a/src/limit.rs b/src/limit.rs
index cc058b6..70f5c06 100644
--- a/src/limit.rs
+++ b/src/limit.rs
@@ -1,6 +1,6 @@
 use crate::{
     api::limits::{Limit, LimitType, Limits, LimitsMutRef},
-    errors::InstanceServerError,
+    errors::ChorusLibError,
 };
 
 use reqwest::{Client, RequestBuilder, Response};
@@ -71,12 +71,12 @@ impl LimitedRequester {
         limit_type: LimitType,
         instance_rate_limits: &mut Limits,
         user_rate_limits: &mut Limits,
-    ) -> Result<Response, InstanceServerError> {
+    ) -> Result<Response, ChorusLibError> {
         if self.can_send_request(limit_type, instance_rate_limits, user_rate_limits) {
             let built_request = match request.build() {
                 Ok(request) => request,
                 Err(e) => {
-                    return Err(InstanceServerError::RequestErrorError {
+                    return Err(ChorusLibError::RequestErrorError {
                         url: "".to_string(),
                         error: e.to_string(),
                     })
@@ -86,7 +86,7 @@ impl LimitedRequester {
             let response = match result {
                 Ok(is_response) => is_response,
                 Err(e) => {
-                    return Err(InstanceServerError::ReceivedErrorCodeError {
+                    return Err(ChorusLibError::ReceivedErrorCodeError {
                         error_code: e.to_string(),
                     })
                 }
@@ -99,10 +99,10 @@ impl LimitedRequester {
             );
             if !response.status().is_success() {
                 match response.status().as_u16() {
-                    401 => return Err(InstanceServerError::TokenExpired),
-                    403 => return Err(InstanceServerError::TokenExpired),
+                    401 => return Err(ChorusLibError::TokenExpired),
+                    403 => return Err(ChorusLibError::TokenExpired),
                     _ => {
-                        return Err(InstanceServerError::ReceivedErrorCodeError {
+                        return Err(ChorusLibError::ReceivedErrorCodeError {
                             error_code: response.status().as_str().to_string(),
                         })
                     }
@@ -115,7 +115,7 @@ impl LimitedRequester {
                 request,
                 limit_type,
             });
-            Err(InstanceServerError::RateLimited {
+            Err(ChorusLibError::RateLimited {
                 bucket: limit_type.to_string(),
             })
         }
@@ -302,7 +302,7 @@ mod rate_limit {
             String::from("http://localhost:3001/cdn"),
         );
         let mut requester = LimitedRequester::new().await;
-        let mut request: Option<Result<Response, InstanceServerError>> = None;
+        let mut request: Option<Result<Response, ChorusLibError>> = None;
         let mut instance_rate_limits = Limits::check_limits(urls.api.clone()).await;
         let mut user_rate_limits = Limits::check_limits(urls.api.clone()).await;
 
diff --git a/src/types/entities/guild.rs b/src/types/entities/guild.rs
index c177932..5e513d9 100644
--- a/src/types/entities/guild.rs
+++ b/src/types/entities/guild.rs
@@ -13,80 +13,81 @@ use crate::types::{
 #[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq)]
 #[cfg_attr(feature = "sqlx", derive(sqlx::FromRow))]
 pub struct Guild {
-    pub id: Snowflake,
-    pub name: Option<String>,
-    pub icon: Option<String>,
-    #[cfg_attr(feature = "sqlx", sqlx(skip))]
-    pub icon_hash: Option<String>,
-    pub splash: Option<String>,
-    pub discovery_splash: Option<String>,
-    #[cfg_attr(feature = "sqlx", sqlx(skip))]
-    pub owner: Option<bool>, // True if requesting user is owner
-    pub owner_id: Option<Snowflake>,
-    #[cfg_attr(feature = "sqlx", sqlx(skip))]
-    pub permissions: Option<String>,
     pub afk_channel_id: Option<Snowflake>,
     pub afk_timeout: Option<i32>,
-    pub widget_enabled: Option<bool>,
-    pub widget_channel_id: Option<Snowflake>,
-    pub verification_level: Option<i32>,
-    pub default_message_notifications: Option<i32>,
-    pub explicit_content_filter: Option<i32>,
-    #[cfg_attr(feature = "sqlx", sqlx(skip))]
-    pub roles: Option<Vec<RoleObject>>,
-    #[cfg_attr(feature = "sqlx", sqlx(skip))]
-    #[serde(default)]
-    pub emojis: Vec<Emoji>,
-    //#[cfg_attr(feature = "sqlx", sqlx(try_from = "String"))]
-    pub features: Option<GuildFeaturesList>,
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
     pub application_id: Option<String>,
-    pub system_channel_id: Option<Snowflake>,
-    pub system_channel_flags: Option<i32>,
-    pub rules_channel_id: Option<Snowflake>,
-    #[cfg_attr(feature = "sqlx", sqlx(skip))]
-    pub rules_channel: Option<String>,
-    pub max_presences: Option<i32>,
-    pub max_members: Option<i32>,
-    #[cfg_attr(feature = "sqlx", sqlx(skip))]
-    pub vanity_url_code: Option<String>,
-    pub description: Option<String>,
-    pub banner: Option<String>,
-    pub premium_tier: Option<i32>,
-    pub premium_subscription_count: Option<i32>,
-    pub preferred_locale: Option<String>,
-    pub public_updates_channel_id: Option<Snowflake>,
-    pub max_video_channel_users: Option<i32>,
-    #[cfg_attr(feature = "sqlx", sqlx(skip))]
-    pub max_stage_video_channel_users: Option<i32>,
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
     pub approximate_member_count: Option<i32>,
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
     pub approximate_presence_count: Option<i32>,
-    #[cfg(feature = "sqlx")]
-    pub welcome_screen: Option<sqlx::types::Json<WelcomeScreenObject>>,
-    #[cfg(not(feature = "sqlx"))]
-    pub welcome_screen: Option<WelcomeScreenObject>,
-    pub nsfw_level: Option<i32>,
-    #[cfg_attr(feature = "sqlx", sqlx(skip))]
-    pub stickers: Option<Vec<Sticker>>,
-    pub premium_progress_bar_enabled: Option<bool>,
-    #[cfg_attr(feature = "sqlx", sqlx(skip))]
-    pub joined_at: Option<String>,
+    pub banner: Option<String>,
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
     pub bans: Option<Vec<GuildBan>>,
-    pub primary_category_id: Option<Snowflake>,
-    pub large: Option<bool>,
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
     pub channels: Option<Vec<Channel>>,
+    pub default_message_notifications: Option<i32>,
+    pub description: Option<String>,
+    pub discovery_splash: Option<String>,
+    #[cfg_attr(feature = "sqlx", sqlx(skip))]
+    #[serde(default)]
+    pub emojis: Vec<Emoji>,
+    pub explicit_content_filter: Option<i32>,
+    //#[cfg_attr(feature = "sqlx", sqlx(try_from = "String"))]
+    pub features: Option<GuildFeaturesList>,
+    pub icon: Option<String>,
+    #[cfg_attr(feature = "sqlx", sqlx(skip))]
+    pub icon_hash: Option<String>,
+    pub id: Snowflake,
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
     pub invites: Option<Vec<GuildInvite>>,
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
+    pub joined_at: Option<String>,
+    pub large: Option<bool>,
+    pub max_members: Option<i32>,
+    pub max_presences: Option<i32>,
+    #[cfg_attr(feature = "sqlx", sqlx(skip))]
+    pub max_stage_video_channel_users: Option<i32>,
+    pub max_video_channel_users: Option<i32>,
+    pub mfa_level: Option<i32>,
+    pub name: Option<String>,
+    pub nsfw_level: Option<i32>,
+    #[cfg_attr(feature = "sqlx", sqlx(skip))]
+    pub owner: Option<bool>,
+    // True if requesting user is owner
+    pub owner_id: Option<Snowflake>,
+    #[cfg_attr(feature = "sqlx", sqlx(skip))]
+    pub permissions: Option<String>,
+    pub preferred_locale: Option<String>,
+    pub premium_progress_bar_enabled: Option<bool>,
+    pub premium_subscription_count: Option<i32>,
+    pub premium_tier: Option<i32>,
+    pub primary_category_id: Option<Snowflake>,
+    pub public_updates_channel_id: Option<Snowflake>,
+    pub region: Option<String>,
+    #[cfg_attr(feature = "sqlx", sqlx(skip))]
+    pub roles: Option<Vec<RoleObject>>,
+    #[cfg_attr(feature = "sqlx", sqlx(skip))]
+    pub rules_channel: Option<String>,
+    pub rules_channel_id: Option<Snowflake>,
+    pub splash: Option<String>,
+    #[cfg_attr(feature = "sqlx", sqlx(skip))]
+    pub stickers: Option<Vec<Sticker>>,
+    pub system_channel_flags: Option<i32>,
+    pub system_channel_id: Option<Snowflake>,
+    #[cfg_attr(feature = "sqlx", sqlx(skip))]
+    pub vanity_url_code: Option<String>,
+    pub verification_level: Option<i32>,
+    #[cfg_attr(feature = "sqlx", sqlx(skip))]
     pub voice_states: Option<Vec<VoiceState>>,
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
     pub webhooks: Option<Vec<Webhook>>,
-    pub mfa_level: Option<i32>,
-    pub region: Option<String>,
+    #[cfg(feature = "sqlx")]
+    pub welcome_screen: Option<sqlx::types::Json<WelcomeScreenObject>>,
+    #[cfg(not(feature = "sqlx"))]
+    pub welcome_screen: Option<WelcomeScreenObject>,
+    pub widget_channel_id: Option<Snowflake>,
+    pub widget_enabled: Option<bool>,
 }
 
 /// See https://docs.spacebar.chat/routes/#get-/guilds/-guild_id-/bans/-user-
diff --git a/src/types/entities/role.rs b/src/types/entities/role.rs
index 6293698..ba4a2fe 100644
--- a/src/types/entities/role.rs
+++ b/src/types/entities/role.rs
@@ -1,5 +1,6 @@
+use bitflags::bitflags;
 use serde::{Deserialize, Serialize};
-use serde_aux::prelude::{deserialize_option_number_from_string, deserialize_string_from_number};
+use serde_aux::prelude::deserialize_option_number_from_string;
 
 use crate::types::utils::Snowflake;
 
@@ -15,7 +16,6 @@ pub struct RoleObject {
     pub unicode_emoji: Option<String>,
     pub position: u16,
     #[serde(default)]
-    #[serde(deserialize_with = "deserialize_string_from_number")]
     pub permissions: String,
     pub managed: bool,
     pub mentionable: bool,
@@ -51,77 +51,59 @@ pub struct RoleTags {
     // guild_connections: bool,
 }
 
-#[derive(Debug)]
-#[repr(u64)]
-pub enum PermissionFlags {
-    CreateInstantInvite = 0x0000000000000001,
-    KickMembers = 0x0000000000000002,
-    BanMembers = 0x0000000000000004,
-    Administrator = 0x0000000000000008,
-    ManageChannels = 0x0000000000000010,
-    ManageGuild = 0x0000000000000020,
-    AddReactions = 0x0000000000000040,
-    ViewAuditLog = 0x0000000000000080,
-    PrioritySpeaker = 0x0000000000000100,
-    Stream = 0x0000000000000200,
-    ViewChannel = 0x0000000000000400,
-    SendMessages = 0x0000000000000800,
-    SendTtsMessages = 0x0000000000001000,
-    ManageMessages = 0x0000000000002000,
-    EmbedLinks = 0x0000000000004000,
-    AttachFiles = 0x0000000000008000,
-    ReadMessageHistory = 0x0000000000010000,
-    MentionEveryone = 0x0000000000020000,
-    UseExternalEmojis = 0x0000000000040000,
-    ViewGuildInsights = 0x0000000000080000,
-    Connect = 0x0000000000100000,
-    Speak = 0x0000000000200000,
-    MuteMembers = 0x0000000000400000,
-    DeafenMembers = 0x0000000000800000,
-    MoveMembers = 0x0000000001000000,
-    UseVad = 0x0000000002000000,
-    ChangeNickname = 0x0000000004000000,
-    ManageNicknames = 0x0000000008000000,
-    ManageRoles = 0x0000000010000000,
-    ManageWebhooks = 0x0000000020000000,
-    ManageGuildExpressions = 0x0000000040000000,
-    UseApplicationCommands = 0x0000000080000000,
-    RequestToSpeak = 0x0000000100000000,
-    ManageEvents = 0x0000000200000000,
-    ManageThreads = 0x0000000400000000,
-    CreatePublicThreads = 0x0000000800000000,
-    CreatePrivateThreads = 0x0000001000000000,
-    UseExternalStickers = 0x0000002000000000,
-    SendMessagesInThreads = 0x0000004000000000,
-    UseEmbeddedActivities = 0x0000008000000000,
-    ModerateMembers = 0x0000010000000000,
-    ViewCreatorMonetizationAnalytics = 0x0000020000000000,
-    UseSoundboard = 0x0000040000000000,
-    UseExternalSounds = 0x0000200000000000,
-    SendVoiceMessages = 0x0000400000000000,
-}
-
-impl RoleObject {
-    /// Checks if the role has a specific permission.
-    ///
-    /// # Arguments
-    ///
-    /// * `permission` - The permission to check for.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use chorus::types;
-    /// let mut role = types::RoleObject::default();
-    /// let permission = types::PermissionFlags::ModerateMembers as u64 | types::PermissionFlags::UseSoundboard as u64;
-    /// role.permissions = permission.to_string();
-    /// assert_eq!(true, role.has_permission(types::PermissionFlags::ModerateMembers));
-    /// assert_eq!(true, role.has_permission(types::PermissionFlags::UseSoundboard));
-    /// ```
-    pub fn has_permission(&self, permission: PermissionFlags) -> bool {
-        if self.permissions.parse::<u64>().unwrap() & permission as u64 != 0 {
-            return true;
-        }
-        false
+bitflags! {
+    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+    pub struct PermissionFlags: u64 {
+        const CREATE_INSTANT_INVITE = 1 << 0;
+        const KICK_MEMBERS = 1 << 1;
+        const BAN_MEMBERS = 1 << 2;
+        const ADMINISTRATOR = 1 << 3;
+        const MANAGE_CHANNELS = 1 << 4;
+        const MANAGE_GUILD = 1 << 5;
+        const ADD_REACTIONS = 1 << 6;
+        const VIEW_AUDIT_LOG = 1 << 7;
+        const PRIORITY_SPEAKER = 1 << 8;
+        const STREAM = 1 << 9;
+        const VIEW_CHANNEL = 1 << 10;
+        const SEND_MESSAGES = 1 << 11;
+        const SEND_TTS_MESSAGES = 1 << 12;
+        const MANAGE_MESSAGES = 1 << 13;
+        const EMBED_LINKS = 1 << 14;
+        const ATTACH_FILES = 1 << 15;
+        const READ_MESSAGE_HISTORY = 1 << 16;
+        const MENTION_EVERYONE = 1 << 17;
+        const USE_EXTERNAL_EMOJIS = 1 << 18;
+        const VIEW_GUILD_INSIGHTS = 1 << 19;
+        const CONNECT = 1 << 20;
+        const SPEAK = 1 << 21;
+        const MUTE_MEMBERS = 1 << 22;
+        const DEAFEN_MEMBERS = 1 << 23;
+        const MOVE_MEMBERS = 1 << 24;
+        const USE_VAD = 1 << 25;
+        const CHANGE_NICKNAME = 1 << 26;
+        const MANAGE_NICKNAMES = 1 << 27;
+        const MANAGE_ROLES = 1 << 28;
+        const MANAGE_WEBHOOKS = 1 << 29;
+        const MANAGE_GUILD_EXPRESSIONS = 1 << 30;
+        const USE_APPLICATION_COMMANDS = 1 << 31;
+        const REQUEST_TO_SPEAK = 1 << 32;
+        const MANAGE_EVENTS = 1 << 33;
+        const MANAGE_THREADS = 1 << 34;
+        const CREATE_PUBLIC_THREADS = 1 << 35;
+        const CREATE_PRIVATE_THREADS = 1 << 36;
+        const USE_EXTERNAL_STICKERS = 1 << 37;
+        const SEND_MESSAGES_IN_THREADS = 1 << 38;
+        const USE_EMBEDDED_ACTIVITIES = 1 << 39;
+        const MODERATE_MEMBERS = 1 << 40;
+        const VIEW_CREATOR_MONETIZATION_ANALYTICS = 1 << 41;
+        const USE_SOUNDBOARD = 1 << 42;
+        const USE_EXTERNAL_SOUNDS = 1 << 45;
+        const SEND_VOICE_MESSAGES = 1 << 46;
+    }
+}
+
+impl PermissionFlags {
+    pub fn has_permission(&self, permission: PermissionFlags) -> bool {
+        self.contains(permission) || self.contains(PermissionFlags::ADMINISTRATOR)
     }
 }
diff --git a/src/types/schema/guild.rs b/src/types/schema/guild.rs
index 4b8b524..a607123 100644
--- a/src/types/schema/guild.rs
+++ b/src/types/schema/guild.rs
@@ -1,8 +1,10 @@
-use crate::types::entities::Channel;
+use crate::types::{entities::Channel, Snowflake};
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(rename_all = "snake_case")]
+/// Represents the schema which needs to be sent to create a Guild.
+/// See: [https://docs.spacebar.chat/routes/#cmp--schemas-guildcreateschema](https://docs.spacebar.chat/routes/#cmp--schemas-guildcreateschema)
 pub struct GuildCreateSchema {
     pub name: Option<String>,
     pub region: Option<String>,
@@ -12,3 +14,27 @@ pub struct GuildCreateSchema {
     pub system_channel_id: Option<String>,
     pub rules_channel_id: Option<String>,
 }
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "snake_case")]
+/// Represents the schema which needs to be sent to create or modify a Role.
+/// See: [https://docs.spacebar.chat/routes/#cmp--schemas-rolemodifyschema](https://docs.spacebar.chat/routes/#cmp--schemas-rolemodifyschema)
+pub struct RoleCreateModifySchema {
+    pub name: Option<String>,
+    pub permissions: Option<String>,
+    pub color: Option<u32>,
+    pub hoist: Option<bool>,
+    pub icon: Option<Vec<u8>>,
+    pub unicode_emoji: Option<String>,
+    pub mentionable: Option<bool>,
+    pub position: Option<i32>,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "snake_case")]
+/// Represents the schema which needs to be sent to update a roles' position.
+/// See: [https://docs.spacebar.chat/routes/#cmp--schemas-rolepositionupdateschema](https://docs.spacebar.chat/routes/#cmp--schemas-rolepositionupdateschema)
+pub struct RolePositionUpdateSchema {
+    pub id: Snowflake,
+    pub position: i32,
+}
diff --git a/tests/roles.rs b/tests/roles.rs
new file mode 100644
index 0000000..b34bdd7
--- /dev/null
+++ b/tests/roles.rs
@@ -0,0 +1,34 @@
+mod common;
+
+use chorus::types::{self, RoleCreateModifySchema};
+
+#[tokio::test]
+async fn create_and_get_roles() {
+    let mut bundle = common::setup().await;
+    let role_create_schema: types::RoleCreateModifySchema = RoleCreateModifySchema {
+        name: Some("cool person".to_string()),
+        permissions: Some("2251804225".to_string()),
+        hoist: Some(true),
+        icon: None,
+        unicode_emoji: Some("".to_string()),
+        mentionable: Some(true),
+        position: None,
+        color: None,
+    };
+    let guild_id = bundle.guild.id.clone().to_string();
+    let role = types::RoleObject::create(&mut bundle.user, &guild_id, role_create_schema)
+        .await
+        .unwrap();
+
+    let expected = types::RoleObject::get_all(&mut bundle.user, &guild_id)
+        .await
+        .unwrap()
+        .unwrap()
+        .iter()
+        .nth(1)
+        .unwrap()
+        .clone();
+
+    assert_eq!(role, expected);
+    common::teardown(bundle).await
+}