{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE DeriveDataTypeable #-}

-- | Data structures pertaining to Discord Channels
module Discord.Internal.Types.Channel where

import Control.Applicative (empty)
import Data.Aeson
import Data.Aeson.Types (Parser)
import Data.Default (Default, def)
import Data.Text (Text)
import Data.Time.Clock
import qualified Data.Text as T
import Data.Bits
import Data.Data (Data)

import Discord.Internal.Types.Prelude
import Discord.Internal.Types.User (User(..), GuildMember)
import Discord.Internal.Types.Embed
import Discord.Internal.Types.Components (ActionRow)
import Discord.Internal.Types.Emoji

-- | Guild channels represent an isolated set of users and messages in a Guild (Server)
data Channel
  -- | A text channel in a guild.
  = ChannelText
      { Channel -> ChannelId
channelId          :: ChannelId         -- ^ The id of the channel (Will be equal to
                                                --   the guild if it's the "general" channel).
      , Channel -> GuildId
channelGuild       :: GuildId           -- ^ The id of the guild.
      , Channel -> Text
channelName        :: T.Text            -- ^ The name of the channel (2 - 1000 characters).
      , Channel -> Integer
channelPosition    :: Integer           -- ^ The storing position of the channel.
      , Channel -> [Overwrite]
channelPermissions :: [Overwrite]       -- ^ An array of permission 'Overwrite's
      , Channel -> Integer
channelUserRateLimit :: Integer         -- ^ Seconds before a user can speak again
      , Channel -> Bool
channelNSFW        :: Bool              -- ^ Is not-safe-for-work
      , Channel -> Text
channelTopic       :: T.Text            -- ^ The topic of the channel. (0 - 1024 chars).
      , Channel -> Maybe MessageId
channelLastMessage :: Maybe MessageId   -- ^ The id of the last message sent in the
                                                --   channel
      , Channel -> Maybe ParentId
channelParentId    :: Maybe ParentId    -- ^ The id of the parent channel (category)
      }
  -- | A news Channel in a guild.
  | ChannelNews
      { channelId          :: ChannelId       -- ^ The id of the channel
      , channelGuild       :: GuildId         -- ^ The id of the guild
      , channelName        :: T.Text          -- ^ The name of the channel (2 - 1000 characters)
      , channelPosition    :: Integer         -- ^ The position of the channel
      , channelPermissions :: [Overwrite]     -- ^ An array of permission 'Overrite's
      , channelNSFW        :: Bool            -- ^ Is not-safe-for-work
      , channelTopic       :: T.Text          -- ^ Topic of the channel (0 - 1024 characters)
      , channelLastMessage :: Maybe MessageId -- ^ The ID of the last message of the channel
      , channelParentId    :: Maybe ParentId  -- ^ The id of the parent channel (category)
      }
   -- | A store page channel in a guild
  | ChannelStorePage
      { channelId          :: ChannelId      -- ^ The id of the channel
      , channelGuild       :: GuildId        -- ^ The id of the guild
      , channelName        :: T.Text         -- ^ The name of the channel (2 - 1000 characters)
      , channelPosition    :: Integer        -- ^ The position of the channel
      , channelNSFW        :: Bool           -- ^ Is not-safe-for-work
      , channelPermissions :: [Overwrite]    -- ^ An array of permission 'Overrite's
      , channelParentId    :: Maybe ParentId -- ^ The id of the parrent channel (category)
      }
  -- | A voice channel in a guild.
  | ChannelVoice
      { channelId          :: ChannelId       -- ^ The id of the channel
      , channelGuild       :: GuildId         -- ^ The id of the guild
      , channelName        :: T.Text          -- ^ The name of the channel (2 - 1000) characters
      , channelPosition    :: Integer         -- ^ The position of the channel
      , channelPermissions :: [Overwrite]     -- ^ An array of permission 'Overrite's
      , channelNSFW        :: Bool            -- ^ Is not-safe-for-work
      , Channel -> Integer
channelBitRate     :: Integer         -- ^ The bitrate (in bps) of the channel.
      , Channel -> Integer
channelUserLimit   :: Integer         -- ^ The user limit of the voice channel.
      , channelParentId    :: Maybe ParentId  -- ^ The id of the parrent channel (category)
      }
  -- | DM Channels represent a one-to-one conversation between two users, outside the scope
  --   of guilds
  | ChannelDirectMessage
      { channelId          :: ChannelId       -- ^ The id of the channel
      , Channel -> [User]
channelRecipients  :: [User]          -- ^ The 'User' object(s) of the DM recipient(s).
      , channelLastMessage :: Maybe MessageId -- ^ The last message sent to the channel
      }
  -- | Like a 'ChannelDirectMessage' but for more people
  | ChannelGroupDM
      { channelId          :: ChannelId       -- ^ The id of the channel
      , channelRecipients  :: [User]          -- ^ The 'User' object(s) of the DM recipent(s).
      , channelLastMessage :: Maybe MessageId -- ^ The last message sent to the channel
      }
  -- | A channel category
  | ChannelGuildCategory
      { channelId          :: ChannelId   -- ^ The id of the category
      , channelGuild       :: GuildId     -- ^ The id of the gild
      , channelName        :: T.Text      -- ^ The name of the category
      , channelPosition    :: Integer     -- ^ The position of the category
      , channelPermissions :: [Overwrite] -- ^ A list of permission 'Overrite's
      }
  -- | A stage channel
  | ChannelStage
      { channelId          :: ChannelId -- ^ The id of the channel
      , channelGuild       :: GuildId   -- ^ The id of the guild
      , Channel -> StageId
channelStageId     :: StageId   -- ^ The id of the stage
      , Channel -> Text
channelStageTopic  :: Text      -- ^ The topic text
      }
  -- | A news Thread
  | ChannelNewsThread
      { channelId          :: ChannelId               -- ^ The id of the thread
      , channelGuild       :: GuildId                 -- ^ The id of the guild.
      , Channel -> Maybe Text
channelThreadName  :: Maybe T.Text            -- ^ The name of the channel (2 - 1000 characters).
      , Channel -> Maybe Integer
channelUserRateLimitThread :: Maybe Integer   -- ^ Seconds before a user can speak again
      , channelLastMessage :: Maybe MessageId         -- ^ The id of the last message sent in the
                                                      --   channel
      , channelParentId    :: Maybe ParentId          -- ^ The id of the parent channel
      , Channel -> Maybe ThreadMetadata
channelThreadMetadata :: Maybe ThreadMetadata -- ^ Metadata about this thread
      , Channel -> Maybe ThreadMember
channelThreadMember :: Maybe ThreadMember     -- ^ Used to indicate if the user has joined the thread
      }
  -- | A thread anyone can join
  | ChannelPublicThread
      { channelId          :: ChannelId               -- ^ The id of the thread
      , channelGuild       :: GuildId                 -- ^ The id of the guild.
      , channelThreadName  :: Maybe T.Text            -- ^ The name of the channel (2 - 1000 characters).
      , channelUserRateLimitThread :: Maybe Integer   -- ^ Seconds before a user can speak again
      , channelLastMessage :: Maybe MessageId         -- ^ The id of the last message sent in the
                                                      --   channel
      , channelParentId    :: Maybe ParentId          -- ^ The id of the parent channel
      , channelThreadMetadata :: Maybe ThreadMetadata -- ^ Metadata about this thread
      , channelThreadMember :: Maybe ThreadMember     -- ^ Used to indicate if the user has joined the thread
      }
  -- | An on-invite thread
  | ChannelPrivateThread
      { channelId          :: ChannelId               -- ^ The id of the thread
      , channelGuild       :: GuildId                 -- ^ The id of the guild.
      , channelThreadName  :: Maybe T.Text            -- ^ The name of the channel (2 - 1000 characters).
      , channelUserRateLimitThread :: Maybe Integer   -- ^ Seconds before a user can speak again
      , channelLastMessage :: Maybe MessageId         -- ^ The id of the last message sent in the
                                                      --   channel
      , channelParentId    :: Maybe ParentId          -- ^ The id of the parent channel
      , channelThreadMetadata :: Maybe ThreadMetadata -- ^ Metadata about this thread
      , channelThreadMember :: Maybe ThreadMember     -- ^ Used to indicate if the user has joined the thread
      }
  -- | A channel of unknown type
  | ChannelUnknownType
      { channelId          :: ChannelId -- ^ The id of the channel
      , Channel -> Text
channelJSON        :: Text      -- ^ The library couldn't parse the channel type, here is the raw JSON
      } deriving (Int -> Channel -> ShowS
[Channel] -> ShowS
Channel -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Channel] -> ShowS
$cshowList :: [Channel] -> ShowS
show :: Channel -> String
$cshow :: Channel -> String
showsPrec :: Int -> Channel -> ShowS
$cshowsPrec :: Int -> Channel -> ShowS
Show, ReadPrec [Channel]
ReadPrec Channel
Int -> ReadS Channel
ReadS [Channel]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Channel]
$creadListPrec :: ReadPrec [Channel]
readPrec :: ReadPrec Channel
$creadPrec :: ReadPrec Channel
readList :: ReadS [Channel]
$creadList :: ReadS [Channel]
readsPrec :: Int -> ReadS Channel
$creadsPrec :: Int -> ReadS Channel
Read, Channel -> Channel -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Channel -> Channel -> Bool
$c/= :: Channel -> Channel -> Bool
== :: Channel -> Channel -> Bool
$c== :: Channel -> Channel -> Bool
Eq, Eq Channel
Channel -> Channel -> Bool
Channel -> Channel -> Ordering
Channel -> Channel -> Channel
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Channel -> Channel -> Channel
$cmin :: Channel -> Channel -> Channel
max :: Channel -> Channel -> Channel
$cmax :: Channel -> Channel -> Channel
>= :: Channel -> Channel -> Bool
$c>= :: Channel -> Channel -> Bool
> :: Channel -> Channel -> Bool
$c> :: Channel -> Channel -> Bool
<= :: Channel -> Channel -> Bool
$c<= :: Channel -> Channel -> Bool
< :: Channel -> Channel -> Bool
$c< :: Channel -> Channel -> Bool
compare :: Channel -> Channel -> Ordering
$ccompare :: Channel -> Channel -> Ordering
Ord)

instance FromJSON Channel where
  parseJSON :: Value -> Parser Channel
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Channel" forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    Int
type' <- (Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type") :: Parser Int
    case Int
type' of
      Int
0 ->
        ChannelId
-> GuildId
-> Text
-> Integer
-> [Overwrite]
-> Integer
-> Bool
-> Text
-> Maybe MessageId
-> Maybe ParentId
-> Channel
ChannelText  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"id"
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"guild_id" forall a. Parser (Maybe a) -> a -> Parser a
.!= GuildId
0
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"name"
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"position"
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"permission_overwrites"
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"rate_limit_per_user"
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"nsfw" forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"topic" forall a. Parser (Maybe a) -> a -> Parser a
.!= Text
""
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"last_message_id"
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"parent_id"
      Int
1 ->
        ChannelId -> [User] -> Maybe MessageId -> Channel
ChannelDirectMessage forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"id"
                             forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"recipients"
                             forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"last_message_id"
      Int
2 ->
        ChannelId
-> GuildId
-> Text
-> Integer
-> [Overwrite]
-> Bool
-> Integer
-> Integer
-> Maybe ParentId
-> Channel
ChannelVoice forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"id"
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"guild_id" forall a. Parser (Maybe a) -> a -> Parser a
.!= GuildId
0
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"name"
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"position"
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"permission_overwrites"
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"nsfw" forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"bitrate"
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"user_limit"
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"parent_id"
      Int
3 ->
        ChannelId -> [User] -> Maybe MessageId -> Channel
ChannelGroupDM forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"id"
                       forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"recipients"
                       forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"last_message_id"
      Int
4 ->
        ChannelId -> GuildId -> Text -> Integer -> [Overwrite] -> Channel
ChannelGuildCategory forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
                             forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"guild_id" forall a. Parser (Maybe a) -> a -> Parser a
.!= GuildId
0
                             forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"name"
                             forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"position"
                             forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"permission_overwrites"
      Int
5 ->
        ChannelId
-> GuildId
-> Text
-> Integer
-> [Overwrite]
-> Bool
-> Text
-> Maybe MessageId
-> Maybe ParentId
-> Channel
ChannelNews forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"id"
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"guild_id" forall a. Parser (Maybe a) -> a -> Parser a
.!= GuildId
0
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"name"
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"position"
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"permission_overwrites"
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"nsfw" forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"topic" forall a. Parser (Maybe a) -> a -> Parser a
.!= Text
""
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"last_message_id"
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"parent_id"
      Int
6 ->
        ChannelId
-> GuildId
-> Text
-> Integer
-> Bool
-> [Overwrite]
-> Maybe ParentId
-> Channel
ChannelStorePage forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"id"
                         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"guild_id" forall a. Parser (Maybe a) -> a -> Parser a
.!= GuildId
0
                         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"name"
                         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"position"
                         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"nsfw" forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False
                         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"permission_overwrites"
                         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"parent_id"
      Int
10 -> ChannelId
-> GuildId
-> Maybe Text
-> Maybe Integer
-> Maybe MessageId
-> Maybe ParentId
-> Maybe ThreadMetadata
-> Maybe ThreadMember
-> Channel
ChannelNewsThread forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
oforall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
                              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"guild_id" forall a. Parser (Maybe a) -> a -> Parser a
.!= GuildId
0
                              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"name"
                              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"rate_limit_per_user"
                              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"last_message_id"
                              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"parent_id"
                              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"thread_metadata"
                              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"member"
      Int
11 -> ChannelId
-> GuildId
-> Maybe Text
-> Maybe Integer
-> Maybe MessageId
-> Maybe ParentId
-> Maybe ThreadMetadata
-> Maybe ThreadMember
-> Channel
ChannelPublicThread forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
oforall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
                                forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"guild_id" forall a. Parser (Maybe a) -> a -> Parser a
.!= GuildId
0
                                forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"name"
                                forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"rate_limit_per_user"
                                forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"last_message_id"
                                forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"parent_id"
                                forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"thread_metadata"
                                forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"member"
      Int
12 -> ChannelId
-> GuildId
-> Maybe Text
-> Maybe Integer
-> Maybe MessageId
-> Maybe ParentId
-> Maybe ThreadMetadata
-> Maybe ThreadMember
-> Channel
ChannelPrivateThread forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
oforall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
                                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"guild_id" forall a. Parser (Maybe a) -> a -> Parser a
.!= GuildId
0
                                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"name"
                                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"rate_limit_per_user"
                                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"last_message_id"
                                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"parent_id"
                                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"thread_metadata"
                                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"member"
      Int
13 ->
        ChannelId -> GuildId -> StageId -> Text -> Channel
ChannelStage forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"id"
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"guild_id" forall a. Parser (Maybe a) -> a -> Parser a
.!= GuildId
0
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"id"
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"topic" forall a. Parser (Maybe a) -> a -> Parser a
.!= Text
""
      Int
_ -> ChannelId -> Text -> Channel
ChannelUnknownType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"id"
                              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Applicative f => a -> f a
pure (String -> Text
T.pack (forall a. Show a => a -> String
show Object
o))

instance ToJSON Channel where
  toJSON :: Channel -> Value
toJSON ChannelText{Bool
Integer
[Overwrite]
Maybe ParentId
Maybe MessageId
Text
GuildId
ChannelId
channelParentId :: Maybe ParentId
channelLastMessage :: Maybe MessageId
channelTopic :: Text
channelNSFW :: Bool
channelUserRateLimit :: Integer
channelPermissions :: [Overwrite]
channelPosition :: Integer
channelName :: Text
channelGuild :: GuildId
channelId :: ChannelId
channelParentId :: Channel -> Maybe ParentId
channelLastMessage :: Channel -> Maybe MessageId
channelTopic :: Channel -> Text
channelNSFW :: Channel -> Bool
channelUserRateLimit :: Channel -> Integer
channelPermissions :: Channel -> [Overwrite]
channelPosition :: Channel -> Integer
channelName :: Channel -> Text
channelGuild :: Channel -> GuildId
channelId :: Channel -> ChannelId
..} = [Maybe Pair] -> Value
objectFromMaybes
              [ Key
"type" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Scientific -> Value
Number Scientific
0
              , Key
"id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== ChannelId
channelId
              , Key
"guild_id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== GuildId
channelGuild
              , Key
"name" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Text
channelName
              , Key
"position" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Integer
channelPosition
              , Key
"rate_limit_per_user" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Integer
channelUserRateLimit
              , Key
"nsfw" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Bool
channelNSFW
              , Key
"permission_overwrites" forall a. ToJSON a => Key -> a -> Maybe Pair
.== [Overwrite]
channelPermissions
              , Key
"topic" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Text
channelTopic
              , Key
"last_message_id" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe MessageId
channelLastMessage
              , Key
"parent_id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Maybe ParentId
channelParentId
              ]
  toJSON ChannelNews{Bool
Integer
[Overwrite]
Maybe ParentId
Maybe MessageId
Text
GuildId
ChannelId
channelParentId :: Maybe ParentId
channelLastMessage :: Maybe MessageId
channelTopic :: Text
channelNSFW :: Bool
channelPermissions :: [Overwrite]
channelPosition :: Integer
channelName :: Text
channelGuild :: GuildId
channelId :: ChannelId
channelParentId :: Channel -> Maybe ParentId
channelLastMessage :: Channel -> Maybe MessageId
channelTopic :: Channel -> Text
channelNSFW :: Channel -> Bool
channelPermissions :: Channel -> [Overwrite]
channelPosition :: Channel -> Integer
channelName :: Channel -> Text
channelGuild :: Channel -> GuildId
channelId :: Channel -> ChannelId
..} = [Maybe Pair] -> Value
objectFromMaybes
              [ Key
"type" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Scientific -> Value
Number Scientific
5
              , Key
"id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== ChannelId
channelId
              , Key
"guild_id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== GuildId
channelGuild
              , Key
"name" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Text
channelName
              , Key
"position" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Integer
channelPosition
              , Key
"permission_overwrites" forall a. ToJSON a => Key -> a -> Maybe Pair
.== [Overwrite]
channelPermissions
              , Key
"nsfw" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Bool
channelNSFW
              , Key
"topic" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Text
channelTopic
              , Key
"last_message_id" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe MessageId
channelLastMessage
              , Key
"parent_id" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe ParentId
channelParentId
              ]
  toJSON ChannelStorePage{Bool
Integer
[Overwrite]
Maybe ParentId
Text
GuildId
ChannelId
channelParentId :: Maybe ParentId
channelPermissions :: [Overwrite]
channelNSFW :: Bool
channelPosition :: Integer
channelName :: Text
channelGuild :: GuildId
channelId :: ChannelId
channelParentId :: Channel -> Maybe ParentId
channelNSFW :: Channel -> Bool
channelPermissions :: Channel -> [Overwrite]
channelPosition :: Channel -> Integer
channelName :: Channel -> Text
channelGuild :: Channel -> GuildId
channelId :: Channel -> ChannelId
..} = [Maybe Pair] -> Value
objectFromMaybes
              [ Key
"type" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Scientific -> Value
Number Scientific
6
              , Key
"id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== ChannelId
channelId
              , Key
"guild_id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== GuildId
channelGuild
              , Key
"name" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Text
channelName
              , Key
"nsfw" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Bool
channelNSFW
              , Key
"position" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Integer
channelPosition
              , Key
"permission_overwrites" forall a. ToJSON a => Key -> a -> Maybe Pair
.== [Overwrite]
channelPermissions
              ]
  toJSON ChannelDirectMessage{[User]
Maybe MessageId
ChannelId
channelLastMessage :: Maybe MessageId
channelRecipients :: [User]
channelId :: ChannelId
channelRecipients :: Channel -> [User]
channelLastMessage :: Channel -> Maybe MessageId
channelId :: Channel -> ChannelId
..} = [Maybe Pair] -> Value
objectFromMaybes
              [ Key
"type" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Scientific -> Value
Number Scientific
1
              , Key
"id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== ChannelId
channelId
              , Key
"recipients" forall a. ToJSON a => Key -> a -> Maybe Pair
.== [User]
channelRecipients
              , Key
"last_message_id" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe MessageId
channelLastMessage
              ]
  toJSON ChannelVoice{Bool
Integer
[Overwrite]
Maybe ParentId
Text
GuildId
ChannelId
channelParentId :: Maybe ParentId
channelUserLimit :: Integer
channelBitRate :: Integer
channelNSFW :: Bool
channelPermissions :: [Overwrite]
channelPosition :: Integer
channelName :: Text
channelGuild :: GuildId
channelId :: ChannelId
channelUserLimit :: Channel -> Integer
channelBitRate :: Channel -> Integer
channelParentId :: Channel -> Maybe ParentId
channelNSFW :: Channel -> Bool
channelPermissions :: Channel -> [Overwrite]
channelPosition :: Channel -> Integer
channelName :: Channel -> Text
channelGuild :: Channel -> GuildId
channelId :: Channel -> ChannelId
..} = [Maybe Pair] -> Value
objectFromMaybes
              [ Key
"type" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Scientific -> Value
Number Scientific
2
              , Key
"id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== ChannelId
channelId
              , Key
"guild_id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== GuildId
channelGuild
              , Key
"name" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Text
channelName
              , Key
"position" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Integer
channelPosition
              , Key
"nsfw" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Bool
channelNSFW
              , Key
"permission_overwrites" forall a. ToJSON a => Key -> a -> Maybe Pair
.== [Overwrite]
channelPermissions
              , Key
"bitrate" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Integer
channelBitRate
              , Key
"user_limit" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Integer
channelUserLimit
              ]
  toJSON ChannelGroupDM{[User]
Maybe MessageId
ChannelId
channelLastMessage :: Maybe MessageId
channelRecipients :: [User]
channelId :: ChannelId
channelRecipients :: Channel -> [User]
channelLastMessage :: Channel -> Maybe MessageId
channelId :: Channel -> ChannelId
..} = [Maybe Pair] -> Value
objectFromMaybes
              [ Key
"type" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Scientific -> Value
Number Scientific
3
              , Key
"id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== ChannelId
channelId
              , Key
"recipients" forall a. ToJSON a => Key -> a -> Maybe Pair
.== [User]
channelRecipients
              , Key
"last_message_id" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe MessageId
channelLastMessage
              ]
  toJSON ChannelGuildCategory{Integer
[Overwrite]
Text
GuildId
ChannelId
channelPermissions :: [Overwrite]
channelPosition :: Integer
channelName :: Text
channelGuild :: GuildId
channelId :: ChannelId
channelPermissions :: Channel -> [Overwrite]
channelPosition :: Channel -> Integer
channelName :: Channel -> Text
channelGuild :: Channel -> GuildId
channelId :: Channel -> ChannelId
..} = [Maybe Pair] -> Value
objectFromMaybes
              [ Key
"type" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Scientific -> Value
Number Scientific
4
              , Key
"id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== ChannelId
channelId
              , Key
"name" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Text
channelName
              , Key
"guild_id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== GuildId
channelGuild
              ]
  toJSON ChannelStage{Text
GuildId
StageId
ChannelId
channelStageTopic :: Text
channelStageId :: StageId
channelGuild :: GuildId
channelId :: ChannelId
channelStageTopic :: Channel -> Text
channelStageId :: Channel -> StageId
channelGuild :: Channel -> GuildId
channelId :: Channel -> ChannelId
..} = [Maybe Pair] -> Value
objectFromMaybes
              [ Key
"type" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Scientific -> Value
Number Scientific
13
              , Key
"id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== ChannelId
channelId
              , Key
"guild_id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== GuildId
channelGuild
              , Key
"channel_id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== StageId
channelStageId
              , Key
"topic" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Text
channelStageTopic
              ]
  toJSON ChannelNewsThread{Maybe Integer
Maybe Text
Maybe ParentId
Maybe MessageId
Maybe ThreadMember
Maybe ThreadMetadata
GuildId
ChannelId
channelThreadMember :: Maybe ThreadMember
channelThreadMetadata :: Maybe ThreadMetadata
channelParentId :: Maybe ParentId
channelLastMessage :: Maybe MessageId
channelUserRateLimitThread :: Maybe Integer
channelThreadName :: Maybe Text
channelGuild :: GuildId
channelId :: ChannelId
channelThreadMember :: Channel -> Maybe ThreadMember
channelThreadMetadata :: Channel -> Maybe ThreadMetadata
channelUserRateLimitThread :: Channel -> Maybe Integer
channelThreadName :: Channel -> Maybe Text
channelParentId :: Channel -> Maybe ParentId
channelLastMessage :: Channel -> Maybe MessageId
channelGuild :: Channel -> GuildId
channelId :: Channel -> ChannelId
..} = [Maybe Pair] -> Value
objectFromMaybes
              [ Key
"type" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Scientific -> Value
Number Scientific
10
              , Key
"id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== ChannelId
channelId
              , Key
"guild_id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== GuildId
channelGuild
              , Key
"name" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe Text
channelThreadName
              , Key
"rate_limit_per_user" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe Integer
channelUserRateLimitThread
              , Key
"last_message_id" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe MessageId
channelLastMessage
              , Key
"parent_id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Maybe ParentId
channelParentId
              , Key
"thread_metadata" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe ThreadMetadata
channelThreadMetadata
              , Key
"member" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe ThreadMember
channelThreadMember
              ]
  toJSON ChannelPublicThread{Maybe Integer
Maybe Text
Maybe ParentId
Maybe MessageId
Maybe ThreadMember
Maybe ThreadMetadata
GuildId
ChannelId
channelThreadMember :: Maybe ThreadMember
channelThreadMetadata :: Maybe ThreadMetadata
channelParentId :: Maybe ParentId
channelLastMessage :: Maybe MessageId
channelUserRateLimitThread :: Maybe Integer
channelThreadName :: Maybe Text
channelGuild :: GuildId
channelId :: ChannelId
channelThreadMember :: Channel -> Maybe ThreadMember
channelThreadMetadata :: Channel -> Maybe ThreadMetadata
channelUserRateLimitThread :: Channel -> Maybe Integer
channelThreadName :: Channel -> Maybe Text
channelParentId :: Channel -> Maybe ParentId
channelLastMessage :: Channel -> Maybe MessageId
channelGuild :: Channel -> GuildId
channelId :: Channel -> ChannelId
..} = [Maybe Pair] -> Value
objectFromMaybes
              [ Key
"type" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Scientific -> Value
Number Scientific
11
              , Key
"id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== ChannelId
channelId
              , Key
"guild_id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== GuildId
channelGuild
              , Key
"name" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe Text
channelThreadName
              , Key
"rate_limit_per_user" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe Integer
channelUserRateLimitThread
              , Key
"last_message_id" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe MessageId
channelLastMessage
              , Key
"parent_id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Maybe ParentId
channelParentId
              , Key
"thread_metadata" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe ThreadMetadata
channelThreadMetadata
              , Key
"member" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe ThreadMember
channelThreadMember
              ]
  toJSON ChannelPrivateThread{Maybe Integer
Maybe Text
Maybe ParentId
Maybe MessageId
Maybe ThreadMember
Maybe ThreadMetadata
GuildId
ChannelId
channelThreadMember :: Maybe ThreadMember
channelThreadMetadata :: Maybe ThreadMetadata
channelParentId :: Maybe ParentId
channelLastMessage :: Maybe MessageId
channelUserRateLimitThread :: Maybe Integer
channelThreadName :: Maybe Text
channelGuild :: GuildId
channelId :: ChannelId
channelThreadMember :: Channel -> Maybe ThreadMember
channelThreadMetadata :: Channel -> Maybe ThreadMetadata
channelUserRateLimitThread :: Channel -> Maybe Integer
channelThreadName :: Channel -> Maybe Text
channelParentId :: Channel -> Maybe ParentId
channelLastMessage :: Channel -> Maybe MessageId
channelGuild :: Channel -> GuildId
channelId :: Channel -> ChannelId
..} = [Maybe Pair] -> Value
objectFromMaybes
              [ Key
"type" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Scientific -> Value
Number Scientific
12
              , Key
"id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== ChannelId
channelId
              , Key
"guild_id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== GuildId
channelGuild
              , Key
"name" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe Text
channelThreadName
              , Key
"rate_limit_per_user" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe Integer
channelUserRateLimitThread
              , Key
"last_message_id" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe MessageId
channelLastMessage
              , Key
"parent_id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Maybe ParentId
channelParentId
              , Key
"thread_metadata" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe ThreadMetadata
channelThreadMetadata
              , Key
"member" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe ThreadMember
channelThreadMember
              ]
  toJSON ChannelUnknownType{Text
ChannelId
channelJSON :: Text
channelId :: ChannelId
channelJSON :: Channel -> Text
channelId :: Channel -> ChannelId
..} = [Maybe Pair] -> Value
objectFromMaybes
              [ Key
"id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== ChannelId
channelId
              , Key
"json" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Text
channelJSON
              ]

-- | If the channel is part of a guild (has a guild id field)
channelIsInGuild :: Channel -> Bool
channelIsInGuild :: Channel -> Bool
channelIsInGuild Channel
c = case Channel
c of
        ChannelGuildCategory{} -> Bool
True
        ChannelText{} -> Bool
True
        ChannelVoice{} -> Bool
True
        ChannelNews{} -> Bool
True
        ChannelStorePage{} -> Bool
True
        ChannelNewsThread{} -> Bool
True
        ChannelPublicThread{} -> Bool
True
        ChannelPrivateThread{} -> Bool
True
        Channel
_ -> Bool
False

-- | Permission overwrites for a channel.
data Overwrite = Overwrite
  { Overwrite -> Either RoleId UserId
overwriteId    :: Either RoleId UserId -- ^ 'Role' or 'User' id
  , Overwrite -> Text
overwriteAllow :: T.Text               -- ^ Allowed permission bit set
  , Overwrite -> Text
overwriteDeny  :: T.Text               -- ^ Denied permission bit set
  } deriving (Int -> Overwrite -> ShowS
[Overwrite] -> ShowS
Overwrite -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Overwrite] -> ShowS
$cshowList :: [Overwrite] -> ShowS
show :: Overwrite -> String
$cshow :: Overwrite -> String
showsPrec :: Int -> Overwrite -> ShowS
$cshowsPrec :: Int -> Overwrite -> ShowS
Show, ReadPrec [Overwrite]
ReadPrec Overwrite
Int -> ReadS Overwrite
ReadS [Overwrite]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Overwrite]
$creadListPrec :: ReadPrec [Overwrite]
readPrec :: ReadPrec Overwrite
$creadPrec :: ReadPrec Overwrite
readList :: ReadS [Overwrite]
$creadList :: ReadS [Overwrite]
readsPrec :: Int -> ReadS Overwrite
$creadsPrec :: Int -> ReadS Overwrite
Read, Overwrite -> Overwrite -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Overwrite -> Overwrite -> Bool
$c/= :: Overwrite -> Overwrite -> Bool
== :: Overwrite -> Overwrite -> Bool
$c== :: Overwrite -> Overwrite -> Bool
Eq, Eq Overwrite
Overwrite -> Overwrite -> Bool
Overwrite -> Overwrite -> Ordering
Overwrite -> Overwrite -> Overwrite
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Overwrite -> Overwrite -> Overwrite
$cmin :: Overwrite -> Overwrite -> Overwrite
max :: Overwrite -> Overwrite -> Overwrite
$cmax :: Overwrite -> Overwrite -> Overwrite
>= :: Overwrite -> Overwrite -> Bool
$c>= :: Overwrite -> Overwrite -> Bool
> :: Overwrite -> Overwrite -> Bool
$c> :: Overwrite -> Overwrite -> Bool
<= :: Overwrite -> Overwrite -> Bool
$c<= :: Overwrite -> Overwrite -> Bool
< :: Overwrite -> Overwrite -> Bool
$c< :: Overwrite -> Overwrite -> Bool
compare :: Overwrite -> Overwrite -> Ordering
$ccompare :: Overwrite -> Overwrite -> Ordering
Ord)

instance FromJSON Overwrite where
  parseJSON :: Value -> Parser Overwrite
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Overwrite" forall a b. (a -> b) -> a -> b
$ \Object
o -> do
    Int
t <- Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type"
    Either RoleId UserId
i <- case (Int
t :: Int) of
      Int
0 -> forall a b. a -> Either a b
Left forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
      Int
1 -> forall a b. b -> Either a b
Right forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
      Int
_ -> forall a. HasCallStack => String -> a
error String
"Type field can only be 0 (role id) or 1 (user id)"
    Either RoleId UserId -> Text -> Text -> Overwrite
Overwrite Either RoleId UserId
i
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"allow"
              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"deny"

instance ToJSON Overwrite where
  toJSON :: Overwrite -> Value
toJSON Overwrite{Either RoleId UserId
Text
overwriteDeny :: Text
overwriteAllow :: Text
overwriteId :: Either RoleId UserId
overwriteDeny :: Overwrite -> Text
overwriteAllow :: Overwrite -> Text
overwriteId :: Overwrite -> Either RoleId UserId
..} = [Pair] -> Value
object
              [ (Key
"id",     forall a. ToJSON a => a -> Value
toJSON forall a b. (a -> b) -> a -> b
$ forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall a. DiscordId a -> Snowflake
unId forall a. DiscordId a -> Snowflake
unId Either RoleId UserId
overwriteId)
              , (Key
"type",   forall a. ToJSON a => a -> Value
toJSON (forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall a b. a -> b -> a
const Int
0) (forall a b. a -> b -> a
const Int
1) Either RoleId UserId
overwriteId :: Int))
              , (Key
"allow",  forall a. ToJSON a => a -> Value
toJSON Text
overwriteAllow)
              , (Key
"deny",   forall a. ToJSON a => a -> Value
toJSON Text
overwriteDeny)
              ]

-- | Metadata for threads.
data ThreadMetadata = ThreadMetadata
 { ThreadMetadata -> Bool
threadMetadataArchived :: Bool -- ^ Is the thread archived?
 , ThreadMetadata -> Integer
threadMetadataAutoArchive :: Integer -- ^ How long after activity should the thread auto archive
 , ThreadMetadata -> UTCTime
threadMetadataArchiveTime :: UTCTime -- ^ When was the last time the archive status changed?
 , ThreadMetadata -> Bool
threadMetadataLocked :: Bool -- ^ Is the thread locked? (only MANAGE_THREADS users can unarchive)
 , ThreadMetadata -> Maybe Bool
threadMetadataInvitable :: Maybe Bool -- ^ Can non-mods add other non-mods? (private threads only)
 , ThreadMetadata -> Maybe UTCTime
threadMetadataCreateTime :: Maybe UTCTime -- ^ When was the thread created?
 } deriving (Int -> ThreadMetadata -> ShowS
[ThreadMetadata] -> ShowS
ThreadMetadata -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ThreadMetadata] -> ShowS
$cshowList :: [ThreadMetadata] -> ShowS
show :: ThreadMetadata -> String
$cshow :: ThreadMetadata -> String
showsPrec :: Int -> ThreadMetadata -> ShowS
$cshowsPrec :: Int -> ThreadMetadata -> ShowS
Show, ReadPrec [ThreadMetadata]
ReadPrec ThreadMetadata
Int -> ReadS ThreadMetadata
ReadS [ThreadMetadata]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ThreadMetadata]
$creadListPrec :: ReadPrec [ThreadMetadata]
readPrec :: ReadPrec ThreadMetadata
$creadPrec :: ReadPrec ThreadMetadata
readList :: ReadS [ThreadMetadata]
$creadList :: ReadS [ThreadMetadata]
readsPrec :: Int -> ReadS ThreadMetadata
$creadsPrec :: Int -> ReadS ThreadMetadata
Read, ThreadMetadata -> ThreadMetadata -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ThreadMetadata -> ThreadMetadata -> Bool
$c/= :: ThreadMetadata -> ThreadMetadata -> Bool
== :: ThreadMetadata -> ThreadMetadata -> Bool
$c== :: ThreadMetadata -> ThreadMetadata -> Bool
Eq, Eq ThreadMetadata
ThreadMetadata -> ThreadMetadata -> Bool
ThreadMetadata -> ThreadMetadata -> Ordering
ThreadMetadata -> ThreadMetadata -> ThreadMetadata
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ThreadMetadata -> ThreadMetadata -> ThreadMetadata
$cmin :: ThreadMetadata -> ThreadMetadata -> ThreadMetadata
max :: ThreadMetadata -> ThreadMetadata -> ThreadMetadata
$cmax :: ThreadMetadata -> ThreadMetadata -> ThreadMetadata
>= :: ThreadMetadata -> ThreadMetadata -> Bool
$c>= :: ThreadMetadata -> ThreadMetadata -> Bool
> :: ThreadMetadata -> ThreadMetadata -> Bool
$c> :: ThreadMetadata -> ThreadMetadata -> Bool
<= :: ThreadMetadata -> ThreadMetadata -> Bool
$c<= :: ThreadMetadata -> ThreadMetadata -> Bool
< :: ThreadMetadata -> ThreadMetadata -> Bool
$c< :: ThreadMetadata -> ThreadMetadata -> Bool
compare :: ThreadMetadata -> ThreadMetadata -> Ordering
$ccompare :: ThreadMetadata -> ThreadMetadata -> Ordering
Ord)

instance FromJSON ThreadMetadata where
  parseJSON :: Value -> Parser ThreadMetadata
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ThreadMetadata" forall a b. (a -> b) -> a -> b
$ \Object
o ->
    Bool
-> Integer
-> UTCTime
-> Bool
-> Maybe Bool
-> Maybe UTCTime
-> ThreadMetadata
ThreadMetadata forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"archived"
                   forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"auto_archive_duration"
                   forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"archive_timestamp"
                   forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"locked"
                   forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"invitable"
                   forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"create_timestamp"

instance ToJSON ThreadMetadata where
  toJSON :: ThreadMetadata -> Value
toJSON ThreadMetadata{Bool
Integer
Maybe Bool
Maybe UTCTime
UTCTime
threadMetadataCreateTime :: Maybe UTCTime
threadMetadataInvitable :: Maybe Bool
threadMetadataLocked :: Bool
threadMetadataArchiveTime :: UTCTime
threadMetadataAutoArchive :: Integer
threadMetadataArchived :: Bool
threadMetadataCreateTime :: ThreadMetadata -> Maybe UTCTime
threadMetadataInvitable :: ThreadMetadata -> Maybe Bool
threadMetadataLocked :: ThreadMetadata -> Bool
threadMetadataArchiveTime :: ThreadMetadata -> UTCTime
threadMetadataAutoArchive :: ThreadMetadata -> Integer
threadMetadataArchived :: ThreadMetadata -> Bool
..} = [Maybe Pair] -> Value
objectFromMaybes
              [ Key
"archived" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Bool
threadMetadataArchived
              , Key
"auto_archive_duration" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Integer
threadMetadataAutoArchive
              , Key
"archive_timestamp" forall a. ToJSON a => Key -> a -> Maybe Pair
.== UTCTime
threadMetadataArchiveTime
              , Key
"locked" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Bool
threadMetadataLocked
              , Key
"invitable" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe Bool
threadMetadataInvitable
              , Key
"create_timestamp" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Maybe UTCTime
threadMetadataCreateTime
              ]

-- | A user in a thread
data ThreadMember = ThreadMember
 { ThreadMember -> Maybe ChannelId
threadMemberThreadId :: Maybe ChannelId -- ^ id of the thread
 , ThreadMember -> Maybe UserId
threadMemberUserId   :: Maybe UserId    -- ^ id of the user
 , ThreadMember -> UTCTime
threadMemberJoinTime :: UTCTime         -- ^ time the current user last joined the thread
 , ThreadMember -> Integer
threadMemberFlags    :: Integer         -- ^ user-thread settings
 } deriving (Int -> ThreadMember -> ShowS
[ThreadMember] -> ShowS
ThreadMember -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ThreadMember] -> ShowS
$cshowList :: [ThreadMember] -> ShowS
show :: ThreadMember -> String
$cshow :: ThreadMember -> String
showsPrec :: Int -> ThreadMember -> ShowS
$cshowsPrec :: Int -> ThreadMember -> ShowS
Show, ReadPrec [ThreadMember]
ReadPrec ThreadMember
Int -> ReadS ThreadMember
ReadS [ThreadMember]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ThreadMember]
$creadListPrec :: ReadPrec [ThreadMember]
readPrec :: ReadPrec ThreadMember
$creadPrec :: ReadPrec ThreadMember
readList :: ReadS [ThreadMember]
$creadList :: ReadS [ThreadMember]
readsPrec :: Int -> ReadS ThreadMember
$creadsPrec :: Int -> ReadS ThreadMember
Read, ThreadMember -> ThreadMember -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ThreadMember -> ThreadMember -> Bool
$c/= :: ThreadMember -> ThreadMember -> Bool
== :: ThreadMember -> ThreadMember -> Bool
$c== :: ThreadMember -> ThreadMember -> Bool
Eq, Eq ThreadMember
ThreadMember -> ThreadMember -> Bool
ThreadMember -> ThreadMember -> Ordering
ThreadMember -> ThreadMember -> ThreadMember
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ThreadMember -> ThreadMember -> ThreadMember
$cmin :: ThreadMember -> ThreadMember -> ThreadMember
max :: ThreadMember -> ThreadMember -> ThreadMember
$cmax :: ThreadMember -> ThreadMember -> ThreadMember
>= :: ThreadMember -> ThreadMember -> Bool
$c>= :: ThreadMember -> ThreadMember -> Bool
> :: ThreadMember -> ThreadMember -> Bool
$c> :: ThreadMember -> ThreadMember -> Bool
<= :: ThreadMember -> ThreadMember -> Bool
$c<= :: ThreadMember -> ThreadMember -> Bool
< :: ThreadMember -> ThreadMember -> Bool
$c< :: ThreadMember -> ThreadMember -> Bool
compare :: ThreadMember -> ThreadMember -> Ordering
$ccompare :: ThreadMember -> ThreadMember -> Ordering
Ord)

instance FromJSON ThreadMember where
  parseJSON :: Value -> Parser ThreadMember
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ThreadMember" forall a b. (a -> b) -> a -> b
$ \Object
o ->
    Maybe ChannelId
-> Maybe UserId -> UTCTime -> Integer -> ThreadMember
ThreadMember forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"id"
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"user_id"
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"join_timestamp"
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"flags"

instance ToJSON ThreadMember where
  toJSON :: ThreadMember -> Value
toJSON ThreadMember{Integer
Maybe UserId
Maybe ChannelId
UTCTime
threadMemberFlags :: Integer
threadMemberJoinTime :: UTCTime
threadMemberUserId :: Maybe UserId
threadMemberThreadId :: Maybe ChannelId
threadMemberFlags :: ThreadMember -> Integer
threadMemberJoinTime :: ThreadMember -> UTCTime
threadMemberUserId :: ThreadMember -> Maybe UserId
threadMemberThreadId :: ThreadMember -> Maybe ChannelId
..} = [Maybe Pair] -> Value
objectFromMaybes
              [ Key
"id" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe ChannelId
threadMemberThreadId
              , Key
"user_id" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe UserId
threadMemberUserId
              , Key
"join_timestamp" forall a. ToJSON a => Key -> a -> Maybe Pair
.== UTCTime
threadMemberJoinTime
              , Key
"flags" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Integer
threadMemberFlags
              ]


data ThreadListSyncFields = ThreadListSyncFields
  { ThreadListSyncFields -> GuildId
threadListSyncFieldsGuildId :: GuildId
  , ThreadListSyncFields -> Maybe [ChannelId]
threadListSyncFieldsChannelIds :: Maybe [ChannelId]
  , ThreadListSyncFields -> [Channel]
threadListSyncFieldsThreads :: [Channel]
  , ThreadListSyncFields -> [ThreadMember]
threadListSyncFieldsThreadMembers :: [ThreadMember]
  } deriving (Int -> ThreadListSyncFields -> ShowS
[ThreadListSyncFields] -> ShowS
ThreadListSyncFields -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ThreadListSyncFields] -> ShowS
$cshowList :: [ThreadListSyncFields] -> ShowS
show :: ThreadListSyncFields -> String
$cshow :: ThreadListSyncFields -> String
showsPrec :: Int -> ThreadListSyncFields -> ShowS
$cshowsPrec :: Int -> ThreadListSyncFields -> ShowS
Show, ReadPrec [ThreadListSyncFields]
ReadPrec ThreadListSyncFields
Int -> ReadS ThreadListSyncFields
ReadS [ThreadListSyncFields]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ThreadListSyncFields]
$creadListPrec :: ReadPrec [ThreadListSyncFields]
readPrec :: ReadPrec ThreadListSyncFields
$creadPrec :: ReadPrec ThreadListSyncFields
readList :: ReadS [ThreadListSyncFields]
$creadList :: ReadS [ThreadListSyncFields]
readsPrec :: Int -> ReadS ThreadListSyncFields
$creadsPrec :: Int -> ReadS ThreadListSyncFields
Read, ThreadListSyncFields -> ThreadListSyncFields -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ThreadListSyncFields -> ThreadListSyncFields -> Bool
$c/= :: ThreadListSyncFields -> ThreadListSyncFields -> Bool
== :: ThreadListSyncFields -> ThreadListSyncFields -> Bool
$c== :: ThreadListSyncFields -> ThreadListSyncFields -> Bool
Eq, Eq ThreadListSyncFields
ThreadListSyncFields -> ThreadListSyncFields -> Bool
ThreadListSyncFields -> ThreadListSyncFields -> Ordering
ThreadListSyncFields
-> ThreadListSyncFields -> ThreadListSyncFields
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ThreadListSyncFields
-> ThreadListSyncFields -> ThreadListSyncFields
$cmin :: ThreadListSyncFields
-> ThreadListSyncFields -> ThreadListSyncFields
max :: ThreadListSyncFields
-> ThreadListSyncFields -> ThreadListSyncFields
$cmax :: ThreadListSyncFields
-> ThreadListSyncFields -> ThreadListSyncFields
>= :: ThreadListSyncFields -> ThreadListSyncFields -> Bool
$c>= :: ThreadListSyncFields -> ThreadListSyncFields -> Bool
> :: ThreadListSyncFields -> ThreadListSyncFields -> Bool
$c> :: ThreadListSyncFields -> ThreadListSyncFields -> Bool
<= :: ThreadListSyncFields -> ThreadListSyncFields -> Bool
$c<= :: ThreadListSyncFields -> ThreadListSyncFields -> Bool
< :: ThreadListSyncFields -> ThreadListSyncFields -> Bool
$c< :: ThreadListSyncFields -> ThreadListSyncFields -> Bool
compare :: ThreadListSyncFields -> ThreadListSyncFields -> Ordering
$ccompare :: ThreadListSyncFields -> ThreadListSyncFields -> Ordering
Ord)

instance FromJSON ThreadListSyncFields where
  parseJSON :: Value -> Parser ThreadListSyncFields
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ThreadListSyncFields" forall a b. (a -> b) -> a -> b
$ \Object
o ->
    GuildId
-> Maybe [ChannelId]
-> [Channel]
-> [ThreadMember]
-> ThreadListSyncFields
ThreadListSyncFields forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"guild_id"
                         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"channel_ids"
                         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"threads"
                         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"members"

data ThreadMembersUpdateFields = ThreadMembersUpdateFields
  { ThreadMembersUpdateFields -> ChannelId
threadMembersUpdateFieldsThreadId :: ChannelId
  , ThreadMembersUpdateFields -> GuildId
threadMembersUpdateFieldsGuildId :: GuildId
  , ThreadMembersUpdateFields -> Integer
threadMembersUpdateFieldsMemberCount :: Integer
  , ThreadMembersUpdateFields -> Maybe [ThreadMember]
threadMembersUpdateFieldsAddedMembers :: Maybe [ThreadMember]
  , ThreadMembersUpdateFields -> Maybe [UserId]
threadMembersUpdateFieldsRemovedMembers :: Maybe [UserId]
  } deriving (Int -> ThreadMembersUpdateFields -> ShowS
[ThreadMembersUpdateFields] -> ShowS
ThreadMembersUpdateFields -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ThreadMembersUpdateFields] -> ShowS
$cshowList :: [ThreadMembersUpdateFields] -> ShowS
show :: ThreadMembersUpdateFields -> String
$cshow :: ThreadMembersUpdateFields -> String
showsPrec :: Int -> ThreadMembersUpdateFields -> ShowS
$cshowsPrec :: Int -> ThreadMembersUpdateFields -> ShowS
Show, ReadPrec [ThreadMembersUpdateFields]
ReadPrec ThreadMembersUpdateFields
Int -> ReadS ThreadMembersUpdateFields
ReadS [ThreadMembersUpdateFields]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ThreadMembersUpdateFields]
$creadListPrec :: ReadPrec [ThreadMembersUpdateFields]
readPrec :: ReadPrec ThreadMembersUpdateFields
$creadPrec :: ReadPrec ThreadMembersUpdateFields
readList :: ReadS [ThreadMembersUpdateFields]
$creadList :: ReadS [ThreadMembersUpdateFields]
readsPrec :: Int -> ReadS ThreadMembersUpdateFields
$creadsPrec :: Int -> ReadS ThreadMembersUpdateFields
Read, ThreadMembersUpdateFields -> ThreadMembersUpdateFields -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ThreadMembersUpdateFields -> ThreadMembersUpdateFields -> Bool
$c/= :: ThreadMembersUpdateFields -> ThreadMembersUpdateFields -> Bool
== :: ThreadMembersUpdateFields -> ThreadMembersUpdateFields -> Bool
$c== :: ThreadMembersUpdateFields -> ThreadMembersUpdateFields -> Bool
Eq, Eq ThreadMembersUpdateFields
ThreadMembersUpdateFields -> ThreadMembersUpdateFields -> Bool
ThreadMembersUpdateFields -> ThreadMembersUpdateFields -> Ordering
ThreadMembersUpdateFields
-> ThreadMembersUpdateFields -> ThreadMembersUpdateFields
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ThreadMembersUpdateFields
-> ThreadMembersUpdateFields -> ThreadMembersUpdateFields
$cmin :: ThreadMembersUpdateFields
-> ThreadMembersUpdateFields -> ThreadMembersUpdateFields
max :: ThreadMembersUpdateFields
-> ThreadMembersUpdateFields -> ThreadMembersUpdateFields
$cmax :: ThreadMembersUpdateFields
-> ThreadMembersUpdateFields -> ThreadMembersUpdateFields
>= :: ThreadMembersUpdateFields -> ThreadMembersUpdateFields -> Bool
$c>= :: ThreadMembersUpdateFields -> ThreadMembersUpdateFields -> Bool
> :: ThreadMembersUpdateFields -> ThreadMembersUpdateFields -> Bool
$c> :: ThreadMembersUpdateFields -> ThreadMembersUpdateFields -> Bool
<= :: ThreadMembersUpdateFields -> ThreadMembersUpdateFields -> Bool
$c<= :: ThreadMembersUpdateFields -> ThreadMembersUpdateFields -> Bool
< :: ThreadMembersUpdateFields -> ThreadMembersUpdateFields -> Bool
$c< :: ThreadMembersUpdateFields -> ThreadMembersUpdateFields -> Bool
compare :: ThreadMembersUpdateFields -> ThreadMembersUpdateFields -> Ordering
$ccompare :: ThreadMembersUpdateFields -> ThreadMembersUpdateFields -> Ordering
Ord)

instance FromJSON ThreadMembersUpdateFields where
  parseJSON :: Value -> Parser ThreadMembersUpdateFields
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ThreadMembersUpdateFields" forall a b. (a -> b) -> a -> b
$ \Object
o ->
    ChannelId
-> GuildId
-> Integer
-> Maybe [ThreadMember]
-> Maybe [UserId]
-> ThreadMembersUpdateFields
ThreadMembersUpdateFields forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"id"
                              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"guild_id"
                              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"member_count"
                              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"added_members"
                              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"removed_member_ids"

-- | Represents information about a message in a Discord channel.
data Message = Message
  { Message -> MessageId
messageId                 :: MessageId                -- ^ The id of the message
  , Message -> ChannelId
messageChannelId          :: ChannelId                -- ^ Id of the channel the message
                                                          --   was sent in
  , Message -> Maybe GuildId
messageGuildId            :: Maybe GuildId            -- ^ The guild the message went to
  , Message -> User
messageAuthor             :: User                     -- ^ The 'User' the message was sent
                                                          --   by
  , Message -> Maybe GuildMember
messageMember             :: Maybe GuildMember        -- ^ A partial guild member object
  , Message -> Text
messageContent            :: Text                     -- ^ Contents of the message
  , Message -> UTCTime
messageTimestamp          :: UTCTime                  -- ^ When the message was sent
  , Message -> Maybe UTCTime
messageEdited             :: Maybe UTCTime            -- ^ When/if the message was edited
  , Message -> Bool
messageTts                :: Bool                     -- ^ Whether this message was a TTS
                                                          --   message
  , Message -> Bool
messageEveryone           :: Bool                     -- ^ Whether this message mentions
                                                          --   everyone
  , Message -> [User]
messageMentions           :: [User]                   -- ^ 'User's specifically mentioned in
                                                          --   the message
  , Message -> [RoleId]
messageMentionRoles       :: [RoleId]                 -- ^ 'Role's specifically mentioned in
                                                          --   the message
  , Message -> [Attachment]
messageAttachments        :: [Attachment]             -- ^ Any attached files
  , Message -> [Embed]
messageEmbeds             :: [Embed]                  -- ^ Any embedded content
  , Message -> [MessageReaction]
messageReactions          :: [MessageReaction]        -- ^ Any reactions to message
  , Message -> Maybe Nonce
messageNonce              :: Maybe Nonce              -- ^ Used for validating if a message
                                                          --   was sent
  , Message -> Bool
messagePinned             :: Bool                     -- ^ Whether this message is pinned
  , Message -> Maybe WebhookId
messageWebhookId          :: Maybe WebhookId          -- ^ The webhook id of the webhook that made the message
  , Message -> MessageType
messageType               :: MessageType              -- ^ What type of message is this.
  , Message -> Maybe MessageActivity
messageActivity           :: Maybe MessageActivity    -- ^ sent with Rich Presence-related chat embeds
  , Message -> Maybe ApplicationId
messageApplicationId      :: Maybe ApplicationId      -- ^ if the message is a response to an Interaction, this is the id of the interaction's application
  , Message -> Maybe MessageReference
messageReference          :: Maybe MessageReference   -- ^ Reference IDs of the original message
  , Message -> Maybe MessageFlags
messageFlags              :: Maybe MessageFlags       -- ^ Various message flags
  , Message -> Maybe Message
messageReferencedMessage  :: Maybe Message            -- ^ The full original message
  , Message -> Maybe MessageInteraction
messageInteraction        :: Maybe MessageInteraction -- ^ sent if message is an interaction response
  , Message -> Maybe Channel
messageThread             :: Maybe Channel            -- ^ the thread that was started from this message, includes thread member object
  , Message -> Maybe [ActionRow]
messageComponents         :: Maybe [ActionRow]        -- ^ sent if the message contains components like buttons, action rows, or other interactive components
  , Message -> Maybe [StickerItem]
messageStickerItems       :: Maybe [StickerItem]      -- ^ sent if the message contains stickers
  } deriving (Int -> Message -> ShowS
[Message] -> ShowS
Message -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Message] -> ShowS
$cshowList :: [Message] -> ShowS
show :: Message -> String
$cshow :: Message -> String
showsPrec :: Int -> Message -> ShowS
$cshowsPrec :: Int -> Message -> ShowS
Show, ReadPrec [Message]
ReadPrec Message
Int -> ReadS Message
ReadS [Message]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Message]
$creadListPrec :: ReadPrec [Message]
readPrec :: ReadPrec Message
$creadPrec :: ReadPrec Message
readList :: ReadS [Message]
$creadList :: ReadS [Message]
readsPrec :: Int -> ReadS Message
$creadsPrec :: Int -> ReadS Message
Read, Message -> Message -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Message -> Message -> Bool
$c/= :: Message -> Message -> Bool
== :: Message -> Message -> Bool
$c== :: Message -> Message -> Bool
Eq, Eq Message
Message -> Message -> Bool
Message -> Message -> Ordering
Message -> Message -> Message
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Message -> Message -> Message
$cmin :: Message -> Message -> Message
max :: Message -> Message -> Message
$cmax :: Message -> Message -> Message
>= :: Message -> Message -> Bool
$c>= :: Message -> Message -> Bool
> :: Message -> Message -> Bool
$c> :: Message -> Message -> Bool
<= :: Message -> Message -> Bool
$c<= :: Message -> Message -> Bool
< :: Message -> Message -> Bool
$c< :: Message -> Message -> Bool
compare :: Message -> Message -> Ordering
$ccompare :: Message -> Message -> Ordering
Ord)

instance FromJSON Message where
  parseJSON :: Value -> Parser Message
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Message" forall a b. (a -> b) -> a -> b
$ \Object
o ->
    MessageId
-> ChannelId
-> Maybe GuildId
-> User
-> Maybe GuildMember
-> Text
-> UTCTime
-> Maybe UTCTime
-> Bool
-> Bool
-> [User]
-> [RoleId]
-> [Attachment]
-> [Embed]
-> [MessageReaction]
-> Maybe Nonce
-> Bool
-> Maybe WebhookId
-> MessageType
-> Maybe MessageActivity
-> Maybe ApplicationId
-> Maybe MessageReference
-> Maybe MessageFlags
-> Maybe Message
-> Maybe MessageInteraction
-> Maybe Channel
-> Maybe [ActionRow]
-> Maybe [StickerItem]
-> Message
Message forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"id"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"channel_id"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"guild_id" forall a. Parser (Maybe a) -> a -> Parser a
.!= forall a. Maybe a
Nothing
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (do Maybe WebhookId
isW <- Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"webhook_id"
                    User
a <- Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"author"
                    case Maybe WebhookId
isW :: Maybe WebhookId of
                      Maybe WebhookId
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure User
a
                      Just WebhookId
_ -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ User
a { userIsWebhook :: Bool
userIsWebhook = Bool
True })
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"member"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"content" forall a. Parser (Maybe a) -> a -> Parser a
.!= Text
""
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"timestamp" forall a. Parser (Maybe a) -> a -> Parser a
.!= UTCTime
epochTime
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"edited_timestamp"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"tts" forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"mention_everyone" forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"mentions" forall a. Parser (Maybe a) -> a -> Parser a
.!= []
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"mention_roles" forall a. Parser (Maybe a) -> a -> Parser a
.!= []
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"attachments" forall a. Parser (Maybe a) -> a -> Parser a
.!= []
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"embeds"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"reactions" forall a. Parser (Maybe a) -> a -> Parser a
.!= []
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"nonce"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"pinned" forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"webhook_id"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"type"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"activity"
            -- <*> o .:? "application"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"application_id"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"message_reference" forall a. Parser (Maybe a) -> a -> Parser a
.!= forall a. Maybe a
Nothing
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"flags"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"referenced_message" forall a. Parser (Maybe a) -> a -> Parser a
.!= forall a. Maybe a
Nothing
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"interaction"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"thread"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"components"
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"sticker_items"


instance ToJSON Message where
  toJSON :: Message -> Value
toJSON Message {Bool
[RoleId]
[Embed]
[User]
[Attachment]
[MessageReaction]
Maybe [StickerItem]
Maybe [ActionRow]
Maybe UTCTime
Maybe ApplicationId
Maybe WebhookId
Maybe GuildId
Maybe GuildMember
Maybe MessageInteraction
Maybe MessageFlags
Maybe MessageActivity
Maybe MessageReference
Maybe Nonce
Maybe Message
Maybe Channel
UTCTime
Text
MessageId
ChannelId
User
MessageType
messageStickerItems :: Maybe [StickerItem]
messageComponents :: Maybe [ActionRow]
messageThread :: Maybe Channel
messageInteraction :: Maybe MessageInteraction
messageReferencedMessage :: Maybe Message
messageFlags :: Maybe MessageFlags
messageReference :: Maybe MessageReference
messageApplicationId :: Maybe ApplicationId
messageActivity :: Maybe MessageActivity
messageType :: MessageType
messageWebhookId :: Maybe WebhookId
messagePinned :: Bool
messageNonce :: Maybe Nonce
messageReactions :: [MessageReaction]
messageEmbeds :: [Embed]
messageAttachments :: [Attachment]
messageMentionRoles :: [RoleId]
messageMentions :: [User]
messageEveryone :: Bool
messageTts :: Bool
messageEdited :: Maybe UTCTime
messageTimestamp :: UTCTime
messageContent :: Text
messageMember :: Maybe GuildMember
messageAuthor :: User
messageGuildId :: Maybe GuildId
messageChannelId :: ChannelId
messageId :: MessageId
messageStickerItems :: Message -> Maybe [StickerItem]
messageComponents :: Message -> Maybe [ActionRow]
messageThread :: Message -> Maybe Channel
messageInteraction :: Message -> Maybe MessageInteraction
messageReferencedMessage :: Message -> Maybe Message
messageFlags :: Message -> Maybe MessageFlags
messageReference :: Message -> Maybe MessageReference
messageApplicationId :: Message -> Maybe ApplicationId
messageActivity :: Message -> Maybe MessageActivity
messageType :: Message -> MessageType
messageWebhookId :: Message -> Maybe WebhookId
messagePinned :: Message -> Bool
messageNonce :: Message -> Maybe Nonce
messageReactions :: Message -> [MessageReaction]
messageEmbeds :: Message -> [Embed]
messageAttachments :: Message -> [Attachment]
messageMentionRoles :: Message -> [RoleId]
messageMentions :: Message -> [User]
messageEveryone :: Message -> Bool
messageTts :: Message -> Bool
messageEdited :: Message -> Maybe UTCTime
messageTimestamp :: Message -> UTCTime
messageContent :: Message -> Text
messageMember :: Message -> Maybe GuildMember
messageAuthor :: Message -> User
messageGuildId :: Message -> Maybe GuildId
messageChannelId :: Message -> ChannelId
messageId :: Message -> MessageId
..} = [Maybe Pair] -> Value
objectFromMaybes
      [ Key
"id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== MessageId
messageId
      , Key
"channel_id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== ChannelId
messageChannelId
      , Key
"guild_id" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe GuildId
messageGuildId
      , Key
"author" forall a. ToJSON a => Key -> a -> Maybe Pair
.== User
messageAuthor
      , Key
"member" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe GuildMember
messageMember
      , Key
"content" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Text
messageContent
      , Key
"timestamp" forall a. ToJSON a => Key -> a -> Maybe Pair
.== UTCTime
messageTimestamp
      , Key
"edited_timestamp" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe UTCTime
messageEdited
      , Key
"tts" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Bool
messageTts
      , Key
"mention_everyone" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Bool
messageEveryone
      , Key
"mentions" forall a. ToJSON a => Key -> a -> Maybe Pair
.== [User]
messageMentions
      , Key
"mention_roles" forall a. ToJSON a => Key -> a -> Maybe Pair
.== [RoleId]
messageMentionRoles
      , Key
"attachments" forall a. ToJSON a => Key -> a -> Maybe Pair
.== [Attachment]
messageAttachments
      , Key
"embeds" forall a. ToJSON a => Key -> a -> Maybe Pair
.== [Embed]
messageEmbeds
      , Key
"reactions" forall a. ToJSON a => Key -> a -> Maybe Pair
.== [MessageReaction]
messageReactions
      , Key
"nonce" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe Nonce
messageNonce
      , Key
"pinned" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Bool
messagePinned
      , Key
"webhook_id" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe WebhookId
messageWebhookId
      , Key
"type" forall a. ToJSON a => Key -> a -> Maybe Pair
.== MessageType
messageType
      , Key
"activity" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe MessageActivity
messageActivity
      -- , ("application",            toJSON <$>      messageApplication)
      , Key
"application_id" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe ApplicationId
messageApplicationId
      , Key
"message_reference" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe MessageReference
messageReference
      , Key
"flags" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe MessageFlags
messageFlags
      , Key
"referenced_message" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe Message
messageReferencedMessage
      , Key
"interaction" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe MessageInteraction
messageInteraction
      , Key
"thread" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe Channel
messageThread
      , Key
"components" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe [ActionRow]
messageComponents
      , Key
"sticker_items" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe [StickerItem]
messageStickerItems
      ]

-- | Data constructor for a part of MessageDetailedOpts.
data AllowedMentions = AllowedMentions
  { AllowedMentions -> Bool
mentionEveryone    :: Bool     -- ^ Can mention @\@everyone@
  , AllowedMentions -> Bool
mentionUsers       :: Bool     -- ^ Can mention any user
  , AllowedMentions -> Bool
mentionRoles       :: Bool     -- ^ Can mention any mentionable role
  , AllowedMentions -> [UserId]
mentionUserIds     :: [UserId] -- ^ List of users able to be mentionned
  , AllowedMentions -> [RoleId]
mentionRoleIds     :: [RoleId] -- ^ List of roles able to be mentioneed 
  , AllowedMentions -> Bool
mentionRepliedUser :: Bool     -- ^ Can mention the sender of the replied message 
  } deriving (Int -> AllowedMentions -> ShowS
[AllowedMentions] -> ShowS
AllowedMentions -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AllowedMentions] -> ShowS
$cshowList :: [AllowedMentions] -> ShowS
show :: AllowedMentions -> String
$cshow :: AllowedMentions -> String
showsPrec :: Int -> AllowedMentions -> ShowS
$cshowsPrec :: Int -> AllowedMentions -> ShowS
Show, ReadPrec [AllowedMentions]
ReadPrec AllowedMentions
Int -> ReadS AllowedMentions
ReadS [AllowedMentions]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AllowedMentions]
$creadListPrec :: ReadPrec [AllowedMentions]
readPrec :: ReadPrec AllowedMentions
$creadPrec :: ReadPrec AllowedMentions
readList :: ReadS [AllowedMentions]
$creadList :: ReadS [AllowedMentions]
readsPrec :: Int -> ReadS AllowedMentions
$creadsPrec :: Int -> ReadS AllowedMentions
Read, AllowedMentions -> AllowedMentions -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AllowedMentions -> AllowedMentions -> Bool
$c/= :: AllowedMentions -> AllowedMentions -> Bool
== :: AllowedMentions -> AllowedMentions -> Bool
$c== :: AllowedMentions -> AllowedMentions -> Bool
Eq, Eq AllowedMentions
AllowedMentions -> AllowedMentions -> Bool
AllowedMentions -> AllowedMentions -> Ordering
AllowedMentions -> AllowedMentions -> AllowedMentions
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: AllowedMentions -> AllowedMentions -> AllowedMentions
$cmin :: AllowedMentions -> AllowedMentions -> AllowedMentions
max :: AllowedMentions -> AllowedMentions -> AllowedMentions
$cmax :: AllowedMentions -> AllowedMentions -> AllowedMentions
>= :: AllowedMentions -> AllowedMentions -> Bool
$c>= :: AllowedMentions -> AllowedMentions -> Bool
> :: AllowedMentions -> AllowedMentions -> Bool
$c> :: AllowedMentions -> AllowedMentions -> Bool
<= :: AllowedMentions -> AllowedMentions -> Bool
$c<= :: AllowedMentions -> AllowedMentions -> Bool
< :: AllowedMentions -> AllowedMentions -> Bool
$c< :: AllowedMentions -> AllowedMentions -> Bool
compare :: AllowedMentions -> AllowedMentions -> Ordering
$ccompare :: AllowedMentions -> AllowedMentions -> Ordering
Ord)

instance Default AllowedMentions where
  def :: AllowedMentions
def = AllowedMentions { mentionEveryone :: Bool
mentionEveryone    = Bool
False
                        , mentionUsers :: Bool
mentionUsers       = Bool
True
                        , mentionRoles :: Bool
mentionRoles       = Bool
True
                        , mentionUserIds :: [UserId]
mentionUserIds     = []
                        , mentionRoleIds :: [RoleId]
mentionRoleIds     = []
                        , mentionRepliedUser :: Bool
mentionRepliedUser = Bool
True
                        }

instance ToJSON AllowedMentions where
  toJSON :: AllowedMentions -> Value
toJSON AllowedMentions{Bool
[RoleId]
[UserId]
mentionRepliedUser :: Bool
mentionRoleIds :: [RoleId]
mentionUserIds :: [UserId]
mentionRoles :: Bool
mentionUsers :: Bool
mentionEveryone :: Bool
mentionRepliedUser :: AllowedMentions -> Bool
mentionRoleIds :: AllowedMentions -> [RoleId]
mentionUserIds :: AllowedMentions -> [UserId]
mentionRoles :: AllowedMentions -> Bool
mentionUsers :: AllowedMentions -> Bool
mentionEveryone :: AllowedMentions -> Bool
..} = [Pair] -> Value
object [
                                 Key
"parse" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [Text
name :: T.Text | (Text
name, Bool
True) <-
                                    [ (Text
"everyone", Bool
mentionEveryone),
                                      (Text
"users",    Bool
mentionUsers Bool -> Bool -> Bool
&& forall (t :: * -> *) a. Foldable t => t a -> Bool
null [UserId]
mentionUserIds),
                                      (Text
"roles",    Bool
mentionRoles Bool -> Bool -> Bool
&& forall (t :: * -> *) a. Foldable t => t a -> Bool
null [RoleId]
mentionRoleIds) ] ],
                                 -- https://discord.com/developers/docs/resources/channel#allowed-mentions-object
                                 --  parse.users and users list cannot both be active, prioritize id list
                                 Key
"roles"        forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [RoleId]
mentionRoleIds,
                                 Key
"users"        forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= [UserId]
mentionUserIds,
                                 Key
"replied_user" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
.= Bool
mentionRepliedUser ]

-- | A reaction to a message
data MessageReaction = MessageReaction
  { MessageReaction -> Int
messageReactionCount :: Int
  , MessageReaction -> Bool
messageReactionMeIncluded :: Bool
  , MessageReaction -> Emoji
messageReactionEmoji :: Emoji
  } deriving (Int -> MessageReaction -> ShowS
[MessageReaction] -> ShowS
MessageReaction -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MessageReaction] -> ShowS
$cshowList :: [MessageReaction] -> ShowS
show :: MessageReaction -> String
$cshow :: MessageReaction -> String
showsPrec :: Int -> MessageReaction -> ShowS
$cshowsPrec :: Int -> MessageReaction -> ShowS
Show, ReadPrec [MessageReaction]
ReadPrec MessageReaction
Int -> ReadS MessageReaction
ReadS [MessageReaction]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MessageReaction]
$creadListPrec :: ReadPrec [MessageReaction]
readPrec :: ReadPrec MessageReaction
$creadPrec :: ReadPrec MessageReaction
readList :: ReadS [MessageReaction]
$creadList :: ReadS [MessageReaction]
readsPrec :: Int -> ReadS MessageReaction
$creadsPrec :: Int -> ReadS MessageReaction
Read, MessageReaction -> MessageReaction -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MessageReaction -> MessageReaction -> Bool
$c/= :: MessageReaction -> MessageReaction -> Bool
== :: MessageReaction -> MessageReaction -> Bool
$c== :: MessageReaction -> MessageReaction -> Bool
Eq, Eq MessageReaction
MessageReaction -> MessageReaction -> Bool
MessageReaction -> MessageReaction -> Ordering
MessageReaction -> MessageReaction -> MessageReaction
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: MessageReaction -> MessageReaction -> MessageReaction
$cmin :: MessageReaction -> MessageReaction -> MessageReaction
max :: MessageReaction -> MessageReaction -> MessageReaction
$cmax :: MessageReaction -> MessageReaction -> MessageReaction
>= :: MessageReaction -> MessageReaction -> Bool
$c>= :: MessageReaction -> MessageReaction -> Bool
> :: MessageReaction -> MessageReaction -> Bool
$c> :: MessageReaction -> MessageReaction -> Bool
<= :: MessageReaction -> MessageReaction -> Bool
$c<= :: MessageReaction -> MessageReaction -> Bool
< :: MessageReaction -> MessageReaction -> Bool
$c< :: MessageReaction -> MessageReaction -> Bool
compare :: MessageReaction -> MessageReaction -> Ordering
$ccompare :: MessageReaction -> MessageReaction -> Ordering
Ord)

instance FromJSON MessageReaction where
  parseJSON :: Value -> Parser MessageReaction
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"MessageReaction" forall a b. (a -> b) -> a -> b
$ \Object
o ->
    Int -> Bool -> Emoji -> MessageReaction
MessageReaction forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"count"
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"me"
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"emoji"

instance ToJSON MessageReaction where
  toJSON :: MessageReaction -> Value
toJSON MessageReaction{Bool
Int
Emoji
messageReactionEmoji :: Emoji
messageReactionMeIncluded :: Bool
messageReactionCount :: Int
messageReactionEmoji :: MessageReaction -> Emoji
messageReactionMeIncluded :: MessageReaction -> Bool
messageReactionCount :: MessageReaction -> Int
..} = [Maybe Pair] -> Value
objectFromMaybes
      [ Key
"count" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Int
messageReactionCount
      , Key
"me" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Bool
messageReactionMeIncluded
      , Key
"emoji" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Emoji
messageReactionEmoji
      ]

-- | Represents an attached to a message file.
data Attachment = Attachment
  { Attachment -> AttachmentId
attachmentId       :: AttachmentId     -- ^ Attachment id
  , Attachment -> Text
attachmentFilename :: T.Text        -- ^ Name of attached file
  , Attachment -> Integer
attachmentSize     :: Integer       -- ^ Size of file (in bytes)
  , Attachment -> Text
attachmentUrl      :: T.Text        -- ^ Source of file
  , Attachment -> Text
attachmentProxy    :: T.Text        -- ^ Proxied url of file
  , Attachment -> Maybe Integer
attachmentHeight   :: Maybe Integer -- ^ Height of file (if image)
  , Attachment -> Maybe Integer
attachmentWidth    :: Maybe Integer -- ^ Width of file (if image)
  } deriving (Int -> Attachment -> ShowS
[Attachment] -> ShowS
Attachment -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Attachment] -> ShowS
$cshowList :: [Attachment] -> ShowS
show :: Attachment -> String
$cshow :: Attachment -> String
showsPrec :: Int -> Attachment -> ShowS
$cshowsPrec :: Int -> Attachment -> ShowS
Show, ReadPrec [Attachment]
ReadPrec Attachment
Int -> ReadS Attachment
ReadS [Attachment]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Attachment]
$creadListPrec :: ReadPrec [Attachment]
readPrec :: ReadPrec Attachment
$creadPrec :: ReadPrec Attachment
readList :: ReadS [Attachment]
$creadList :: ReadS [Attachment]
readsPrec :: Int -> ReadS Attachment
$creadsPrec :: Int -> ReadS Attachment
Read, Attachment -> Attachment -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Attachment -> Attachment -> Bool
$c/= :: Attachment -> Attachment -> Bool
== :: Attachment -> Attachment -> Bool
$c== :: Attachment -> Attachment -> Bool
Eq, Eq Attachment
Attachment -> Attachment -> Bool
Attachment -> Attachment -> Ordering
Attachment -> Attachment -> Attachment
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Attachment -> Attachment -> Attachment
$cmin :: Attachment -> Attachment -> Attachment
max :: Attachment -> Attachment -> Attachment
$cmax :: Attachment -> Attachment -> Attachment
>= :: Attachment -> Attachment -> Bool
$c>= :: Attachment -> Attachment -> Bool
> :: Attachment -> Attachment -> Bool
$c> :: Attachment -> Attachment -> Bool
<= :: Attachment -> Attachment -> Bool
$c<= :: Attachment -> Attachment -> Bool
< :: Attachment -> Attachment -> Bool
$c< :: Attachment -> Attachment -> Bool
compare :: Attachment -> Attachment -> Ordering
$ccompare :: Attachment -> Attachment -> Ordering
Ord)

instance FromJSON Attachment where
  parseJSON :: Value -> Parser Attachment
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Attachment" forall a b. (a -> b) -> a -> b
$ \Object
o ->
    AttachmentId
-> Text
-> Integer
-> Text
-> Text
-> Maybe Integer
-> Maybe Integer
-> Attachment
Attachment forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"id"
               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"filename"
               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"size"
               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"url"
               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:  Key
"proxy_url"
               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"height"
               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"width"

instance ToJSON Attachment where
  toJSON :: Attachment -> Value
toJSON Attachment {Integer
Maybe Integer
Text
AttachmentId
attachmentWidth :: Maybe Integer
attachmentHeight :: Maybe Integer
attachmentProxy :: Text
attachmentUrl :: Text
attachmentSize :: Integer
attachmentFilename :: Text
attachmentId :: AttachmentId
attachmentWidth :: Attachment -> Maybe Integer
attachmentHeight :: Attachment -> Maybe Integer
attachmentProxy :: Attachment -> Text
attachmentUrl :: Attachment -> Text
attachmentSize :: Attachment -> Integer
attachmentFilename :: Attachment -> Text
attachmentId :: Attachment -> AttachmentId
..} = [Maybe Pair] -> Value
objectFromMaybes
      [ Key
"id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== AttachmentId
attachmentId
      , Key
"filename" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Text
attachmentFilename
      , Key
"size" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Integer
attachmentSize
      , Key
"url" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Text
attachmentUrl
      , Key
"proxy_url" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Text
attachmentProxy
      , Key
"height" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe Integer
attachmentHeight
      , Key
"width" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe Integer
attachmentWidth
      ]

newtype Nonce = Nonce T.Text
  deriving (Int -> Nonce -> ShowS
[Nonce] -> ShowS
Nonce -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Nonce] -> ShowS
$cshowList :: [Nonce] -> ShowS
show :: Nonce -> String
$cshow :: Nonce -> String
showsPrec :: Int -> Nonce -> ShowS
$cshowsPrec :: Int -> Nonce -> ShowS
Show, ReadPrec [Nonce]
ReadPrec Nonce
Int -> ReadS Nonce
ReadS [Nonce]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Nonce]
$creadListPrec :: ReadPrec [Nonce]
readPrec :: ReadPrec Nonce
$creadPrec :: ReadPrec Nonce
readList :: ReadS [Nonce]
$creadList :: ReadS [Nonce]
readsPrec :: Int -> ReadS Nonce
$creadsPrec :: Int -> ReadS Nonce
Read, Nonce -> Nonce -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Nonce -> Nonce -> Bool
$c/= :: Nonce -> Nonce -> Bool
== :: Nonce -> Nonce -> Bool
$c== :: Nonce -> Nonce -> Bool
Eq, Eq Nonce
Nonce -> Nonce -> Bool
Nonce -> Nonce -> Ordering
Nonce -> Nonce -> Nonce
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Nonce -> Nonce -> Nonce
$cmin :: Nonce -> Nonce -> Nonce
max :: Nonce -> Nonce -> Nonce
$cmax :: Nonce -> Nonce -> Nonce
>= :: Nonce -> Nonce -> Bool
$c>= :: Nonce -> Nonce -> Bool
> :: Nonce -> Nonce -> Bool
$c> :: Nonce -> Nonce -> Bool
<= :: Nonce -> Nonce -> Bool
$c<= :: Nonce -> Nonce -> Bool
< :: Nonce -> Nonce -> Bool
$c< :: Nonce -> Nonce -> Bool
compare :: Nonce -> Nonce -> Ordering
$ccompare :: Nonce -> Nonce -> Ordering
Ord)

instance FromJSON Nonce where
  parseJSON :: Value -> Parser Nonce
parseJSON (String Text
nonce) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Text -> Nonce
Nonce Text
nonce
  parseJSON (Number Scientific
nonce) = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Nonce
Nonce forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show forall a b. (a -> b) -> a -> b
$ Scientific
nonce
  parseJSON Value
_ = forall (f :: * -> *) a. Alternative f => f a
empty

instance ToJSON Nonce where
  toJSON :: Nonce -> Value
toJSON (Nonce Text
t) = Text -> Value
String Text
t


-- | Represents a Message Reference
data MessageReference = MessageReference
  { MessageReference -> Maybe MessageId
referenceMessageId      :: Maybe MessageId  -- ^ id of the originating message
  , MessageReference -> Maybe ChannelId
referenceChannelId      :: Maybe ChannelId  -- ^ id of the originating message's channel
  , MessageReference -> Maybe GuildId
referenceGuildId        :: Maybe GuildId    -- ^ id of the originating message's guild
  , MessageReference -> Bool
failIfNotExists         :: Bool             -- ^ Whether to not send if reference not exist
  } deriving (Int -> MessageReference -> ShowS
[MessageReference] -> ShowS
MessageReference -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MessageReference] -> ShowS
$cshowList :: [MessageReference] -> ShowS
show :: MessageReference -> String
$cshow :: MessageReference -> String
showsPrec :: Int -> MessageReference -> ShowS
$cshowsPrec :: Int -> MessageReference -> ShowS
Show, ReadPrec [MessageReference]
ReadPrec MessageReference
Int -> ReadS MessageReference
ReadS [MessageReference]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MessageReference]
$creadListPrec :: ReadPrec [MessageReference]
readPrec :: ReadPrec MessageReference
$creadPrec :: ReadPrec MessageReference
readList :: ReadS [MessageReference]
$creadList :: ReadS [MessageReference]
readsPrec :: Int -> ReadS MessageReference
$creadsPrec :: Int -> ReadS MessageReference
Read, MessageReference -> MessageReference -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MessageReference -> MessageReference -> Bool
$c/= :: MessageReference -> MessageReference -> Bool
== :: MessageReference -> MessageReference -> Bool
$c== :: MessageReference -> MessageReference -> Bool
Eq, Eq MessageReference
MessageReference -> MessageReference -> Bool
MessageReference -> MessageReference -> Ordering
MessageReference -> MessageReference -> MessageReference
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: MessageReference -> MessageReference -> MessageReference
$cmin :: MessageReference -> MessageReference -> MessageReference
max :: MessageReference -> MessageReference -> MessageReference
$cmax :: MessageReference -> MessageReference -> MessageReference
>= :: MessageReference -> MessageReference -> Bool
$c>= :: MessageReference -> MessageReference -> Bool
> :: MessageReference -> MessageReference -> Bool
$c> :: MessageReference -> MessageReference -> Bool
<= :: MessageReference -> MessageReference -> Bool
$c<= :: MessageReference -> MessageReference -> Bool
< :: MessageReference -> MessageReference -> Bool
$c< :: MessageReference -> MessageReference -> Bool
compare :: MessageReference -> MessageReference -> Ordering
$ccompare :: MessageReference -> MessageReference -> Ordering
Ord)

instance FromJSON MessageReference where
  parseJSON :: Value -> Parser MessageReference
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"MessageReference" forall a b. (a -> b) -> a -> b
$ \Object
o ->
    Maybe MessageId
-> Maybe ChannelId -> Maybe GuildId -> Bool -> MessageReference
MessageReference forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"message_id"
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"channel_id"
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"guild_id"
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"fail_if_not_exists" forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
True

instance ToJSON MessageReference where
  toJSON :: MessageReference -> Value
toJSON MessageReference{Bool
Maybe MessageId
Maybe GuildId
Maybe ChannelId
failIfNotExists :: Bool
referenceGuildId :: Maybe GuildId
referenceChannelId :: Maybe ChannelId
referenceMessageId :: Maybe MessageId
failIfNotExists :: MessageReference -> Bool
referenceGuildId :: MessageReference -> Maybe GuildId
referenceChannelId :: MessageReference -> Maybe ChannelId
referenceMessageId :: MessageReference -> Maybe MessageId
..} = [Maybe Pair] -> Value
objectFromMaybes
              [ Key
"message_id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Maybe MessageId
referenceMessageId
              , Key
"channel_id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Maybe ChannelId
referenceChannelId
              , Key
"guild_id" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Maybe GuildId
referenceGuildId
              , Key
"fail_if_not_exists" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Bool
failIfNotExists
              ]

instance Default MessageReference where
  def :: MessageReference
def = MessageReference { referenceMessageId :: Maybe MessageId
referenceMessageId = forall a. Maybe a
Nothing
                         , referenceChannelId :: Maybe ChannelId
referenceChannelId = forall a. Maybe a
Nothing
                         , referenceGuildId :: Maybe GuildId
referenceGuildId   = forall a. Maybe a
Nothing
                         , failIfNotExists :: Bool
failIfNotExists    = Bool
False
                         }


data MessageType
  = MessageTypeDefault
  | MessageTypeRecipientAdd
  | MessageTypeRecipientRemove
  | MessageTypeCall
  | MessageTypeChannelNameChange
  | MessageTypeChannelIconChange
  | MessageTypeChannelPinnedMessage
  | MessageTypeGuildMemberJoin
  | MessageTypeUserPremiumGuildSubscription
  | MessageTypeUserPremiumGuildSubscriptionTier1
  | MessageTypeUserPremiumGuildSubscriptionTier2
  | MessageTypeUserPremiumGuildSubscriptionTier3
  | MessageTypeChannelFollowAdd
  | MessageTypeGuildDiscoveryDisqualified
  | MessageTypeGuildDiscoveryRequalified
  | MessageTypeGuildDiscoveryGracePeriodInitialWarning
  | MessageTypeGuildDiscoveryGracePeriodFinalWarning
  | MessageTypeThreadCreated
  | MessageTypeReply
  | MessageTypeChatInputCommand
  | MessageTypeThreadStarterMessage
  | MessageTypeGuildInviteReminder
  | MessageTypeContextMenuCommand
  deriving (Int -> MessageType -> ShowS
[MessageType] -> ShowS
MessageType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MessageType] -> ShowS
$cshowList :: [MessageType] -> ShowS
show :: MessageType -> String
$cshow :: MessageType -> String
showsPrec :: Int -> MessageType -> ShowS
$cshowsPrec :: Int -> MessageType -> ShowS
Show, ReadPrec [MessageType]
ReadPrec MessageType
Int -> ReadS MessageType
ReadS [MessageType]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MessageType]
$creadListPrec :: ReadPrec [MessageType]
readPrec :: ReadPrec MessageType
$creadPrec :: ReadPrec MessageType
readList :: ReadS [MessageType]
$creadList :: ReadS [MessageType]
readsPrec :: Int -> ReadS MessageType
$creadsPrec :: Int -> ReadS MessageType
Read, Typeable MessageType
MessageType -> DataType
MessageType -> Constr
(forall b. Data b => b -> b) -> MessageType -> MessageType
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> MessageType -> u
forall u. (forall d. Data d => d -> u) -> MessageType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MessageType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MessageType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MessageType -> m MessageType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MessageType -> m MessageType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MessageType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MessageType -> c MessageType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MessageType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MessageType)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MessageType -> m MessageType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MessageType -> m MessageType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MessageType -> m MessageType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MessageType -> m MessageType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MessageType -> m MessageType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MessageType -> m MessageType
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MessageType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MessageType -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> MessageType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MessageType -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MessageType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MessageType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MessageType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MessageType -> r
gmapT :: (forall b. Data b => b -> b) -> MessageType -> MessageType
$cgmapT :: (forall b. Data b => b -> b) -> MessageType -> MessageType
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MessageType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MessageType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MessageType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MessageType)
dataTypeOf :: MessageType -> DataType
$cdataTypeOf :: MessageType -> DataType
toConstr :: MessageType -> Constr
$ctoConstr :: MessageType -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MessageType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MessageType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MessageType -> c MessageType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MessageType -> c MessageType
Data, MessageType -> MessageType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MessageType -> MessageType -> Bool
$c/= :: MessageType -> MessageType -> Bool
== :: MessageType -> MessageType -> Bool
$c== :: MessageType -> MessageType -> Bool
Eq, Eq MessageType
MessageType -> MessageType -> Bool
MessageType -> MessageType -> Ordering
MessageType -> MessageType -> MessageType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: MessageType -> MessageType -> MessageType
$cmin :: MessageType -> MessageType -> MessageType
max :: MessageType -> MessageType -> MessageType
$cmax :: MessageType -> MessageType -> MessageType
>= :: MessageType -> MessageType -> Bool
$c>= :: MessageType -> MessageType -> Bool
> :: MessageType -> MessageType -> Bool
$c> :: MessageType -> MessageType -> Bool
<= :: MessageType -> MessageType -> Bool
$c<= :: MessageType -> MessageType -> Bool
< :: MessageType -> MessageType -> Bool
$c< :: MessageType -> MessageType -> Bool
compare :: MessageType -> MessageType -> Ordering
$ccompare :: MessageType -> MessageType -> Ordering
Ord)

instance InternalDiscordEnum MessageType where
  discordTypeStartValue :: MessageType
discordTypeStartValue = MessageType
MessageTypeDefault
  fromDiscordType :: MessageType -> Int
fromDiscordType MessageType
MessageTypeDefault = Int
0
  fromDiscordType MessageType
MessageTypeRecipientAdd = Int
1
  fromDiscordType MessageType
MessageTypeRecipientRemove = Int
2
  fromDiscordType MessageType
MessageTypeCall = Int
3
  fromDiscordType MessageType
MessageTypeChannelNameChange = Int
4
  fromDiscordType MessageType
MessageTypeChannelIconChange = Int
5
  fromDiscordType MessageType
MessageTypeChannelPinnedMessage = Int
6
  fromDiscordType MessageType
MessageTypeGuildMemberJoin = Int
7
  fromDiscordType MessageType
MessageTypeUserPremiumGuildSubscription = Int
8
  fromDiscordType MessageType
MessageTypeUserPremiumGuildSubscriptionTier1 = Int
9
  fromDiscordType MessageType
MessageTypeUserPremiumGuildSubscriptionTier2 = Int
10
  fromDiscordType MessageType
MessageTypeUserPremiumGuildSubscriptionTier3 = Int
11
  fromDiscordType MessageType
MessageTypeChannelFollowAdd = Int
12
  fromDiscordType MessageType
MessageTypeGuildDiscoveryDisqualified = Int
14
  fromDiscordType MessageType
MessageTypeGuildDiscoveryRequalified = Int
15
  fromDiscordType MessageType
MessageTypeGuildDiscoveryGracePeriodInitialWarning = Int
16
  fromDiscordType MessageType
MessageTypeGuildDiscoveryGracePeriodFinalWarning = Int
17
  fromDiscordType MessageType
MessageTypeThreadCreated = Int
18
  fromDiscordType MessageType
MessageTypeReply = Int
19
  fromDiscordType MessageType
MessageTypeChatInputCommand = Int
20
  fromDiscordType MessageType
MessageTypeThreadStarterMessage = Int
21
  fromDiscordType MessageType
MessageTypeGuildInviteReminder = Int
22
  fromDiscordType MessageType
MessageTypeContextMenuCommand = Int
23

instance ToJSON MessageType where
  toJSON :: MessageType -> Value
toJSON = forall a. ToJSON a => a -> Value
toJSON forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. InternalDiscordEnum a => a -> Int
fromDiscordType

instance FromJSON MessageType where
  parseJSON :: Value -> Parser MessageType
parseJSON = forall a. InternalDiscordEnum a => String -> Value -> Parser a
discordTypeParseJSON String
"MessageType"

data MessageActivity = MessageActivity
  { MessageActivity -> MessageActivityType
messageActivityType :: MessageActivityType
  , MessageActivity -> Maybe Text
messageActivityPartyId :: Maybe T.Text
  }
  deriving (Int -> MessageActivity -> ShowS
[MessageActivity] -> ShowS
MessageActivity -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MessageActivity] -> ShowS
$cshowList :: [MessageActivity] -> ShowS
show :: MessageActivity -> String
$cshow :: MessageActivity -> String
showsPrec :: Int -> MessageActivity -> ShowS
$cshowsPrec :: Int -> MessageActivity -> ShowS
Show, ReadPrec [MessageActivity]
ReadPrec MessageActivity
Int -> ReadS MessageActivity
ReadS [MessageActivity]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MessageActivity]
$creadListPrec :: ReadPrec [MessageActivity]
readPrec :: ReadPrec MessageActivity
$creadPrec :: ReadPrec MessageActivity
readList :: ReadS [MessageActivity]
$creadList :: ReadS [MessageActivity]
readsPrec :: Int -> ReadS MessageActivity
$creadsPrec :: Int -> ReadS MessageActivity
Read, Typeable MessageActivity
MessageActivity -> DataType
MessageActivity -> Constr
(forall b. Data b => b -> b) -> MessageActivity -> MessageActivity
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> MessageActivity -> u
forall u. (forall d. Data d => d -> u) -> MessageActivity -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MessageActivity -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MessageActivity -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MessageActivity -> m MessageActivity
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MessageActivity -> m MessageActivity
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MessageActivity
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MessageActivity -> c MessageActivity
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MessageActivity)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MessageActivity)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MessageActivity -> m MessageActivity
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MessageActivity -> m MessageActivity
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MessageActivity -> m MessageActivity
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MessageActivity -> m MessageActivity
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MessageActivity -> m MessageActivity
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MessageActivity -> m MessageActivity
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MessageActivity -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MessageActivity -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> MessageActivity -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MessageActivity -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MessageActivity -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MessageActivity -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MessageActivity -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MessageActivity -> r
gmapT :: (forall b. Data b => b -> b) -> MessageActivity -> MessageActivity
$cgmapT :: (forall b. Data b => b -> b) -> MessageActivity -> MessageActivity
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MessageActivity)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MessageActivity)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MessageActivity)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MessageActivity)
dataTypeOf :: MessageActivity -> DataType
$cdataTypeOf :: MessageActivity -> DataType
toConstr :: MessageActivity -> Constr
$ctoConstr :: MessageActivity -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MessageActivity
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MessageActivity
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MessageActivity -> c MessageActivity
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MessageActivity -> c MessageActivity
Data, MessageActivity -> MessageActivity -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MessageActivity -> MessageActivity -> Bool
$c/= :: MessageActivity -> MessageActivity -> Bool
== :: MessageActivity -> MessageActivity -> Bool
$c== :: MessageActivity -> MessageActivity -> Bool
Eq, Eq MessageActivity
MessageActivity -> MessageActivity -> Bool
MessageActivity -> MessageActivity -> Ordering
MessageActivity -> MessageActivity -> MessageActivity
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: MessageActivity -> MessageActivity -> MessageActivity
$cmin :: MessageActivity -> MessageActivity -> MessageActivity
max :: MessageActivity -> MessageActivity -> MessageActivity
$cmax :: MessageActivity -> MessageActivity -> MessageActivity
>= :: MessageActivity -> MessageActivity -> Bool
$c>= :: MessageActivity -> MessageActivity -> Bool
> :: MessageActivity -> MessageActivity -> Bool
$c> :: MessageActivity -> MessageActivity -> Bool
<= :: MessageActivity -> MessageActivity -> Bool
$c<= :: MessageActivity -> MessageActivity -> Bool
< :: MessageActivity -> MessageActivity -> Bool
$c< :: MessageActivity -> MessageActivity -> Bool
compare :: MessageActivity -> MessageActivity -> Ordering
$ccompare :: MessageActivity -> MessageActivity -> Ordering
Ord)

instance FromJSON MessageActivity where
  parseJSON :: Value -> Parser MessageActivity
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"MessageActivity" forall a b. (a -> b) -> a -> b
$ \Object
o ->
    MessageActivityType -> Maybe Text -> MessageActivity
MessageActivity forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.:   Key
"type"
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"party_id"

instance ToJSON MessageActivity where
  toJSON :: MessageActivity -> Value
toJSON MessageActivity{Maybe Text
MessageActivityType
messageActivityPartyId :: Maybe Text
messageActivityType :: MessageActivityType
messageActivityPartyId :: MessageActivity -> Maybe Text
messageActivityType :: MessageActivity -> MessageActivityType
..} = [Maybe Pair] -> Value
objectFromMaybes
              [ Key
"type" forall a. ToJSON a => Key -> a -> Maybe Pair
.== MessageActivityType
messageActivityType
              , Key
"party_id" forall a. ToJSON a => Key -> Maybe a -> Maybe Pair
.=? Maybe Text
messageActivityPartyId
              ]

data MessageActivityType
  = MessageActivityTypeJoin -- ^ Join a Rich Presence event
  | MessageActivityTypeSpectate -- ^ Spectate a Rich Presence event
  | MessageActivityTypeListen -- ^ Listen to a Rich Presence event
  | MessageActivityTypeJoinRequest -- ^ Request to join a Rich Presence event
  deriving (Int -> MessageActivityType -> ShowS
[MessageActivityType] -> ShowS
MessageActivityType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MessageActivityType] -> ShowS
$cshowList :: [MessageActivityType] -> ShowS
show :: MessageActivityType -> String
$cshow :: MessageActivityType -> String
showsPrec :: Int -> MessageActivityType -> ShowS
$cshowsPrec :: Int -> MessageActivityType -> ShowS
Show, ReadPrec [MessageActivityType]
ReadPrec MessageActivityType
Int -> ReadS MessageActivityType
ReadS [MessageActivityType]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MessageActivityType]
$creadListPrec :: ReadPrec [MessageActivityType]
readPrec :: ReadPrec MessageActivityType
$creadPrec :: ReadPrec MessageActivityType
readList :: ReadS [MessageActivityType]
$creadList :: ReadS [MessageActivityType]
readsPrec :: Int -> ReadS MessageActivityType
$creadsPrec :: Int -> ReadS MessageActivityType
Read, Typeable MessageActivityType
MessageActivityType -> DataType
MessageActivityType -> Constr
(forall b. Data b => b -> b)
-> MessageActivityType -> MessageActivityType
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> MessageActivityType -> u
forall u.
(forall d. Data d => d -> u) -> MessageActivityType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MessageActivityType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MessageActivityType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MessageActivityType -> m MessageActivityType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MessageActivityType -> m MessageActivityType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MessageActivityType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> MessageActivityType
-> c MessageActivityType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MessageActivityType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MessageActivityType)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MessageActivityType -> m MessageActivityType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MessageActivityType -> m MessageActivityType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MessageActivityType -> m MessageActivityType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MessageActivityType -> m MessageActivityType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MessageActivityType -> m MessageActivityType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MessageActivityType -> m MessageActivityType
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MessageActivityType -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MessageActivityType -> u
gmapQ :: forall u.
(forall d. Data d => d -> u) -> MessageActivityType -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> MessageActivityType -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MessageActivityType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MessageActivityType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MessageActivityType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MessageActivityType -> r
gmapT :: (forall b. Data b => b -> b)
-> MessageActivityType -> MessageActivityType
$cgmapT :: (forall b. Data b => b -> b)
-> MessageActivityType -> MessageActivityType
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MessageActivityType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MessageActivityType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MessageActivityType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MessageActivityType)
dataTypeOf :: MessageActivityType -> DataType
$cdataTypeOf :: MessageActivityType -> DataType
toConstr :: MessageActivityType -> Constr
$ctoConstr :: MessageActivityType -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MessageActivityType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MessageActivityType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> MessageActivityType
-> c MessageActivityType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> MessageActivityType
-> c MessageActivityType
Data, MessageActivityType -> MessageActivityType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MessageActivityType -> MessageActivityType -> Bool
$c/= :: MessageActivityType -> MessageActivityType -> Bool
== :: MessageActivityType -> MessageActivityType -> Bool
$c== :: MessageActivityType -> MessageActivityType -> Bool
Eq, Eq MessageActivityType
MessageActivityType -> MessageActivityType -> Bool
MessageActivityType -> MessageActivityType -> Ordering
MessageActivityType -> MessageActivityType -> MessageActivityType
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: MessageActivityType -> MessageActivityType -> MessageActivityType
$cmin :: MessageActivityType -> MessageActivityType -> MessageActivityType
max :: MessageActivityType -> MessageActivityType -> MessageActivityType
$cmax :: MessageActivityType -> MessageActivityType -> MessageActivityType
>= :: MessageActivityType -> MessageActivityType -> Bool
$c>= :: MessageActivityType -> MessageActivityType -> Bool
> :: MessageActivityType -> MessageActivityType -> Bool
$c> :: MessageActivityType -> MessageActivityType -> Bool
<= :: MessageActivityType -> MessageActivityType -> Bool
$c<= :: MessageActivityType -> MessageActivityType -> Bool
< :: MessageActivityType -> MessageActivityType -> Bool
$c< :: MessageActivityType -> MessageActivityType -> Bool
compare :: MessageActivityType -> MessageActivityType -> Ordering
$ccompare :: MessageActivityType -> MessageActivityType -> Ordering
Ord)

instance InternalDiscordEnum MessageActivityType where
  discordTypeStartValue :: MessageActivityType
discordTypeStartValue = MessageActivityType
MessageActivityTypeJoin
  fromDiscordType :: MessageActivityType -> Int
fromDiscordType MessageActivityType
MessageActivityTypeJoin = Int
1
  fromDiscordType MessageActivityType
MessageActivityTypeSpectate = Int
2
  fromDiscordType MessageActivityType
MessageActivityTypeListen = Int
3
  fromDiscordType MessageActivityType
MessageActivityTypeJoinRequest = Int
4

instance ToJSON MessageActivityType where
  toJSON :: MessageActivityType -> Value
toJSON = forall a. ToJSON a => a -> Value
toJSON forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. InternalDiscordEnum a => a -> Int
fromDiscordType

instance FromJSON MessageActivityType where
  parseJSON :: Value -> Parser MessageActivityType
parseJSON = forall a. InternalDiscordEnum a => String -> Value -> Parser a
discordTypeParseJSON String
"MessageActivityType"

-- | Types of flags to attach to the message.
data MessageFlag =
    MessageFlagCrossposted
  | MessageFlagIsCrosspost
  | MessageFlagSupressEmbeds
  | MessageFlagSourceMessageDeleted
  | MessageFlagUrgent
  | MessageFlagHasThread
  | MessageFlagEphemeral
  | MessageFlagLoading
  | MessageFlagFailedToMentionRollesInThread
  deriving (Int -> MessageFlag -> ShowS
[MessageFlag] -> ShowS
MessageFlag -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MessageFlag] -> ShowS
$cshowList :: [MessageFlag] -> ShowS
show :: MessageFlag -> String
$cshow :: MessageFlag -> String
showsPrec :: Int -> MessageFlag -> ShowS
$cshowsPrec :: Int -> MessageFlag -> ShowS
Show, ReadPrec [MessageFlag]
ReadPrec MessageFlag
Int -> ReadS MessageFlag
ReadS [MessageFlag]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MessageFlag]
$creadListPrec :: ReadPrec [MessageFlag]
readPrec :: ReadPrec MessageFlag
$creadPrec :: ReadPrec MessageFlag
readList :: ReadS [MessageFlag]
$creadList :: ReadS [MessageFlag]
readsPrec :: Int -> ReadS MessageFlag
$creadsPrec :: Int -> ReadS MessageFlag
Read, MessageFlag -> MessageFlag -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MessageFlag -> MessageFlag -> Bool
$c/= :: MessageFlag -> MessageFlag -> Bool
== :: MessageFlag -> MessageFlag -> Bool
$c== :: MessageFlag -> MessageFlag -> Bool
Eq, Typeable MessageFlag
MessageFlag -> DataType
MessageFlag -> Constr
(forall b. Data b => b -> b) -> MessageFlag -> MessageFlag
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> MessageFlag -> u
forall u. (forall d. Data d => d -> u) -> MessageFlag -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MessageFlag -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MessageFlag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MessageFlag -> m MessageFlag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MessageFlag -> m MessageFlag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MessageFlag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MessageFlag -> c MessageFlag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MessageFlag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MessageFlag)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MessageFlag -> m MessageFlag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MessageFlag -> m MessageFlag
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MessageFlag -> m MessageFlag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MessageFlag -> m MessageFlag
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MessageFlag -> m MessageFlag
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MessageFlag -> m MessageFlag
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MessageFlag -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MessageFlag -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> MessageFlag -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MessageFlag -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MessageFlag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MessageFlag -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MessageFlag -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MessageFlag -> r
gmapT :: (forall b. Data b => b -> b) -> MessageFlag -> MessageFlag
$cgmapT :: (forall b. Data b => b -> b) -> MessageFlag -> MessageFlag
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MessageFlag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MessageFlag)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MessageFlag)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MessageFlag)
dataTypeOf :: MessageFlag -> DataType
$cdataTypeOf :: MessageFlag -> DataType
toConstr :: MessageFlag -> Constr
$ctoConstr :: MessageFlag -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MessageFlag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MessageFlag
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MessageFlag -> c MessageFlag
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MessageFlag -> c MessageFlag
Data, Eq MessageFlag
MessageFlag -> MessageFlag -> Bool
MessageFlag -> MessageFlag -> Ordering
MessageFlag -> MessageFlag -> MessageFlag
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: MessageFlag -> MessageFlag -> MessageFlag
$cmin :: MessageFlag -> MessageFlag -> MessageFlag
max :: MessageFlag -> MessageFlag -> MessageFlag
$cmax :: MessageFlag -> MessageFlag -> MessageFlag
>= :: MessageFlag -> MessageFlag -> Bool
$c>= :: MessageFlag -> MessageFlag -> Bool
> :: MessageFlag -> MessageFlag -> Bool
$c> :: MessageFlag -> MessageFlag -> Bool
<= :: MessageFlag -> MessageFlag -> Bool
$c<= :: MessageFlag -> MessageFlag -> Bool
< :: MessageFlag -> MessageFlag -> Bool
$c< :: MessageFlag -> MessageFlag -> Bool
compare :: MessageFlag -> MessageFlag -> Ordering
$ccompare :: MessageFlag -> MessageFlag -> Ordering
Ord)

newtype MessageFlags = MessageFlags [MessageFlag]
  deriving (Int -> MessageFlags -> ShowS
[MessageFlags] -> ShowS
MessageFlags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MessageFlags] -> ShowS
$cshowList :: [MessageFlags] -> ShowS
show :: MessageFlags -> String
$cshow :: MessageFlags -> String
showsPrec :: Int -> MessageFlags -> ShowS
$cshowsPrec :: Int -> MessageFlags -> ShowS
Show, ReadPrec [MessageFlags]
ReadPrec MessageFlags
Int -> ReadS MessageFlags
ReadS [MessageFlags]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MessageFlags]
$creadListPrec :: ReadPrec [MessageFlags]
readPrec :: ReadPrec MessageFlags
$creadPrec :: ReadPrec MessageFlags
readList :: ReadS [MessageFlags]
$creadList :: ReadS [MessageFlags]
readsPrec :: Int -> ReadS MessageFlags
$creadsPrec :: Int -> ReadS MessageFlags
Read, MessageFlags -> MessageFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MessageFlags -> MessageFlags -> Bool
$c/= :: MessageFlags -> MessageFlags -> Bool
== :: MessageFlags -> MessageFlags -> Bool
$c== :: MessageFlags -> MessageFlags -> Bool
Eq, Eq MessageFlags
MessageFlags -> MessageFlags -> Bool
MessageFlags -> MessageFlags -> Ordering
MessageFlags -> MessageFlags -> MessageFlags
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: MessageFlags -> MessageFlags -> MessageFlags
$cmin :: MessageFlags -> MessageFlags -> MessageFlags
max :: MessageFlags -> MessageFlags -> MessageFlags
$cmax :: MessageFlags -> MessageFlags -> MessageFlags
>= :: MessageFlags -> MessageFlags -> Bool
$c>= :: MessageFlags -> MessageFlags -> Bool
> :: MessageFlags -> MessageFlags -> Bool
$c> :: MessageFlags -> MessageFlags -> Bool
<= :: MessageFlags -> MessageFlags -> Bool
$c<= :: MessageFlags -> MessageFlags -> Bool
< :: MessageFlags -> MessageFlags -> Bool
$c< :: MessageFlags -> MessageFlags -> Bool
compare :: MessageFlags -> MessageFlags -> Ordering
$ccompare :: MessageFlags -> MessageFlags -> Ordering
Ord)

instance InternalDiscordEnum MessageFlag where
  discordTypeStartValue :: MessageFlag
discordTypeStartValue = MessageFlag
MessageFlagCrossposted
  fromDiscordType :: MessageFlag -> Int
fromDiscordType MessageFlag
MessageFlagCrossposted = Int
1 forall a. Bits a => a -> Int -> a
`shift` Int
0
  fromDiscordType MessageFlag
MessageFlagIsCrosspost = Int
1 forall a. Bits a => a -> Int -> a
`shift` Int
1
  fromDiscordType MessageFlag
MessageFlagSupressEmbeds = Int
1 forall a. Bits a => a -> Int -> a
`shift` Int
2
  fromDiscordType MessageFlag
MessageFlagSourceMessageDeleted = Int
1 forall a. Bits a => a -> Int -> a
`shift` Int
3
  fromDiscordType MessageFlag
MessageFlagUrgent = Int
1 forall a. Bits a => a -> Int -> a
`shift` Int
4
  fromDiscordType MessageFlag
MessageFlagHasThread = Int
1 forall a. Bits a => a -> Int -> a
`shift` Int
5
  fromDiscordType MessageFlag
MessageFlagEphemeral = Int
1 forall a. Bits a => a -> Int -> a
`shift` Int
6
  fromDiscordType MessageFlag
MessageFlagLoading = Int
1 forall a. Bits a => a -> Int -> a
`shift` Int
7
  fromDiscordType MessageFlag
MessageFlagFailedToMentionRollesInThread = Int
1 forall a. Bits a => a -> Int -> a
`shift` Int
8

instance ToJSON MessageFlags where
  toJSON :: MessageFlags -> Value
toJSON (MessageFlags [MessageFlag]
fs) = Scientific -> Value
Number forall a b. (a -> b) -> a -> b
$ forall a. Num a => Integer -> a
fromInteger forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr forall a. Bits a => a -> a -> a
(.|.) Int
0 (forall a. InternalDiscordEnum a => a -> Int
fromDiscordType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [MessageFlag]
fs)

-- TODO: maybe make this a type class or something - the ability to handle flags automatically would be Very Good.

instance FromJSON MessageFlags where
  parseJSON :: Value -> Parser MessageFlags
parseJSON = forall a. String -> (Scientific -> Parser a) -> Value -> Parser a
withScientific String
"MessageFlags" forall a b. (a -> b) -> a -> b
$ \Scientific
s ->
      let i :: Int
i = forall a b. (RealFrac a, Integral b) => a -> b
round Scientific
s
          -- TODO check to see that we know about all the flags
          -- if i /= (i .&. range)
          -- range = sum $ fst <$> (discordTypeTable @MessageFlag)
      in forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [MessageFlag] -> MessageFlags
MessageFlags (forall a b. (a, b) -> b
snd forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. (a -> Bool) -> [a] -> [a]
filter (\(Int
i',MessageFlag
_) -> Int
i forall a. Bits a => a -> a -> a
.&. Int
i' forall a. Eq a => a -> a -> Bool
== Int
i') forall a. InternalDiscordEnum a => [(Int, a)]
discordTypeTable)

-- | This is sent on the message object when the message is a response to an Interaction without an existing message (i.e., any non-component interaction).
data MessageInteraction = MessageInteraction
  { MessageInteraction -> InteractionId
messageInteractionId :: InteractionId -- ^ Id of the interaction
  , MessageInteraction -> Integer
messageInteractionType :: Integer -- ^ Type of the interaction (liekly always application command)
  , MessageInteraction -> Text
messageInteractionName :: T.Text -- ^ Name of the interaction
  , MessageInteraction -> User
messageInteractionUser :: User -- ^ User who invoked the interaction
  } deriving (Int -> MessageInteraction -> ShowS
[MessageInteraction] -> ShowS
MessageInteraction -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MessageInteraction] -> ShowS
$cshowList :: [MessageInteraction] -> ShowS
show :: MessageInteraction -> String
$cshow :: MessageInteraction -> String
showsPrec :: Int -> MessageInteraction -> ShowS
$cshowsPrec :: Int -> MessageInteraction -> ShowS
Show, ReadPrec [MessageInteraction]
ReadPrec MessageInteraction
Int -> ReadS MessageInteraction
ReadS [MessageInteraction]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MessageInteraction]
$creadListPrec :: ReadPrec [MessageInteraction]
readPrec :: ReadPrec MessageInteraction
$creadPrec :: ReadPrec MessageInteraction
readList :: ReadS [MessageInteraction]
$creadList :: ReadS [MessageInteraction]
readsPrec :: Int -> ReadS MessageInteraction
$creadsPrec :: Int -> ReadS MessageInteraction
Read, MessageInteraction -> MessageInteraction -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MessageInteraction -> MessageInteraction -> Bool
$c/= :: MessageInteraction -> MessageInteraction -> Bool
== :: MessageInteraction -> MessageInteraction -> Bool
$c== :: MessageInteraction -> MessageInteraction -> Bool
Eq, Eq MessageInteraction
MessageInteraction -> MessageInteraction -> Bool
MessageInteraction -> MessageInteraction -> Ordering
MessageInteraction -> MessageInteraction -> MessageInteraction
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: MessageInteraction -> MessageInteraction -> MessageInteraction
$cmin :: MessageInteraction -> MessageInteraction -> MessageInteraction
max :: MessageInteraction -> MessageInteraction -> MessageInteraction
$cmax :: MessageInteraction -> MessageInteraction -> MessageInteraction
>= :: MessageInteraction -> MessageInteraction -> Bool
$c>= :: MessageInteraction -> MessageInteraction -> Bool
> :: MessageInteraction -> MessageInteraction -> Bool
$c> :: MessageInteraction -> MessageInteraction -> Bool
<= :: MessageInteraction -> MessageInteraction -> Bool
$c<= :: MessageInteraction -> MessageInteraction -> Bool
< :: MessageInteraction -> MessageInteraction -> Bool
$c< :: MessageInteraction -> MessageInteraction -> Bool
compare :: MessageInteraction -> MessageInteraction -> Ordering
$ccompare :: MessageInteraction -> MessageInteraction -> Ordering
Ord)

instance ToJSON MessageInteraction where
  toJSON :: MessageInteraction -> Value
toJSON MessageInteraction{Integer
Text
InteractionId
User
messageInteractionUser :: User
messageInteractionName :: Text
messageInteractionType :: Integer
messageInteractionId :: InteractionId
messageInteractionUser :: MessageInteraction -> User
messageInteractionName :: MessageInteraction -> Text
messageInteractionType :: MessageInteraction -> Integer
messageInteractionId :: MessageInteraction -> InteractionId
..} = [Maybe Pair] -> Value
objectFromMaybes
              [ Key
"id"   forall a. ToJSON a => Key -> a -> Maybe Pair
.== InteractionId
messageInteractionId
              , Key
"type" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Integer
messageInteractionType
              , Key
"name" forall a. ToJSON a => Key -> a -> Maybe Pair
.== Text
messageInteractionName
              , Key
"user" forall a. ToJSON a => Key -> a -> Maybe Pair
.== User
messageInteractionUser
              ]


instance FromJSON MessageInteraction where
  parseJSON :: Value -> Parser MessageInteraction
parseJSON = forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"MessageInteraction" forall a b. (a -> b) -> a -> b
$ \Object
o ->
    InteractionId -> Integer -> Text -> User -> MessageInteraction
MessageInteraction forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
                       forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type"
                       forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
                       forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user"