feat(http, gateway, model, validate): Add support for premium apps

twilight-cache-inmemory/src/event/interaction.rs

@@ -269,6 +269,7 @@ mod tests {
                 }),
                 target_id: None,
             }))),
+            entitlements: Vec::new(),
             guild_id: Some(Id::new(3)),
             guild_locale: None,
             id: Id::new(4),

twilight-cache-inmemory/src/lib.rs

@@ -976,6 +976,9 @@ impl<CacheModels: CacheableModels> UpdateCache<CacheModels> for Event {
             | Event::BanAdd(_)
             | Event::BanRemove(_)
             | Event::CommandPermissionsUpdate(_)
+            | Event::EntitlementCreate(_)
+            | Event::EntitlementDelete(_)
+            | Event::EntitlementUpdate(_)
             | Event::GatewayClose(_)
             | Event::GatewayHeartbeat(_)
             | Event::GatewayHeartbeatAck

twilight-gateway/src/event.rs

@@ -52,6 +52,12 @@ bitflags! {
         ///
         /// [`AutoModerationRule`]: crate::guild::auto_moderation::AutoModerationRule
         const AUTO_MODERATION_RULE_UPDATE = 1 << 74;
+        /// An entitlement has been created.
+        const ENTITLEMENT_CREATE = 1 << 76;
+        /// An entitlement has been deleted.
+        const ENTITLEMENT_DELETE = 1 << 77;
+        /// An entitlement has been updated.
+        const ENTITLEMENT_UPDATE = 1 << 78;
         /// User has been banned from a guild.
         const BAN_ADD = 1;
         /// User has been unbanned from a guild.
@@ -330,6 +336,9 @@ impl From<EventType> for EventTypeFlags {
             EventType::ChannelPinsUpdate => Self::CHANNEL_PINS_UPDATE,
             EventType::ChannelUpdate => Self::CHANNEL_UPDATE,
             EventType::CommandPermissionsUpdate => Self::COMMAND_PERMISSIONS_UPDATE,
+            EventType::EntitlementCreate => Self::ENTITLEMENT_CREATE,
+            EventType::EntitlementDelete => Self::ENTITLEMENT_DELETE,
+            EventType::EntitlementUpdate => Self::ENTITLEMENT_UPDATE,
             EventType::GatewayClose => Self::empty(),
             EventType::GatewayHeartbeat => Self::GATEWAY_HEARTBEAT,
             EventType::GatewayHeartbeatAck => Self::GATEWAY_HEARTBEAT_ACK,

twilight-http-ratelimiting/src/request.rs

@@ -166,6 +166,10 @@ pub enum Path {
     ChannelsIdTyping(u64),
     /// Operating on a channel's webhooks.
     ChannelsIdWebhooks(u64),
+    /// Operating on an application's entitlements.
+    ApplicationIdEntitlements(u64),
+    /// Operating on an application's SKUs.
+    ApplicationIdSKUs(u64),
     /// Operating with the gateway information.
     Gateway,
     /// Operating with the gateway information tailored to the current user.
@@ -337,6 +341,7 @@ impl FromStr for Path {
             ["applications", "me"] => ApplicationsMe,
             ["applications", id, "commands"] => ApplicationCommand(parse_id(id)?),
             ["applications", id, "commands", _] => ApplicationCommandId(parse_id(id)?),
+            ["applications", id, "entitlements"] => ApplicationIdEntitlements(parse_id(id)?),
             ["applications", id, "guilds", _, "commands"]
             | ["applications", id, "guilds", _, "commands", "permissions"] => {
                 ApplicationGuildCommand(parse_id(id)?)
@@ -345,6 +350,7 @@ impl FromStr for Path {
             | ["applications", id, "guilds", _, "commands", _, "permissions"] => {
                 ApplicationGuildCommandId(parse_id(id)?)
             }
+            ["applications", id, "skus"] => ApplicationIdSKUs(parse_id(id)?),
             ["channels", id] => ChannelsId(parse_id(id)?),
             ["channels", id, "followers"] => ChannelsIdFollowers(parse_id(id)?),
             ["channels", id, "invites"] => ChannelsIdInvites(parse_id(id)?),

twilight-http/src/client/mod.rs

@@ -4,6 +4,11 @@ mod interaction;
 
 pub use self::{builder::ClientBuilder, interaction::InteractionClient};
 
+use crate::request::application::monetization::{
+    CreateTestEntitlement, CreateTestEntitlementOwner, DeleteTestEntitlement, GetEntitlements,
+    GetSKUs,
+};
+#[allow(deprecated)]
 use crate::{
     client::connector::Connector,
     error::{Error, ErrorType},
@@ -104,9 +109,9 @@ use twilight_model::{
     http::{channel_position::Position, permission_overwrite::PermissionOverwrite},
     id::{
         marker::{
-            ApplicationMarker, AutoModerationRuleMarker, ChannelMarker, EmojiMarker, GuildMarker,
-            IntegrationMarker, MessageMarker, RoleMarker, ScheduledEventMarker, StickerMarker,
-            UserMarker, WebhookMarker,
+            ApplicationMarker, AutoModerationRuleMarker, ChannelMarker, EmojiMarker,
+            EntitlementMarker, GuildMarker, IntegrationMarker, MessageMarker, RoleMarker,
+            ScheduledEventMarker, SkuMarker, StickerMarker, UserMarker, WebhookMarker,
         },
         Id,
     },
@@ -775,6 +780,29 @@ impl Client {
         GetEmojis::new(self, guild_id)
     }
 
+    /// Get the entitlements for an application.
+    ///
+    /// # Examples
+    ///
+    /// Get emojis for the application `100`:
+    ///
+    /// ```no_run
+    /// # use twilight_http::Client;
+    /// # use twilight_model::id::Id;
+    ///
+    /// # #[tokio::main]
+    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /// # let client = Client::new("my token".to_owned());
+    /// #
+    /// let application_id = Id::new(100);
+    ///
+    /// client.entitlements(application_id).await?;
+    /// # Ok(()) }
+    /// ```
+    pub const fn entitlements(&self, application_id: Id<ApplicationMarker>) -> GetEntitlements<'_> {
+        GetEntitlements::new(self, application_id)
+    }
+
     /// Get an emoji for a guild by the the guild's ID and emoji's ID.
     ///
     /// # Examples
@@ -2557,6 +2585,90 @@ impl Client {
         DeleteGuildSticker::new(self, guild_id, sticker_id)
     }
 
+    /// Creates a test entitlement to a given SKU for a given guild or user. Discord
+    /// will act as though that user or guild has entitlement to your premium offering.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use twilight_http::{Client, request::application::monetization::CreateTestEntitlementOwner};
+    /// use twilight_model::id::Id;
+    ///
+    /// # #[tokio::main]
+    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /// let client = Client::new("my token".to_owned());
+    ///
+    /// let application_id = Id::new(1);
+    /// let sku_id = Id::new(2);
+    /// let owner = CreateTestEntitlementOwner::Guild(Id::new(3));
+    ///
+    /// client.create_test_entitlement(
+    ///    application_id,
+    ///    sku_id,
+    ///    owner,
+    /// ).await?;
+    ///
+    /// # Ok(()) }
+    pub const fn create_test_entitlement(
+        &self,
+        application_id: Id<ApplicationMarker>,
+        sku_id: Id<SkuMarker>,
+        owner: CreateTestEntitlementOwner,
+    ) -> CreateTestEntitlement<'_> {
+        CreateTestEntitlement::new(self, application_id, sku_id, owner)
+    }
+
+    /// Deletes a currently-active test entitlement. Discord will act as though that user or
+    /// guild no longer has entitlement to your premium offering.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use twilight_http::Client;
+    /// use twilight_model::id::Id;
+    ///
+    /// # #[tokio::main]
+    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /// let client = Client::new("my token".to_owned());
+    ///
+    /// let application_id = Id::new(1);
+    /// let entitlement_id = Id::new(2);
+    ///
+    /// client.delete_test_entitlement(
+    ///   application_id,
+    ///   entitlement_id,
+    /// ).await?;
+    ///
+    /// # Ok(()) }
+    pub const fn delete_test_entitlement(
+        &self,
+        application_id: Id<ApplicationMarker>,
+        entitlement_id: Id<EntitlementMarker>,
+    ) -> DeleteTestEntitlement<'_> {
+        DeleteTestEntitlement::new(self, application_id, entitlement_id)
+    }
+
+    /// Returns all SKUs for a given application.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use twilight_http::Client;
+    /// use twilight_model::id::Id;
+    ///
+    /// # #[tokio::main]
+    /// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /// let client = Client::new("my token".to_owned());
+    ///
+    /// let application_id = Id::new(1);
+    ///
+    /// let skus = client.get_skus(application_id).await?;
+    ///
+    /// # Ok(()) }
+    pub const fn get_skus(&self, application_id: Id<ApplicationMarker>) -> GetSKUs<'_> {
+        GetSKUs::new(self, application_id)
+    }
+
     /// Execute a request, returning a future resolving to a [`Response`].
     ///
     /// # Errors

twilight-http/src/request/application/mod.rs

@@ -1,2 +1,3 @@
 pub mod command;
 pub mod interaction;
+pub mod monetization;

twilight-http/src/request/application/monetization/create_test_entitlement.rs

@@ -0,0 +1,136 @@
+use std::future::IntoFuture;
+
+use serde::ser::{Serialize, SerializeStruct, Serializer};
+use twilight_model::{
+    application::monetization::Entitlement,
+    id::{
+        marker::{ApplicationMarker, GuildMarker, SkuMarker, UserMarker},
+        Id,
+    },
+};
+
+use crate::{
+    request::{Request, TryIntoRequest},
+    response::ResponseFuture,
+    routing::Route,
+    Client, Error, Response,
+};
+
+/// Owner of a test entitlement.
+pub enum CreateTestEntitlementOwner {
+    Guild(Id<GuildMarker>),
+    User(Id<UserMarker>),
+}
+
+impl CreateTestEntitlementOwner {
+    pub const fn id(&self) -> u64 {
+        match self {
+            CreateTestEntitlementOwner::Guild(id) => id.get(),
+            CreateTestEntitlementOwner::User(id) => id.get(),
+        }
+    }
+
+    pub const fn kind(&self) -> u8 {
+        match self {
+            CreateTestEntitlementOwner::Guild(_) => 1,
+            CreateTestEntitlementOwner::User(_) => 2,
+        }
+    }
+}
+
+struct CreateTestEntitlementFields {
+    sku_id: Id<SkuMarker>,
+    owner: CreateTestEntitlementOwner,
+}
+
+impl Serialize for CreateTestEntitlementFields {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut state = serializer.serialize_struct("CreateTestEntitlementFields", 2)?;
+        state.serialize_field("sku_id", &self.sku_id.get())?;
+        state.serialize_field("owner_id", &self.owner.id())?;
+        state.serialize_field("owner_type", &self.owner.kind())?;
+        state.end()
+    }
+}
+
+pub struct CreateTestEntitlement<'a> {
+    application_id: Id<ApplicationMarker>,
+    fields: CreateTestEntitlementFields,
+    http: &'a Client,
+}
+
+impl<'a> CreateTestEntitlement<'a> {
+    pub(crate) const fn new(
+        http: &'a Client,
+        application_id: Id<ApplicationMarker>,
+        sku_id: Id<SkuMarker>,
+        owner: CreateTestEntitlementOwner,
+    ) -> Self {
+        Self {
+            application_id,
+            fields: CreateTestEntitlementFields { sku_id, owner },
+            http,
+        }
+    }
+}
+
+impl IntoFuture for CreateTestEntitlement<'_> {
+    type Output = Result<Response<Entitlement>, Error>;
+
+    type IntoFuture = ResponseFuture<Entitlement>;
+
+    fn into_future(self) -> Self::IntoFuture {
+        let http = self.http;
+
+        match self.try_into_request() {
+            Ok(request) => http.request(request),
+            Err(source) => ResponseFuture::error(source),
+        }
+    }
+}
+
+impl TryIntoRequest for CreateTestEntitlement<'_> {
+    fn try_into_request(self) -> Result<Request, Error> {
+        Request::builder(&Route::CreateTestEntitlement {
+            application_id: self.application_id.get(),
+        })
+        .json(&self.fields)
+        .build()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_test::Token;
+    use twilight_model::id::Id;
+
+    use super::{CreateTestEntitlementFields, CreateTestEntitlementOwner};
+
+    #[test]
+    fn fields_serialization() {
+        let value = CreateTestEntitlementFields {
+            sku_id: Id::new(1),
+            owner: CreateTestEntitlementOwner::Guild(Id::new(2)),
+        };
+
+        serde_test::assert_ser_tokens(
+            &value,
+            &[
+                Token::Struct {
+                    name: "CreateTestEntitlementFields",
+                    len: 2,
+                },
+                Token::Str("sku_id"),
+                Token::U64(1),
+                Token::Str("owner_id"),
+                Token::U64(2),
+                Token::Str("owner_type"),
+                Token::U8(1),
+                Token::StructEnd,
+            ],
+        );
+    }
+}