Merge branch 'perpetual/gateway-dev' of https://github.com/polyphony-chat/chorus into perpetual/gateway-dev

README.md

@@ -39,13 +39,13 @@
 
 ### Messaging
 - [x] [Sending messages](https://github.com/polyphony-chat/chorus/issues/23)
-- [ ] [Events (Message, User, Channel, etc.)](https://github.com/polyphony-chat/chorus/issues/51)
+- [x] [Events (Message, User, Channel, etc.)](https://github.com/polyphony-chat/chorus/issues/51)
 - [x] Channel creation
 - [x] Channel deletion
-- [ ] [Channel management (name, description, icon, etc.)](https://github.com/polyphony-chat/chorus/issues/48)
+- [x] [Channel management (name, description, icon, etc.)](https://github.com/polyphony-chat/chorus/issues/48)
 - [ ] Deleting messages
 - [ ] Message threads
-- [ ] Reactions
+- [ ] [Reactions](https://github.com/polyphony-chat/chorus/issues/85)
 - [ ] Message Search
 - [ ] Message history
 

src/api/auth/register.rs

@@ -48,7 +48,6 @@ pub mod register {
             let response_unwrap = response.unwrap();
             let status = response_unwrap.status();
             let response_unwrap_text = response_unwrap.text().await.unwrap();
-            println!("{}", response_unwrap_text);
             let token = from_str::<Token>(&response_unwrap_text).unwrap();
             let token = token.token;
             if status.is_client_error() {

src/api/channels/channels.rs

@@ -1,28 +1,34 @@
 use reqwest::Client;
-use serde_json::from_str;
+use serde_json::{from_str, to_string};
 
 use crate::{
-    api::limits::Limits, errors::InstanceServerError, limit::LimitedRequester, types::Channel,
+    api::limits::Limits,
+    errors::InstanceServerError,
+    instance::UserMeta,
+    limit::LimitedRequester,
+    types::{Channel, ChannelModifySchema},
 };
 
 impl Channel {
     pub async fn get(
-        token: &str,
+        user: &mut UserMeta,
-        url_api: &str,
         channel_id: &str,
-        limits_user: &mut Limits,
-        limits_instance: &mut Limits,
     ) -> Result<Channel, InstanceServerError> {
+        let mut belongs_to = user.belongs_to.borrow_mut();
         let request = Client::new()
-            .get(format!("{}/channels/{}/", url_api, channel_id))
+            .get(format!(
-            .bearer_auth(token);
+                "{}/channels/{}/",
+                belongs_to.urls.get_api(),
+                channel_id
+            ))
+            .bearer_auth(user.token());
         let mut requester = LimitedRequester::new().await;
         let result = match requester
             .send_request(
                 request,
                 crate::api::limits::LimitType::Guild,
-                limits_instance,
+                &mut belongs_to.limits,
-                limits_user,
+                &mut user.limits,
             )
             .await
         {
@@ -33,9 +39,90 @@ impl Channel {
         match from_str::<Channel>(&result_text) {
             Ok(object) => Ok(object),
             Err(e) => Err(InstanceServerError::RequestErrorError {
-                url: format!("{}/channels/{}/", url_api, channel_id),
+                url: format!("{}/channels/{}/", belongs_to.urls.get_api(), channel_id),
                 error: e.to_string(),
             }),
         }
     }
+
+    /// Deletes a channel.
+    ///
+    /// # Arguments
+    ///
+    /// * `token` - A string slice that holds the authorization token.
+    /// * `url_api` - A string slice that holds the URL of the API.
+    /// * `channel` - A `Channel` object that represents the channel to be deleted.
+    /// * `limits_user` - A mutable reference to a `Limits` object that represents the user's rate limits.
+    /// * `limits_instance` - A mutable reference to a `Limits` object that represents the instance's rate limits.
+    ///
+    /// # 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> {
+        let mut belongs_to = user.belongs_to.borrow_mut();
+        let request = Client::new()
+            .delete(format!(
+                "{}/channels/{}/",
+                belongs_to.urls.get_api(),
+                self.id.to_string()
+            ))
+            .bearer_auth(user.token());
+        match LimitedRequester::new()
+            .await
+            .send_request(
+                request,
+                crate::api::limits::LimitType::Channel,
+                &mut belongs_to.limits,
+                &mut user.limits,
+            )
+            .await
+        {
+            Ok(_) => None,
+            Err(e) => return Some(e),
+        }
+    }
+
+    /// Modifies a channel.
+    ///
+    /// # Arguments
+    ///
+    /// * `modify_data` - A `ChannelModifySchema` object that represents the modifications to be made to the channel.
+    /// * `token` - A string slice that holds the authorization token.
+    /// * `url_api` - A string slice that holds the URL of the API.
+    /// * `channel_id` - A string slice that holds the ID of the channel to be modified.
+    /// * `limits_user` - A mutable reference to a `Limits` object that represents the user's rate limits.
+    /// * `limits_instance` - A mutable reference to a `Limits` object that represents the instance's rate limits.
+    ///
+    /// # Returns
+    ///
+    /// A `Result` that contains a `Channel` object if the request was successful, or an `InstanceServerError` if an error occurred during the request.
+    pub async fn modify(
+        modify_data: ChannelModifySchema,
+        channel_id: &str,
+        user: &mut UserMeta,
+    ) -> Result<Channel, InstanceServerError> {
+        let mut belongs_to = user.belongs_to.borrow_mut();
+        let request = Client::new()
+            .patch(format!(
+                "{}/channels/{}/",
+                belongs_to.urls.get_api(),
+                channel_id
+            ))
+            .bearer_auth(user.token())
+            .body(to_string(&modify_data).unwrap());
+        let channel = match LimitedRequester::new()
+            .await
+            .send_request(
+                request,
+                crate::api::limits::LimitType::Channel,
+                &mut belongs_to.limits,
+                &mut user.limits,
+            )
+            .await
+        {
+            Ok(channel) => from_str::<Channel>(&channel.text().await.unwrap()).unwrap(),
+            Err(e) => return Err(e),
+        };
+        Ok(channel)
+    }
 }

src/api/channels/messages.rs

@@ -4,7 +4,6 @@ pub mod messages {
     use reqwest::{multipart, Client};
     use serde_json::to_string;
 
-    use crate::api::limits::Limits;
     use crate::instance::UserMeta;
     use crate::limit::LimitedRequester;
     use crate::types::{Message, MessageSendSchema, PartialDiscordFileAttachment};
@@ -21,28 +20,27 @@ pub mod messages {
         # Errors
         * [`InstanceServerError`] - If the message cannot be sent.
          */
-        pub async fn send<'a>(
+        pub async fn send(
-            url_api: String,
+            user: &mut UserMeta,
             channel_id: String,
             message: &mut MessageSendSchema,
             files: Option<Vec<PartialDiscordFileAttachment>>,
-            token: String,
-            limits_user: &mut Limits,
-            limits_instance: &mut Limits,
         ) -> Result<reqwest::Response, crate::errors::InstanceServerError> {
+            let mut belongs_to = user.belongs_to.borrow_mut();
+            let url_api = belongs_to.urls.get_api();
             let mut requester = LimitedRequester::new().await;
 
             if files.is_none() {
                 let message_request = Client::new()
                     .post(format!("{}/channels/{}/messages/", url_api, channel_id))
-                    .bearer_auth(token)
+                    .bearer_auth(user.token())
                     .body(to_string(message).unwrap());
                 requester
                     .send_request(
                         message_request,
                         crate::api::limits::LimitType::Channel,
-                        limits_instance,
+                        &mut belongs_to.limits,
-                        limits_user,
+                        &mut user.limits,
                     )
                     .await
             } else {
@@ -75,17 +73,15 @@ pub mod messages {
 
                 let message_request = Client::new()
                     .post(format!("{}/channels/{}/messages/", url_api, channel_id))
-                    .bearer_auth(token)
+                    .bearer_auth(user.token())
                     .multipart(form);
 
-                println!("[Request Headers: ] {:?}", message_request);
-
                 requester
                     .send_request(
                         message_request,
                         crate::api::limits::LimitType::Channel,
-                        limits_instance,
+                        &mut belongs_to.limits,
-                        limits_user,
+                        &mut user.limits,
                     )
                     .await
             }
@@ -93,24 +89,25 @@ pub mod messages {
     }
 
     impl UserMeta {
+        /// Shorthand call for Message::send()
+        /**
+        Sends a message to the Spacebar server.
+        # Arguments
+        * `url_api` - The URL of the Spacebar server's API.
+        * `message` - The [`Message`] that will be sent to the Spacebar server.
+        * `limits_user` - The [`Limits`] of the user.
+        * `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.
+         */
         pub async fn send_message(
             &mut self,
             message: &mut MessageSendSchema,
             channel_id: String,
             files: Option<Vec<PartialDiscordFileAttachment>>,
         ) -> Result<reqwest::Response, crate::errors::InstanceServerError> {
-            let token = self.token().clone();
+            Message::send(self, channel_id, message, files).await
-            let mut belongs_to = self.belongs_to.borrow_mut();
-            Message::send(
-                belongs_to.urls.get_api().to_string(),
-                channel_id,
-                message,
-                files,
-                token,
-                &mut self.limits,
-                &mut belongs_to.limits,
-            )
-            .await
         }
     }
 }

src/api/guilds/guilds.rs

@@ -19,32 +19,18 @@ impl Guild {
     ///
     /// # Returns
     ///
-    /// A `Result<String>` containing the ID of the newly created guild, or an error if the request fails.
+    /// A `Result<Guild>` containing the object of the newly created guild, or an error if the request fails.
     ///
     /// # Errors
     ///
     /// Returns an `InstanceServerError` if the request fails.
     ///
-    /// # Examples
-    ///
-    /// ```rs
-    /// let guild_create_schema = chorus::api::schemas::GuildCreateSchema::new(insert args here);
-    ///
-    /// let result = Guild::create(&mut user, &mut instance, &guild_create_schema).await;
-    ///
-    /// match result {
-    ///     Ok(guild_id) => println!("Created guild with ID {}", guild_id),
-    ///     Err(e) => println!("Failed to create guild: {}", e),
-    /// }
-    /// ```
     pub async fn create(
         user: &mut UserMeta,
-        url_api: &str,
         guild_create_schema: GuildCreateSchema,
-    ) -> Result<String, crate::errors::InstanceServerError> {
+    ) -> Result<Guild, crate::errors::InstanceServerError> {
-        let url = format!("{}/guilds/", url_api);
+        let mut belongs_to = user.belongs_to.borrow_mut();
-        let limits_user = user.limits.get_as_mut();
+        let url = format!("{}/guilds/", belongs_to.urls.get_api());
-        let limits_instance = &mut user.belongs_to.borrow_mut().limits;
         let request = reqwest::Client::new()
             .post(url.clone())
             .bearer_auth(user.token.clone())
@@ -54,8 +40,8 @@ impl Guild {
             .send_request(
                 request,
                 crate::api::limits::LimitType::Guild,
-                limits_instance,
+                &mut belongs_to.limits,
-                limits_user,
+                &mut user.limits,
             )
             .await
         {
@@ -63,7 +49,16 @@ impl Guild {
             Err(e) => return Err(e),
         };
         let id: GuildCreateResponse = from_str(&result.text().await.unwrap()).unwrap();
-        Ok(id.id)
+        let guild = Guild::_get(
+            belongs_to.clone().urls.get_api(),
+            &id.id,
+            &user.token,
+            &mut user.limits,
+            &mut belongs_to.limits,
+        )
+        .await
+        .unwrap();
+        Ok(guild)
     }
 
     /// Deletes a guild.
@@ -90,14 +85,9 @@ impl Guild {
     ///     None => println!("Guild deleted successfully"),
     /// }
     /// ```
-    pub async fn delete(
+    pub async fn delete(user: &mut UserMeta, guild_id: &str) -> Option<InstanceServerError> {
-        user: &mut UserMeta,
+        let mut belongs_to = user.belongs_to.borrow_mut();
-        url_api: &str,
+        let url = format!("{}/guilds/{}/delete/", belongs_to.urls.get_api(), guild_id);
-        guild_id: String,
-    ) -> Option<InstanceServerError> {
-        let url = format!("{}/guilds/{}/delete/", url_api, guild_id);
-        let limits_user = user.limits.get_as_mut();
-        let limits_instance = &mut user.belongs_to.borrow_mut().limits;
         let request = reqwest::Client::new()
             .post(url.clone())
             .bearer_auth(user.token.clone());
@@ -106,8 +96,8 @@ impl Guild {
             .send_request(
                 request,
                 crate::api::limits::LimitType::Guild,
-                limits_instance,
+                &mut belongs_to.limits,
-                limits_user,
+                &mut user.limits,
             )
             .await;
         if result.is_err() {
@@ -132,22 +122,120 @@ impl Guild {
     /// A `Result` containing a `reqwest::Response` if the request was successful, or an `InstanceServerError` if there was an error.
     pub async fn create_channel(
         &self,
-        url_api: &str,
+        user: &mut UserMeta,
-        token: &str,
         schema: ChannelCreateSchema,
-        limits_user: &mut Limits,
-        limits_instance: &mut Limits,
     ) -> Result<Channel, InstanceServerError> {
-        Channel::create(
+        let mut belongs_to = user.belongs_to.borrow_mut();
-            token,
+        Channel::_create(
-            url_api,
+            &user.token,
+            &format!("{}", belongs_to.urls.get_api()),
             &self.id.to_string(),
             schema,
-            limits_user,
+            &mut user.limits,
-            limits_instance,
+            &mut belongs_to.limits,
         )
         .await
     }
+
+    /// Returns a `Result` containing a vector of `Channel` structs if the request was successful, or an `InstanceServerError` if there was an error.
+    ///
+    /// # Arguments
+    ///
+    /// * `url_api` - A string slice that holds the URL of the API.
+    /// * `token` - A string slice that holds the authorization token.
+    /// * `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> {
+        let mut belongs_to = user.belongs_to.borrow_mut();
+        let request = Client::new()
+            .get(format!(
+                "{}/guilds/{}/channels/",
+                belongs_to.urls.get_api(),
+                self.id.to_string()
+            ))
+            .bearer_auth(user.token());
+        let result = match LimitedRequester::new()
+            .await
+            .send_request(
+                request,
+                crate::api::limits::LimitType::Guild,
+                &mut belongs_to.limits,
+                &mut user.limits,
+            )
+            .await
+        {
+            Ok(result) => result,
+            Err(e) => return Err(e),
+        };
+        let stringed_response = match result.text().await {
+            Ok(value) => value,
+            Err(e) => {
+                return Err(InstanceServerError::InvalidResponseError {
+                    error: e.to_string(),
+                })
+            }
+        };
+        let _: Vec<Channel> = match from_str(&stringed_response) {
+            Ok(result) => return Ok(result),
+            Err(e) => {
+                return Err(InstanceServerError::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.
+    ///
+    /// # Arguments
+    ///
+    /// * `url_api` - A string slice that holds the URL of the API.
+    /// * `guild_id` - A string slice that holds the ID of the guild.
+    /// * `token` - A string slice that holds the authorization token.
+    /// * `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> {
+        let mut belongs_to = user.belongs_to.borrow_mut();
+        Guild::_get(
+            &format!("{}", belongs_to.urls.get_api()),
+            guild_id,
+            &user.token,
+            &mut user.limits,
+            &mut belongs_to.limits,
+        )
+        .await
+    }
+
+    /// For internal use. Does the same as the public get method, but does not require a second, mutable
+    /// borrow of `UserMeta::belongs_to`, when used in conjunction with other methods, which borrow `UserMeta::belongs_to`.
+    async fn _get(
+        url_api: &str,
+        guild_id: &str,
+        token: &str,
+        limits_user: &mut Limits,
+        limits_instance: &mut Limits,
+    ) -> Result<Guild, InstanceServerError> {
+        let request = Client::new()
+            .get(format!("{}/guilds/{}/", url_api, guild_id))
+            .bearer_auth(token);
+        let response = match LimitedRequester::new()
+            .await
+            .send_request(
+                request,
+                crate::api::limits::LimitType::Guild,
+                limits_instance,
+                limits_user,
+            )
+            .await
+        {
+            Ok(response) => response,
+            Err(e) => return Err(e),
+        };
+        let guild: Guild = from_str(&response.text().await.unwrap()).unwrap();
+        Ok(guild)
+    }
 }
 
 impl Channel {
@@ -166,6 +254,23 @@ impl Channel {
     ///
     /// A `Result` containing a `reqwest::Response` if the request was successful, or an `InstanceServerError` if there was an error.
     pub async fn create(
+        user: &mut UserMeta,
+        guild_id: &str,
+        schema: ChannelCreateSchema,
+    ) -> Result<Channel, InstanceServerError> {
+        let mut belongs_to = user.belongs_to.borrow_mut();
+        Channel::_create(
+            &user.token,
+            &format!("{}", belongs_to.urls.get_api()),
+            guild_id,
+            schema,
+            &mut user.limits,
+            &mut belongs_to.limits,
+        )
+        .await
+    }
+
+    async fn _create(
         token: &str,
         url_api: &str,
         guild_id: &str,

src/api/users/users.rs

@@ -21,35 +21,10 @@ impl UserMeta {
     * [`InstanceServerError`] - If the request fails.
      */
     pub async fn get(
-        token: &String,
+        user: &mut UserMeta,
-        url_api: &String,
         id: Option<&String>,
-        instance_limits: &mut Limits,
     ) -> Result<User, InstanceServerError> {
-        let url: String;
+        User::get(user, id).await
-        if id.is_none() {
-            url = format!("{}/users/@me/", url_api);
-        } else {
-            url = format!("{}/users/{}", url_api, id.unwrap());
-        }
-        let request = reqwest::Client::new().get(url).bearer_auth(token);
-        let mut requester = crate::limit::LimitedRequester::new().await;
-        let mut cloned_limits = instance_limits.clone();
-        match requester
-            .send_request(
-                request,
-                crate::api::limits::LimitType::Ip,
-                instance_limits,
-                &mut cloned_limits,
-            )
-            .await
-        {
-            Ok(result) => {
-                let result_text = result.text().await.unwrap();
-                Ok(serde_json::from_str::<User>(&result_text).unwrap())
-            }
-            Err(e) => Err(e),
-        }
     }
 
     pub async fn get_settings(
@@ -57,23 +32,7 @@ impl UserMeta {
         url_api: &String,
         instance_limits: &mut Limits,
     ) -> Result<UserSettings, InstanceServerError> {
-        let request: reqwest::RequestBuilder = Client::new()
+        User::get_settings(token, url_api, instance_limits).await
-            .get(format!("{}/users/@me/settings/", url_api))
-            .bearer_auth(token);
-        let mut cloned_limits = instance_limits.clone();
-        let mut requester = crate::limit::LimitedRequester::new().await;
-        match requester
-            .send_request(
-                request,
-                crate::api::limits::LimitType::Ip,
-                instance_limits,
-                &mut cloned_limits,
-            )
-            .await
-        {
-            Ok(result) => Ok(serde_json::from_str(&result.text().await.unwrap()).unwrap()),
-            Err(e) => Err(e),
-        }
     }
 
     /// Modify the current user's `UserObject`.
@@ -153,6 +112,78 @@ impl UserMeta {
     }
 }
 
+impl User {
+    pub async fn get(
+        user: &mut UserMeta,
+        id: Option<&String>,
+    ) -> Result<User, InstanceServerError> {
+        let mut belongs_to = user.belongs_to.borrow_mut();
+        User::_get(
+            &user.token(),
+            &format!("{}", belongs_to.urls.get_api()),
+            &mut belongs_to.limits,
+            id,
+        )
+        .await
+    }
+
+    async fn _get(
+        token: &str,
+        url_api: &str,
+        limits_instance: &mut Limits,
+        id: Option<&String>,
+    ) -> Result<User, InstanceServerError> {
+        let url: String;
+        if id.is_none() {
+            url = format!("{}/users/@me/", url_api);
+        } else {
+            url = format!("{}/users/{}", url_api, id.unwrap());
+        }
+        let request = reqwest::Client::new().get(url).bearer_auth(token);
+        let mut requester = crate::limit::LimitedRequester::new().await;
+        let mut cloned_limits = limits_instance.clone();
+        match requester
+            .send_request(
+                request,
+                crate::api::limits::LimitType::Ip,
+                limits_instance,
+                &mut cloned_limits,
+            )
+            .await
+        {
+            Ok(result) => {
+                let result_text = result.text().await.unwrap();
+                Ok(serde_json::from_str::<User>(&result_text).unwrap())
+            }
+            Err(e) => Err(e),
+        }
+    }
+
+    pub async fn get_settings(
+        token: &String,
+        url_api: &String,
+        instance_limits: &mut Limits,
+    ) -> Result<UserSettings, InstanceServerError> {
+        let request: reqwest::RequestBuilder = Client::new()
+            .get(format!("{}/users/@me/settings/", url_api))
+            .bearer_auth(token);
+        let mut cloned_limits = instance_limits.clone();
+        let mut requester = crate::limit::LimitedRequester::new().await;
+        match requester
+            .send_request(
+                request,
+                crate::api::limits::LimitType::Ip,
+                instance_limits,
+                &mut cloned_limits,
+            )
+            .await
+        {
+            Ok(result) => Ok(serde_json::from_str(&result.text().await.unwrap()).unwrap()),
+            Err(e) => Err(e),
+        }
+    }
+}
+
 impl Instance {
     /**
     Get a user object by id, or get the current user.
@@ -169,11 +200,11 @@ impl Instance {
         token: String,
         id: Option<&String>,
     ) -> Result<User, InstanceServerError> {
-        UserMeta::get(
+        User::_get(
             &token,
             &self.urls.get_api().to_string(),
-            id,
             &mut self.limits,
+            id,
         )
         .await
     }

src/errors.rs

@@ -23,6 +23,7 @@ custom_error! {
     NoPermission = "You do not have the permissions needed to perform this action.",
     NotFound{error: String} = "The provided resource hasn't been found: {}",
     PasswordRequiredError = "You need to provide your current password to authenticate for this action.",
+    InvalidResponseError{error: String} = "The response is malformed and cannot be processed. Error: {}",
 }
 
 custom_error! {

src/types/config/types/guild_configuration.rs

@@ -1,8 +1,20 @@
 use serde::{Deserialize, Serialize};
+#[cfg(feature = "sqlx")]
+use sqlx::{
+    database::{HasArguments, HasValueRef},
+    encode::IsNull,
+    error::BoxDynError,
+    Decode, Encode, MySql,
+};
+use std::fmt::{Display, Formatter};
+use std::io::Write;
+use std::ops::{Deref, DerefMut};
+use std::str::FromStr;
 
 use crate::types::config::types::subconfigs::guild::{
     autojoin::AutoJoinConfiguration, discovery::DiscoverConfiguration,
 };
+use crate::types::{Error, GuildError};
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
 #[serde(rename_all = "SCREAMING_SNAKE_CASE")]
@@ -19,7 +31,7 @@ pub enum GuildFeatures {
     AutoModTriggerSpamLinkFilter,
     AutoModTriggerUserProfile,
     Banner,
-    BFG,
+    Bfg,
     BoostingTiersExperimentMediumGuild,
     BoostingTiersExperimentSmallGuild,
     BotDeveloperEarlyAccess,
@@ -67,7 +79,7 @@ pub enum GuildFeatures {
     GuildWebPageVanityURL,
     HadEarlyActivitiesAccess,
     HasDirectoryEntry,
-    HideFromExperimentUI,
+    HideFromExperimentUi,
     Hub,
     IncreasedThreadLimit,
     InternalEmployeeOnly,
@@ -85,6 +97,7 @@ pub enum GuildFeatures {
     News,
     NewThreadPermissions,
     Partnered,
+    #[serde(rename = "PREMIUM_TIER_3_OVERRIDE")]
     PremiumTier3Override,
     PreviewEnabled,
     RaidAlertsDisabled,
@@ -98,7 +111,7 @@ pub enum GuildFeatures {
     SharedCanvasFriendsAndFamilyTest,
     Soundboard,
     SummariesEnabled,
-    SummariesEnabledGA,
+    SummariesEnabledGa,
     SummariesDisabledByUser,
     SummariesEnabledByUser,
     TextInStageEnabled,
@@ -109,11 +122,400 @@ pub enum GuildFeatures {
     ThreadsOnlyChannel,
     TicketedEventsEnabled,
     TicketingEnabled,
-    VanityUrls,
+    VanityUrl,
     Verified,
-    VIPRegions,
+    VipRegions,
     VoiceChannelEffects,
     WelcomeScreenEnabled,
+
+    /// Spacebar Specific
+    AliasableNames,
+    AllowInvalidChannelName,
+    AllowUnnamedChannels,
+    CrossChannelReplies,
+    IrcLikeCategoryNames,
+    InvitesClosed,
+}
+
+#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+pub struct GuildFeaturesList(Vec<GuildFeatures>);
+
+impl Deref for GuildFeaturesList {
+    type Target = Vec<GuildFeatures>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for GuildFeaturesList {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl Display for GuildFeaturesList {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let features = self
+            .iter()
+            .map(|x| serde_json::to_string(x).unwrap().replace('"', ""))
+            .collect::<Vec<_>>()
+            .join(",");
+        write!(f, "{features}")
+    }
+}
+
+#[cfg(feature = "sqlx")]
+impl<'r> sqlx::Decode<'r, sqlx::MySql> for GuildFeaturesList {
+    fn decode(value: <MySql as HasValueRef<'r>>::ValueRef) -> Result<Self, BoxDynError> {
+        let v = <&str as Decode<sqlx::MySql>>::decode(value)?;
+        Ok(Self(
+            v.split(',')
+                .filter(|f| !f.is_empty())
+                .flat_map(GuildFeatures::from_str)
+                .collect(),
+        ))
+    }
+}
+
+#[cfg(feature = "sqlx")]
+impl<'q> sqlx::Encode<'q, sqlx::MySql> for GuildFeaturesList {
+    fn encode_by_ref(&self, buf: &mut <MySql as HasArguments<'q>>::ArgumentBuffer) -> IsNull {
+        if self.is_empty() {
+            return IsNull::Yes;
+        }
+        let features = self
+            .iter()
+            .map(|x| x.to_str())
+            .collect::<Vec<_>>()
+            .join(",");
+
+        let _ = buf.write(features.as_bytes());
+        IsNull::No
+    }
+}
+
+#[cfg(feature = "sqlx")]
+impl sqlx::Type<sqlx::MySql> for GuildFeaturesList {
+    fn type_info() -> sqlx::mysql::MySqlTypeInfo {
+        <&str as sqlx::Type<sqlx::MySql>>::type_info()
+    }
+
+    fn compatible(ty: &sqlx::mysql::MySqlTypeInfo) -> bool {
+        <&str as sqlx::Type<sqlx::MySql>>::compatible(ty)
+    }
+}
+
+#[cfg(feature = "sqlx")]
+impl sqlx::TypeInfo for GuildFeaturesList {
+    fn is_null(&self) -> bool {
+        false
+    }
+
+    fn name(&self) -> &str {
+        "TEXT"
+    }
+}
+
+impl FromStr for GuildFeatures {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let s = s.to_ascii_uppercase();
+        match s.as_str() {
+            "ACTIVITIES_ALPHA" => Ok(GuildFeatures::ActivitiesAlpha),
+            "ACTIVITIES_EMPLOYEE" => Ok(GuildFeatures::ActivitiesEmployee),
+            "ACTIVITIES_INTERNAL_DEV" => Ok(GuildFeatures::ActivitiesInternalDev),
+            "ANIMATED_BANNER" => Ok(GuildFeatures::AnimatedBanner),
+            "ANIMATED_ICON" => Ok(GuildFeatures::AnimatedIcon),
+            "APPLICATION_COMMAND_PERMISSIONS_V2" => {
+                Ok(GuildFeatures::ApplicationCommandPermissionsV2)
+            }
+            "AUTO_MODERATION" => Ok(GuildFeatures::AutoModeration),
+            "AUTO_MOD_TRIGGER_KEYWORD_FILTER" => Ok(GuildFeatures::AutoModTriggerKeywordFilter),
+            "AUTO_MOD_TRIGGER_ML_SPAM_FILTER" => Ok(GuildFeatures::AutoModTriggerMLSpamFilter),
+            "AUTO_MOD_TRIGGER_SPAM_LINK_FILTER" => Ok(GuildFeatures::AutoModTriggerSpamLinkFilter),
+            "AUTO_MOD_TRIGGER_USER_PROFILE" => Ok(GuildFeatures::AutoModTriggerUserProfile),
+            "BANNER" => Ok(GuildFeatures::Banner),
+            "BFG" => Ok(GuildFeatures::Bfg),
+            "BOOSTING_TIERS_EXPERIMENT_MEDIUM_GUILD" => {
+                Ok(GuildFeatures::BoostingTiersExperimentMediumGuild)
+            }
+            "BOOSTING_TIERS_EXPERIMENT_SMALL_GUILD" => {
+                Ok(GuildFeatures::BoostingTiersExperimentSmallGuild)
+            }
+            "BOT_DEVELOPER_EARLY_ACCESS" => Ok(GuildFeatures::BotDeveloperEarlyAccess),
+            "BURST_REACTIONS" => Ok(GuildFeatures::BurstReactions),
+            "COMMUNITY_CANARY" => Ok(GuildFeatures::CommunityCanary),
+            "COMMUNITY_EXP_LARGE_GATED" => Ok(GuildFeatures::CommunityExpLargeGated),
+            "COMMUNITY_EXP_LARGE_UNGATED" => Ok(GuildFeatures::CommunityExpLargeUngated),
+            "COMMUNITY_EXP_MEDIUM" => Ok(GuildFeatures::CommunityExpMedium),
+            "CHANNEL_EMOJIS_GENERATED" => Ok(GuildFeatures::ChannelEmojisGenerated),
+            "CHANNEL_HIGHLIGHTS" => Ok(GuildFeatures::ChannelHighlights),
+            "CHANNEL_HIGHLIGHTS_DISABLED" => Ok(GuildFeatures::ChannelHighlightsDisabled),
+            "CLYDE_ENABLED" => Ok(GuildFeatures::ClydeEnabled),
+            "CLYDE_EXPERIMENT_ENABLED" => Ok(GuildFeatures::ClydeExperimentEnabled),
+            "CLYDE_DISABLED" => Ok(GuildFeatures::ClydeDisabled),
+            "COMMUNITY" => Ok(GuildFeatures::Community),
+            "CREATOR_ACCEPTED_NEW_TERMS" => Ok(GuildFeatures::CreatorAcceptedNewTerms),
+            "CREATOR_MONETIZABLE" => Ok(GuildFeatures::CreatorMonetizable),
+            "CREATOR_MONETIZABLE_DISABLED" => Ok(GuildFeatures::CreatorMonetizableDisabled),
+            "CREATOR_MONETIZABLE_PENDING_NEW_OWNER_ONBOARDING" => {
+                Ok(GuildFeatures::CreatorMonetizablePendingNewOwnerOnboarding)
+            }
+            "CREATOR_MONETIZABLE_PROVISIONAL" => Ok(GuildFeatures::CreatorMonetizableProvisional),
+            "CREATOR_MONETIZABLE_RESTRICTED" => Ok(GuildFeatures::CreatorMonetizableRestricted),
+            "CREATOR_MONETIZABLE_WHITEGLOVE" => Ok(GuildFeatures::CreatorMonetizableWhiteglove),
+            "CREATOR_MONETIZABLE_APPLICATION_ALLOWLIST" => {
+                Ok(GuildFeatures::CreatorMonetizableApplicationAllowlist)
+            }
+            "CREATE_STORE_PAGE" => Ok(GuildFeatures::CreateStorePage),
+            "DEVELOPER_SUPPORT_SERVER" => Ok(GuildFeatures::DeveloperSupportServer),
+            "DISCOVERABLE_DISABLED" => Ok(GuildFeatures::DiscoverableDisabled),
+            "DISCOVERABLE" => Ok(GuildFeatures::Discoverable),
+            "ENABLED_DISCOVERABLE_BEFORE" => Ok(GuildFeatures::EnabledDiscoverableBefore),
+            "EXPOSED_TO_ACTIVITIES_WTP_EXPERIMENT" => {
+                Ok(GuildFeatures::ExposedToActivitiesWTPExperiment)
+            }
+            "GUESTS_ENABLED" => Ok(GuildFeatures::GuestsEnabled),
+            "GUILD_AUTOMOD_DEFAULT_LIST" => Ok(GuildFeatures::GuildAutomodDefaultList),
+            "GUILD_COMMUNICATION_DISABLED_GUILDS" => {
+                Ok(GuildFeatures::GuildCommunicationDisabledGuilds)
+            }
+            "GUILD_HOME_DEPRECATION_OVERRIDE" => Ok(GuildFeatures::GuildHomeDeprecationOverride),
+            "GUILD_HOME_OVERRIDE" => Ok(GuildFeatures::GuildHomeOverride),
+            "GUILD_HOME_TEST" => Ok(GuildFeatures::GuildHomeTest),
+            "GUILD_MEMBER_VERIFICATION_EXPERIMENT" => {
+                Ok(GuildFeatures::GuildMemberVerificationExperiment)
+            }
+            "GUILD_ONBOARDING" => Ok(GuildFeatures::GuildOnboarding),
+            "GUILD_ONBOARDING_ADMIN_ONLY" => Ok(GuildFeatures::GuildOnboardingAdminOnly),
+            "GUILD_ONBOARDING_EVER_ENABLED" => Ok(GuildFeatures::GuildOnboardingEverEnabled),
+            "GUILD_ONBOARDING_HAS_PROMPTS" => Ok(GuildFeatures::GuildOnboardingHasPrompts),
+            "GUILD_ROLE_SUBSCRIPTION" => Ok(GuildFeatures::GuildRoleSubscription),
+            "GUILD_ROLE_SUBSCRIPTION_PURCHASE_FEEDBACK_LOOP" => {
+                Ok(GuildFeatures::GuildRoleSubscriptionPurchaseFeedbackLoop)
+            }
+            "GUILD_ROLE_SUBSCRIPTION_TRIALS" => Ok(GuildFeatures::GuildRoleSubscriptionTrials),
+            "GUILD_SERVER_GUIDE" => Ok(GuildFeatures::GuildServerGuide),
+            "GUILD_WEB_PAGE_VANITY_URL" => Ok(GuildFeatures::GuildWebPageVanityURL),
+            "HAD_EARLY_ACTIVITIES_ACCESS" => Ok(GuildFeatures::HadEarlyActivitiesAccess),
+            "HAS_DIRECTORY_ENTRY" => Ok(GuildFeatures::HasDirectoryEntry),
+            "HIDE_FROM_EXPERIMENT_UI" => Ok(GuildFeatures::HideFromExperimentUi),
+            "HUB" => Ok(GuildFeatures::Hub),
+            "INCREASED_THREAD_LIMIT" => Ok(GuildFeatures::IncreasedThreadLimit),
+            "INTERNAL_EMPLOYEE_ONLY" => Ok(GuildFeatures::InternalEmployeeOnly),
+            "INVITE_SPLASH" => Ok(GuildFeatures::InviteSplash),
+            "INVITES_DISABLED" => Ok(GuildFeatures::InvitesDisabled),
+            "LINKED_TO_HUB" => Ok(GuildFeatures::LinkedToHub),
+            "MARKETPLACES_CONNECTION_ROLES" => Ok(GuildFeatures::MarketplacesConnectionRoles),
+            "MEMBER_PROFILES" => Ok(GuildFeatures::MemberProfiles),
+            "MEMBER_VERIFICATION_GATE_ENABLED" => Ok(GuildFeatures::MemberVerificationGateEnabled),
+            "MEMBER_VERIFICATION_MANUAL_APPROVAL" => {
+                Ok(GuildFeatures::MemberVerificationManualApproval)
+            }
+            "MOBILE_WEB_ROLE_SUBSCRIPTION_PURCHASE_PAGE" => {
+                Ok(GuildFeatures::MobileWebRoleSubscriptionPurchasePage)
+            }
+            "MONETIZATION_ENABLED" => Ok(GuildFeatures::MonetizationEnabled),
+            "MORE_EMOJI" => Ok(GuildFeatures::MoreEmoji),
+            "MORE_STICKERS" => Ok(GuildFeatures::MoreStickers),
+            "NEWS" => Ok(GuildFeatures::News),
+            "NEW_THREAD_PERMISSIONS" => Ok(GuildFeatures::NewThreadPermissions),
+            "PARTNERED" => Ok(GuildFeatures::Partnered),
+            "PREMIUM_TIER_3_OVERRIDE" => Ok(GuildFeatures::PremiumTier3Override),
+            "PREVIEW_ENABLED" => Ok(GuildFeatures::PreviewEnabled),
+            "RAID_ALERTS_DISABLED" => Ok(GuildFeatures::RaidAlertsDisabled),
+            "RELAY_ENABLED" => Ok(GuildFeatures::RelayEnabled),
+            "RESTRICT_SPAM_RISK_GUILD" => Ok(GuildFeatures::RestrictSpamRiskGuild),
+            "ROLE_ICONS" => Ok(GuildFeatures::RoleIcons),
+            "ROLE_SUBSCRIPTIONS_AVAILABLE_FOR_PURCHASE" => {
+                Ok(GuildFeatures::RoleSubscriptionsAvailableForPurchase)
+            }
+            "ROLE_SUBSCRIPTIONS_ENABLED" => Ok(GuildFeatures::RoleSubscriptionsEnabled),
+            "ROLE_SUBSCRIPTIONS_ENABLED_FOR_PURCHASE" => {
+                Ok(GuildFeatures::RoleSubscriptionsEnabledForPurchase)
+            }
+            "SHARD" => Ok(GuildFeatures::Shard),
+            "SHARED_CANVAS_FRIENDS_AND_FAMILY_TEST" => {
+                Ok(GuildFeatures::SharedCanvasFriendsAndFamilyTest)
+            }
+            "SOUNDBOARD" => Ok(GuildFeatures::Soundboard),
+            "SUMMARIES_ENABLED" => Ok(GuildFeatures::SummariesEnabled),
+            "SUMMARIES_ENABLED_GA" => Ok(GuildFeatures::SummariesEnabledGa),
+            "SUMMARIES_DISABLED_BY_USER" => Ok(GuildFeatures::SummariesDisabledByUser),
+            "SUMMARIES_ENABLED_BY_USER" => Ok(GuildFeatures::SummariesEnabledByUser),
+            "TEXT_IN_STAGE_ENABLED" => Ok(GuildFeatures::TextInStageEnabled),
+            "TEXT_IN_VOICE_ENABLED" => Ok(GuildFeatures::TextInVoiceEnabled),
+            "THREADS_ENABLED_TESTING" => Ok(GuildFeatures::ThreadsEnabledTesting),
+            "THREADS_ENABLED" => Ok(GuildFeatures::ThreadsEnabled),
+            "THREAD_DEFAULT_AUTO_ARCHIVE_DURATION" => {
+                Ok(GuildFeatures::ThreadDefaultAutoArchiveDuration)
+            }
+            "THREADS_ONLY_CHANNEL" => Ok(GuildFeatures::ThreadsOnlyChannel),
+            "TICKETED_EVENTS_ENABLED" => Ok(GuildFeatures::TicketedEventsEnabled),
+            "TICKETING_ENABLED" => Ok(GuildFeatures::TicketingEnabled),
+            "VANITY_URL" => Ok(GuildFeatures::VanityUrl),
+            "VERIFIED" => Ok(GuildFeatures::Verified),
+            "VIP_REGIONS" => Ok(GuildFeatures::VipRegions),
+            "VOICE_CHANNEL_EFFECTS" => Ok(GuildFeatures::VoiceChannelEffects),
+            "WELCOME_SCREEN_ENABLED" => Ok(GuildFeatures::WelcomeScreenEnabled),
+            "ALIASABLE_NAMES" => Ok(GuildFeatures::AliasableNames),
+            "ALLOW_INVALID_CHANNEL_NAME" => Ok(GuildFeatures::AllowInvalidChannelName),
+            "ALLOW_UNNAMED_CHANNELS" => Ok(GuildFeatures::AllowUnnamedChannels),
+            "CROSS_CHANNEL_REPLIES" => Ok(GuildFeatures::CrossChannelReplies),
+            "IRC_LIKE_CATEGORY_NAMES" => Ok(GuildFeatures::IrcLikeCategoryNames),
+            "INVITES_CLOSED" => Ok(GuildFeatures::InvitesClosed),
+            _ => Err(Error::Guild(GuildError::InvalidGuildFeature)),
+        }
+    }
+}
+
+impl GuildFeatures {
+    pub fn to_str(&self) -> &'static str {
+        match *self {
+            GuildFeatures::ActivitiesAlpha => "ACTIVITIES_ALPHA",
+            GuildFeatures::ActivitiesEmployee => "ACTIVITIES_EMPLOYEE",
+            GuildFeatures::ActivitiesInternalDev => "ACTIVITIES_INTERNAL_DEV",
+            GuildFeatures::AnimatedBanner => "ANIMATED_BANNER",
+            GuildFeatures::AnimatedIcon => "ANIMATED_ICON",
+            GuildFeatures::ApplicationCommandPermissionsV2 => "APPLICATION_COMMAND_PERMISSIONS_V2",
+            GuildFeatures::AutoModeration => "AUTO_MODERATION",
+            GuildFeatures::AutoModTriggerKeywordFilter => "AUTO_MOD_TRIGGER_KEYWORD_FILTER",
+            GuildFeatures::AutoModTriggerMLSpamFilter => "AUTO_MOD_TRIGGER_ML_SPAM_FILTER",
+            GuildFeatures::AutoModTriggerSpamLinkFilter => "AUTO_MOD_TRIGGER_SPAM_LINK_FILTER",
+            GuildFeatures::AutoModTriggerUserProfile => "AUTO_MOD_TRIGGER_USER_PROFILE",
+            GuildFeatures::Banner => "BANNER",
+            GuildFeatures::Bfg => "BFG",
+            GuildFeatures::BoostingTiersExperimentMediumGuild => {
+                "BOOSTING_TIERS_EXPERIMENT_MEDIUM_GUILD"
+            }
+            GuildFeatures::BoostingTiersExperimentSmallGuild => {
+                "BOOSTING_TIERS_EXPERIMENT_SMALL_GUILD"
+            }
+            GuildFeatures::BotDeveloperEarlyAccess => "BOT_DEVELOPER_EARLY_ACCESS",
+            GuildFeatures::BurstReactions => "BURST_REACTIONS",
+            GuildFeatures::CommunityCanary => "COMMUNITY_CANARY",
+            GuildFeatures::CommunityExpLargeGated => "COMMUNITY_EXP_LARGE_GATED",
+            GuildFeatures::CommunityExpLargeUngated => "COMMUNITY_EXP_LARGE_UNGATED",
+            GuildFeatures::CommunityExpMedium => "COMMUNITY_EXP_MEDIUM",
+            GuildFeatures::ChannelEmojisGenerated => "CHANNEL_EMOJIS_GENERATED",
+            GuildFeatures::ChannelHighlights => "CHANNEL_HIGHLIGHTS",
+            GuildFeatures::ChannelHighlightsDisabled => "CHANNEL_HIGHLIGHTS_DISABLED",
+            GuildFeatures::ClydeEnabled => "CLYDE_ENABLED",
+            GuildFeatures::ClydeExperimentEnabled => "CLYDE_EXPERIMENT_ENABLED",
+            GuildFeatures::ClydeDisabled => "CLYDE_DISABLED",
+            GuildFeatures::Community => "COMMUNITY",
+            GuildFeatures::CreatorAcceptedNewTerms => "CREATOR_ACCEPTED_NEW_TERMS",
+            GuildFeatures::CreatorMonetizable => "CREATOR_MONETIZABLE",
+            GuildFeatures::CreatorMonetizableDisabled => "CREATOR_MONETIZABLE_DISABLED",
+            GuildFeatures::CreatorMonetizablePendingNewOwnerOnboarding => {
+                "CREATOR_MONETIZABLE_PENDING_NEW_OWNER_ONBOARDING"
+            }
+            GuildFeatures::CreatorMonetizableProvisional => "CREATOR_MONETIZABLE_PROVISIONAL",
+            GuildFeatures::CreatorMonetizableRestricted => "CREATOR_MONETIZABLE_RESTRICTED",
+            GuildFeatures::CreatorMonetizableWhiteglove => "CREATOR_MONETIZABLE_WHITEGLOVE",
+            GuildFeatures::CreatorMonetizableApplicationAllowlist => {
+                "CREATOR_MONETIZABLE_APPLICATION_ALLOWLIST"
+            }
+            GuildFeatures::CreateStorePage => "CREATE_STORE_PAGE",
+            GuildFeatures::DeveloperSupportServer => "DEVELOPER_SUPPORT_SERVER",
+            GuildFeatures::DiscoverableDisabled => "DISCOVERABLE_DISABLED",
+            GuildFeatures::Discoverable => "DISCOVERABLE",
+            GuildFeatures::EnabledDiscoverableBefore => "ENABLED_DISCOVERABLE_BEFORE",
+            GuildFeatures::ExposedToActivitiesWTPExperiment => {
+                "EXPOSED_TO_ACTIVITIES_WTP_EXPERIMENT"
+            }
+            GuildFeatures::GuestsEnabled => "GUESTS_ENABLED",
+            GuildFeatures::GuildAutomodDefaultList => "GUILD_AUTOMOD_DEFAULT_LIST",
+            GuildFeatures::GuildCommunicationDisabledGuilds => {
+                "GUILD_COMMUNICATION_DISABLED_GUILDS"
+            }
+            GuildFeatures::GuildHomeDeprecationOverride => "GUILD_HOME_DEPRECATION_OVERRIDE",
+            GuildFeatures::GuildHomeOverride => "GUILD_HOME_OVERRIDE",
+            GuildFeatures::GuildHomeTest => "GUILD_HOME_TEST",
+            GuildFeatures::GuildMemberVerificationExperiment => {
+                "GUILD_MEMBER_VERIFICATION_EXPERIMENT"
+            }
+            GuildFeatures::GuildOnboarding => "GUILD_ONBOARDING",
+            GuildFeatures::GuildOnboardingAdminOnly => "GUILD_ONBOARDING_ADMIN_ONLY",
+            GuildFeatures::GuildOnboardingEverEnabled => "GUILD_ONBOARDING_EVER_ENABLED",
+            GuildFeatures::GuildOnboardingHasPrompts => "GUILD_ONBOARDING_HAS_PROMPTS",
+            GuildFeatures::GuildRoleSubscription => "GUILD_ROLE_SUBSCRIPTION",
+            GuildFeatures::GuildRoleSubscriptionPurchaseFeedbackLoop => {
+                "GUILD_ROLE_SUBSCRIPTION_PURCHASE_FEEDBACK_LOOP"
+            }
+            GuildFeatures::GuildRoleSubscriptionTrials => "GUILD_ROLE_SUBSCRIPTION_TRIALS",
+            GuildFeatures::GuildServerGuide => "GUILD_SERVER_GUIDE",
+            GuildFeatures::GuildWebPageVanityURL => "GUILD_WEB_PAGE_VANITY_URL",
+            GuildFeatures::HadEarlyActivitiesAccess => "HAD_EARLY_ACTIVITIES_ACCESS",
+            GuildFeatures::HasDirectoryEntry => "HAS_DIRECTORY_ENTRY",
+            GuildFeatures::HideFromExperimentUi => "HIDE_FROM_EXPERIMENT_UI",
+            GuildFeatures::Hub => "HUB",
+            GuildFeatures::IncreasedThreadLimit => "INCREASED_THREAD_LIMIT",
+            GuildFeatures::InternalEmployeeOnly => "INTERNAL_EMPLOYEE_ONLY",
+            GuildFeatures::InviteSplash => "INVITE_SPLASH",
+            GuildFeatures::InvitesDisabled => "INVITES_DISABLED",
+            GuildFeatures::LinkedToHub => "LINKED_TO_HUB",
+            GuildFeatures::MarketplacesConnectionRoles => "MARKETPLACES_CONNECTION_ROLES",
+            GuildFeatures::MemberProfiles => "MEMBER_PROFILES",
+            GuildFeatures::MemberVerificationGateEnabled => "MEMBER_VERIFICATION_GATE_ENABLED",
+            GuildFeatures::MemberVerificationManualApproval => {
+                "MEMBER_VERIFICATION_MANUAL_APPROVAL"
+            }
+            GuildFeatures::MobileWebRoleSubscriptionPurchasePage => {
+                "MOBILE_WEB_ROLE_SUBSCRIPTION_PURCHASE_PAGE"
+            }
+            GuildFeatures::MonetizationEnabled => "MONETIZATION_ENABLED",
+            GuildFeatures::MoreEmoji => "MORE_EMOJI",
+            GuildFeatures::MoreStickers => "MORE_STICKERS",
+            GuildFeatures::News => "NEWS",
+            GuildFeatures::NewThreadPermissions => "NEW_THREAD_PERMISSIONS",
+            GuildFeatures::Partnered => "PARTNERED",
+            GuildFeatures::PremiumTier3Override => "PREMIUM_TIER_3_OVERRIDE",
+            GuildFeatures::PreviewEnabled => "PREVIEW_ENABLED",
+            GuildFeatures::RaidAlertsDisabled => "RAID_ALERTS_DISABLED",
+            GuildFeatures::RelayEnabled => "RELAY_ENABLED",
+            GuildFeatures::RestrictSpamRiskGuild => "RESTRICT_SPAM_RISK_GUILD",
+            GuildFeatures::RoleIcons => "ROLE_ICONS",
+            GuildFeatures::RoleSubscriptionsAvailableForPurchase => {
+                "ROLE_SUBSCRIPTIONS_AVAILABLE_FOR_PURCHASE"
+            }
+            GuildFeatures::RoleSubscriptionsEnabled => "ROLE_SUBSCRIPTIONS_ENABLED",
+            GuildFeatures::RoleSubscriptionsEnabledForPurchase => {
+                "ROLE_SUBSCRIPTIONS_ENABLED_FOR_PURCHASE"
+            }
+            GuildFeatures::Shard => "SHARD",
+            GuildFeatures::SharedCanvasFriendsAndFamilyTest => {
+                "SHARED_CANVAS_FRIENDS_AND_FAMILY_TEST"
+            }
+            GuildFeatures::Soundboard => "SOUNDBOARD",
+            GuildFeatures::SummariesEnabled => "SUMMARIES_ENABLED",
+            GuildFeatures::SummariesEnabledGa => "SUMMARIES_ENABLED_GA",
+            GuildFeatures::SummariesDisabledByUser => "SUMMARIES_DISABLED_BY_USER",
+            GuildFeatures::SummariesEnabledByUser => "SUMMARIES_ENABLED_BY_USER",
+            GuildFeatures::TextInStageEnabled => "TEXT_IN_STAGE_ENABLED",
+            GuildFeatures::TextInVoiceEnabled => "TEXT_IN_VOICE_ENABLED",
+            GuildFeatures::ThreadsEnabledTesting => "THREADS_ENABLED_TESTING",
+            GuildFeatures::ThreadsEnabled => "THREADS_ENABLED",
+            GuildFeatures::ThreadDefaultAutoArchiveDuration => {
+                "THREAD_DEFAULT_AUTO_ARCHIVE_DURATION"
+            }
+            GuildFeatures::ThreadsOnlyChannel => "THREADS_ONLY_CHANNEL",
+            GuildFeatures::TicketedEventsEnabled => "TICKETED_EVENTS_ENABLED",
+            GuildFeatures::TicketingEnabled => "TICKETING_ENABLED",
+            GuildFeatures::VanityUrl => "VANITY_URL",
+            GuildFeatures::Verified => "VERIFIED",
+            GuildFeatures::VipRegions => "VIP_REGIONS",
+            GuildFeatures::VoiceChannelEffects => "VOICE_CHANNEL_EFFECTS",
+            GuildFeatures::WelcomeScreenEnabled => "WELCOME_SCREEN_ENABLED",
+            GuildFeatures::AliasableNames => "ALIASABLE_NAMES",
+            GuildFeatures::AllowInvalidChannelName => "ALLOW_INVALID_CHANNEL_NAME",
+            GuildFeatures::AllowUnnamedChannels => "ALLOW_UNNAMED_CHANNELS",
+            GuildFeatures::CrossChannelReplies => "CROSS_CHANNEL_REPLIES",
+            GuildFeatures::IrcLikeCategoryNames => "IRC_LIKE_CATEGORY_NAMES",
+            GuildFeatures::InvitesClosed => "INVITES_CLOSED",
+        }
+    }
 }
 
 #[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]

src/types/entities/guild.rs

@@ -2,6 +2,7 @@ use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 use serde_repr::{Deserialize_repr, Serialize_repr};
 
+use crate::types::types::guild_configuration::GuildFeaturesList;
 use crate::types::{
     entities::{Channel, Emoji, RoleObject, Sticker, User, VoiceState, Webhook},
     interfaces::WelcomeScreenObject,
@@ -15,54 +16,63 @@ 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<u8>,
+    pub afk_timeout: Option<i32>,
     pub widget_enabled: Option<bool>,
     pub widget_channel_id: Option<Snowflake>,
-    pub verification_level: Option<u8>,
+    pub verification_level: Option<i32>,
-    pub default_message_notifications: Option<u8>,
+    pub default_message_notifications: Option<i32>,
-    pub explicit_content_filter: Option<u8>,
+    pub explicit_content_filter: Option<i32>,
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
-    pub roles: Vec<RoleObject>,
+    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: GuildFeaturesList,
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
-    pub features: Option<Vec<String>>,
     pub application_id: Option<String>,
     pub system_channel_id: Option<Snowflake>,
-    pub system_channel_flags: Option<u8>,
+    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<u64>,
+    pub max_presences: Option<i32>,
-    pub max_members: Option<u64>,
+    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<u8>,
+    pub premium_tier: Option<i32>,
-    pub premium_subscription_count: Option<u64>,
+    pub premium_subscription_count: Option<i32>,
     pub preferred_locale: Option<String>,
     pub public_updates_channel_id: Option<Snowflake>,
-    pub max_video_channel_users: Option<u8>,
+    pub max_video_channel_users: Option<i32>,
-    pub max_stage_video_channel_users: Option<u8>,
+    #[cfg_attr(feature = "sqlx", sqlx(skip))]
-    pub approximate_member_count: Option<u64>,
+    pub max_stage_video_channel_users: Option<i32>,
-    pub approximate_presence_count: Option<u64>,
+    #[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<u8>,
+    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: String,
+    pub joined_at: Option<String>,
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
     pub bans: Option<Vec<GuildBan>>,
     pub primary_category_id: Option<Snowflake>,
@@ -75,7 +85,7 @@ pub struct Guild {
     pub voice_states: Option<Vec<VoiceState>>,
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
     pub webhooks: Option<Vec<Webhook>>,
-    pub mfa_level: Option<u8>,
+    pub mfa_level: Option<i32>,
     pub region: Option<String>,
 }
 

src/types/entities/role.rs

@@ -19,6 +19,9 @@ pub struct RoleObject {
     pub permissions: String,
     pub managed: bool,
     pub mentionable: bool,
+    #[cfg(feature = "sqlx")]
+    pub tags: Option<sqlx::types::Json<RoleTags>>,
+    #[cfg(not(feature = "sqlx"))]
     pub tags: Option<RoleTags>,
 }
 

src/types/entities/user.rs

@@ -36,7 +36,7 @@ pub struct User {
     /// So we need to account for that
     #[serde(default)]
     #[serde(deserialize_with = "deserialize_option_number_from_string")]
-    flags: Option<i32>,
+    pub flags: Option<i32>,
     pub premium_since: Option<DateTime<Utc>>,
     pub premium_type: Option<u8>,
     pub pronouns: Option<String>,

src/types/errors.rs

@@ -14,6 +14,15 @@ pub enum Error {
 
     #[error(transparent)]
     FieldFormat(#[from] FieldFormatError),
+
+    #[error(transparent)]
+    Guild(#[from] GuildError),
+}
+
+#[derive(Debug, PartialEq, Eq, thiserror::Error)]
+pub enum GuildError {
+    #[error("Invalid Guild Feature")]
+    InvalidGuildFeature,
 }
 
 #[derive(Debug, PartialEq, Eq, thiserror::Error)]
@@ -44,11 +53,11 @@ pub struct IntermittentError {
 #[derive(Serialize, Deserialize, Debug, Default)]
 pub struct ErrorField {
     #[serde(default)]
-    pub _errors: Vec<APIError>,
+    pub _errors: Vec<APIErrorPayload>,
 }
 
 #[derive(Serialize, Deserialize, Debug)]
-pub struct APIError {
+pub struct APIErrorPayload {
     pub message: String,
     pub code: String,
 }

src/types/schema/channel.rs

@@ -25,3 +25,25 @@ pub struct ChannelCreateSchema {
     pub default_thread_rate_limit_per_user: Option<i32>,
     pub video_quality_mode: Option<i32>,
 }
+
+#[derive(Debug, Deserialize, Serialize, Clone, Default)]
+#[serde(rename_all = "snake_case")]
+pub struct ChannelModifySchema {
+    pub name: Option<String>,
+    pub channel_type: Option<u8>,
+    pub topic: Option<String>,
+    pub icon: Option<String>,
+    pub bitrate: Option<i32>,
+    pub user_limit: Option<i32>,
+    pub rate_limit_per_user: Option<i32>,
+    pub position: Option<i32>,
+    pub permission_overwrites: Option<Vec<PermissionOverwrite>>,
+    pub parent_id: Option<String>,
+    pub nsfw: Option<bool>,
+    pub rtc_region: Option<String>,
+    pub default_auto_archive_duration: Option<i32>,
+    pub default_reaction_emoji: Option<String>,
+    pub flags: Option<i32>,
+    pub default_thread_rate_limit_per_user: Option<i32>,
+    pub video_quality_mode: Option<i32>,
+}

tests/channel.rs

@@ -1,23 +1,58 @@
 mod common;
-use chorus::types::Channel;
+use chorus::types::{self, Channel};
 
 #[tokio::test]
 async fn get_channel() {
     let mut bundle = common::setup().await;
     let bundle_channel = bundle.channel.clone();
-    let bundle_user = &mut bundle.user;
+    let mut bundle_user = &mut bundle.user;
 
     assert_eq!(
         bundle_channel,
-        Channel::get(
+        Channel::get(&mut bundle_user, &bundle_channel.id.to_string(),)
-            bundle_user.token.as_str(),
-            bundle.instance.urls.get_api(),
-            &bundle_channel.id.to_string(),
-            &mut bundle_user.limits,
-            &mut bundle.instance.limits
-        )
             .await
             .unwrap()
     );
     common::teardown(bundle).await
 }
+
+#[tokio::test]
+async fn delete_channel() {
+    let mut bundle = common::setup().await;
+    let result = bundle.channel.clone().delete(&mut bundle.user).await;
+    assert!(result.is_none());
+    common::teardown(bundle).await
+}
+
+#[tokio::test]
+async fn modify_channel() {
+    let mut bundle = common::setup().await;
+    let modify_data: types::ChannelModifySchema = types::ChannelModifySchema {
+        name: Some("beepboop".to_string()),
+        channel_type: None,
+        topic: None,
+        icon: None,
+        bitrate: None,
+        user_limit: None,
+        rate_limit_per_user: None,
+        position: None,
+        permission_overwrites: None,
+        parent_id: None,
+        nsfw: None,
+        rtc_region: None,
+        default_auto_archive_duration: None,
+        default_reaction_emoji: None,
+        flags: None,
+        default_thread_rate_limit_per_user: None,
+        video_quality_mode: None,
+    };
+    let result = Channel::modify(
+        modify_data,
+        &bundle.channel.id.to_string(),
+        &mut bundle.user,
+    )
+    .await
+    .unwrap();
+    assert_eq!(result.name, Some("beepboop".to_string()));
+    common::teardown(bundle).await
+}

tests/common/mod.rs

@@ -9,7 +9,7 @@ pub struct TestBundle {
     pub urls: URLBundle,
     pub user: UserMeta,
     pub instance: Instance,
-    pub guild_id: String,
+    pub guild: Guild,
     pub channel: Channel,
 }
 
@@ -65,17 +65,8 @@ pub async fn setup() -> TestBundle {
         video_quality_mode: None,
     };
     let mut user = instance.register_account(&reg).await.unwrap();
-    let guild_id = Guild::create(&mut user, urls.get_api(), guild_create_schema)
+    let guild = Guild::create(&mut user, guild_create_schema).await.unwrap();
-        .await
+    let channel = Channel::create(&mut user, &guild.id.to_string(), channel_create_schema)
-        .unwrap();
-    let channel = Channel::create(
-        &user.token,
-        urls.get_api(),
-        guild_id.as_str(),
-        channel_create_schema,
-        &mut user.limits,
-        &mut instance.limits,
-    )
         .await
         .unwrap();
 
@@ -83,18 +74,13 @@ pub async fn setup() -> TestBundle {
         urls,
         user,
         instance,
-        guild_id,
+        guild,
         channel,
     }
 }
 
 // Teardown method to clean up after a test.
 pub async fn teardown(mut bundle: TestBundle) {
-    Guild::delete(
+    Guild::delete(&mut bundle.user, &bundle.guild.id.to_string()).await;
-        &mut bundle.user,
-        bundle.instance.urls.get_api(),
-        bundle.guild_id,
-    )
-    .await;
     bundle.user.delete().await;
 }

tests/guild.rs

@@ -15,15 +15,23 @@ async fn guild_creation_deletion() {
         rules_channel_id: None,
     };
 
-    let guild = Guild::create(&mut bundle.user, bundle.urls.get_api(), guild_create_schema)
+    let guild = Guild::create(&mut bundle.user, guild_create_schema)
         .await
         .unwrap();
 
-    println!("{}", guild);
+    match Guild::delete(&mut bundle.user, &guild.id.to_string()).await {
-
-    match Guild::delete(&mut bundle.user, bundle.urls.get_api(), guild).await {
         None => assert!(true),
         Some(_) => assert!(false),
     }
     common::teardown(bundle).await
 }
+
+#[tokio::test]
+async fn get_channels() {
+    let mut bundle = common::setup().await;
+    println!(
+        "{:?}",
+        bundle.guild.channels(&mut bundle.user).await.unwrap()
+    );
+    common::teardown(bundle).await;
+}

types/config/mod.rs

@@ -1,187 +0,0 @@
-use serde::{Deserialize, Serialize};
-use serde_json::{Map, Value};
-
-pub use crate::{
-    config::types::{
-        api_configuration::ApiConfiguration, cdn_configuration::CdnConfiguration,
-        defaults_configuration::DefaultsConfiguration, email_configuration::EmailConfiguration,
-        endpoint_configuration::EndpointConfiguration,
-        external_tokens_configuration::ExternalTokensConfiguration,
-        general_configuration::GeneralConfiguration, gif_configuration::GifConfiguration,
-        guild_configuration::GuildConfiguration, kafka_configuration::KafkaConfiguration,
-        limit_configuration::LimitsConfiguration, login_configuration::LoginConfiguration,
-        metrics_configuration::MetricsConfiguration,
-        password_reset_configuration::PasswordResetConfiguration,
-        rabbit_mq_configuration::RabbitMQConfiguration, region_configuration::RegionConfiguration,
-        register_configuration::RegisterConfiguration,
-        security_configuration::SecurityConfiguration, sentry_configuration::SentryConfiguration,
-        template_configuration::TemplateConfiguration,
-    },
-    entities::ConfigEntity,
-};
-
-mod types;
-
-#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ConfigValue {
-    pub gateway: EndpointConfiguration,
-    pub cdn: CdnConfiguration,
-    pub api: ApiConfiguration,
-    pub general: GeneralConfiguration,
-    pub limits: LimitsConfiguration,
-    pub security: SecurityConfiguration,
-    pub login: LoginConfiguration,
-    pub register: RegisterConfiguration,
-    pub regions: RegionConfiguration,
-    pub guild: GuildConfiguration,
-    pub gif: GifConfiguration,
-    pub rabbitmq: RabbitMQConfiguration,
-    pub kafka: KafkaConfiguration,
-    pub templates: TemplateConfiguration,
-    pub metrics: MetricsConfiguration,
-    pub sentry: SentryConfiguration,
-    pub defaults: DefaultsConfiguration,
-    pub external: ExternalTokensConfiguration,
-    pub email: EmailConfiguration,
-    pub password_reset: PasswordResetConfiguration,
-}
-
-impl ConfigValue {
-    pub fn to_pairs(&self) -> Vec<ConfigEntity> {
-        let v = serde_json::json!(self);
-
-        generate_pairs(&v, "")
-    }
-
-    pub fn from_pairs(pairs: Vec<ConfigEntity>) -> Self {
-        pairs_to_config(pairs)
-    }
-}
-
-fn generate_pairs(obj: &Value, key: &str) -> Vec<ConfigEntity> {
-    let mut pairs = Vec::new();
-    match obj {
-        Value::Object(map) => {
-            for (k, v) in map {
-                let new_key = if key.is_empty() {
-                    k.to_string()
-                } else {
-                    format!("{}_{}", key, k)
-                };
-                pairs.extend(generate_pairs(v, &new_key));
-            }
-        }
-        Value::Array(arr) => {
-            for (i, v) in arr.iter().enumerate() {
-                let new_key = format!("{}_{}", key, i);
-                pairs.extend(generate_pairs(v, &new_key));
-            }
-        }
-        _ => pairs.push(ConfigEntity {
-            key: key.to_string(),
-            value: Some(obj.clone()),
-        }),
-    }
-    pairs
-}
-
-fn pairs_to_config(pairs: Vec<ConfigEntity>) -> ConfigValue {
-    let mut value = Value::Object(Map::new());
-    
-    for p in pairs {
-        let keys: Vec<&str> = p.key.split('_').collect();
-        let mut path = vec![];
-        
-        for (i, &key) in keys.iter().enumerate() {
-            path.push(key);
-            
-            if i == keys.len() - 1 {
-                insert_into(&mut value, &path, p.value.clone().unwrap_or(Value::Null));
-            } else if keys[i+1].parse::<usize>().is_ok() {
-                if !path_exists(&value, &path) {
-                    insert_into(&mut value, &path, Value::Array(Vec::new()));
-                }
-            } else if !path_exists(&value, &path) {
-                insert_into(&mut value, &path, Value::Object(Map::new()));
-            }
-        }
-    }
-
-    serde_json::from_value(value).unwrap()
-}
-
-fn path_exists(value: &Value, path: &[&str]) -> bool {
-    let mut current = value;
-    
-    for &key in path {
-        match current {
-            Value::Object(map) => {
-                if let Some(v) = map.get(key) {
-                    current = v;
-                } else {
-                    return false;
-                }
-            },
-            Value::Array(arr) => {
-                if let Ok(index) = key.parse::<usize>() {
-                    if let Some(v) = arr.get(index) {
-                        current = v;
-                    } else {
-                        return false;
-                    }
-                } else {
-                    return false;
-                }
-            },
-            _ => return false,
-        }
-    }
-    
-    true
-}
-
-fn insert_into(value: &mut Value, path: &[&str], new_value: Value) {
-    let last_key = path.last().unwrap();
-    let parent_path = &path[0..path.len()-1];
-    
-    let mut current = value;
-    
-    for &key in parent_path {
-        current = match current {
-            Value::Object(map) => map.get_mut(key).unwrap(),
-            Value::Array(arr) => arr.get_mut(key.parse::<usize>().unwrap()).unwrap(),
-            _ => unreachable!(),
-        };
-    }
-    
-    match current {
-        Value::Object(map) => {
-            map.insert((*last_key).to_string(), new_value);
-        },
-        Value::Array(arr) => {
-            let index = last_key.parse::<usize>().unwrap();
-            if index >= arr.len() {
-                arr.resize(index + 1, Value::Null);
-            }
-            arr[index] = new_value;
-        },
-        _ => unreachable!(),
-    };
-}
-
-#[cfg(test)]
-mod test {
-    use crate::config::{generate_pairs, pairs_to_config, ConfigValue};
-
-    #[test]
-    fn test_pairs() {
-        let c = ConfigValue::default();
-        let v = serde_json::json!(&c);
-
-        let pairs = generate_pairs(&v, "");
-
-        let cfg = pairs_to_config(pairs);
-        assert_eq!(cfg, c)
-    }
-}

types/config/types/api_configuration.rs

@@ -1,24 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
-#[serde(rename_all = "camelCase")]
-pub struct ApiConfiguration {
-    pub default_version: String,
-    pub active_versions: Vec<String>,
-    pub endpoint_public: Option<String>,
-}
-
-impl Default for ApiConfiguration {
-    fn default() -> Self {
-        Self {
-            default_version: String::from("9"),
-            active_versions: vec![
-                String::from("6"),
-                String::from("7"),
-                String::from("8"),
-                String::from("9"),
-            ],
-            endpoint_public: None,
-        }
-    }
-}

types/config/types/cdn_configuration.rs

@@ -1,25 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct CdnConfiguration {
-    pub resize_height_max: u64,
-    pub resize_width_max: u64,
-    pub imagor_server_url: Option<String>,
-
-    pub endpoint_public: Option<String>,
-    pub endpoint_private: Option<String>,
-}
-
-impl Default for CdnConfiguration {
-    fn default() -> Self {
-        Self {
-            resize_height_max: 1000,
-            resize_width_max: 1000,
-            imagor_server_url: None,
-
-            endpoint_private: None,
-            endpoint_public: None,
-        }
-    }
-}

types/config/types/defaults_configuration.rs

@@ -1,10 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::config::types::subconfigs::defaults::{guild::GuildDefaults, user::UserDefaults};
-
-#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct DefaultsConfiguration {
-    pub guild: GuildDefaults,
-    pub user: UserDefaults,
-}

types/config/types/email_configuration.rs

@@ -1,27 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::config::types::subconfigs::email::{
-    mailgun::MailGunConfiguration, mailjet::MailJetConfiguration, sendgrid::SendGridConfiguration,
-    smtp::SMTPConfiguration,
-};
-
-#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
-pub enum EmailProvider {
-    Smtp,
-    MailGun,
-    MailJet,
-    SendGrid,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-#[derive(Default)]
-pub struct EmailConfiguration {
-    pub provider: Option<EmailProvider>,
-    pub smtp: SMTPConfiguration,
-    pub mailgun: MailGunConfiguration,
-    pub mailjet: MailJetConfiguration,
-    pub sendgrid: SendGridConfiguration,
-}
-
-

types/config/types/endpoint_configuration.rs

@@ -1,9 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct EndpointConfiguration {
-    pub endpoint_client: Option<String>,
-    pub endpoint_private: Option<String>,
-    pub endpoint_public: Option<String>,
-}

types/config/types/external_tokens_configuration.rs

@@ -1,7 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ExternalTokensConfiguration {
-    pub twitter: Option<String>,
-}

types/config/types/general_configuration.rs

@@ -1,35 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::utils::Snowflake;
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GeneralConfiguration {
-    pub instance_name: String,
-    pub instance_description: Option<String>,
-    pub front_page: Option<String>,
-    pub tos_page: Option<String>,
-    pub correspondence_email: Option<String>,
-    pub correspondence_user_id: Option<String>,
-    pub image: Option<String>,
-    pub instance_id: Option<Snowflake>,
-    pub auto_create_bot_users: Option<bool>,
-}
-
-impl Default for GeneralConfiguration {
-    fn default() -> Self {
-        Self {
-            instance_name: String::from("Spacebar Instance"),
-            instance_description: Some(String::from(
-                "This is a Spacebar instance made in the pre-release days",
-            )),
-            front_page: None,
-            tos_page: None,
-            correspondence_email: None,
-            correspondence_user_id: None,
-            image: None,
-            instance_id: Some(Snowflake::generate()),
-            auto_create_bot_users: Some(false),
-        }
-    }
-}

types/config/types/gif_configuration.rs

@@ -1,26 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum GifProvider {
-    #[default]
-    Tenor,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GifConfiguration {
-    pub enabled: bool,
-    pub provider: GifProvider,
-    pub api_key: Option<String>,
-}
-
-impl Default for GifConfiguration {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            provider: GifProvider::Tenor,
-            api_key: Some(String::from("LIVDSRZULELA")),
-        }
-    }
-}

types/config/types/guild_configuration.rs

@@ -1,126 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::config::types::subconfigs::guild::{
-    autojoin::AutoJoinConfiguration, discovery::DiscoverConfiguration,
-};
-
-#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
-#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
-pub enum GuildFeatures {
-    ActivitiesAlpha,
-    ActivitiesEmployee,
-    ActivitiesInternalDev,
-    AnimatedBanner,
-    AnimatedIcon,
-    ApplicationCommandPermissionsV2,
-    AutoModeration,
-    AutoModTriggerKeywordFilter,
-    AutoModTriggerMLSpamFilter,
-    AutoModTriggerSpamLinkFilter,
-    AutoModTriggerUserProfile,
-    Banner,
-    BFG,
-    BoostingTiersExperimentMediumGuild,
-    BoostingTiersExperimentSmallGuild,
-    BotDeveloperEarlyAccess,
-    BurstReactions,
-    CommunityCanary,
-    CommunityExpLargeGated,
-    CommunityExpLargeUngated,
-    CommunityExpMedium,
-    ChannelEmojisGenerated,
-    ChannelHighlights,
-    ChannelHighlightsDisabled,
-    ClydeEnabled,
-    ClydeExperimentEnabled,
-    ClydeDisabled,
-    Community,
-    CreatorAcceptedNewTerms,
-    CreatorMonetizable,
-    CreatorMonetizableDisabled,
-    CreatorMonetizablePendingNewOwnerOnboarding,
-    CreatorMonetizableProvisional,
-    CreatorMonetizableRestricted,
-    CreatorMonetizableWhiteglove,
-    CreatorMonetizableApplicationAllowlist,
-    CreateStorePage,
-    DeveloperSupportServer,
-    DiscoverableDisabled,
-    Discoverable,
-    EnabledDiscoverableBefore,
-    ExposedToActivitiesWTPExperiment,
-    GuestsEnabled,
-    GuildAutomodDefaultList,
-    GuildCommunicationDisabledGuilds,
-    GuildHomeDeprecationOverride,
-    GuildHomeOverride,
-    GuildHomeTest,
-    GuildMemberVerificationExperiment,
-    GuildOnboarding,
-    GuildOnboardingAdminOnly,
-    GuildOnboardingEverEnabled,
-    GuildOnboardingHasPrompts,
-    GuildRoleSubscription,
-    GuildRoleSubscriptionPurchaseFeedbackLoop,
-    GuildRoleSubscriptionTrials,
-    GuildServerGuide,
-    GuildWebPageVanityURL,
-    HadEarlyActivitiesAccess,
-    HasDirectoryEntry,
-    HideFromExperimentUI,
-    Hub,
-    IncreasedThreadLimit,
-    InternalEmployeeOnly,
-    InviteSplash,
-    InvitesDisabled,
-    LinkedToHub,
-    MarketplacesConnectionRoles,
-    MemberProfiles,
-    MemberVerificationGateEnabled,
-    MemberVerificationManualApproval,
-    MobileWebRoleSubscriptionPurchasePage,
-    MonetizationEnabled,
-    MoreEmoji,
-    MoreStickers,
-    News,
-    NewThreadPermissions,
-    Partnered,
-    PremiumTier3Override,
-    PreviewEnabled,
-    RaidAlertsDisabled,
-    RelayEnabled,
-    RestrictSpamRiskGuild,
-    RoleIcons,
-    RoleSubscriptionsAvailableForPurchase,
-    RoleSubscriptionsEnabled,
-    RoleSubscriptionsEnabledForPurchase,
-    Shard,
-    SharedCanvasFriendsAndFamilyTest,
-    Soundboard,
-    SummariesEnabled,
-    SummariesEnabledGA,
-    SummariesDisabledByUser,
-    SummariesEnabledByUser,
-    TextInStageEnabled,
-    TextInVoiceEnabled,
-    ThreadsEnabledTesting,
-    ThreadsEnabled,
-    ThreadDefaultAutoArchiveDuration,
-    ThreadsOnlyChannel,
-    TicketedEventsEnabled,
-    TicketingEnabled,
-    VanityUrls,
-    Verified,
-    VIPRegions,
-    VoiceChannelEffects,
-    WelcomeScreenEnabled,
-}
-
-#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GuildConfiguration {
-    pub discovery: DiscoverConfiguration,
-    pub auto_join: AutoJoinConfiguration,
-    #[serde(default)]
-    pub default_features: Vec<GuildFeatures>,
-}

types/config/types/kafka_configuration.rs

@@ -1,10 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::config::types::subconfigs::kafka::KafkaBroker;
-
-#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct KafkaConfiguration {
-    #[serde(default)]
-    pub brokers: Option<Vec<KafkaBroker>>,
-}

types/config/types/limit_configuration.rs

@@ -1,17 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::config::types::subconfigs::limits::{
-    channel::ChannelLimits, global::GlobalRateLimits, guild::GuildLimits, message::MessageLimits,
-    rates::RateLimits, user::UserLimits,
-};
-
-#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct LimitsConfiguration {
-    pub user: UserLimits,
-    pub guild: GuildLimits,
-    pub message: MessageLimits,
-    pub channel: ChannelLimits,
-    pub rate: RateLimits,
-    pub absolute_rate: GlobalRateLimits,
-}

types/config/types/login_configuration.rs

@@ -1,8 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct LoginConfiguration {
-    pub require_captcha: bool,
-    pub require_verification: bool,
-}

types/config/types/metrics_configuration.rs

@@ -1,13 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct MetricsConfiguration {
-    pub timeout: u64,
-}
-
-impl Default for MetricsConfiguration {
-    fn default() -> Self {
-        Self { timeout: 30000 }
-    }
-}

types/config/types/mod.rs

@@ -1,21 +0,0 @@
-pub mod api_configuration;
-pub mod cdn_configuration;
-pub mod defaults_configuration;
-pub mod email_configuration;
-pub mod endpoint_configuration;
-pub mod external_tokens_configuration;
-pub mod general_configuration;
-pub mod gif_configuration;
-pub mod guild_configuration;
-pub mod kafka_configuration;
-pub mod limit_configuration;
-pub mod login_configuration;
-pub mod metrics_configuration;
-pub mod password_reset_configuration;
-pub mod rabbit_mq_configuration;
-pub mod region_configuration;
-pub mod register_configuration;
-pub mod security_configuration;
-pub mod sentry_configuration;
-pub mod subconfigs;
-pub mod template_configuration;

types/config/types/password_reset_configuration.rs

@@ -1,7 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct PasswordResetConfiguration {
-    pub require_captcha: bool,
-}

types/config/types/rabbit_mq_configuration.rs

@@ -1,7 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct RabbitMQConfiguration {
-    pub host: Option<String>,
-}

types/config/types/region_configuration.rs

@@ -1,29 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::config::types::subconfigs::region::Region;
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct RegionConfiguration {
-    pub default: String,
-    pub use_default_as_optimal: bool,
-    pub available: Vec<Region>,
-}
-
-impl Default for RegionConfiguration {
-    fn default() -> Self {
-        Self {
-            default: String::from("spacebar"),
-            use_default_as_optimal: true,
-            available: vec![Region {
-                id: String::from("spacebar"),
-                name: String::from("spacebar"),
-                endpoint: String::from("127.0.0.1:3004"),
-                location: None,
-                vip: false,
-                custom: false,
-                deprecated: false,
-            }],
-        }
-    }
-}

types/config/types/register_configuration.rs

@@ -1,41 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::config::types::subconfigs::register::{
-    DateOfBirthConfiguration, PasswordConfiguration, RegistrationEmailConfiguration,
-};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct RegisterConfiguration {
-    pub email: RegistrationEmailConfiguration,
-    pub date_of_birth: DateOfBirthConfiguration,
-    pub password: PasswordConfiguration,
-    pub disabled: bool,
-    pub require_captcha: bool,
-    pub require_invite: bool,
-    pub guests_require_invite: bool,
-    pub allow_new_registration: bool,
-    pub allow_multiple_accounts: bool,
-    pub block_proxies: bool,
-    pub incrementing_discriminators: bool,
-    pub default_rights: String,
-}
-
-impl Default for RegisterConfiguration {
-    fn default() -> Self {
-        Self {
-            email: RegistrationEmailConfiguration::default(),
-            date_of_birth: DateOfBirthConfiguration::default(),
-            password: PasswordConfiguration::default(),
-            disabled: false,
-            require_captcha: true,
-            require_invite: false,
-            guests_require_invite: true,
-            allow_new_registration: true,
-            allow_multiple_accounts: true,
-            block_proxies: true,
-            incrementing_discriminators: false,
-            default_rights: String::from("875069521787904"),
-        }
-    }
-}

types/config/types/security_configuration.rs

@@ -1,42 +0,0 @@
-use base64::Engine;
-use serde::{Deserialize, Serialize};
-
-use crate::config::types::subconfigs::security::{CaptchaConfiguration, TwoFactorConfiguration};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SecurityConfiguration {
-    pub captcha: CaptchaConfiguration,
-    pub two_factor: TwoFactorConfiguration,
-    pub auto_update: bool,
-    pub request_signature: String,
-    pub jwt_secret: String,
-    pub forwarded_for: Option<String>,
-    pub ipdata_api_key: Option<String>,
-    pub mfa_backup_code_count: u8,
-    pub stats_world_readable: bool,
-    pub default_registration_token_expiration: u64,
-}
-
-impl Default for SecurityConfiguration {
-    fn default() -> Self {
-        let mut req_sig: [u8; 32] = [0; 32];
-        let _ = openssl::rand::rand_bytes(&mut req_sig);
-        let mut jwt_secret: [u8; 256] = [0; 256];
-        let _ = openssl::rand::rand_bytes(&mut jwt_secret);
-        Self {
-            captcha: Default::default(),
-            two_factor: Default::default(),
-            auto_update: true,
-            request_signature: base64::engine::general_purpose::STANDARD.encode(req_sig),
-            jwt_secret: base64::engine::general_purpose::STANDARD.encode(jwt_secret),
-            forwarded_for: None,
-            ipdata_api_key: Some(String::from(
-                "eca677b284b3bac29eb72f5e496aa9047f26543605efe99ff2ce35c9",
-            )),
-            mfa_backup_code_count: 10,
-            stats_world_readable: true,
-            default_registration_token_expiration: 1000 * 60 * 60 * 24 * 7,
-        }
-    }
-}

types/config/types/sentry_configuration.rs

@@ -1,28 +0,0 @@
-use std::ffi::OsString;
-
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SentryConfiguration {
-    pub enabled: bool,
-    pub endpoint: String,
-    pub trace_sample_rate: f64,
-    pub environment: String,
-}
-
-impl Default for SentryConfiguration {
-    fn default() -> Self {
-        Self {
-            enabled: false,
-            endpoint: String::from(
-                "https://241c6fb08adb469da1bb82522b25c99f@sentry.quartzinc.space/3",
-            ),
-            trace_sample_rate: 1.0,
-            environment: hostname::get()
-                .unwrap_or_else(|_| OsString::new())
-                .to_string_lossy()
-                .to_string(),
-        }
-    }
-}

types/config/types/subconfigs/client/mod.rs

@@ -1,17 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ClientReleaseConfiguration {
-    pub use_local_release: bool,
-    pub upstream_version: String,
-}
-
-impl Default for ClientReleaseConfiguration {
-    fn default() -> Self {
-        Self {
-            use_local_release: true,
-            upstream_version: String::from("0.0.264"),
-        }
-    }
-}

types/config/types/subconfigs/defaults/guild.rs

@@ -1,23 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GuildDefaults {
-    pub max_presences: u64,
-    pub max_video_channel_users: u16,
-    pub afk_timeout: u16,
-    pub default_message_notifications: u8,
-    pub explicit_content_filter: u8,
-}
-
-impl Default for GuildDefaults {
-    fn default() -> Self {
-        Self {
-            max_presences: 250_000,
-            max_video_channel_users: 200,
-            afk_timeout: 300,
-            default_message_notifications: 1,
-            explicit_content_filter: 0,
-        }
-    }
-}

types/config/types/subconfigs/defaults/mod.rs

@@ -1,2 +0,0 @@
-pub mod guild;
-pub mod user;

types/config/types/subconfigs/defaults/user.rs

@@ -1,19 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct UserDefaults {
-    pub premium: bool,
-    pub premium_type: u8,
-    pub verified: bool,
-}
-
-impl Default for UserDefaults {
-    fn default() -> Self {
-        Self {
-            premium: true,
-            premium_type: 2,
-            verified: true,
-        }
-    }
-}

types/config/types/subconfigs/email/mailgun.rs

@@ -1,8 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct MailGunConfiguration {
-    pub api_key: Option<String>,
-    pub domain: Option<String>,
-}

types/config/types/subconfigs/email/mailjet.rs

@@ -1,8 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct MailJetConfiguration {
-    pub api_key: Option<String>,
-    pub api_secret: Option<String>,
-}

types/config/types/subconfigs/email/mod.rs

@@ -1,4 +0,0 @@
-pub mod mailgun;
-pub mod mailjet;
-pub mod sendgrid;
-pub mod smtp;

types/config/types/subconfigs/email/sendgrid.rs

@@ -1,7 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SendGridConfiguration {
-    pub api_key: Option<String>,
-}

types/config/types/subconfigs/email/smtp.rs

@@ -1,10 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
-pub struct SMTPConfiguration {
-    pub host: Option<String>,
-    pub port: Option<u16>,
-    pub secure: bool,
-    pub username: Option<String>,
-    pub password: Option<String>,
-}

types/config/types/subconfigs/guild/autojoin.rs

@@ -1,22 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::utils::Snowflake;
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct AutoJoinConfiguration {
-    pub enabled: bool,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub guilds: Option<Vec<Snowflake>>,
-    pub can_leave: bool,
-}
-
-impl Default for AutoJoinConfiguration {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            guilds: None,
-            can_leave: true,
-        }
-    }
-}

types/config/types/subconfigs/guild/discovery.rs

@@ -1,21 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct DiscoverConfiguration {
-    pub show_all_guilds: bool,
-    pub use_recommendation: bool,
-    pub offset: u16,
-    pub limit: u16,
-}
-
-impl Default for DiscoverConfiguration {
-    fn default() -> Self {
-        Self {
-            show_all_guilds: false,
-            use_recommendation: false,
-            offset: 0,
-            limit: 24,
-        }
-    }
-}

types/config/types/subconfigs/guild/mod.rs

@@ -1,2 +0,0 @@
-pub mod autojoin;
-pub mod discovery;

types/config/types/subconfigs/kafka/mod.rs

@@ -1,7 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct KafkaBroker {
-    pub ip: String,
-    pub port: u16,
-}

types/config/types/subconfigs/limits/channel.rs

@@ -1,19 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ChannelLimits {
-    pub max_pins: u16,
-    pub max_topic: u16,
-    pub max_webhooks: u16,
-}
-
-impl Default for ChannelLimits {
-    fn default() -> Self {
-        Self {
-            max_pins: 500,
-            max_topic: 1024,
-            max_webhooks: 100,
-        }
-    }
-}

types/config/types/subconfigs/limits/global.rs

@@ -1,41 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct GlobalRateLimit {
-    pub limit: u16,
-    pub window: u64,
-    pub enabled: bool,
-}
-
-impl Default for GlobalRateLimit {
-    fn default() -> Self {
-        Self {
-            limit: 100,
-            window: 60 * 60 * 1000,
-            enabled: true,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GlobalRateLimits {
-    pub register: GlobalRateLimit,
-    pub send_message: GlobalRateLimit,
-}
-
-impl Default for GlobalRateLimits {
-    fn default() -> Self {
-        Self {
-            register: GlobalRateLimit {
-                limit: 25,
-                ..Default::default()
-            },
-            send_message: GlobalRateLimit {
-                limit: 200,
-                window: 60 * 1000,
-                ..Default::default()
-            },
-        }
-    }
-}

types/config/types/subconfigs/limits/guild.rs

@@ -1,23 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct GuildLimits {
-    pub max_roles: u16,
-    pub max_emojis: u16,
-    pub max_members: u64,
-    pub max_channels: u32,
-    pub max_channels_in_category: u32,
-}
-
-impl Default for GuildLimits {
-    fn default() -> Self {
-        Self {
-            max_roles: 1000,
-            max_emojis: 20_000,
-            max_members: 25_000_000,
-            max_channels: 65_535,
-            max_channels_in_category: 65_535,
-        }
-    }
-}

types/config/types/subconfigs/limits/message.rs

@@ -1,26 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct MessageLimits {
-    pub max_characters: u32,
-    #[serde(default)]
-    pub max_tts_characters: u32,
-    pub max_reactions: u32,
-    pub max_attachment_size: u64,
-    pub max_bulk_delete: u32,
-    pub max_embed_download_size: u64,
-}
-
-impl Default for MessageLimits {
-    fn default() -> Self {
-        Self {
-            max_characters: 1048576,
-            max_tts_characters: 160,
-            max_reactions: 2048,
-            max_attachment_size: 1024 * 1024 * 1024,
-            max_bulk_delete: 1000,
-            max_embed_download_size: 1024 * 1024 * 5,
-        }
-    }
-}

types/config/types/subconfigs/limits/mod.rs

@@ -1,7 +0,0 @@
-pub mod channel;
-pub mod global;
-pub mod guild;
-pub mod message;
-pub mod ratelimits;
-pub mod rates;
-pub mod user;

types/config/types/subconfigs/limits/ratelimits/auth.rs

@@ -1,28 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::config::types::subconfigs::limits::ratelimits::RateLimitOptions;
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct AuthRateLimit {
-    pub login: RateLimitOptions,
-    pub register: RateLimitOptions,
-}
-
-impl Default for AuthRateLimit {
-    fn default() -> Self {
-        Self {
-            login: RateLimitOptions {
-                bot: None,
-                count: 5,
-                window: 60,
-                only_ip: false,
-            },
-            register: RateLimitOptions {
-                bot: None,
-                count: 2,
-                window: 60 * 60 * 12,
-                only_ip: false,
-            },
-        }
-    }
-}

types/config/types/subconfigs/limits/ratelimits/mod.rs

@@ -1,14 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-pub mod auth;
-pub mod route;
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct RateLimitOptions {
-    pub bot: Option<u64>,
-    pub count: u64,
-    pub window: u64,
-    #[serde(default)]
-    pub only_ip: bool,
-}

types/config/types/subconfigs/limits/ratelimits/route.rs

@@ -1,37 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::config::types::subconfigs::limits::ratelimits::{auth::AuthRateLimit, RateLimitOptions};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct RouteRateLimit {
-    pub guild: RateLimitOptions,
-    pub webhook: RateLimitOptions,
-    pub channel: RateLimitOptions,
-    pub auth: AuthRateLimit,
-}
-
-impl Default for RouteRateLimit {
-    fn default() -> Self {
-        Self {
-            guild: RateLimitOptions {
-                bot: None,
-                count: 5,
-                window: 5,
-                only_ip: false,
-            },
-            webhook: RateLimitOptions {
-                bot: None,
-                count: 10,
-                window: 5,
-                only_ip: false,
-            },
-            channel: RateLimitOptions {
-                bot: None,
-                count: 10,
-                window: 5,
-                only_ip: false,
-            },
-            auth: AuthRateLimit::default(),
-        }
-    }
-}

types/config/types/subconfigs/limits/rates.rs

@@ -1,41 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::config::types::subconfigs::limits::ratelimits::{
-    route::RouteRateLimit, RateLimitOptions,
-};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct RateLimits {
-    pub enabled: bool,
-    pub ip: RateLimitOptions,
-    pub global: RateLimitOptions,
-    pub error: RateLimitOptions,
-    pub routes: RouteRateLimit,
-}
-
-impl Default for RateLimits {
-    fn default() -> Self {
-        Self {
-            enabled: false,
-            ip: RateLimitOptions {
-                bot: None,
-                count: 500,
-                window: 5,
-                only_ip: false,
-            },
-            global: RateLimitOptions {
-                bot: None,
-                count: 250,
-                window: 5,
-                only_ip: false,
-            },
-            error: RateLimitOptions {
-                bot: None,
-                count: 10,
-                window: 5,
-                only_ip: false,
-            },
-            routes: RouteRateLimit::default(),
-        }
-    }
-}

types/config/types/subconfigs/limits/user.rs

@@ -1,19 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct UserLimits {
-    pub max_guilds: u64,
-    pub max_username: u16,
-    pub max_friends: u64,
-}
-
-impl Default for UserLimits {
-    fn default() -> Self {
-        Self {
-            max_guilds: 1048576,
-            max_username: 32,
-            max_friends: 5000,
-        }
-    }
-}

types/config/types/subconfigs/mod.rs

@@ -1,9 +0,0 @@
-pub mod client;
-pub mod defaults;
-pub mod email;
-pub mod guild;
-pub mod kafka;
-pub mod limits;
-pub mod region;
-pub mod register;
-pub mod security;

types/config/types/subconfigs/region/mod.rs

@@ -1,21 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct LatLong {
-    pub latitude: f64,
-    pub longitude: f64,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct Region {
-    pub id: String,
-    pub name: String,
-    pub endpoint: String,
-    pub location: Option<LatLong>,
-    pub vip: bool,
-    pub custom: bool,
-    #[serde(default)]
-    pub deprecated: bool,
-}

types/config/types/subconfigs/register/date_of_birth.rs

@@ -1,16 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct DateOfBirthConfiguration {
-    pub required: bool,
-    pub minimum: u8,
-}
-
-impl Default for DateOfBirthConfiguration {
-    fn default() -> Self {
-        Self {
-            required: true,
-            minimum: 13,
-        }
-    }
-}

types/config/types/subconfigs/register/email.rs

@@ -1,21 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct RegistrationEmailConfiguration {
-    pub required: bool,
-    pub allowlist: bool,
-    #[serde(default)]
-    pub blacklist: bool,
-    #[serde(default)]
-    pub domains: Vec<String>,
-}
-impl Default for RegistrationEmailConfiguration {
-    fn default() -> Self {
-        Self {
-            required: false,
-            allowlist: false,
-            blacklist: true,
-            domains: Vec::new(),
-        }
-    }
-}

types/config/types/subconfigs/register/mod.rs

@@ -1,7 +0,0 @@
-mod date_of_birth;
-mod email;
-mod password;
-
-pub use date_of_birth::DateOfBirthConfiguration;
-pub use email::RegistrationEmailConfiguration;
-pub use password::PasswordConfiguration;

types/config/types/subconfigs/register/password.rs

@@ -1,23 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct PasswordConfiguration {
-    pub required: bool,
-    pub min_length: u8,
-    pub min_numbers: u8,
-    pub min_upper_case: u8,
-    pub min_symbols: u8,
-}
-
-impl Default for PasswordConfiguration {
-    fn default() -> Self {
-        Self {
-            required: false,
-            min_length: 8,
-            min_numbers: 2,
-            min_upper_case: 2,
-            min_symbols: 0,
-        }
-    }
-}

types/config/types/subconfigs/security/captcha.rs

@@ -1,27 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum CaptchaService {
-    Recaptcha,
-    HCaptcha,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct CaptchaConfiguration {
-    pub enabled: bool,
-    pub service: CaptchaService,
-    pub sitekey: Option<String>,
-    pub secret: Option<String>,
-}
-
-impl Default for CaptchaConfiguration {
-    fn default() -> Self {
-        Self {
-            enabled: false,
-            service: CaptchaService::HCaptcha,
-            sitekey: None,
-            secret: None,
-        }
-    }
-}

types/config/types/subconfigs/security/mod.rs

@@ -1,5 +0,0 @@
-mod captcha;
-mod twofactor;
-
-pub use captcha::{CaptchaConfiguration, CaptchaService};
-pub use twofactor::TwoFactorConfiguration;

types/config/types/subconfigs/security/twofactor.rs

@@ -1,15 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct TwoFactorConfiguration {
-    pub generate_backup_codes: bool,
-}
-
-impl Default for TwoFactorConfiguration {
-    fn default() -> Self {
-        Self {
-            generate_backup_codes: true,
-        }
-    }
-}

types/config/types/template_configuration.rs

@@ -1,21 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct TemplateConfiguration {
-    pub enabled: bool,
-    pub allow_template_creation: bool,
-    pub allow_discord_templates: bool,
-    pub allow_raws: bool,
-}
-
-impl Default for TemplateConfiguration {
-    fn default() -> Self {
-        Self {
-            enabled: true,
-            allow_template_creation: true,
-            allow_discord_templates: true,
-            allow_raws: true,
-        }
-    }
-}

types/entities/application.rs

@@ -1,140 +0,0 @@
-
-
-use crate::utils::Snowflake;
-use bitflags::{bitflags, Flags};
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-#[cfg(feature = "sqlx")]
-use sqlx::FromRow;
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[cfg_attr(feature = "sqlx", derive(FromRow))]
-pub struct Application {
-    pub id: Snowflake,
-    pub name: String,
-    pub icon: Option<String>,
-    pub description: Option<String>,
-    pub summary: Option<String>,
-    #[cfg(feature = "sqlx")]
-    pub r#type: Option<sqlx::types::Json<Value>>,
-    #[cfg(not(feature = "sqlx"))]
-    pub r#type: Option<Value>,
-    pub hook: bool,
-    pub bot_public: bool,
-    pub bot_require_code_grant: bool,
-    pub verify_key: String,
-    pub owner_id: Snowflake,
-    pub flags: u64,
-    #[cfg(feature = "sqlx")]
-    pub redirect_uris: Option<sqlx::types::Json<Vec<String>>>,
-    #[cfg(not(feature = "sqlx"))]
-    pub redirect_uris: Option<Vec<String>>,
-    pub rpc_application_state: i64,
-    pub store_application_state: i64,
-    pub verification_state: i64,
-    pub interactions_endpoint_url: Option<String>,
-    pub integration_public: bool,
-    pub integration_require_code_grant: bool,
-    pub discoverability_state: i64,
-    pub discovery_eligibility_flags: i64,
-    pub bot_user_id: Snowflake,
-    #[cfg(feature = "sqlx")]
-    pub tags: Option<sqlx::types::Json<Vec<String>>>,
-    #[cfg(not(feature = "sqlx"))]
-    pub tags: Option<Vec<String>>,
-    pub cover_image: Option<String>,
-    #[cfg(feature = "sqlx")]
-    pub install_params: Option<sqlx::types::Json<InstallParams>>,
-    #[cfg(not(feature = "sqlx"))]
-    pub install_params: Option<InstallParams>,
-    pub terms_of_service_url: Option<String>,
-    pub privacy_policy_url: Option<String>,
-    pub team_id: Option<Snowflake>,
-}
-
-impl Application {
-    pub fn flags(&self) -> ApplicationFlags {
-        ApplicationFlags::from_bits(self.flags.to_owned()).unwrap()
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct InstallParams {
-    pub scopes: Vec<String>,
-    pub permissions: String,
-}
-
-bitflags! {
-    #[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
-    pub struct ApplicationFlags: u64 {
-        const APPLICATION_AUTO_MODERATION_RULE_CREATE_BADGE = 1 << 6;
-        const GATEWAY_PRESENCE = 1 << 12;
-        const GATEWAY_PRESENCE_LIMITED = 1 << 13;
-        const GATEWAY_GUILD_MEMBERS = 1 << 14;
-        const GATEWAY_GUILD_MEMBERS_LIMITED = 1 << 15;
-        const VERIFICATION_PENDING_GUILD_LIMIT = 1 << 16;
-        const EMBEDDED = 1 << 17;
-        const GATEWAY_MESSAGE_CONTENT = 1 << 18;
-        const GATEWAY_MESSAGE_CONTENT_LIMITED = 1 << 19;
-        const APPLICATION_COMMAND_BADGE = 1 << 23;
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct ApplicationCommand {
-    pub id: Snowflake,
-    pub application_id: Snowflake,
-    pub name: String,
-    pub description: String,
-    pub options: Vec<ApplicationCommandOption>,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct ApplicationCommandOption {
-    pub r#type: ApplicationCommandOptionType,
-    pub name: String,
-    pub description: String,
-    pub required: bool,
-    pub choices: Vec<ApplicationCommandOptionChoice>,
-    pub options: Vec<ApplicationCommandOption>,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct ApplicationCommandOptionChoice {
-    pub name: String,
-    pub value: Value,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
-pub enum ApplicationCommandOptionType {
-    #[serde(rename = "SUB_COMMAND")]
-    SubCommand = 1,
-    #[serde(rename = "SUB_COMMAND_GROUP")]
-    SubCommandGroup = 2,
-    #[serde(rename = "STRING")]
-    String = 3,
-    #[serde(rename = "INTEGER")]
-    Integer = 4,
-    #[serde(rename = "BOOLEAN")]
-    Boolean = 5,
-    #[serde(rename = "USER")]
-    User = 6,
-    #[serde(rename = "CHANNEL")]
-    Channel = 7,
-    #[serde(rename = "ROLE")]
-    Role = 8,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct ApplicationCommandInteractionData {
-    pub id: Snowflake,
-    pub name: String,
-    pub options: Vec<ApplicationCommandInteractionDataOption>,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct ApplicationCommandInteractionDataOption {
-    pub name: String,
-    pub value: Value,
-    pub options: Vec<ApplicationCommandInteractionDataOption>,
-}

types/entities/attachment.rs

@@ -1,113 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::utils::Snowflake;
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct Attachment {
-    pub id: Snowflake,
-    pub filename: String,
-    pub description: Option<String>,
-    pub content_type: Option<String>,
-    pub size: u64,
-    pub url: String,
-    pub proxy_url: String,
-    pub height: Option<u64>,
-    pub width: Option<u64>,
-    pub message_id: Snowflake,
-    pub ephemeral: Option<bool>,
-    pub duration_secs: Option<f32>,
-    pub waveform: Option<String>,
-    #[serde(skip_serializing)]
-    pub content: Vec<u8>,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-
-pub struct PartialDiscordFileAttachment {
-    pub id: Option<i16>,
-    pub filename: String,
-    pub description: Option<String>,
-    pub content_type: Option<String>,
-    pub size: Option<i64>,
-    pub url: Option<String>,
-    pub proxy_url: Option<String>,
-    pub height: Option<i32>,
-    pub width: Option<i32>,
-    pub ephemeral: Option<bool>,
-    pub duration_secs: Option<f32>,
-    pub waveform: Option<String>,
-    #[serde(skip_serializing)]
-    pub content: Vec<u8>,
-}
-
-impl PartialDiscordFileAttachment {
-    /**
-    Moves `self.content` out of `self` and returns it.
-    # Returns
-    Vec<u8>
-     */
-    pub fn move_content(self) -> (Vec<u8>, PartialDiscordFileAttachment) {
-        let content = self.content;
-        let updated_struct = PartialDiscordFileAttachment {
-            id: self.id,
-            filename: self.filename,
-            description: self.description,
-            content_type: self.content_type,
-            size: self.size,
-            url: self.url,
-            proxy_url: self.proxy_url,
-            height: self.height,
-            width: self.width,
-            ephemeral: self.ephemeral,
-            duration_secs: self.duration_secs,
-            waveform: self.waveform,
-            content: Vec::new(),
-        };
-        (content, updated_struct)
-    }
-
-    pub fn move_filename(self) -> (String, PartialDiscordFileAttachment) {
-        let filename = self.filename;
-        let updated_struct = PartialDiscordFileAttachment {
-            id: self.id,
-            filename: String::new(),
-            description: self.description,
-            content_type: self.content_type,
-            size: self.size,
-            url: self.url,
-            proxy_url: self.proxy_url,
-            height: self.height,
-            width: self.width,
-
-            ephemeral: self.ephemeral,
-            duration_secs: self.duration_secs,
-            waveform: self.waveform,
-            content: self.content,
-        };
-        (filename, updated_struct)
-    }
-
-    pub fn move_content_type(self) -> (Option<String>, PartialDiscordFileAttachment) {
-        let content_type = self.content_type;
-        let updated_struct = PartialDiscordFileAttachment {
-            id: self.id,
-            filename: self.filename,
-            description: self.description,
-            content_type: None,
-            size: self.size,
-            url: self.url,
-            proxy_url: self.proxy_url,
-            height: self.height,
-            width: self.width,
-            ephemeral: self.ephemeral,
-            duration_secs: self.duration_secs,
-            waveform: self.waveform,
-            content: self.content,
-        };
-        (content_type, updated_struct)
-    }
-
-    pub fn set_id(&mut self, id: i16) {
-        self.id = Some(id);
-    }
-}

types/entities/channel.rs

@@ -1,116 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::{
-    entities::{GuildMember, User},
-    utils::Snowflake,
-};
-
-#[derive(Default, Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
-pub struct Channel {
-    pub id: Snowflake,
-    #[serde(rename = "type")]
-    pub channel_type: ChannelType,
-    pub guild_id: Option<String>,
-    pub position: Option<i32>,
-    pub permission_overwrites: Option<Vec<PermissionOverwrite>>,
-    pub name: Option<String>,
-    pub topic: Option<String>,
-    pub nsfw: Option<bool>,
-    pub last_message_id: Option<String>,
-    pub bitrate: Option<i32>,
-    pub user_limit: Option<i32>,
-    pub rate_limit_per_user: Option<i32>,
-    pub recipients: Option<Vec<User>>,
-    pub icon: Option<String>,
-    pub owner_id: Option<String>,
-    pub application_id: Option<String>,
-    pub parent_id: Option<String>,
-    pub last_pin_timestamp: Option<String>,
-    pub rtc_region: Option<String>,
-    pub video_quality_mode: Option<i32>,
-    pub message_count: Option<i32>,
-    pub member_count: Option<i32>,
-    pub thread_metadata: Option<ThreadMetadata>,
-    pub member: Option<ThreadMember>,
-    pub default_auto_archive_duration: Option<i32>,
-    pub permissions: Option<String>,
-    pub flags: Option<i32>,
-    pub total_message_sent: Option<i32>,
-    pub available_tags: Option<Vec<Tag>>,
-    pub applied_tags: Option<Vec<String>>,
-    pub default_reaction_emoji: Option<DefaultReaction>,
-    pub default_thread_rate_limit_per_user: Option<i32>,
-    pub default_sort_order: Option<i32>,
-    pub default_forum_layout: Option<i32>,
-}
-
-#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
-pub struct Tag {
-    pub id: u64,
-    pub name: String,
-    pub moderated: bool,
-    pub emoji_id: Option<u64>,
-    pub emoji_name: Option<String>,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
-pub struct PermissionOverwrite {
-    pub id: String,
-    #[serde(rename = "type")]
-    pub overwrite_type: u8,
-    pub allow: String,
-    pub deny: String,
-}
-
-#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
-pub struct ThreadMetadata {
-    pub archived: bool,
-    pub auto_archive_duration: i32,
-    pub archive_timestamp: String,
-    pub locked: bool,
-    pub invitable: Option<bool>,
-    pub create_timestamp: Option<String>,
-}
-
-#[derive(Default, Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
-pub struct ThreadMember {
-    pub id: Option<u64>,
-    pub user_id: Option<u64>,
-    pub join_timestamp: Option<String>,
-    pub flags: Option<u64>,
-    pub member: Option<GuildMember>,
-}
-
-#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
-pub struct DefaultReaction {
-    pub emoji_id: Option<String>,
-    pub emoji_name: Option<String>,
-}
-
-#[derive(Default, Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
-#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
-#[repr(i32)]
-pub enum ChannelType {
-    #[default]
-    GuildText = 0,
-    Dm = 1,
-    GuildVoice = 2,
-    GroupDm = 3,
-    GuildCategory = 4,
-    GuildNews = 5,
-    GuildStore = 6,
-    Encrypted = 7,
-    EncryptedThreads = 8,
-    Transactional = 9,
-    GuildNewsThread = 10,
-    GuildPublicThread = 11,
-    GuildPrivateThread = 12,
-    GuildStageVoice = 13,
-    Directory = 14,
-    GuildForum = 15,
-    TicketTracker = 33,
-    Kanban = 34,
-    VoicelessWhiteboard = 35,
-    CustomStart = 64,
-    Unhandled = 255,
-}

types/entities/config.rs

@@ -1,34 +0,0 @@
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-#[cfg(feature = "sqlx")]
-use sqlx::FromRow;
-
-#[derive(Debug, Serialize, Deserialize)]
-#[cfg_attr(feature = "sqlx", derive(FromRow))]
-pub struct ConfigEntity {
-    pub key: String,
-    pub value: Option<Value>,
-}
-
-impl ConfigEntity {
-    pub fn as_string(&self) -> Option<String> {
-        let Some(v) = self.value.as_ref() else {
-            return None;
-        };
-        Some(v.as_str().expect("value is not a string").to_string())
-    }
-
-    pub fn as_bool(&self) -> Option<bool> {
-        let Some(v) = self.value.as_ref() else {
-            return None;
-        };
-        Some(v.as_bool().expect("value is not a boolean"))
-    }
-
-    pub fn as_int(&self) -> Option<i64> {
-        let Some(v) = self.value.as_ref() else {
-            return None;
-        };
-        Some(v.as_i64().expect("value is not a number"))
-    }
-}

types/entities/emoji.rs

@@ -1,15 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::entities::User;
-
-#[derive(Debug, Deserialize, Serialize, Default, Clone)]
-pub struct Emoji {
-    pub id: Option<u64>,
-    pub name: Option<String>,
-    pub roles: Option<Vec<u64>>,
-    pub user: Option<User>,
-    pub require_colons: Option<bool>,
-    pub managed: Option<bool>,
-    pub animated: Option<bool>,
-    pub available: Option<bool>,
-}

types/entities/guild.rs

@@ -1,117 +0,0 @@
-use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
-
-use crate::{
-    entities::{Channel, Emoji, GuildTemplate, RoleObject, Sticker, User, VoiceState, Webhook},
-    interfaces::WelcomeScreenObject,
-    utils::Snowflake,
-};
-
-/// See https://discord.com/developers/docs/resources/guild
-#[derive(Serialize, Deserialize, Debug, Default, Clone)]
-pub struct Guild {
-    pub id: Snowflake,
-    pub name: String,
-    pub icon: Option<String>,
-    pub icon_hash: Option<String>,
-    pub splash: Option<String>,
-    pub discovery_splash: Option<String>,
-    pub owner: Option<User>,
-    pub owner_id: Option<Snowflake>,
-    pub permissions: Option<String>,
-    pub afk_channel_id: Option<Snowflake>,
-    pub afk_timeout: Option<u8>,
-    pub widget_enabled: Option<bool>,
-    pub widget_channel_id: Option<Snowflake>,
-    pub widget_channel: Option<Channel>,
-    pub verification_level: Option<u8>,
-    pub default_message_notifications: Option<u8>,
-    pub explicit_content_filter: Option<u8>,
-    pub roles: Vec<RoleObject>,
-    pub emojis: Vec<Emoji>,
-    pub features: Vec<String>,
-    pub application_id: Option<String>,
-    pub system_channel_id: Option<Snowflake>,
-    pub system_channel_flags: Option<u8>,
-    pub rules_channel_id: Option<String>,
-    pub rules_channel: Option<String>,
-    pub max_presences: Option<u64>,
-    pub max_members: Option<u64>,
-    pub vanity_url_code: Option<String>,
-    pub description: Option<String>,
-    pub banner: Option<String>,
-    pub premium_tier: Option<u8>,
-    pub premium_subscription_count: Option<u64>,
-    pub preferred_locale: Option<String>,
-    pub public_updates_channel_id: Option<Snowflake>,
-    pub public_updates_channel: Option<Channel>,
-    pub max_video_channel_users: Option<u8>,
-    pub max_stage_video_channel_users: Option<u8>,
-    pub approximate_member_count: Option<u64>,
-    pub approximate_presence_count: Option<u64>,
-    pub member_count: Option<u64>,
-    pub presence_count: Option<u64>,
-    pub welcome_screen: Option<WelcomeScreenObject>,
-    pub nsfw_level: u8,
-    pub nsfw: bool,
-    pub stickers: Option<Vec<Sticker>>,
-    pub premium_progress_bar_enabled: Option<bool>,
-    pub joined_at: String,
-    pub afk_channel: Option<Channel>,
-    pub bans: Option<Vec<GuildBan>>,
-    pub primary_category_id: Option<Snowflake>,
-    pub large: Option<bool>,
-    pub channels: Option<Vec<Channel>>,
-    pub template_id: Option<Snowflake>,
-    pub template: Option<GuildTemplate>,
-    pub invites: Option<Vec<GuildInvite>>,
-    pub voice_states: Option<Vec<VoiceState>>,
-    pub webhooks: Option<Vec<Webhook>>,
-    pub mfa_level: Option<u8>,
-    pub region: Option<String>,
-    pub unavailable: bool,
-    pub parent: Option<String>,
-}
-
-/// See https://docs.spacebar.chat/routes/#get-/guilds/-guild_id-/bans/-user-
-#[derive(Serialize, Deserialize, Debug, Default, Clone)]
-pub struct GuildBan {
-    pub id: Snowflake,
-    pub user_id: Snowflake,
-    pub guild_id: Snowflake,
-    pub executor_id: Snowflake,
-    pub reason: Option<String>,
-}
-
-/// See https://docs.spacebar.chat/routes/#cmp--schemas-invite
-#[derive(Serialize, Deserialize, Debug, Default, Clone)]
-pub struct GuildInvite {
-    pub code: String,
-    pub temporary: Option<bool>,
-    pub uses: Option<i32>,
-    pub max_uses: Option<i32>,
-    pub max_age: Option<i32>,
-    pub created_at: DateTime<Utc>,
-    pub expires_at: Option<DateTime<Utc>>,
-    pub guild_id: String,
-    pub guild: Option<Guild>,
-    pub channel_id: String,
-    pub channel: Option<Channel>,
-    pub inviter_id: Option<String>,
-    pub inviter: Option<User>,
-    pub target_user_id: Option<String>,
-    pub target_user: Option<String>,
-    pub target_user_type: Option<i32>,
-    pub vanity_url: Option<bool>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Default)]
-pub struct UnavailableGuild {
-    id: String,
-    unavailable: bool,
-}
-
-#[derive(Serialize, Deserialize, Debug, Default, Clone)]
-pub struct GuildCreateResponse {
-    pub id: String,
-}

types/entities/guild_member.rs

@@ -1,19 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::entities::User;
-
-#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq)]
-pub struct GuildMember {
-    pub user: Option<User>,
-    pub nick: Option<String>,
-    pub avatar: Option<String>,
-    pub roles: Vec<String>,
-    pub joined_at: String,
-    pub premium_since: Option<String>,
-    pub deaf: bool,
-    pub mute: bool,
-    pub flags: i32,
-    pub pending: Option<bool>,
-    pub permissions: Option<String>,
-    pub communication_disabled_until: Option<String>,
-}

types/entities/integration.rs

@@ -1,36 +0,0 @@
-use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
-
-use crate::{
-    entities::{Application, User},
-    utils::Snowflake,
-};
-
-#[derive(Default, Debug, Deserialize, Serialize, Clone)]
-/// See https://discord.com/developers/docs/resources/guild#integration-object-integration-structure
-pub struct Integration {
-    pub id: Snowflake,
-    pub name: String,
-    #[serde(rename = "type")]
-    pub integration_type: String,
-    pub enabled: bool,
-    pub syncing: Option<bool>,
-    pub role_id: Option<String>,
-    pub enabled_emoticons: Option<bool>,
-    pub expire_behaviour: Option<u8>,
-    pub expire_grace_period: Option<u16>,
-    pub user: Option<User>,
-    pub account: IntegrationAccount,
-    pub synced_at: Option<DateTime<Utc>>,
-    pub subscriber_count: Option<f64>,
-    pub revoked: Option<bool>,
-    pub application: Option<Application>,
-    pub scopes: Option<Vec<String>>,
-}
-
-#[derive(Default, Debug, Deserialize, Serialize, Clone)]
-/// See https://discord.com/developers/docs/resources/guild#integration-account-object-integration-account-structure
-pub struct IntegrationAccount {
-    pub id: String,
-    pub name: String,
-}

types/entities/message.rs

@@ -1,185 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::{
-    entities::{
-        Application, Attachment, Channel, Emoji, GuildMember, RoleSubscriptionData, Sticker,
-        StickerItem, User,
-    },
-    utils::Snowflake,
-};
-
-#[derive(Debug, Serialize, Deserialize, Default)]
-pub struct Message {
-    id: Snowflake,
-    pub channel_id: Snowflake,
-    author: User,
-    content: String,
-    timestamp: String,
-    edited_timestamp: Option<String>,
-    tts: bool,
-    mention_everyone: bool,
-    mentions: Vec<User>,
-    mention_roles: Vec<String>,
-    mention_channels: Option<Vec<ChannelMention>>,
-    pub attachments: Vec<Attachment>,
-    embeds: Vec<Embed>,
-    reactions: Option<Vec<Reaction>>,
-    nonce: Option<serde_json::Value>,
-    pinned: bool,
-    webhook_id: Option<String>,
-    #[serde(rename = "type")]
-    message_type: i32,
-    activity: Option<MessageActivity>,
-    application: Option<Application>,
-    application_id: Option<String>,
-    message_reference: Option<MessageReference>,
-    flags: Option<i32>,
-    referenced_message: Option<Box<Message>>,
-    interaction: Option<MessageInteraction>,
-    thread: Option<Channel>,
-    components: Option<Vec<Component>>,
-    sticker_items: Option<Vec<StickerItem>>,
-    stickers: Option<Vec<Sticker>>,
-    position: Option<i32>,
-    role_subscription_data: Option<RoleSubscriptionData>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct MessageReference {
-    pub message_id: Snowflake,
-    pub channel_id: Snowflake,
-    pub guild_id: Option<Snowflake>,
-    pub fail_if_not_exists: Option<bool>,
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-pub struct MessageInteraction {
-    pub id: Snowflake,
-    #[serde(rename = "type")]
-    pub interaction_type: u8,
-    pub name: String,
-    pub user: User,
-    pub member: Option<GuildMember>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct AllowedMention {
-    parse: Vec<AllowedMentionType>,
-    roles: Vec<Snowflake>,
-    users: Vec<Snowflake>,
-    replied_user: bool,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum AllowedMentionType {
-    Roles,
-    Users,
-    Everyone,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct ChannelMention {
-    id: Snowflake,
-    guild_id: Snowflake,
-    #[serde(rename = "type")]
-    channel_type: i32,
-    name: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Embed {
-    title: Option<String>,
-    #[serde(rename = "type")]
-    embed_type: Option<String>,
-    description: Option<String>,
-    url: Option<String>,
-    timestamp: Option<String>,
-    color: Option<i32>,
-    footer: Option<EmbedFooter>,
-    image: Option<EmbedImage>,
-    thumbnail: Option<EmbedThumbnail>,
-    video: Option<EmbedVideo>,
-    provider: Option<EmbedProvider>,
-    author: Option<EmbedAuthor>,
-    fields: Option<Vec<EmbedField>>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct EmbedFooter {
-    text: String,
-    icon_url: Option<String>,
-    proxy_icon_url: Option<String>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct EmbedImage {
-    url: String,
-    proxy_url: String,
-    height: Option<i32>,
-    width: Option<i32>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct EmbedThumbnail {
-    url: String,
-    proxy_url: Option<String>,
-    height: Option<i32>,
-    width: Option<i32>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct EmbedVideo {
-    url: Option<String>,
-    proxy_url: Option<String>,
-    height: Option<i32>,
-    width: Option<i32>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct EmbedProvider {
-    name: Option<String>,
-    url: Option<String>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct EmbedAuthor {
-    name: String,
-    url: Option<String>,
-    icon_url: Option<String>,
-    proxy_icon_url: Option<String>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-
-struct EmbedField {
-    name: String,
-    value: String,
-    inline: Option<bool>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Reaction {
-    pub count: i32,
-    pub me: bool,
-    pub emoji: Emoji,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub enum Component {
-    ActionRow = 1,
-    Button = 2,
-    StringSelect = 3,
-    TextInput = 4,
-    UserSelect = 5,
-    RoleSelect = 6,
-    MentionableSelect = 7,
-    ChannelSelect = 8,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct MessageActivity {
-    #[serde(rename = "type")]
-    pub activity_type: i64,
-    pub party_id: Option<String>,
-}

types/entities/mod.rs

@@ -1,37 +0,0 @@
-mod application;
-mod attachment;
-mod channel;
-mod config;
-mod emoji;
-mod guild;
-mod guild_member;
-mod integration;
-mod message;
-mod role;
-mod security_key;
-mod sticker;
-mod team;
-mod template;
-mod user;
-mod user_settings;
-mod voice_state;
-mod webhook;
-
-pub use application::*;
-pub use attachment::*;
-pub use channel::*;
-pub use config::*;
-pub use emoji::*;
-pub use guild::*;
-pub use guild_member::*;
-pub use integration::*;
-pub use message::*;
-pub use role::*;
-pub use security_key::*;
-pub use sticker::*;
-pub use team::*;
-pub use template::*;
-pub use user::*;
-pub use user_settings::*;
-pub use voice_state::*;
-pub use webhook::*;

types/entities/role.rs

@@ -1,28 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::utils::Snowflake;
-
-#[derive(Serialize, Deserialize, Debug, Default, Clone)]
-/// See https://discord.com/developers/docs/topics/permissions#role-object
-pub struct RoleObject {
-    pub id: Snowflake,
-    pub name: String,
-    pub color: f64,
-    pub hoist: bool,
-    pub icon: Option<String>,
-    pub unicode_emoji: Option<String>,
-    pub position: u16,
-    pub permissions: String,
-    pub managed: bool,
-    pub mentionable: bool,
-    // to:do add role tags https://discord.com/developers/docs/topics/permissions#role-object-role-tags-structure
-    //pub tags: Option<RoleTags>
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct RoleSubscriptionData {
-    pub role_subscription_listing_id: Snowflake,
-    pub tier_name: String,
-    pub total_months_subscribed: u32,
-    pub is_renewal: bool,
-}

types/entities/security_key.rs

@@ -1,26 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::utils::Snowflake;
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct SecurityKey {
-    pub id: String,
-    pub user_id: String,
-    pub key_id: String,
-    pub public_key: String,
-    pub counter: u64,
-    pub name: String,
-}
-
-impl Default for SecurityKey {
-    fn default() -> Self {
-        Self {
-            id: Snowflake::generate().to_string(),
-            user_id: String::new(),
-            key_id: String::new(),
-            public_key: String::new(),
-            counter: 0,
-            name: String::new(),
-        }
-    }
-}

types/entities/sticker.rs

@@ -1,27 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::{entities::User, utils::Snowflake};
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-pub struct Sticker {
-    pub id: Snowflake,
-    pub pack_id: Option<Snowflake>,
-    pub name: String,
-    pub description: Option<String>,
-    pub tags: String,
-    pub asset: Option<String>,
-    #[serde(rename = "type")]
-    pub sticker_type: u8,
-    pub format_type: u8,
-    pub available: Option<bool>,
-    pub guild_id: Option<u64>,
-    pub user: Option<User>,
-    pub sort_value: Option<u8>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct StickerItem {
-    pub id: Snowflake,
-    pub name: String,
-    pub format_type: u8,
-}

types/entities/team.rs

@@ -1,20 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::entities::User;
-
-#[derive(Debug, Deserialize, Serialize, Clone)]
-pub struct Team {
-    pub icon: Option<String>,
-    pub id: u64,
-    pub members: Vec<TeamMember>,
-    pub name: String,
-    pub owner_user_id: u64,
-}
-
-#[derive(Debug, Deserialize, Serialize, Clone)]
-pub struct TeamMember {
-    pub membership_state: u8,
-    pub permissions: Vec<String>,
-    pub team_id: u64,
-    pub user: User,
-}

types/entities/template.rs

@@ -1,24 +0,0 @@
-use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
-
-use crate::{
-    entities::{Guild, User},
-    utils::Snowflake,
-};
-
-/// See https://docs.spacebar.chat/routes/#cmp--schemas-template
-#[derive(Serialize, Deserialize, Debug, Default, Clone)]
-pub struct GuildTemplate {
-    pub code: String,
-    pub name: String,
-    pub description: Option<String>,
-    pub usage_count: Option<u64>,
-    pub creator_id: Snowflake,
-    pub creator: User,
-    pub created_at: DateTime<Utc>,
-    pub updated_at: DateTime<Utc>,
-    pub source_guild_id: String,
-    pub source_guild: Vec<Guild>, // Unsure how a {recursive: Guild} looks like, might be a Vec?
-    pub serialized_source_guild: Vec<Guild>,
-    id: Snowflake,
-}

types/entities/user.rs

@@ -1,112 +0,0 @@
-use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
-use serde_json::{Map, Value};
-#[cfg(feature = "sqlx")]
-use sqlx::{FromRow, Type};
-
-use crate::{
-    errors::Error,
-    utils::Snowflake, //util::{email::adjust_email, entities::user_setting::UserSettings},
-};
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
-#[cfg_attr(feature = "sqlx", derive(Type))]
-pub struct UserData {
-    pub valid_tokens_since: DateTime<Utc>,
-    pub hash: Option<String>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Default, Clone)]
-pub struct User {
-    pub id: String,
-    username: String,
-    discriminator: String,
-    avatar: Option<String>,
-    bot: bool,
-    system: Option<bool>,
-    mfa_enabled: Option<bool>,
-    accent_color: Option<String>,
-    locale: Option<String>,
-    verified: Option<bool>,
-    email: Option<String>,
-    flags: String,
-    premium_since: Option<String>,
-    premium_type: i8,
-    pronouns: Option<String>,
-    public_flags: Option<i8>,
-    banner: Option<String>,
-    bio: String,
-    theme_colors: Option<Vec<i32>>,
-    phone: Option<String>,
-    nsfw_allowed: bool,
-    premium: bool,
-    purchased_flags: i32,
-    premium_usage_flags: i32,
-    disabled: Option<bool>,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct User {
-    pub id: Snowflake,
-    pub username: String,
-    pub discriminator: String,
-    pub avatar: Option<String>,
-    pub accent_color: Option<u8>,
-    pub banner: Option<String>,
-    pub theme_colors: Option<Vec<u8>>,
-    pub pronouns: Option<String>,
-    pub bot: bool,
-    pub bio: String,
-    pub premium_type: u8,
-    pub premium_since: Option<DateTime<Utc>>,
-    pub public_flags: u16,
-}
-
-impl From<User> for PublicUser {
-    fn from(value: User) -> Self {
-        Self {
-            id: value.id,
-            username: value.username,
-            discriminator: value.discriminator,
-            avatar: value.avatar,
-            accent_color: value.accent_color,
-            banner: value.banner,
-            theme_colors: value.theme_colors,
-            pronouns: value.pronouns,
-            bot: value.bot,
-            bio: value.bio,
-            premium_type: value.premium_type,
-            premium_since: value.premium_since,
-            public_flags: value.public_flags,
-        }
-    }
-}
-
-const CUSTOM_USER_FLAG_OFFSET: u64 = 1 << 32;
-
-bitflags::bitflags! {
-    #[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
-    #[cfg_attr(feature = "sqlx", derive(Type))]
-    pub struct UserFlags: u64 {
-        const DISCORD_EMPLOYEE = 1 << 0;
-        const PARTNERED_SERVER_OWNER = 1 << 1;
-        const HYPESQUAD_EVENTS = 1 << 2;
-        const BUGHUNTER_LEVEL_1 =1 << 3;
-        const MFA_SMS = 1 << 4;
-        const PREMIUM_PROMO_DISMISSED = 1 << 5;
-        const HOUSE_BRAVERY = 1 << 6;
-        const HOUSE_BRILLIANCE = 1 << 7;
-        const HOUSE_BALANCE = 1 << 8;
-        const EARLY_SUPPORTER = 1 << 9;
-        const TEAM_USER = 1 << 10;
-        const TRUST_AND_SAFETY = 1 << 11;
-        const SYSTEM = 1 << 12;
-        const HAS_UNREAD_URGENT_MESSAGES = 1 << 13;
-        const BUGHUNTER_LEVEL_2 = 1 << 14;
-        const UNDERAGE_DELETED = 1 << 15;
-        const VERIFIED_BOT = 1 << 16;
-        const EARLY_VERIFIED_BOT_DEVELOPER = 1 << 17;
-        const CERTIFIED_MODERATOR = 1 << 18;
-        const BOT_HTTP_INTERACTIONS = 1 << 19;
-    }
-}

types/entities/user_settings.rs

@@ -1,133 +0,0 @@
-use chrono::{serde::ts_milliseconds_option, Utc};
-use serde::{Deserialize, Serialize};
-
-use crate::utils::Snowflake;
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
-#[serde(rename_all = "lowercase")]
-pub enum UserStatus {
-    #[default]
-    Online,
-    Offline,
-    Dnd,
-    Idle,
-    Invisible,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
-#[serde(rename_all = "lowercase")]
-pub enum UserTheme {
-    #[default]
-    Dark,
-    Light,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct UserSettings {
-    #[serde(skip_serializing)]
-    pub index: String, // Database relevance only
-    pub afk_timeout: u16,
-    pub allow_accessibility_detection: bool,
-    pub animate_emoji: bool,
-    pub animate_stickers: u8,
-    pub contact_sync_enabled: bool,
-    pub convert_emoticons: bool,
-    pub custom_status: Option<CustomStatus>,
-    pub default_guilds_restricted: bool,
-    pub detect_platform_accounts: bool,
-    pub developer_mode: bool,
-    pub disable_games_tab: bool,
-    pub enable_tts_command: bool,
-    pub explicit_content_filter: u8,
-    pub friend_source_flags: FriendSourceFlags,
-    pub gateway_connected: bool,
-    pub gif_auto_play: bool,
-    pub guild_folders: Vec<GuildFolder>,
-    pub guild_positions: Vec<String>,
-    pub inline_attachment_media: bool,
-    pub inline_embed_media: bool,
-    pub locale: String,
-    pub message_display_compact: bool,
-    pub native_phone_integration_enabled: bool,
-    pub render_embeds: bool,
-    pub render_reactions: bool,
-    pub restricted_guilds: Vec<String>,
-    pub show_current_game: bool,
-    pub status: UserStatus,
-    pub stream_notifications_enabled: bool,
-    pub theme: UserTheme,
-    pub timezone_offset: i16,
-}
-
-impl Default for UserSettings {
-    fn default() -> Self {
-        Self {
-            index: Snowflake::generate().to_string(),
-            afk_timeout: 3600,
-            allow_accessibility_detection: true,
-            animate_emoji: true,
-            animate_stickers: 0,
-            contact_sync_enabled: false,
-            convert_emoticons: false,
-            custom_status: None,
-            default_guilds_restricted: false,
-            detect_platform_accounts: false,
-            developer_mode: true,
-            disable_games_tab: true,
-            enable_tts_command: false,
-            explicit_content_filter: 0,
-            friend_source_flags: FriendSourceFlags::default(),
-            gateway_connected: false,
-            gif_auto_play: false,
-            guild_folders: Vec::new(),
-            guild_positions: Vec::new(),
-            inline_attachment_media: true,
-            inline_embed_media: true,
-            locale: "en-US".to_string(),
-            message_display_compact: false,
-            native_phone_integration_enabled: true,
-            render_embeds: true,
-            render_reactions: true,
-            restricted_guilds: Vec::new(),
-            show_current_game: true,
-            status: UserStatus::Online,
-            stream_notifications_enabled: false,
-            theme: UserTheme::Dark,
-            timezone_offset: 0,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct CustomStatus {
-    pub emoji_id: Option<String>,
-    pub emoji_name: Option<String>,
-    #[serde(with = "ts_milliseconds_option")]
-    pub expires_at: Option<chrono::DateTime<Utc>>,
-    pub text: Option<String>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct FriendSourceFlags {
-    pub all: bool,
-}
-
-impl Default for FriendSourceFlags {
-    fn default() -> Self {
-        Self { all: true }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct GuildFolder {
-    pub color: u32,
-    pub guild_ids: Vec<String>,
-    pub id: u16,
-    pub name: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct LoginResult {
-    pub token: String,
-    pub settings: UserSettings,
-}

types/entities/voice_state.rs

@@ -1,30 +0,0 @@
-use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
-
-use crate::{
-    entities::{Channel, Guild, GuildMember, User},
-    utils::Snowflake,
-};
-
-/// See https://docs.spacebar.chat/routes/#cmp--schemas-voicestate
-#[derive(Serialize, Deserialize, Debug, Default, Clone)]
-pub struct VoiceState {
-    pub guild_id: Snowflake,
-    pub guild: Option<Guild>,
-    pub channel_id: Snowflake,
-    pub channel: Option<Channel>,
-    pub user_id: Snowflake,
-    pub user: Option<User>,
-    pub member: Option<GuildMember>,
-    pub session_id: Snowflake,
-    pub token: String,
-    pub deaf: bool,
-    pub mute: bool,
-    pub self_deaf: bool,
-    pub self_mute: bool,
-    pub self_stream: Option<bool>,
-    pub self_video: bool,
-    pub suppress: bool,
-    pub request_to_speak_timestamp: Option<DateTime<Utc>>,
-    pub id: Snowflake,
-}

types/entities/webhook.rs

@@ -1,32 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::{
-    entities::{Application, Channel, Guild, User},
-    utils::Snowflake,
-};
-
-/// See https://docs.spacebar.chat/routes/#cmp--schemas-webhook
-#[derive(Serialize, Deserialize, Debug, Default, Clone)]
-pub struct Webhook {
-    #[serde(rename = "type")]
-    pub webhook_type: i32,
-    pub name: String,
-    pub avatar: String,
-    pub token: String,
-    pub guild_id: Snowflake,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub guild: Option<Guild>,
-    pub channel_id: Snowflake,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub channel: Option<Channel>,
-    pub application_id: Snowflake,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub application: Option<Application>,
-    pub user_id: Snowflake,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub user: Option<User>,
-    pub source_guild_id: Snowflake,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub source_guild: Option<Guild>,
-    pub id: Snowflake,
-}

types/errors.rs

@@ -1,54 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, thiserror::Error)]
-pub enum Error {
-    #[cfg(feature = "sqlx")]
-    #[error("SQLX error: {0}")]
-    SQLX(#[from] sqlx::Error),
-
-    #[error("serde: {0}")]
-    Serde(#[from] serde_json::Error),
-
-    #[error(transparent)]
-    IO(#[from] std::io::Error),
-
-    #[error(transparent)]
-    FieldFormat(#[from] FieldFormatError),
-}
-
-#[derive(Debug, PartialEq, Eq, thiserror::Error)]
-pub enum FieldFormatError {
-    #[error("Password must be between 1 and 72 characters.")]
-    PasswordError,
-    #[error("Username must be between 2 and 32 characters.")]
-    UsernameError,
-    #[error("Consent must be 'true' to register.")]
-    ConsentError,
-    #[error("The provided email address is in an invalid format.")]
-    EmailError,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct ErrorResponse {
-    pub code: i32,
-    pub message: String,
-    pub errors: IntermittentError,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct IntermittentError {
-    #[serde(flatten)]
-    pub errors: std::collections::HashMap<String, ErrorField>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Default)]
-pub struct ErrorField {
-    #[serde(default)]
-    pub _errors: Vec<APIError>,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-pub struct APIError {
-    pub message: String,
-    pub code: String,
-}

types/events/channel.rs

@@ -1,41 +0,0 @@
-use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
-use crate::entities::Channel;
-use crate::events::WebSocketEvent;
-
-#[derive(Debug, Default, Deserialize, Serialize)]
-/// See https://discord.com/developers/docs/topics/gateway-events#channel-pins-update
-pub struct ChannelPinsUpdate {
-    pub guild_id: Option<String>,
-    pub channel_id: String,
-    pub last_pin_timestamp: Option<DateTime<Utc>>,
-}
-
-impl WebSocketEvent for ChannelPinsUpdate {}
-
-#[derive(Debug, Default, Deserialize, Serialize)]
-/// See https://discord.com/developers/docs/topics/gateway-events#channel-create
-/// Not directly serialized, as the inner payload is a channel object
-pub struct ChannelCreate {
-    pub channel: Channel,
-}
-
-impl WebSocketEvent for ChannelCreate {}
-
-#[derive(Debug, Default, Deserialize, Serialize)]
-/// See https://discord.com/developers/docs/topics/gateway-events#channel-update
-/// Not directly serialized, as the inner payload is a channel object
-pub struct ChannelUpdate {
-    pub channel: Channel,
-}
-
-impl WebSocketEvent for ChannelUpdate {}
-
-#[derive(Debug, Default, Deserialize, Serialize)]
-/// See https://discord.com/developers/docs/topics/gateway-events#channel-delete
-/// Not directly serialized, as the inner payload is a channel object
-pub struct ChannelDelete {
-    pub channel: Channel,
-}
-
-impl WebSocketEvent for ChannelDelete {}

types/events/guild.rs

@@ -1,41 +0,0 @@
-use serde::{Deserialize, Serialize};
-use crate::entities::{Guild, UnavailableGuild, User};
-use crate::events::WebSocketEvent;
-
-#[derive(Debug, Deserialize, Serialize, Default)]
-/// See https://discord.com/developers/docs/topics/gateway-events#guild-create
-/// This one is particularly painful, it can be a Guild object with extra field or an unavailbile guild object
-pub struct GuildCreate {
-    pub d: GuildCreateDataOption,
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-pub enum GuildCreateDataOption {
-    UnavailableGuild(UnavailableGuild),
-    Guild(Guild),
-}
-
-impl Default for GuildCreateDataOption {
-    fn default() -> Self {
-        GuildCreateDataOption::UnavailableGuild(UnavailableGuild::default())
-    }
-}
-impl WebSocketEvent for GuildCreate {}
-
-#[derive(Debug, Default, Deserialize, Serialize)]
-/// See https://discord.com/developers/docs/topics/gateway-events#guild-ban-add-guild-ban-add-event-fields
-pub struct GuildBanAdd {
-    pub guild_id: String,
-    pub user: User,
-}
-
-impl WebSocketEvent for GuildBanAdd {}
-
-#[derive(Debug, Default, Deserialize, Serialize)]
-/// See https://discord.com/developers/docs/topics/gateway-events#guild-ban-remove
-pub struct GuildBanRemove {
-    pub guild_id: String,
-    pub user: User,
-}
-
-impl WebSocketEvent for GuildBanRemove {}

types/events/heartbeat.rs

@@ -1,17 +0,0 @@
-use serde::{Deserialize, Serialize};
-use crate::events::WebSocketEvent;
-
-#[derive(Debug, Default, Deserialize, Serialize)]
-pub struct GatewayHeartbeat {
-    pub op: u8,
-    pub d: Option<u64>,
-}
-
-impl WebSocketEvent for GatewayHeartbeat {}
-
-#[derive(Debug, Default, Deserialize, Serialize)]
-pub struct GatewayHeartbeatAck {
-    pub op: i32,
-}
-
-impl WebSocketEvent for GatewayHeartbeatAck {}

types/events/hello.rs

@@ -1,17 +0,0 @@
-use serde::{Deserialize, Serialize};
-use crate::events::WebSocketEvent;
-
-#[derive(Debug, Default, Deserialize, Serialize)]
-pub struct GatewayHello {
-    pub op: i32,
-    pub d: HelloData,
-}
-
-impl WebSocketEvent for GatewayHello {}
-
-#[derive(Debug, Default, Deserialize, Serialize)]
-pub struct HelloData {
-    pub heartbeat_interval: u128,
-}
-
-impl WebSocketEvent for HelloData {}

types/events/identify.rs

@@ -1,22 +0,0 @@
-use serde::{Deserialize, Serialize};
-use crate::events::{PresenceUpdate, WebSocketEvent};
-
-#[derive(Debug, Deserialize, Serialize, Default)]
-pub struct GatewayIdentifyPayload {
-    pub token: String,
-    pub properties: GatewayIdentifyConnectionProps,
-    pub compress: Option<bool>,
-    pub large_threshold: Option<i16>, //default: 50
-    pub shard: Option<Vec<(i32, i32)>>,
-    pub presence: Option<PresenceUpdate>,
-    pub intents: i32,
-}
-
-impl WebSocketEvent for GatewayIdentifyPayload {}
-
-#[derive(Debug, Deserialize, Serialize, Default)]
-pub struct GatewayIdentifyConnectionProps {
-    pub os: String,
-    pub browser: String,
-    pub device: String,
-}

types/events/message.rs

@@ -1,101 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::{
-    entities::{Emoji, GuildMember, Message, User},
-    utils::Snowflake,
-};
-
-use super::WebSocketEvent;
-
-#[derive(Debug, Deserialize, Serialize, Default)]
-pub struct TypingStartEvent {
-    pub channel_id: String,
-    pub guild_id: Option<String>,
-    pub user_id: String,
-    pub timestamp: i64,
-    pub member: Option<GuildMember>,
-}
-
-impl WebSocketEvent for TypingStartEvent {}
-
-#[derive(Debug, Serialize, Deserialize, Default)]
-pub struct MessageCreate {
-    #[serde(flatten)]
-    message: Message,
-    guild_id: Option<Snowflake>,
-    member: Option<GuildMember>,
-    mentions: Vec<(User, GuildMember)>, // Not sure if this is correct: https://discord.com/developers/docs/topics/gateway-events#message-create
-}
-
-impl WebSocketEvent for MessageCreate {}
-
-#[derive(Debug, Serialize, Deserialize, Default)]
-pub struct MessageUpdate {
-    #[serde(flatten)]
-    message: Message,
-    guild_id: Option<String>,
-    member: Option<GuildMember>,
-    mentions: Vec<(User, GuildMember)>, // Not sure if this is correct: https://discord.com/developers/docs/topics/gateway-events#message-create
-}
-
-impl WebSocketEvent for MessageUpdate {}
-
-#[derive(Debug, Serialize, Deserialize, Default)]
-pub struct MessageDelete {
-    id: String,
-    channel_id: String,
-    guild_id: Option<String>,
-}
-
-impl WebSocketEvent for MessageDelete {}
-
-#[derive(Debug, Serialize, Deserialize, Default)]
-pub struct MessageDeleteBulk {
-    ids: Vec<String>,
-    channel_id: String,
-    guild_id: Option<String>,
-}
-
-impl WebSocketEvent for MessageDeleteBulk {}
-
-#[derive(Debug, Serialize, Deserialize, Default)]
-pub struct MessageReactionAdd {
-    user_id: String,
-    channel_id: String,
-    message_id: String,
-    guild_id: Option<String>,
-    member: Option<GuildMember>,
-    emoji: Emoji,
-}
-
-impl WebSocketEvent for MessageReactionAdd {}
-
-#[derive(Debug, Serialize, Deserialize, Default)]
-pub struct MessageReactionRemove {
-    user_id: String,
-    channel_id: String,
-    message_id: String,
-    guild_id: Option<String>,
-    emoji: Emoji,
-}
-
-impl WebSocketEvent for MessageReactionRemove {}
-
-#[derive(Debug, Serialize, Deserialize, Default)]
-pub struct MessageReactionRemoveAll {
-    channel_id: String,
-    message_id: String,
-    guild_id: Option<String>,
-}
-
-impl WebSocketEvent for MessageReactionRemoveAll {}
-
-#[derive(Debug, Serialize, Deserialize, Default)]
-pub struct MessageReactionRemoveEmoji {
-    channel_id: String,
-    message_id: String,
-    guild_id: Option<String>,
-    emoji: Emoji,
-}
-
-impl WebSocketEvent for MessageReactionRemoveEmoji {}

types/events/mod.rs

@@ -1,41 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-mod channel;
-mod guild;
-mod heartbeat;
-mod hello;
-mod identify;
-mod message;
-mod presence;
-mod ready;
-mod request_members;
-mod resume;
-mod thread;
-mod user;
-mod voice_status;
-
-pub use channel::*;
-pub use guild::*;
-pub use heartbeat::*;
-pub use hello::*;
-pub use identify::*;
-pub use message::*;
-pub use presence::*;
-pub use ready::*;
-pub use request_members::*;
-pub use resume::*;
-pub use thread::*;
-pub use user::*;
-pub use voice_status::*;
-
-pub trait WebSocketEvent {}
-
-#[derive(Debug, Default, Deserialize, Serialize)]
-pub struct GatewayPayload {
-    pub op: u8,
-    pub d: Option<serde_json::Value>,
-    pub s: Option<u64>,
-    pub t: Option<String>,
-}
-
-impl WebSocketEvent for GatewayPayload {}

types/events/presence.rs

@@ -1,24 +0,0 @@
-use serde::{Deserialize, Serialize};
-use crate::entities::User;
-use crate::events::WebSocketEvent;
-use crate::interfaces::Activity;
-
-#[derive(Debug, Deserialize, Serialize, Default, Clone)]
-/// See https://discord.com/developers/docs/topics/gateway-events#presence-update-presence-update-event-fields
-pub struct PresenceUpdate {
-    pub user: User,
-    pub guild_id: String,
-    pub status: String,
-    pub activities: Vec<Activity>,
-    pub client_status: ClientStatusObject,
-}
-
-#[derive(Debug, Deserialize, Serialize, Default, Clone)]
-/// See https://discord.com/developers/docs/topics/gateway-events#client-status-object
-pub struct ClientStatusObject {
-    pub desktop: Option<String>,
-    pub mobile: Option<String>,
-    pub web: Option<String>,
-}
-
-impl WebSocketEvent for PresenceUpdate {}

types/events/ready.rs

@@ -1,15 +0,0 @@
-use serde::{Deserialize, Serialize};
-use crate::entities::{UnavailableGuild, User};
-use crate::events::WebSocketEvent;
-
-#[derive(Debug, Deserialize, Serialize, Default)]
-pub struct GatewayReady {
-    pub v: u8,
-    pub user: User,
-    pub guilds: Vec<UnavailableGuild>,
-    pub session_id: String,
-    pub resume_gateway_url: Option<String>,
-    pub shard: Option<(u64, u64)>,
-}
-
-impl WebSocketEvent for GatewayReady {}

types/events/request_members.rs

@@ -1,15 +0,0 @@
-use serde::{Deserialize, Serialize};
-use crate::events::WebSocketEvent;
-
-#[derive(Debug, Deserialize, Serialize, Default)]
-/// See https://discord.com/developers/docs/topics/gateway-events#request-guild-members-request-guild-members-structure
-pub struct GatewayRequestGuildMembers {
-    pub guild_id: String,
-    pub query: Option<String>,
-    pub limit: u64,
-    pub presence: Option<bool>,
-    pub user_ids: Option<String>,
-    pub nonce: Option<String>,
-}
-
-impl WebSocketEvent for GatewayRequestGuildMembers {}