{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TemplateHaskell #-}

-- This file is part of the Wire Server implementation.
--
-- Copyright (C) 2022 Wire Swiss GmbH <opensource@wire.com>
--
-- This program is free software: you can redistribute it and/or modify it under
-- the terms of the GNU Affero General Public License as published by the Free
-- Software Foundation, either version 3 of the License, or (at your option) any
-- later version.
--
-- This program is distributed in the hope that it will be useful, but WITHOUT
-- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-- FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-- details.
--
-- You should have received a copy of the GNU Affero General Public License along
-- with this program. If not, see <https://www.gnu.org/licenses/>.

module Wire.API.Event.Conversation
  ( -- * Event
    Event (..),
    evtType,
    EventType (..),
    EventData (..),
    AddCodeResult (..),

    -- * Event lenses
    _EdMembersJoin,
    _EdMembersLeave,
    _EdConnect,
    _EdConvReceiptModeUpdate,
    _EdConvRename,
    _EdConvDelete,
    _EdConvAccessUpdate,
    _EdConvMessageTimerUpdate,
    _EdConvCodeUpdate,
    _EdConvCodeDelete,
    _EdMemberUpdate,
    _EdConversation,
    _EdTyping,
    _EdOtrMessage,
    _EdMLSMessage,
    _EdMLSWelcome,

    -- * Event data helpers
    SimpleMember (..),
    smId,
    SimpleMembers (..),
    Connect (..),
    MemberUpdateData (..),
    OtrMessage (..),

    -- * re-exports
    ConversationReceiptModeUpdate (..),
    ConversationRename (..),
    ConversationAccessData (..),
    ConversationMessageTimerUpdate (..),
    ConversationCode (..),
    QualifiedUserIdList (..),
  )
where

import Control.Applicative
import Control.Arrow ((&&&))
import Control.Lens (makePrisms, (?~), _1)
import Data.Aeson (FromJSON (..), ToJSON (..))
import Data.Aeson qualified as A
import Data.Aeson.KeyMap qualified as KeyMap
import Data.Id
import Data.Json.Util
import Data.OpenApi (deprecated)
import Data.OpenApi qualified as S
import Data.Qualified
import Data.SOP
import Data.Schema
import Data.Time
import Imports
import Test.QuickCheck qualified as QC
import URI.ByteString ()
import Wire.API.Conversation
import Wire.API.Conversation.Code (ConversationCode (..), ConversationCodeInfo)
import Wire.API.Conversation.Protocol (ProtocolUpdate (unProtocolUpdate))
import Wire.API.Conversation.Protocol qualified as P
import Wire.API.Conversation.Role
import Wire.API.Conversation.Typing
import Wire.API.Event.LeaveReason
import Wire.API.MLS.SubConversation
import Wire.API.Routes.MultiVerb
import Wire.API.Routes.Version
import Wire.API.User (QualifiedUserIdList (..), qualifiedUserIdListObjectSchema)
import Wire.Arbitrary (Arbitrary (arbitrary), GenericUniform (..))

--------------------------------------------------------------------------------
-- Event

data Event = Event
  { Event -> Qualified ConvId
evtConv :: Qualified ConvId,
    Event -> Maybe SubConvId
evtSubConv :: Maybe SubConvId,
    Event -> Qualified UserId
evtFrom :: Qualified UserId,
    Event -> UTCTime
evtTime :: UTCTime,
    Event -> EventData
evtData :: EventData
  }
  deriving stock (Event -> Event -> Bool
(Event -> Event -> Bool) -> (Event -> Event -> Bool) -> Eq Event
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Event -> Event -> Bool
== :: Event -> Event -> Bool
$c/= :: Event -> Event -> Bool
/= :: Event -> Event -> Bool
Eq, Int -> Event -> ShowS
[Event] -> ShowS
Event -> String
(Int -> Event -> ShowS)
-> (Event -> String) -> ([Event] -> ShowS) -> Show Event
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Event -> ShowS
showsPrec :: Int -> Event -> ShowS
$cshow :: Event -> String
show :: Event -> String
$cshowList :: [Event] -> ShowS
showList :: [Event] -> ShowS
Show, (forall x. Event -> Rep Event x)
-> (forall x. Rep Event x -> Event) -> Generic Event
forall x. Rep Event x -> Event
forall x. Event -> Rep Event x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Event -> Rep Event x
from :: forall x. Event -> Rep Event x
$cto :: forall x. Rep Event x -> Event
to :: forall x. Rep Event x -> Event
Generic)

evtType :: Event -> EventType
evtType :: Event -> EventType
evtType = EventData -> EventType
eventDataType (EventData -> EventType)
-> (Event -> EventData) -> Event -> EventType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Event -> EventData
evtData

instance Arbitrary Event where
  arbitrary :: Gen Event
arbitrary = do
    EventType
typ <- Gen EventType
forall a. Arbitrary a => Gen a
arbitrary
    Qualified ConvId
-> Maybe SubConvId
-> Qualified UserId
-> UTCTime
-> EventData
-> Event
Event
      (Qualified ConvId
 -> Maybe SubConvId
 -> Qualified UserId
 -> UTCTime
 -> EventData
 -> Event)
-> Gen (Qualified ConvId)
-> Gen
     (Maybe SubConvId
      -> Qualified UserId -> UTCTime -> EventData -> Event)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Qualified ConvId)
forall a. Arbitrary a => Gen a
arbitrary
      Gen
  (Maybe SubConvId
   -> Qualified UserId -> UTCTime -> EventData -> Event)
-> Gen (Maybe SubConvId)
-> Gen (Qualified UserId -> UTCTime -> EventData -> Event)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (Maybe SubConvId)
forall a. Arbitrary a => Gen a
arbitrary
      Gen (Qualified UserId -> UTCTime -> EventData -> Event)
-> Gen (Qualified UserId) -> Gen (UTCTime -> EventData -> Event)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (Qualified UserId)
forall a. Arbitrary a => Gen a
arbitrary
      Gen (UTCTime -> EventData -> Event)
-> Gen UTCTime -> Gen (EventData -> Event)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (UTCTime -> UTCTime
milli (UTCTime -> UTCTime) -> Gen UTCTime -> Gen UTCTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen UTCTime
forall a. Arbitrary a => Gen a
arbitrary)
      Gen (EventData -> Event) -> Gen EventData -> Gen Event
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> EventType -> Gen EventData
genEventData EventType
typ
    where
      milli :: UTCTime -> UTCTime
milli = UTCTimeMillis -> UTCTime
fromUTCTimeMillis (UTCTimeMillis -> UTCTime)
-> (UTCTime -> UTCTimeMillis) -> UTCTime -> UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UTCTime -> UTCTimeMillis
toUTCTimeMillis

data EventType
  = MemberJoin
  | MemberLeave
  | MemberStateUpdate
  | ConvRename
  | ConvAccessUpdate
  | ConvMessageTimerUpdate
  | ConvCodeUpdate
  | ConvCodeDelete
  | ConvCreate
  | ConvConnect
  | ConvDelete
  | ConvReceiptModeUpdate
  | OtrMessageAdd
  | MLSMessageAdd
  | MLSWelcome
  | Typing
  | ProtocolUpdate
  deriving stock (EventType -> EventType -> Bool
(EventType -> EventType -> Bool)
-> (EventType -> EventType -> Bool) -> Eq EventType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EventType -> EventType -> Bool
== :: EventType -> EventType -> Bool
$c/= :: EventType -> EventType -> Bool
/= :: EventType -> EventType -> Bool
Eq, Int -> EventType -> ShowS
[EventType] -> ShowS
EventType -> String
(Int -> EventType -> ShowS)
-> (EventType -> String)
-> ([EventType] -> ShowS)
-> Show EventType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EventType -> ShowS
showsPrec :: Int -> EventType -> ShowS
$cshow :: EventType -> String
show :: EventType -> String
$cshowList :: [EventType] -> ShowS
showList :: [EventType] -> ShowS
Show, (forall x. EventType -> Rep EventType x)
-> (forall x. Rep EventType x -> EventType) -> Generic EventType
forall x. Rep EventType x -> EventType
forall x. EventType -> Rep EventType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. EventType -> Rep EventType x
from :: forall x. EventType -> Rep EventType x
$cto :: forall x. Rep EventType x -> EventType
to :: forall x. Rep EventType x -> EventType
Generic, Int -> EventType
EventType -> Int
EventType -> [EventType]
EventType -> EventType
EventType -> EventType -> [EventType]
EventType -> EventType -> EventType -> [EventType]
(EventType -> EventType)
-> (EventType -> EventType)
-> (Int -> EventType)
-> (EventType -> Int)
-> (EventType -> [EventType])
-> (EventType -> EventType -> [EventType])
-> (EventType -> EventType -> [EventType])
-> (EventType -> EventType -> EventType -> [EventType])
-> Enum EventType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: EventType -> EventType
succ :: EventType -> EventType
$cpred :: EventType -> EventType
pred :: EventType -> EventType
$ctoEnum :: Int -> EventType
toEnum :: Int -> EventType
$cfromEnum :: EventType -> Int
fromEnum :: EventType -> Int
$cenumFrom :: EventType -> [EventType]
enumFrom :: EventType -> [EventType]
$cenumFromThen :: EventType -> EventType -> [EventType]
enumFromThen :: EventType -> EventType -> [EventType]
$cenumFromTo :: EventType -> EventType -> [EventType]
enumFromTo :: EventType -> EventType -> [EventType]
$cenumFromThenTo :: EventType -> EventType -> EventType -> [EventType]
enumFromThenTo :: EventType -> EventType -> EventType -> [EventType]
Enum, EventType
EventType -> EventType -> Bounded EventType
forall a. a -> a -> Bounded a
$cminBound :: EventType
minBound :: EventType
$cmaxBound :: EventType
maxBound :: EventType
Bounded, Eq EventType
Eq EventType =>
(EventType -> EventType -> Ordering)
-> (EventType -> EventType -> Bool)
-> (EventType -> EventType -> Bool)
-> (EventType -> EventType -> Bool)
-> (EventType -> EventType -> Bool)
-> (EventType -> EventType -> EventType)
-> (EventType -> EventType -> EventType)
-> Ord EventType
EventType -> EventType -> Bool
EventType -> EventType -> Ordering
EventType -> EventType -> EventType
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
$ccompare :: EventType -> EventType -> Ordering
compare :: EventType -> EventType -> Ordering
$c< :: EventType -> EventType -> Bool
< :: EventType -> EventType -> Bool
$c<= :: EventType -> EventType -> Bool
<= :: EventType -> EventType -> Bool
$c> :: EventType -> EventType -> Bool
> :: EventType -> EventType -> Bool
$c>= :: EventType -> EventType -> Bool
>= :: EventType -> EventType -> Bool
$cmax :: EventType -> EventType -> EventType
max :: EventType -> EventType -> EventType
$cmin :: EventType -> EventType -> EventType
min :: EventType -> EventType -> EventType
Ord)
  deriving (Gen EventType
Gen EventType -> (EventType -> [EventType]) -> Arbitrary EventType
EventType -> [EventType]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen EventType
arbitrary :: Gen EventType
$cshrink :: EventType -> [EventType]
shrink :: EventType -> [EventType]
Arbitrary) via (GenericUniform EventType)
  deriving (Value -> Parser [EventType]
Value -> Parser EventType
(Value -> Parser EventType)
-> (Value -> Parser [EventType]) -> FromJSON EventType
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser EventType
parseJSON :: Value -> Parser EventType
$cparseJSONList :: Value -> Parser [EventType]
parseJSONList :: Value -> Parser [EventType]
FromJSON, [EventType] -> Value
[EventType] -> Encoding
EventType -> Value
EventType -> Encoding
(EventType -> Value)
-> (EventType -> Encoding)
-> ([EventType] -> Value)
-> ([EventType] -> Encoding)
-> ToJSON EventType
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: EventType -> Value
toJSON :: EventType -> Value
$ctoEncoding :: EventType -> Encoding
toEncoding :: EventType -> Encoding
$ctoJSONList :: [EventType] -> Value
toJSONList :: [EventType] -> Value
$ctoEncodingList :: [EventType] -> Encoding
toEncodingList :: [EventType] -> Encoding
ToJSON, Typeable EventType
Typeable EventType =>
(Proxy EventType -> Declare (Definitions Schema) NamedSchema)
-> ToSchema EventType
Proxy EventType -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy EventType -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy EventType -> Declare (Definitions Schema) NamedSchema
S.ToSchema) via Schema EventType

instance ToSchema EventType where
  schema :: ValueSchema NamedSwaggerDoc EventType
schema =
    forall v doc a b.
(With v, HasEnum v doc) =>
Text
-> SchemaP [Value] v (Alt Maybe v) a b
-> SchemaP doc Value Value a b
enum @Text Text
"EventType" (SchemaP [Value] Text (Alt Maybe Text) EventType EventType
 -> ValueSchema NamedSwaggerDoc EventType)
-> SchemaP [Value] Text (Alt Maybe Text) EventType EventType
-> ValueSchema NamedSwaggerDoc EventType
forall a b. (a -> b) -> a -> b
$
      [SchemaP [Value] Text (Alt Maybe Text) EventType EventType]
-> SchemaP [Value] Text (Alt Maybe Text) EventType EventType
forall a. Monoid a => [a] -> a
mconcat
        [ Text
-> EventType
-> SchemaP [Value] Text (Alt Maybe Text) EventType EventType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"conversation.member-join" EventType
MemberJoin,
          Text
-> EventType
-> SchemaP [Value] Text (Alt Maybe Text) EventType EventType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"conversation.member-leave" EventType
MemberLeave,
          Text
-> EventType
-> SchemaP [Value] Text (Alt Maybe Text) EventType EventType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"conversation.member-update" EventType
MemberStateUpdate,
          Text
-> EventType
-> SchemaP [Value] Text (Alt Maybe Text) EventType EventType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"conversation.rename" EventType
ConvRename,
          Text
-> EventType
-> SchemaP [Value] Text (Alt Maybe Text) EventType EventType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"conversation.access-update" EventType
ConvAccessUpdate,
          Text
-> EventType
-> SchemaP [Value] Text (Alt Maybe Text) EventType EventType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"conversation.receipt-mode-update" EventType
ConvReceiptModeUpdate,
          Text
-> EventType
-> SchemaP [Value] Text (Alt Maybe Text) EventType EventType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"conversation.message-timer-update" EventType
ConvMessageTimerUpdate,
          Text
-> EventType
-> SchemaP [Value] Text (Alt Maybe Text) EventType EventType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"conversation.code-update" EventType
ConvCodeUpdate,
          Text
-> EventType
-> SchemaP [Value] Text (Alt Maybe Text) EventType EventType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"conversation.code-delete" EventType
ConvCodeDelete,
          Text
-> EventType
-> SchemaP [Value] Text (Alt Maybe Text) EventType EventType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"conversation.create" EventType
ConvCreate,
          Text
-> EventType
-> SchemaP [Value] Text (Alt Maybe Text) EventType EventType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"conversation.delete" EventType
ConvDelete,
          Text
-> EventType
-> SchemaP [Value] Text (Alt Maybe Text) EventType EventType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"conversation.connect-request" EventType
ConvConnect,
          Text
-> EventType
-> SchemaP [Value] Text (Alt Maybe Text) EventType EventType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"conversation.typing" EventType
Typing,
          Text
-> EventType
-> SchemaP [Value] Text (Alt Maybe Text) EventType EventType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"conversation.otr-message-add" EventType
OtrMessageAdd,
          Text
-> EventType
-> SchemaP [Value] Text (Alt Maybe Text) EventType EventType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"conversation.mls-message-add" EventType
MLSMessageAdd,
          Text
-> EventType
-> SchemaP [Value] Text (Alt Maybe Text) EventType EventType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"conversation.mls-welcome" EventType
MLSWelcome,
          Text
-> EventType
-> SchemaP [Value] Text (Alt Maybe Text) EventType EventType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"conversation.protocol-update" EventType
ProtocolUpdate
        ]

data EventData
  = EdMembersJoin SimpleMembers
  | EdMembersLeave EdMemberLeftReason QualifiedUserIdList
  | EdConnect Connect
  | EdConvReceiptModeUpdate ConversationReceiptModeUpdate
  | EdConvRename ConversationRename
  | EdConvDelete
  | EdConvAccessUpdate ConversationAccessData
  | EdConvMessageTimerUpdate ConversationMessageTimerUpdate
  | EdConvCodeUpdate ConversationCodeInfo
  | EdConvCodeDelete
  | EdMemberUpdate MemberUpdateData
  | EdConversation Conversation
  | EdTyping TypingStatus
  | EdOtrMessage OtrMessage
  | EdMLSMessage ByteString
  | EdMLSWelcome ByteString
  | EdProtocolUpdate P.ProtocolTag
  deriving stock (EventData -> EventData -> Bool
(EventData -> EventData -> Bool)
-> (EventData -> EventData -> Bool) -> Eq EventData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EventData -> EventData -> Bool
== :: EventData -> EventData -> Bool
$c/= :: EventData -> EventData -> Bool
/= :: EventData -> EventData -> Bool
Eq, Int -> EventData -> ShowS
[EventData] -> ShowS
EventData -> String
(Int -> EventData -> ShowS)
-> (EventData -> String)
-> ([EventData] -> ShowS)
-> Show EventData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EventData -> ShowS
showsPrec :: Int -> EventData -> ShowS
$cshow :: EventData -> String
show :: EventData -> String
$cshowList :: [EventData] -> ShowS
showList :: [EventData] -> ShowS
Show, (forall x. EventData -> Rep EventData x)
-> (forall x. Rep EventData x -> EventData) -> Generic EventData
forall x. Rep EventData x -> EventData
forall x. EventData -> Rep EventData x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. EventData -> Rep EventData x
from :: forall x. EventData -> Rep EventData x
$cto :: forall x. Rep EventData x -> EventData
to :: forall x. Rep EventData x -> EventData
Generic)

genEventData :: EventType -> QC.Gen EventData
genEventData :: EventType -> Gen EventData
genEventData = \case
  EventType
MemberJoin -> SimpleMembers -> EventData
EdMembersJoin (SimpleMembers -> EventData) -> Gen SimpleMembers -> Gen EventData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen SimpleMembers
forall a. Arbitrary a => Gen a
arbitrary
  EventType
MemberLeave -> EdMemberLeftReason -> QualifiedUserIdList -> EventData
EdMembersLeave (EdMemberLeftReason -> QualifiedUserIdList -> EventData)
-> Gen EdMemberLeftReason -> Gen (QualifiedUserIdList -> EventData)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen EdMemberLeftReason
forall a. Arbitrary a => Gen a
arbitrary Gen (QualifiedUserIdList -> EventData)
-> Gen QualifiedUserIdList -> Gen EventData
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen QualifiedUserIdList
forall a. Arbitrary a => Gen a
arbitrary
  EventType
MemberStateUpdate -> MemberUpdateData -> EventData
EdMemberUpdate (MemberUpdateData -> EventData)
-> Gen MemberUpdateData -> Gen EventData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen MemberUpdateData
forall a. Arbitrary a => Gen a
arbitrary
  EventType
ConvRename -> ConversationRename -> EventData
EdConvRename (ConversationRename -> EventData)
-> Gen ConversationRename -> Gen EventData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ConversationRename
forall a. Arbitrary a => Gen a
arbitrary
  EventType
ConvAccessUpdate -> ConversationAccessData -> EventData
EdConvAccessUpdate (ConversationAccessData -> EventData)
-> Gen ConversationAccessData -> Gen EventData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ConversationAccessData
forall a. Arbitrary a => Gen a
arbitrary
  EventType
ConvMessageTimerUpdate -> ConversationMessageTimerUpdate -> EventData
EdConvMessageTimerUpdate (ConversationMessageTimerUpdate -> EventData)
-> Gen ConversationMessageTimerUpdate -> Gen EventData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ConversationMessageTimerUpdate
forall a. Arbitrary a => Gen a
arbitrary
  EventType
ConvCodeUpdate -> ConversationCodeInfo -> EventData
EdConvCodeUpdate (ConversationCodeInfo -> EventData)
-> Gen ConversationCodeInfo -> Gen EventData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ConversationCodeInfo
forall a. Arbitrary a => Gen a
arbitrary
  EventType
ConvCodeDelete -> EventData -> Gen EventData
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure EventData
EdConvCodeDelete
  EventType
ConvConnect -> Connect -> EventData
EdConnect (Connect -> EventData) -> Gen Connect -> Gen EventData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Connect
forall a. Arbitrary a => Gen a
arbitrary
  EventType
ConvCreate -> Conversation -> EventData
EdConversation (Conversation -> EventData) -> Gen Conversation -> Gen EventData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Conversation
forall a. Arbitrary a => Gen a
arbitrary
  EventType
ConvReceiptModeUpdate -> ConversationReceiptModeUpdate -> EventData
EdConvReceiptModeUpdate (ConversationReceiptModeUpdate -> EventData)
-> Gen ConversationReceiptModeUpdate -> Gen EventData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ConversationReceiptModeUpdate
forall a. Arbitrary a => Gen a
arbitrary
  EventType
Typing -> TypingStatus -> EventData
EdTyping (TypingStatus -> EventData) -> Gen TypingStatus -> Gen EventData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen TypingStatus
forall a. Arbitrary a => Gen a
arbitrary
  EventType
OtrMessageAdd -> OtrMessage -> EventData
EdOtrMessage (OtrMessage -> EventData) -> Gen OtrMessage -> Gen EventData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen OtrMessage
forall a. Arbitrary a => Gen a
arbitrary
  EventType
MLSMessageAdd -> ByteString -> EventData
EdMLSMessage (ByteString -> EventData) -> Gen ByteString -> Gen EventData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByteString
forall a. Arbitrary a => Gen a
arbitrary
  EventType
MLSWelcome -> ByteString -> EventData
EdMLSWelcome (ByteString -> EventData) -> Gen ByteString -> Gen EventData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ByteString
forall a. Arbitrary a => Gen a
arbitrary
  EventType
ConvDelete -> EventData -> Gen EventData
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure EventData
EdConvDelete
  EventType
ProtocolUpdate -> ProtocolTag -> EventData
EdProtocolUpdate (ProtocolTag -> EventData) -> Gen ProtocolTag -> Gen EventData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen ProtocolTag
forall a. Arbitrary a => Gen a
arbitrary

eventDataType :: EventData -> EventType
eventDataType :: EventData -> EventType
eventDataType (EdMembersJoin SimpleMembers
_) = EventType
MemberJoin
eventDataType (EdMembersLeave EdMemberLeftReason
_ QualifiedUserIdList
_) = EventType
MemberLeave
eventDataType (EdMemberUpdate MemberUpdateData
_) = EventType
MemberStateUpdate
eventDataType (EdConvRename ConversationRename
_) = EventType
ConvRename
eventDataType (EdConvAccessUpdate ConversationAccessData
_) = EventType
ConvAccessUpdate
eventDataType (EdConvMessageTimerUpdate ConversationMessageTimerUpdate
_) = EventType
ConvMessageTimerUpdate
eventDataType (EdConvCodeUpdate ConversationCodeInfo
_) = EventType
ConvCodeUpdate
eventDataType EventData
EdConvCodeDelete = EventType
ConvCodeDelete
eventDataType (EdConnect Connect
_) = EventType
ConvConnect
eventDataType (EdConversation Conversation
_) = EventType
ConvCreate
eventDataType (EdConvReceiptModeUpdate ConversationReceiptModeUpdate
_) = EventType
ConvReceiptModeUpdate
eventDataType (EdTyping TypingStatus
_) = EventType
Typing
eventDataType (EdOtrMessage OtrMessage
_) = EventType
OtrMessageAdd
eventDataType (EdMLSMessage ByteString
_) = EventType
MLSMessageAdd
eventDataType (EdMLSWelcome ByteString
_) = EventType
MLSWelcome
eventDataType EventData
EdConvDelete = EventType
ConvDelete
eventDataType (EdProtocolUpdate ProtocolTag
_) = EventType
ProtocolUpdate

--------------------------------------------------------------------------------
-- Event data helpers

newtype SimpleMembers = SimpleMembers
  { SimpleMembers -> [SimpleMember]
mMembers :: [SimpleMember]
  }
  deriving stock (SimpleMembers -> SimpleMembers -> Bool
(SimpleMembers -> SimpleMembers -> Bool)
-> (SimpleMembers -> SimpleMembers -> Bool) -> Eq SimpleMembers
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SimpleMembers -> SimpleMembers -> Bool
== :: SimpleMembers -> SimpleMembers -> Bool
$c/= :: SimpleMembers -> SimpleMembers -> Bool
/= :: SimpleMembers -> SimpleMembers -> Bool
Eq, Int -> SimpleMembers -> ShowS
[SimpleMembers] -> ShowS
SimpleMembers -> String
(Int -> SimpleMembers -> ShowS)
-> (SimpleMembers -> String)
-> ([SimpleMembers] -> ShowS)
-> Show SimpleMembers
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SimpleMembers -> ShowS
showsPrec :: Int -> SimpleMembers -> ShowS
$cshow :: SimpleMembers -> String
show :: SimpleMembers -> String
$cshowList :: [SimpleMembers] -> ShowS
showList :: [SimpleMembers] -> ShowS
Show, (forall x. SimpleMembers -> Rep SimpleMembers x)
-> (forall x. Rep SimpleMembers x -> SimpleMembers)
-> Generic SimpleMembers
forall x. Rep SimpleMembers x -> SimpleMembers
forall x. SimpleMembers -> Rep SimpleMembers x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SimpleMembers -> Rep SimpleMembers x
from :: forall x. SimpleMembers -> Rep SimpleMembers x
$cto :: forall x. Rep SimpleMembers x -> SimpleMembers
to :: forall x. Rep SimpleMembers x -> SimpleMembers
Generic)
  deriving newtype (Gen SimpleMembers
Gen SimpleMembers
-> (SimpleMembers -> [SimpleMembers]) -> Arbitrary SimpleMembers
SimpleMembers -> [SimpleMembers]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen SimpleMembers
arbitrary :: Gen SimpleMembers
$cshrink :: SimpleMembers -> [SimpleMembers]
shrink :: SimpleMembers -> [SimpleMembers]
Arbitrary)
  deriving (Value -> Parser [SimpleMembers]
Value -> Parser SimpleMembers
(Value -> Parser SimpleMembers)
-> (Value -> Parser [SimpleMembers]) -> FromJSON SimpleMembers
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser SimpleMembers
parseJSON :: Value -> Parser SimpleMembers
$cparseJSONList :: Value -> Parser [SimpleMembers]
parseJSONList :: Value -> Parser [SimpleMembers]
FromJSON, [SimpleMembers] -> Value
[SimpleMembers] -> Encoding
SimpleMembers -> Value
SimpleMembers -> Encoding
(SimpleMembers -> Value)
-> (SimpleMembers -> Encoding)
-> ([SimpleMembers] -> Value)
-> ([SimpleMembers] -> Encoding)
-> ToJSON SimpleMembers
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: SimpleMembers -> Value
toJSON :: SimpleMembers -> Value
$ctoEncoding :: SimpleMembers -> Encoding
toEncoding :: SimpleMembers -> Encoding
$ctoJSONList :: [SimpleMembers] -> Value
toJSONList :: [SimpleMembers] -> Value
$ctoEncodingList :: [SimpleMembers] -> Encoding
toEncodingList :: [SimpleMembers] -> Encoding
ToJSON, Typeable SimpleMembers
Typeable SimpleMembers =>
(Proxy SimpleMembers -> Declare (Definitions Schema) NamedSchema)
-> ToSchema SimpleMembers
Proxy SimpleMembers -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy SimpleMembers -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy SimpleMembers -> Declare (Definitions Schema) NamedSchema
S.ToSchema) via Schema SimpleMembers

instance ToSchema SimpleMembers where
  schema :: ValueSchema NamedSwaggerDoc SimpleMembers
schema =
    Text
-> SchemaP SwaggerDoc Object [Pair] SimpleMembers SimpleMembers
-> ValueSchema NamedSwaggerDoc SimpleMembers
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"SimpleMembers" (SchemaP SwaggerDoc Object [Pair] SimpleMembers SimpleMembers
 -> ValueSchema NamedSwaggerDoc SimpleMembers)
-> SchemaP SwaggerDoc Object [Pair] SimpleMembers SimpleMembers
-> ValueSchema NamedSwaggerDoc SimpleMembers
forall a b. (a -> b) -> a -> b
$
      [SimpleMember] -> SimpleMembers
SimpleMembers
        ([SimpleMember] -> SimpleMembers)
-> SchemaP SwaggerDoc Object [Pair] SimpleMembers [SimpleMember]
-> SchemaP SwaggerDoc Object [Pair] SimpleMembers SimpleMembers
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SimpleMembers -> [SimpleMember]
mMembers (SimpleMembers -> [SimpleMember])
-> SchemaP SwaggerDoc Object [Pair] [SimpleMember] [SimpleMember]
-> SchemaP SwaggerDoc Object [Pair] SimpleMembers [SimpleMember]
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP SwaggerDoc Value Value [SimpleMember] [SimpleMember]
-> SchemaP SwaggerDoc Object [Pair] [SimpleMember] [SimpleMember]
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"users" (ValueSchema NamedSwaggerDoc SimpleMember
-> SchemaP SwaggerDoc Value Value [SimpleMember] [SimpleMember]
forall ndoc doc a.
(HasArray ndoc doc, HasName ndoc) =>
ValueSchema ndoc a -> ValueSchema doc [a]
array ValueSchema NamedSwaggerDoc SimpleMember
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP SwaggerDoc Object [Pair] SimpleMembers SimpleMembers
-> SchemaP SwaggerDoc Object [Pair] SimpleMembers (Maybe [UserId])
-> SchemaP SwaggerDoc Object [Pair] SimpleMembers SimpleMembers
forall a b.
SchemaP SwaggerDoc Object [Pair] SimpleMembers a
-> SchemaP SwaggerDoc Object [Pair] SimpleMembers b
-> SchemaP SwaggerDoc Object [Pair] SimpleMembers a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ((SimpleMember -> UserId) -> [SimpleMember] -> [UserId]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap SimpleMember -> UserId
smId ([SimpleMember] -> [UserId])
-> (SimpleMembers -> [SimpleMember]) -> SimpleMembers -> [UserId]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SimpleMembers -> [SimpleMember]
mMembers)
          (SimpleMembers -> [UserId])
-> SchemaP SwaggerDoc Object [Pair] [UserId] (Maybe [UserId])
-> SchemaP SwaggerDoc Object [Pair] SimpleMembers (Maybe [UserId])
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] [UserId] [UserId]
-> SchemaP SwaggerDoc Object [Pair] [UserId] (Maybe [UserId])
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
            ( Text
-> (SwaggerDoc -> SwaggerDoc)
-> SchemaP SwaggerDoc Value Value [UserId] [UserId]
-> SchemaP SwaggerDoc Object [Pair] [UserId] [UserId]
forall doc' doc a b.
HasField doc' doc =>
Text
-> (doc' -> doc')
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a b
fieldWithDocModifier
                Text
"user_ids"
                ( ((Maybe Text -> Identity (Maybe Text))
-> SwaggerDoc -> Identity SwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' SwaggerDoc (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> SwaggerDoc -> Identity SwaggerDoc)
-> Text -> SwaggerDoc -> SwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"deprecated")
                    (SwaggerDoc -> SwaggerDoc)
-> (SwaggerDoc -> SwaggerDoc) -> SwaggerDoc -> SwaggerDoc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Maybe Bool -> Identity (Maybe Bool))
-> SwaggerDoc -> Identity SwaggerDoc
forall s a. HasDeprecated s a => Lens' s a
Lens' SwaggerDoc (Maybe Bool)
deprecated ((Maybe Bool -> Identity (Maybe Bool))
 -> SwaggerDoc -> Identity SwaggerDoc)
-> Bool -> SwaggerDoc -> SwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Bool
True)
                )
                (ValueSchema NamedSwaggerDoc UserId
-> SchemaP SwaggerDoc Value Value [UserId] [UserId]
forall ndoc doc a.
(HasArray ndoc doc, HasName ndoc) =>
ValueSchema ndoc a -> ValueSchema doc [a]
array ValueSchema NamedSwaggerDoc UserId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
            )

data SimpleMember = SimpleMember
  { SimpleMember -> Qualified UserId
smQualifiedId :: Qualified UserId,
    SimpleMember -> RoleName
smConvRoleName :: RoleName
  }
  deriving stock (SimpleMember -> SimpleMember -> Bool
(SimpleMember -> SimpleMember -> Bool)
-> (SimpleMember -> SimpleMember -> Bool) -> Eq SimpleMember
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SimpleMember -> SimpleMember -> Bool
== :: SimpleMember -> SimpleMember -> Bool
$c/= :: SimpleMember -> SimpleMember -> Bool
/= :: SimpleMember -> SimpleMember -> Bool
Eq, Eq SimpleMember
Eq SimpleMember =>
(SimpleMember -> SimpleMember -> Ordering)
-> (SimpleMember -> SimpleMember -> Bool)
-> (SimpleMember -> SimpleMember -> Bool)
-> (SimpleMember -> SimpleMember -> Bool)
-> (SimpleMember -> SimpleMember -> Bool)
-> (SimpleMember -> SimpleMember -> SimpleMember)
-> (SimpleMember -> SimpleMember -> SimpleMember)
-> Ord SimpleMember
SimpleMember -> SimpleMember -> Bool
SimpleMember -> SimpleMember -> Ordering
SimpleMember -> SimpleMember -> SimpleMember
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
$ccompare :: SimpleMember -> SimpleMember -> Ordering
compare :: SimpleMember -> SimpleMember -> Ordering
$c< :: SimpleMember -> SimpleMember -> Bool
< :: SimpleMember -> SimpleMember -> Bool
$c<= :: SimpleMember -> SimpleMember -> Bool
<= :: SimpleMember -> SimpleMember -> Bool
$c> :: SimpleMember -> SimpleMember -> Bool
> :: SimpleMember -> SimpleMember -> Bool
$c>= :: SimpleMember -> SimpleMember -> Bool
>= :: SimpleMember -> SimpleMember -> Bool
$cmax :: SimpleMember -> SimpleMember -> SimpleMember
max :: SimpleMember -> SimpleMember -> SimpleMember
$cmin :: SimpleMember -> SimpleMember -> SimpleMember
min :: SimpleMember -> SimpleMember -> SimpleMember
Ord, Int -> SimpleMember -> ShowS
[SimpleMember] -> ShowS
SimpleMember -> String
(Int -> SimpleMember -> ShowS)
-> (SimpleMember -> String)
-> ([SimpleMember] -> ShowS)
-> Show SimpleMember
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SimpleMember -> ShowS
showsPrec :: Int -> SimpleMember -> ShowS
$cshow :: SimpleMember -> String
show :: SimpleMember -> String
$cshowList :: [SimpleMember] -> ShowS
showList :: [SimpleMember] -> ShowS
Show, (forall x. SimpleMember -> Rep SimpleMember x)
-> (forall x. Rep SimpleMember x -> SimpleMember)
-> Generic SimpleMember
forall x. Rep SimpleMember x -> SimpleMember
forall x. SimpleMember -> Rep SimpleMember x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SimpleMember -> Rep SimpleMember x
from :: forall x. SimpleMember -> Rep SimpleMember x
$cto :: forall x. Rep SimpleMember x -> SimpleMember
to :: forall x. Rep SimpleMember x -> SimpleMember
Generic)
  deriving (Gen SimpleMember
Gen SimpleMember
-> (SimpleMember -> [SimpleMember]) -> Arbitrary SimpleMember
SimpleMember -> [SimpleMember]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen SimpleMember
arbitrary :: Gen SimpleMember
$cshrink :: SimpleMember -> [SimpleMember]
shrink :: SimpleMember -> [SimpleMember]
Arbitrary) via (GenericUniform SimpleMember)
  deriving (Value -> Parser [SimpleMember]
Value -> Parser SimpleMember
(Value -> Parser SimpleMember)
-> (Value -> Parser [SimpleMember]) -> FromJSON SimpleMember
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser SimpleMember
parseJSON :: Value -> Parser SimpleMember
$cparseJSONList :: Value -> Parser [SimpleMember]
parseJSONList :: Value -> Parser [SimpleMember]
FromJSON, [SimpleMember] -> Value
[SimpleMember] -> Encoding
SimpleMember -> Value
SimpleMember -> Encoding
(SimpleMember -> Value)
-> (SimpleMember -> Encoding)
-> ([SimpleMember] -> Value)
-> ([SimpleMember] -> Encoding)
-> ToJSON SimpleMember
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: SimpleMember -> Value
toJSON :: SimpleMember -> Value
$ctoEncoding :: SimpleMember -> Encoding
toEncoding :: SimpleMember -> Encoding
$ctoJSONList :: [SimpleMember] -> Value
toJSONList :: [SimpleMember] -> Value
$ctoEncodingList :: [SimpleMember] -> Encoding
toEncodingList :: [SimpleMember] -> Encoding
ToJSON) via Schema SimpleMember

smId :: SimpleMember -> UserId
smId :: SimpleMember -> UserId
smId = Qualified UserId -> UserId
forall a. Qualified a -> a
qUnqualified (Qualified UserId -> UserId)
-> (SimpleMember -> Qualified UserId) -> SimpleMember -> UserId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SimpleMember -> Qualified UserId
smQualifiedId

instance ToSchema SimpleMember where
  schema :: ValueSchema NamedSwaggerDoc SimpleMember
schema =
    Text
-> SchemaP SwaggerDoc Object [Pair] SimpleMember SimpleMember
-> ValueSchema NamedSwaggerDoc SimpleMember
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"SimpleMember" (SchemaP SwaggerDoc Object [Pair] SimpleMember SimpleMember
 -> ValueSchema NamedSwaggerDoc SimpleMember)
-> SchemaP SwaggerDoc Object [Pair] SimpleMember SimpleMember
-> ValueSchema NamedSwaggerDoc SimpleMember
forall a b. (a -> b) -> a -> b
$
      Qualified UserId -> RoleName -> SimpleMember
SimpleMember
        (Qualified UserId -> RoleName -> SimpleMember)
-> SchemaP SwaggerDoc Object [Pair] SimpleMember (Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] SimpleMember (RoleName -> SimpleMember)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SimpleMember -> Qualified UserId
smQualifiedId (SimpleMember -> Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] (Qualified UserId) (Qualified UserId)
-> SchemaP SwaggerDoc Object [Pair] SimpleMember (Qualified UserId)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP
     NamedSwaggerDoc Value Value (Qualified UserId) (Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] (Qualified UserId) (Qualified UserId)
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"qualified_id" SchemaP
  NamedSwaggerDoc Value Value (Qualified UserId) (Qualified UserId)
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc Object [Pair] SimpleMember (RoleName -> SimpleMember)
-> SchemaP SwaggerDoc Object [Pair] SimpleMember (Maybe UserId)
-> SchemaP
     SwaggerDoc Object [Pair] SimpleMember (RoleName -> SimpleMember)
forall a b.
SchemaP SwaggerDoc Object [Pair] SimpleMember a
-> SchemaP SwaggerDoc Object [Pair] SimpleMember b
-> SchemaP SwaggerDoc Object [Pair] SimpleMember a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* SimpleMember -> UserId
smId (SimpleMember -> UserId)
-> SchemaP SwaggerDoc Object [Pair] UserId (Maybe UserId)
-> SchemaP SwaggerDoc Object [Pair] SimpleMember (Maybe UserId)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] UserId UserId
-> SchemaP SwaggerDoc Object [Pair] UserId (Maybe UserId)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Text
-> ValueSchema NamedSwaggerDoc UserId
-> SchemaP SwaggerDoc Object [Pair] UserId UserId
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"id" ValueSchema NamedSwaggerDoc UserId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP
  SwaggerDoc Object [Pair] SimpleMember (RoleName -> SimpleMember)
-> SchemaP SwaggerDoc Object [Pair] SimpleMember RoleName
-> SchemaP SwaggerDoc Object [Pair] SimpleMember SimpleMember
forall a b.
SchemaP SwaggerDoc Object [Pair] SimpleMember (a -> b)
-> SchemaP SwaggerDoc Object [Pair] SimpleMember a
-> SchemaP SwaggerDoc Object [Pair] SimpleMember b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> SimpleMember -> RoleName
smConvRoleName
          (SimpleMember -> RoleName)
-> SchemaP SwaggerDoc Object [Pair] RoleName RoleName
-> SchemaP SwaggerDoc Object [Pair] SimpleMember RoleName
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= (Text
-> SchemaP NamedSwaggerDoc Value Value RoleName RoleName
-> SchemaP SwaggerDoc Object [Pair] RoleName RoleName
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"conversation_role" SchemaP NamedSwaggerDoc Value Value RoleName RoleName
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema SchemaP SwaggerDoc Object [Pair] RoleName RoleName
-> SchemaP SwaggerDoc Object [Pair] RoleName RoleName
-> SchemaP SwaggerDoc Object [Pair] RoleName RoleName
forall a.
SchemaP SwaggerDoc Object [Pair] RoleName a
-> SchemaP SwaggerDoc Object [Pair] RoleName a
-> SchemaP SwaggerDoc Object [Pair] RoleName a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> RoleName -> SchemaP SwaggerDoc Object [Pair] RoleName RoleName
forall a. a -> SchemaP SwaggerDoc Object [Pair] RoleName a
forall (f :: * -> *) a. Applicative f => a -> f a
pure RoleName
roleNameWireAdmin)

data Connect = Connect
  { Connect -> Qualified UserId
cRecipient :: Qualified UserId,
    -- FUTUREWORK: As a follow-up from
    -- https://github.com/wireapp/wire-server/pull/1726, the message field can
    -- be removed from this event.
    Connect -> Maybe Text
cMessage :: Maybe Text,
    Connect -> Maybe Text
cName :: Maybe Text,
    Connect -> Maybe Text
cEmail :: Maybe Text
  }
  deriving stock (Connect -> Connect -> Bool
(Connect -> Connect -> Bool)
-> (Connect -> Connect -> Bool) -> Eq Connect
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Connect -> Connect -> Bool
== :: Connect -> Connect -> Bool
$c/= :: Connect -> Connect -> Bool
/= :: Connect -> Connect -> Bool
Eq, Int -> Connect -> ShowS
[Connect] -> ShowS
Connect -> String
(Int -> Connect -> ShowS)
-> (Connect -> String) -> ([Connect] -> ShowS) -> Show Connect
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Connect -> ShowS
showsPrec :: Int -> Connect -> ShowS
$cshow :: Connect -> String
show :: Connect -> String
$cshowList :: [Connect] -> ShowS
showList :: [Connect] -> ShowS
Show, (forall x. Connect -> Rep Connect x)
-> (forall x. Rep Connect x -> Connect) -> Generic Connect
forall x. Rep Connect x -> Connect
forall x. Connect -> Rep Connect x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Connect -> Rep Connect x
from :: forall x. Connect -> Rep Connect x
$cto :: forall x. Rep Connect x -> Connect
to :: forall x. Rep Connect x -> Connect
Generic)
  deriving (Gen Connect
Gen Connect -> (Connect -> [Connect]) -> Arbitrary Connect
Connect -> [Connect]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen Connect
arbitrary :: Gen Connect
$cshrink :: Connect -> [Connect]
shrink :: Connect -> [Connect]
Arbitrary) via (GenericUniform Connect)
  deriving (Value -> Parser [Connect]
Value -> Parser Connect
(Value -> Parser Connect)
-> (Value -> Parser [Connect]) -> FromJSON Connect
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser Connect
parseJSON :: Value -> Parser Connect
$cparseJSONList :: Value -> Parser [Connect]
parseJSONList :: Value -> Parser [Connect]
FromJSON, [Connect] -> Value
[Connect] -> Encoding
Connect -> Value
Connect -> Encoding
(Connect -> Value)
-> (Connect -> Encoding)
-> ([Connect] -> Value)
-> ([Connect] -> Encoding)
-> ToJSON Connect
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: Connect -> Value
toJSON :: Connect -> Value
$ctoEncoding :: Connect -> Encoding
toEncoding :: Connect -> Encoding
$ctoJSONList :: [Connect] -> Value
toJSONList :: [Connect] -> Value
$ctoEncodingList :: [Connect] -> Encoding
toEncodingList :: [Connect] -> Encoding
ToJSON, Typeable Connect
Typeable Connect =>
(Proxy Connect -> Declare (Definitions Schema) NamedSchema)
-> ToSchema Connect
Proxy Connect -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy Connect -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy Connect -> Declare (Definitions Schema) NamedSchema
S.ToSchema) via Schema Connect

instance ToSchema Connect where
  schema :: ValueSchema NamedSwaggerDoc Connect
schema = Text
-> SchemaP SwaggerDoc Object [Pair] Connect Connect
-> ValueSchema NamedSwaggerDoc Connect
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"Connect" SchemaP SwaggerDoc Object [Pair] Connect Connect
connectObjectSchema

connectObjectSchema :: ObjectSchema SwaggerDoc Connect
connectObjectSchema :: SchemaP SwaggerDoc Object [Pair] Connect Connect
connectObjectSchema =
  Qualified UserId
-> Maybe Text -> Maybe Text -> Maybe Text -> Connect
Connect
    (Qualified UserId
 -> Maybe Text -> Maybe Text -> Maybe Text -> Connect)
-> SchemaP SwaggerDoc Object [Pair] Connect (Qualified UserId)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     Connect
     (Maybe Text -> Maybe Text -> Maybe Text -> Connect)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Connect -> Qualified UserId
cRecipient (Connect -> Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] (Qualified UserId) (Qualified UserId)
-> SchemaP SwaggerDoc Object [Pair] Connect (Qualified UserId)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP
     NamedSwaggerDoc Value Value (Qualified UserId) (Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] (Qualified UserId) (Qualified UserId)
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"qualified_recipient" SchemaP
  NamedSwaggerDoc Value Value (Qualified UserId) (Qualified UserId)
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  Connect
  (Maybe Text -> Maybe Text -> Maybe Text -> Connect)
-> SchemaP SwaggerDoc Object [Pair] Connect (Maybe UserId)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     Connect
     (Maybe Text -> Maybe Text -> Maybe Text -> Connect)
forall a b.
SchemaP SwaggerDoc Object [Pair] Connect a
-> SchemaP SwaggerDoc Object [Pair] Connect b
-> SchemaP SwaggerDoc Object [Pair] Connect a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* (Qualified UserId -> UserId
forall a. Qualified a -> a
qUnqualified (Qualified UserId -> UserId)
-> (Connect -> Qualified UserId) -> Connect -> UserId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Connect -> Qualified UserId
cRecipient) (Connect -> UserId)
-> SchemaP SwaggerDoc Object [Pair] UserId (Maybe UserId)
-> SchemaP SwaggerDoc Object [Pair] Connect (Maybe UserId)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] UserId UserId
-> SchemaP SwaggerDoc Object [Pair] UserId (Maybe UserId)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Text
-> ValueSchema NamedSwaggerDoc UserId
-> SchemaP SwaggerDoc Object [Pair] UserId UserId
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"recipient" ValueSchema NamedSwaggerDoc UserId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  Connect
  (Maybe Text -> Maybe Text -> Maybe Text -> Connect)
-> SchemaP SwaggerDoc Object [Pair] Connect (Maybe Text)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     Connect
     (Maybe Text -> Maybe Text -> Connect)
forall a b.
SchemaP SwaggerDoc Object [Pair] Connect (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Connect a
-> SchemaP SwaggerDoc Object [Pair] Connect b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Connect -> Maybe Text
cMessage (Connect -> Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] Connect (Maybe Text)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe Text) Text
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optField Text
"message" (Value
-> SchemaP NamedSwaggerDoc Value Value Text Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe Text) Text
forall w d v a b.
w -> SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybeWithDefault Value
A.Null SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  Connect
  (Maybe Text -> Maybe Text -> Connect)
-> SchemaP SwaggerDoc Object [Pair] Connect (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] Connect (Maybe Text -> Connect)
forall a b.
SchemaP SwaggerDoc Object [Pair] Connect (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Connect a
-> SchemaP SwaggerDoc Object [Pair] Connect b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Connect -> Maybe Text
cName (Connect -> Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] Connect (Maybe Text)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe Text) Text
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optField Text
"name" (Value
-> SchemaP NamedSwaggerDoc Value Value Text Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe Text) Text
forall w d v a b.
w -> SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybeWithDefault Value
A.Null SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
    SchemaP SwaggerDoc Object [Pair] Connect (Maybe Text -> Connect)
-> SchemaP SwaggerDoc Object [Pair] Connect (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] Connect Connect
forall a b.
SchemaP SwaggerDoc Object [Pair] Connect (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Connect a
-> SchemaP SwaggerDoc Object [Pair] Connect b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Connect -> Maybe Text
cEmail (Connect -> Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] Connect (Maybe Text)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe Text) Text
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optField Text
"email" (Value
-> SchemaP NamedSwaggerDoc Value Value Text Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe Text) Text
forall w d v a b.
w -> SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybeWithDefault Value
A.Null SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)

-- | Outbound member updates. When a user A acts upon a user B,
-- then a user event is generated where B's user ID is set
-- as misTarget.
-- Used for events (sent over the websocket, etc.).  See also
-- 'MemberUpdate' and 'OtherMemberUpdate'.
data MemberUpdateData = MemberUpdateData
  { -- | Target user of this action
    MemberUpdateData -> Qualified UserId
misTarget :: Qualified UserId,
    MemberUpdateData -> Maybe MutedStatus
misOtrMutedStatus :: Maybe MutedStatus,
    MemberUpdateData -> Maybe Text
misOtrMutedRef :: Maybe Text,
    MemberUpdateData -> Maybe Bool
misOtrArchived :: Maybe Bool,
    MemberUpdateData -> Maybe Text
misOtrArchivedRef :: Maybe Text,
    MemberUpdateData -> Maybe Bool
misHidden :: Maybe Bool,
    MemberUpdateData -> Maybe Text
misHiddenRef :: Maybe Text,
    MemberUpdateData -> Maybe RoleName
misConvRoleName :: Maybe RoleName
  }
  deriving stock (MemberUpdateData -> MemberUpdateData -> Bool
(MemberUpdateData -> MemberUpdateData -> Bool)
-> (MemberUpdateData -> MemberUpdateData -> Bool)
-> Eq MemberUpdateData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MemberUpdateData -> MemberUpdateData -> Bool
== :: MemberUpdateData -> MemberUpdateData -> Bool
$c/= :: MemberUpdateData -> MemberUpdateData -> Bool
/= :: MemberUpdateData -> MemberUpdateData -> Bool
Eq, Int -> MemberUpdateData -> ShowS
[MemberUpdateData] -> ShowS
MemberUpdateData -> String
(Int -> MemberUpdateData -> ShowS)
-> (MemberUpdateData -> String)
-> ([MemberUpdateData] -> ShowS)
-> Show MemberUpdateData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MemberUpdateData -> ShowS
showsPrec :: Int -> MemberUpdateData -> ShowS
$cshow :: MemberUpdateData -> String
show :: MemberUpdateData -> String
$cshowList :: [MemberUpdateData] -> ShowS
showList :: [MemberUpdateData] -> ShowS
Show, (forall x. MemberUpdateData -> Rep MemberUpdateData x)
-> (forall x. Rep MemberUpdateData x -> MemberUpdateData)
-> Generic MemberUpdateData
forall x. Rep MemberUpdateData x -> MemberUpdateData
forall x. MemberUpdateData -> Rep MemberUpdateData x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. MemberUpdateData -> Rep MemberUpdateData x
from :: forall x. MemberUpdateData -> Rep MemberUpdateData x
$cto :: forall x. Rep MemberUpdateData x -> MemberUpdateData
to :: forall x. Rep MemberUpdateData x -> MemberUpdateData
Generic)
  deriving (Gen MemberUpdateData
Gen MemberUpdateData
-> (MemberUpdateData -> [MemberUpdateData])
-> Arbitrary MemberUpdateData
MemberUpdateData -> [MemberUpdateData]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen MemberUpdateData
arbitrary :: Gen MemberUpdateData
$cshrink :: MemberUpdateData -> [MemberUpdateData]
shrink :: MemberUpdateData -> [MemberUpdateData]
Arbitrary) via (GenericUniform MemberUpdateData)
  deriving (Value -> Parser [MemberUpdateData]
Value -> Parser MemberUpdateData
(Value -> Parser MemberUpdateData)
-> (Value -> Parser [MemberUpdateData])
-> FromJSON MemberUpdateData
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser MemberUpdateData
parseJSON :: Value -> Parser MemberUpdateData
$cparseJSONList :: Value -> Parser [MemberUpdateData]
parseJSONList :: Value -> Parser [MemberUpdateData]
FromJSON, [MemberUpdateData] -> Value
[MemberUpdateData] -> Encoding
MemberUpdateData -> Value
MemberUpdateData -> Encoding
(MemberUpdateData -> Value)
-> (MemberUpdateData -> Encoding)
-> ([MemberUpdateData] -> Value)
-> ([MemberUpdateData] -> Encoding)
-> ToJSON MemberUpdateData
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: MemberUpdateData -> Value
toJSON :: MemberUpdateData -> Value
$ctoEncoding :: MemberUpdateData -> Encoding
toEncoding :: MemberUpdateData -> Encoding
$ctoJSONList :: [MemberUpdateData] -> Value
toJSONList :: [MemberUpdateData] -> Value
$ctoEncodingList :: [MemberUpdateData] -> Encoding
toEncodingList :: [MemberUpdateData] -> Encoding
ToJSON, Typeable MemberUpdateData
Typeable MemberUpdateData =>
(Proxy MemberUpdateData
 -> Declare (Definitions Schema) NamedSchema)
-> ToSchema MemberUpdateData
Proxy MemberUpdateData -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy MemberUpdateData -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy MemberUpdateData -> Declare (Definitions Schema) NamedSchema
S.ToSchema) via Schema MemberUpdateData

instance ToSchema MemberUpdateData where
  schema :: ValueSchema NamedSwaggerDoc MemberUpdateData
schema = Text
-> SchemaP
     SwaggerDoc Object [Pair] MemberUpdateData MemberUpdateData
-> ValueSchema NamedSwaggerDoc MemberUpdateData
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"MemberUpdateData" SchemaP SwaggerDoc Object [Pair] MemberUpdateData MemberUpdateData
memberUpdateDataObjectSchema

memberUpdateDataObjectSchema :: ObjectSchema SwaggerDoc MemberUpdateData
memberUpdateDataObjectSchema :: SchemaP SwaggerDoc Object [Pair] MemberUpdateData MemberUpdateData
memberUpdateDataObjectSchema =
  Qualified UserId
-> Maybe MutedStatus
-> Maybe Text
-> Maybe Bool
-> Maybe Text
-> Maybe Bool
-> Maybe Text
-> Maybe RoleName
-> MemberUpdateData
MemberUpdateData
    (Qualified UserId
 -> Maybe MutedStatus
 -> Maybe Text
 -> Maybe Bool
 -> Maybe Text
 -> Maybe Bool
 -> Maybe Text
 -> Maybe RoleName
 -> MemberUpdateData)
-> SchemaP
     SwaggerDoc Object [Pair] MemberUpdateData (Qualified UserId)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     MemberUpdateData
     (Maybe MutedStatus
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Text
      -> Maybe RoleName
      -> MemberUpdateData)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MemberUpdateData -> Qualified UserId
misTarget (MemberUpdateData -> Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] (Qualified UserId) (Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] MemberUpdateData (Qualified UserId)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP
     NamedSwaggerDoc Value Value (Qualified UserId) (Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] (Qualified UserId) (Qualified UserId)
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"qualified_target" SchemaP
  NamedSwaggerDoc Value Value (Qualified UserId) (Qualified UserId)
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  MemberUpdateData
  (Maybe MutedStatus
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Text
   -> Maybe RoleName
   -> MemberUpdateData)
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData (Maybe UserId)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     MemberUpdateData
     (Maybe MutedStatus
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Text
      -> Maybe RoleName
      -> MemberUpdateData)
forall a b.
SchemaP SwaggerDoc Object [Pair] MemberUpdateData a
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData b
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* (Qualified UserId -> UserId
forall a. Qualified a -> a
qUnqualified (Qualified UserId -> UserId)
-> (MemberUpdateData -> Qualified UserId)
-> MemberUpdateData
-> UserId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MemberUpdateData -> Qualified UserId
misTarget) (MemberUpdateData -> UserId)
-> SchemaP SwaggerDoc Object [Pair] UserId (Maybe UserId)
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData (Maybe UserId)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] UserId UserId
-> SchemaP SwaggerDoc Object [Pair] UserId (Maybe UserId)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Text
-> ValueSchema NamedSwaggerDoc UserId
-> SchemaP SwaggerDoc Object [Pair] UserId UserId
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"target" ValueSchema NamedSwaggerDoc UserId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  MemberUpdateData
  (Maybe MutedStatus
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Text
   -> Maybe RoleName
   -> MemberUpdateData)
-> SchemaP
     SwaggerDoc Object [Pair] MemberUpdateData (Maybe MutedStatus)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     MemberUpdateData
     (Maybe Text
      -> Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Text
      -> Maybe RoleName
      -> MemberUpdateData)
forall a b.
SchemaP SwaggerDoc Object [Pair] MemberUpdateData (a -> b)
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData a
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> MemberUpdateData -> Maybe MutedStatus
misOtrMutedStatus (MemberUpdateData -> Maybe MutedStatus)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe MutedStatus) (Maybe MutedStatus)
-> SchemaP
     SwaggerDoc Object [Pair] MemberUpdateData (Maybe MutedStatus)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] MutedStatus (Maybe MutedStatus)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe MutedStatus) (Maybe MutedStatus)
forall w d v a b.
Monoid w =>
SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybe_ (Text
-> SchemaP NamedSwaggerDoc Value Value MutedStatus MutedStatus
-> SchemaP SwaggerDoc Object [Pair] MutedStatus (Maybe MutedStatus)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optField Text
"otr_muted_status" SchemaP NamedSwaggerDoc Value Value MutedStatus MutedStatus
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  MemberUpdateData
  (Maybe Text
   -> Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Text
   -> Maybe RoleName
   -> MemberUpdateData)
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData (Maybe Text)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     MemberUpdateData
     (Maybe Bool
      -> Maybe Text
      -> Maybe Bool
      -> Maybe Text
      -> Maybe RoleName
      -> MemberUpdateData)
forall a b.
SchemaP SwaggerDoc Object [Pair] MemberUpdateData (a -> b)
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData a
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> MemberUpdateData -> Maybe Text
misOtrMutedRef (MemberUpdateData -> Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData (Maybe Text)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] Text (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
forall w d v a b.
Monoid w =>
SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybe_ (Text
-> SchemaP NamedSwaggerDoc Value Value Text Text
-> SchemaP SwaggerDoc Object [Pair] Text (Maybe Text)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optField Text
"otr_muted_ref" SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  MemberUpdateData
  (Maybe Bool
   -> Maybe Text
   -> Maybe Bool
   -> Maybe Text
   -> Maybe RoleName
   -> MemberUpdateData)
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData (Maybe Bool)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     MemberUpdateData
     (Maybe Text
      -> Maybe Bool -> Maybe Text -> Maybe RoleName -> MemberUpdateData)
forall a b.
SchemaP SwaggerDoc Object [Pair] MemberUpdateData (a -> b)
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData a
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> MemberUpdateData -> Maybe Bool
misOtrArchived (MemberUpdateData -> Maybe Bool)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Bool) (Maybe Bool)
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData (Maybe Bool)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] Bool (Maybe Bool)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Bool) (Maybe Bool)
forall w d v a b.
Monoid w =>
SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybe_ (Text
-> SchemaP NamedSwaggerDoc Value Value Bool Bool
-> SchemaP SwaggerDoc Object [Pair] Bool (Maybe Bool)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optField Text
"otr_archived" SchemaP NamedSwaggerDoc Value Value Bool Bool
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  MemberUpdateData
  (Maybe Text
   -> Maybe Bool -> Maybe Text -> Maybe RoleName -> MemberUpdateData)
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData (Maybe Text)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     MemberUpdateData
     (Maybe Bool -> Maybe Text -> Maybe RoleName -> MemberUpdateData)
forall a b.
SchemaP SwaggerDoc Object [Pair] MemberUpdateData (a -> b)
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData a
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> MemberUpdateData -> Maybe Text
misOtrArchivedRef (MemberUpdateData -> Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData (Maybe Text)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] Text (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
forall w d v a b.
Monoid w =>
SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybe_ (Text
-> SchemaP NamedSwaggerDoc Value Value Text Text
-> SchemaP SwaggerDoc Object [Pair] Text (Maybe Text)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optField Text
"otr_archived_ref" SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  MemberUpdateData
  (Maybe Bool -> Maybe Text -> Maybe RoleName -> MemberUpdateData)
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData (Maybe Bool)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     MemberUpdateData
     (Maybe Text -> Maybe RoleName -> MemberUpdateData)
forall a b.
SchemaP SwaggerDoc Object [Pair] MemberUpdateData (a -> b)
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData a
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> MemberUpdateData -> Maybe Bool
misHidden (MemberUpdateData -> Maybe Bool)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Bool) (Maybe Bool)
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData (Maybe Bool)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] Bool (Maybe Bool)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Bool) (Maybe Bool)
forall w d v a b.
Monoid w =>
SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybe_ (Text
-> SchemaP NamedSwaggerDoc Value Value Bool Bool
-> SchemaP SwaggerDoc Object [Pair] Bool (Maybe Bool)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optField Text
"hidden" SchemaP NamedSwaggerDoc Value Value Bool Bool
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  MemberUpdateData
  (Maybe Text -> Maybe RoleName -> MemberUpdateData)
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData (Maybe Text)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     MemberUpdateData
     (Maybe RoleName -> MemberUpdateData)
forall a b.
SchemaP SwaggerDoc Object [Pair] MemberUpdateData (a -> b)
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData a
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> MemberUpdateData -> Maybe Text
misHiddenRef (MemberUpdateData -> Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData (Maybe Text)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] Text (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
forall w d v a b.
Monoid w =>
SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybe_ (Text
-> SchemaP NamedSwaggerDoc Value Value Text Text
-> SchemaP SwaggerDoc Object [Pair] Text (Maybe Text)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optField Text
"hidden_ref" SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  MemberUpdateData
  (Maybe RoleName -> MemberUpdateData)
-> SchemaP
     SwaggerDoc Object [Pair] MemberUpdateData (Maybe RoleName)
-> SchemaP
     SwaggerDoc Object [Pair] MemberUpdateData MemberUpdateData
forall a b.
SchemaP SwaggerDoc Object [Pair] MemberUpdateData (a -> b)
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData a
-> SchemaP SwaggerDoc Object [Pair] MemberUpdateData b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> MemberUpdateData -> Maybe RoleName
misConvRoleName (MemberUpdateData -> Maybe RoleName)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe RoleName) (Maybe RoleName)
-> SchemaP
     SwaggerDoc Object [Pair] MemberUpdateData (Maybe RoleName)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] RoleName (Maybe RoleName)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe RoleName) (Maybe RoleName)
forall w d v a b.
Monoid w =>
SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybe_ (Text
-> SchemaP NamedSwaggerDoc Value Value RoleName RoleName
-> SchemaP SwaggerDoc Object [Pair] RoleName (Maybe RoleName)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optField Text
"conversation_role" SchemaP NamedSwaggerDoc Value Value RoleName RoleName
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)

data AddCodeResult
  = CodeAdded Event
  | CodeAlreadyExisted ConversationCodeInfo

data OtrMessage = OtrMessage
  { OtrMessage -> ClientId
otrSender :: ClientId,
    OtrMessage -> ClientId
otrRecipient :: ClientId,
    OtrMessage -> Text
otrCiphertext :: Text,
    OtrMessage -> Maybe Text
otrData :: Maybe Text
  }
  deriving stock (OtrMessage -> OtrMessage -> Bool
(OtrMessage -> OtrMessage -> Bool)
-> (OtrMessage -> OtrMessage -> Bool) -> Eq OtrMessage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OtrMessage -> OtrMessage -> Bool
== :: OtrMessage -> OtrMessage -> Bool
$c/= :: OtrMessage -> OtrMessage -> Bool
/= :: OtrMessage -> OtrMessage -> Bool
Eq, Int -> OtrMessage -> ShowS
[OtrMessage] -> ShowS
OtrMessage -> String
(Int -> OtrMessage -> ShowS)
-> (OtrMessage -> String)
-> ([OtrMessage] -> ShowS)
-> Show OtrMessage
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OtrMessage -> ShowS
showsPrec :: Int -> OtrMessage -> ShowS
$cshow :: OtrMessage -> String
show :: OtrMessage -> String
$cshowList :: [OtrMessage] -> ShowS
showList :: [OtrMessage] -> ShowS
Show, (forall x. OtrMessage -> Rep OtrMessage x)
-> (forall x. Rep OtrMessage x -> OtrMessage) -> Generic OtrMessage
forall x. Rep OtrMessage x -> OtrMessage
forall x. OtrMessage -> Rep OtrMessage x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. OtrMessage -> Rep OtrMessage x
from :: forall x. OtrMessage -> Rep OtrMessage x
$cto :: forall x. Rep OtrMessage x -> OtrMessage
to :: forall x. Rep OtrMessage x -> OtrMessage
Generic)
  deriving (Gen OtrMessage
Gen OtrMessage
-> (OtrMessage -> [OtrMessage]) -> Arbitrary OtrMessage
OtrMessage -> [OtrMessage]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen OtrMessage
arbitrary :: Gen OtrMessage
$cshrink :: OtrMessage -> [OtrMessage]
shrink :: OtrMessage -> [OtrMessage]
Arbitrary) via (GenericUniform OtrMessage)
  deriving (Value -> Parser [OtrMessage]
Value -> Parser OtrMessage
(Value -> Parser OtrMessage)
-> (Value -> Parser [OtrMessage]) -> FromJSON OtrMessage
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser OtrMessage
parseJSON :: Value -> Parser OtrMessage
$cparseJSONList :: Value -> Parser [OtrMessage]
parseJSONList :: Value -> Parser [OtrMessage]
FromJSON, [OtrMessage] -> Value
[OtrMessage] -> Encoding
OtrMessage -> Value
OtrMessage -> Encoding
(OtrMessage -> Value)
-> (OtrMessage -> Encoding)
-> ([OtrMessage] -> Value)
-> ([OtrMessage] -> Encoding)
-> ToJSON OtrMessage
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: OtrMessage -> Value
toJSON :: OtrMessage -> Value
$ctoEncoding :: OtrMessage -> Encoding
toEncoding :: OtrMessage -> Encoding
$ctoJSONList :: [OtrMessage] -> Value
toJSONList :: [OtrMessage] -> Value
$ctoEncodingList :: [OtrMessage] -> Encoding
toEncodingList :: [OtrMessage] -> Encoding
ToJSON, Typeable OtrMessage
Typeable OtrMessage =>
(Proxy OtrMessage -> Declare (Definitions Schema) NamedSchema)
-> ToSchema OtrMessage
Proxy OtrMessage -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy OtrMessage -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy OtrMessage -> Declare (Definitions Schema) NamedSchema
S.ToSchema) via Schema OtrMessage

instance ToSchema OtrMessage where
  schema :: ValueSchema NamedSwaggerDoc OtrMessage
schema =
    Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> ObjectSchema SwaggerDoc OtrMessage
-> ValueSchema NamedSwaggerDoc OtrMessage
forall doc doc' a.
HasObject doc doc' =>
Text -> (doc' -> doc') -> ObjectSchema doc a -> ValueSchema doc' a
objectWithDocModifier
      Text
"OtrMessage"
      ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"Encrypted message of a conversation")
      ObjectSchema SwaggerDoc OtrMessage
otrMessageObjectSchema

otrMessageObjectSchema :: ObjectSchema SwaggerDoc OtrMessage
otrMessageObjectSchema :: ObjectSchema SwaggerDoc OtrMessage
otrMessageObjectSchema =
  ClientId -> ClientId -> Text -> Maybe Text -> OtrMessage
OtrMessage
    (ClientId -> ClientId -> Text -> Maybe Text -> OtrMessage)
-> SchemaP SwaggerDoc Object [Pair] OtrMessage ClientId
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     OtrMessage
     (ClientId -> Text -> Maybe Text -> OtrMessage)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> OtrMessage -> ClientId
otrSender (OtrMessage -> ClientId)
-> SchemaP SwaggerDoc Object [Pair] ClientId ClientId
-> SchemaP SwaggerDoc Object [Pair] OtrMessage ClientId
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value ClientId ClientId
-> SchemaP SwaggerDoc Object [Pair] ClientId ClientId
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"sender" SchemaP NamedSwaggerDoc Value Value ClientId ClientId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  OtrMessage
  (ClientId -> Text -> Maybe Text -> OtrMessage)
-> SchemaP SwaggerDoc Object [Pair] OtrMessage ClientId
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     OtrMessage
     (Text -> Maybe Text -> OtrMessage)
forall a b.
SchemaP SwaggerDoc Object [Pair] OtrMessage (a -> b)
-> SchemaP SwaggerDoc Object [Pair] OtrMessage a
-> SchemaP SwaggerDoc Object [Pair] OtrMessage b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> OtrMessage -> ClientId
otrRecipient (OtrMessage -> ClientId)
-> SchemaP SwaggerDoc Object [Pair] ClientId ClientId
-> SchemaP SwaggerDoc Object [Pair] OtrMessage ClientId
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value ClientId ClientId
-> SchemaP SwaggerDoc Object [Pair] ClientId ClientId
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"recipient" SchemaP NamedSwaggerDoc Value Value ClientId ClientId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  OtrMessage
  (Text -> Maybe Text -> OtrMessage)
-> SchemaP SwaggerDoc Object [Pair] OtrMessage Text
-> SchemaP
     SwaggerDoc Object [Pair] OtrMessage (Maybe Text -> OtrMessage)
forall a b.
SchemaP SwaggerDoc Object [Pair] OtrMessage (a -> b)
-> SchemaP SwaggerDoc Object [Pair] OtrMessage a
-> SchemaP SwaggerDoc Object [Pair] OtrMessage b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> OtrMessage -> Text
otrCiphertext
      (OtrMessage -> Text)
-> SchemaP SwaggerDoc Object [Pair] Text Text
-> SchemaP SwaggerDoc Object [Pair] OtrMessage Text
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> SchemaP NamedSwaggerDoc Value Value Text Text
-> SchemaP SwaggerDoc Object [Pair] Text Text
forall doc' doc a b.
HasField doc' doc =>
Text
-> (doc' -> doc')
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a b
fieldWithDocModifier
        Text
"text"
        ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
textDesc)
        SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
    SchemaP
  SwaggerDoc Object [Pair] OtrMessage (Maybe Text -> OtrMessage)
-> SchemaP SwaggerDoc Object [Pair] OtrMessage (Maybe Text)
-> ObjectSchema SwaggerDoc OtrMessage
forall a b.
SchemaP SwaggerDoc Object [Pair] OtrMessage (a -> b)
-> SchemaP SwaggerDoc Object [Pair] OtrMessage a
-> SchemaP SwaggerDoc Object [Pair] OtrMessage b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> OtrMessage -> Maybe Text
otrData
      (OtrMessage -> Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] OtrMessage (Maybe Text)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] Text (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
forall w d v a b.
Monoid w =>
SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybe_
        ( Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> SchemaP NamedSwaggerDoc Value Value Text Text
-> SchemaP SwaggerDoc Object [Pair] Text (Maybe Text)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> (doc' -> doc')
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optFieldWithDocModifier
            Text
"data"
            ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
dataDesc)
            SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        )
  where
    textDesc :: Text
textDesc = Text
"The ciphertext for the recipient (Base64 in JSON)"
    dataDesc :: Text
dataDesc =
      Text
"Extra (symmetric) data (i.e. ciphertext, Base64 in JSON) \
      \that is common with all other recipients."

makePrisms ''EventData

taggedEventDataSchema :: ObjectSchema SwaggerDoc (EventType, EventData)
taggedEventDataSchema :: ObjectSchema SwaggerDoc (EventType, EventData)
taggedEventDataSchema =
  SchemaP SwaggerDoc Object [Pair] (EventType, EventData) EventType
-> SchemaP
     SwaggerDoc
     (Object, EventType)
     [Pair]
     (EventType, EventData)
     EventData
-> ObjectSchema SwaggerDoc (EventType, EventData)
forall d w v a b c.
(Monoid d, Monoid w) =>
SchemaP d v w a b
-> SchemaP d (v, b) w a c -> SchemaP d v w a (b, c)
bind
    ((EventType, EventData) -> EventType
forall a b. (a, b) -> a
fst ((EventType, EventData) -> EventType)
-> SchemaP SwaggerDoc Object [Pair] EventType EventType
-> SchemaP
     SwaggerDoc Object [Pair] (EventType, EventData) EventType
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> ValueSchema NamedSwaggerDoc EventType
-> SchemaP SwaggerDoc Object [Pair] EventType EventType
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"type" ValueSchema NamedSwaggerDoc EventType
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
    ((EventType, EventData) -> EventData
forall a b. (a, b) -> b
snd ((EventType, EventData) -> EventData)
-> SchemaP
     SwaggerDoc (Object, EventType) [Pair] EventData EventData
-> SchemaP
     SwaggerDoc
     (Object, EventType)
     [Pair]
     (EventType, EventData)
     EventData
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Lens (Object, EventType) (Value, EventType) Object Value
-> Text
-> SchemaP SwaggerDoc (Value, EventType) Value EventData EventData
-> SchemaP
     SwaggerDoc (Object, EventType) [Pair] EventData EventData
forall doc' doc v v' a b.
HasField doc' doc =>
Lens v v' Object Value
-> Text -> SchemaP doc' v' Value a b -> SchemaP doc v [Pair] a b
fieldOver (Object -> f Value) -> (Object, EventType) -> f (Value, EventType)
forall s t a b. Field1 s t a b => Lens s t a b
Lens (Object, EventType) (Value, EventType) Object Value
_1 Text
"data" SchemaP SwaggerDoc (Value, EventType) Value EventData EventData
edata)
  where
    edata :: SchemaP SwaggerDoc (Value, EventType) Value EventData EventData
edata = (EventType -> SchemaP SwaggerDoc Value Value EventData EventData)
-> SchemaP SwaggerDoc (Value, EventType) Value EventData EventData
forall t d v w a b.
(Bounded t, Enum t, Monoid d) =>
(t -> SchemaP d v w a b) -> SchemaP d (v, t) w a b
dispatch ((EventType -> SchemaP SwaggerDoc Value Value EventData EventData)
 -> SchemaP SwaggerDoc (Value, EventType) Value EventData EventData)
-> (EventType
    -> SchemaP SwaggerDoc Value Value EventData EventData)
-> SchemaP SwaggerDoc (Value, EventType) Value EventData EventData
forall a b. (a -> b) -> a -> b
$ \case
      EventType
MemberJoin -> Prism' EventData SimpleMembers
-> SchemaP SwaggerDoc Value Value SimpleMembers SimpleMembers
-> SchemaP SwaggerDoc Value Value EventData EventData
forall b b' a a' ss v m.
Prism b b' a a' -> SchemaP ss v m a a' -> SchemaP ss v m b b'
tag p SimpleMembers (f SimpleMembers) -> p EventData (f EventData)
Prism' EventData SimpleMembers
_EdMembersJoin (ValueSchema NamedSwaggerDoc SimpleMembers
-> SchemaP SwaggerDoc Value Value SimpleMembers SimpleMembers
forall doc doc' v m a b.
HasObject doc doc' =>
SchemaP doc' v m a b -> SchemaP doc v m a b
unnamed ValueSchema NamedSwaggerDoc SimpleMembers
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
      EventType
MemberLeave -> Prism' EventData (EdMemberLeftReason, QualifiedUserIdList)
-> SchemaP
     SwaggerDoc
     Value
     Value
     (EdMemberLeftReason, QualifiedUserIdList)
     (EdMemberLeftReason, QualifiedUserIdList)
-> SchemaP SwaggerDoc Value Value EventData EventData
forall b b' a a' ss v m.
Prism b b' a a' -> SchemaP ss v m a a' -> SchemaP ss v m b b'
tag p (EdMemberLeftReason, QualifiedUserIdList)
  (f (EdMemberLeftReason, QualifiedUserIdList))
-> p EventData (f EventData)
Prism' EventData (EdMemberLeftReason, QualifiedUserIdList)
_EdMembersLeave (SchemaP
  NamedSwaggerDoc
  Value
  Value
  (EdMemberLeftReason, QualifiedUserIdList)
  (EdMemberLeftReason, QualifiedUserIdList)
-> SchemaP
     SwaggerDoc
     Value
     Value
     (EdMemberLeftReason, QualifiedUserIdList)
     (EdMemberLeftReason, QualifiedUserIdList)
forall doc doc' v m a b.
HasObject doc doc' =>
SchemaP doc' v m a b -> SchemaP doc v m a b
unnamed SchemaP
  NamedSwaggerDoc
  Value
  Value
  (EdMemberLeftReason, QualifiedUserIdList)
  (EdMemberLeftReason, QualifiedUserIdList)
memberLeaveSchema)
      EventType
MemberStateUpdate -> Prism' EventData MemberUpdateData
-> SchemaP SwaggerDoc Value Value MemberUpdateData MemberUpdateData
-> SchemaP SwaggerDoc Value Value EventData EventData
forall b b' a a' ss v m.
Prism b b' a a' -> SchemaP ss v m a a' -> SchemaP ss v m b b'
tag p MemberUpdateData (f MemberUpdateData)
-> p EventData (f EventData)
Prism' EventData MemberUpdateData
_EdMemberUpdate (ValueSchema NamedSwaggerDoc MemberUpdateData
-> SchemaP SwaggerDoc Value Value MemberUpdateData MemberUpdateData
forall doc doc' v m a b.
HasObject doc doc' =>
SchemaP doc' v m a b -> SchemaP doc v m a b
unnamed ValueSchema NamedSwaggerDoc MemberUpdateData
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
      EventType
ConvRename -> Prism' EventData ConversationRename
-> SchemaP
     SwaggerDoc Value Value ConversationRename ConversationRename
-> SchemaP SwaggerDoc Value Value EventData EventData
forall b b' a a' ss v m.
Prism b b' a a' -> SchemaP ss v m a a' -> SchemaP ss v m b b'
tag p ConversationRename (f ConversationRename)
-> p EventData (f EventData)
Prism' EventData ConversationRename
_EdConvRename (SchemaP
  NamedSwaggerDoc Value Value ConversationRename ConversationRename
-> SchemaP
     SwaggerDoc Value Value ConversationRename ConversationRename
forall doc doc' v m a b.
HasObject doc doc' =>
SchemaP doc' v m a b -> SchemaP doc v m a b
unnamed SchemaP
  NamedSwaggerDoc Value Value ConversationRename ConversationRename
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
      -- FUTUREWORK: when V2 is dropped, it is fine to change this schema to
      -- V3, since V3 clients are guaranteed to know how to parse V2 and V3
      -- conversation access update events.
      EventType
ConvAccessUpdate ->
        Prism' EventData ConversationAccessData
-> SchemaP
     SwaggerDoc
     Value
     Value
     ConversationAccessData
     ConversationAccessData
-> SchemaP SwaggerDoc Value Value EventData EventData
forall b b' a a' ss v m.
Prism b b' a a' -> SchemaP ss v m a a' -> SchemaP ss v m b b'
tag
          p ConversationAccessData (f ConversationAccessData)
-> p EventData (f EventData)
Prism' EventData ConversationAccessData
_EdConvAccessUpdate
          (SchemaP
  NamedSwaggerDoc
  Value
  Value
  ConversationAccessData
  ConversationAccessData
-> SchemaP
     SwaggerDoc
     Value
     Value
     ConversationAccessData
     ConversationAccessData
forall doc doc' v m a b.
HasObject doc doc' =>
SchemaP doc' v m a b -> SchemaP doc v m a b
unnamed (Maybe Version
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     ConversationAccessData
     ConversationAccessData
conversationAccessDataSchema (Version -> Maybe Version
forall a. a -> Maybe a
Just Version
V2)))
      EventType
ConvCodeUpdate -> Prism' EventData ConversationCodeInfo
-> SchemaP
     SwaggerDoc Value Value ConversationCodeInfo ConversationCodeInfo
-> SchemaP SwaggerDoc Value Value EventData EventData
forall b b' a a' ss v m.
Prism b b' a a' -> SchemaP ss v m a a' -> SchemaP ss v m b b'
tag p ConversationCodeInfo (f ConversationCodeInfo)
-> p EventData (f EventData)
Prism' EventData ConversationCodeInfo
_EdConvCodeUpdate (SchemaP
  NamedSwaggerDoc
  Value
  Value
  ConversationCodeInfo
  ConversationCodeInfo
-> SchemaP
     SwaggerDoc Value Value ConversationCodeInfo ConversationCodeInfo
forall doc doc' v m a b.
HasObject doc doc' =>
SchemaP doc' v m a b -> SchemaP doc v m a b
unnamed SchemaP
  NamedSwaggerDoc
  Value
  Value
  ConversationCodeInfo
  ConversationCodeInfo
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
      EventType
ConvConnect -> Prism' EventData Connect
-> SchemaP SwaggerDoc Value Value Connect Connect
-> SchemaP SwaggerDoc Value Value EventData EventData
forall b b' a a' ss v m.
Prism b b' a a' -> SchemaP ss v m a a' -> SchemaP ss v m b b'
tag p Connect (f Connect) -> p EventData (f EventData)
Prism' EventData Connect
_EdConnect (ValueSchema NamedSwaggerDoc Connect
-> SchemaP SwaggerDoc Value Value Connect Connect
forall doc doc' v m a b.
HasObject doc doc' =>
SchemaP doc' v m a b -> SchemaP doc v m a b
unnamed ValueSchema NamedSwaggerDoc Connect
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
      EventType
ConvCreate -> Prism' EventData Conversation
-> SchemaP SwaggerDoc Value Value Conversation Conversation
-> SchemaP SwaggerDoc Value Value EventData EventData
forall b b' a a' ss v m.
Prism b b' a a' -> SchemaP ss v m a a' -> SchemaP ss v m b b'
tag p Conversation (f Conversation) -> p EventData (f EventData)
Prism' EventData Conversation
_EdConversation (SchemaP NamedSwaggerDoc Value Value Conversation Conversation
-> SchemaP SwaggerDoc Value Value Conversation Conversation
forall doc doc' v m a b.
HasObject doc doc' =>
SchemaP doc' v m a b -> SchemaP doc v m a b
unnamed (Maybe Version
-> SchemaP NamedSwaggerDoc Value Value Conversation Conversation
conversationSchema (Version -> Maybe Version
forall a. a -> Maybe a
Just Version
V2)))
      EventType
ConvMessageTimerUpdate -> Prism' EventData ConversationMessageTimerUpdate
-> SchemaP
     SwaggerDoc
     Value
     Value
     ConversationMessageTimerUpdate
     ConversationMessageTimerUpdate
-> SchemaP SwaggerDoc Value Value EventData EventData
forall b b' a a' ss v m.
Prism b b' a a' -> SchemaP ss v m a a' -> SchemaP ss v m b b'
tag p ConversationMessageTimerUpdate (f ConversationMessageTimerUpdate)
-> p EventData (f EventData)
Prism' EventData ConversationMessageTimerUpdate
_EdConvMessageTimerUpdate (SchemaP
  NamedSwaggerDoc
  Value
  Value
  ConversationMessageTimerUpdate
  ConversationMessageTimerUpdate
-> SchemaP
     SwaggerDoc
     Value
     Value
     ConversationMessageTimerUpdate
     ConversationMessageTimerUpdate
forall doc doc' v m a b.
HasObject doc doc' =>
SchemaP doc' v m a b -> SchemaP doc v m a b
unnamed SchemaP
  NamedSwaggerDoc
  Value
  Value
  ConversationMessageTimerUpdate
  ConversationMessageTimerUpdate
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
      EventType
ConvReceiptModeUpdate -> Prism' EventData ConversationReceiptModeUpdate
-> SchemaP
     SwaggerDoc
     Value
     Value
     ConversationReceiptModeUpdate
     ConversationReceiptModeUpdate
-> SchemaP SwaggerDoc Value Value EventData EventData
forall b b' a a' ss v m.
Prism b b' a a' -> SchemaP ss v m a a' -> SchemaP ss v m b b'
tag p ConversationReceiptModeUpdate (f ConversationReceiptModeUpdate)
-> p EventData (f EventData)
Prism' EventData ConversationReceiptModeUpdate
_EdConvReceiptModeUpdate (SchemaP
  NamedSwaggerDoc
  Value
  Value
  ConversationReceiptModeUpdate
  ConversationReceiptModeUpdate
-> SchemaP
     SwaggerDoc
     Value
     Value
     ConversationReceiptModeUpdate
     ConversationReceiptModeUpdate
forall doc doc' v m a b.
HasObject doc doc' =>
SchemaP doc' v m a b -> SchemaP doc v m a b
unnamed SchemaP
  NamedSwaggerDoc
  Value
  Value
  ConversationReceiptModeUpdate
  ConversationReceiptModeUpdate
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
      EventType
OtrMessageAdd -> Prism' EventData OtrMessage
-> SchemaP SwaggerDoc Value Value OtrMessage OtrMessage
-> SchemaP SwaggerDoc Value Value EventData EventData
forall b b' a a' ss v m.
Prism b b' a a' -> SchemaP ss v m a a' -> SchemaP ss v m b b'
tag p OtrMessage (f OtrMessage) -> p EventData (f EventData)
Prism' EventData OtrMessage
_EdOtrMessage (ValueSchema NamedSwaggerDoc OtrMessage
-> SchemaP SwaggerDoc Value Value OtrMessage OtrMessage
forall doc doc' v m a b.
HasObject doc doc' =>
SchemaP doc' v m a b -> SchemaP doc v m a b
unnamed ValueSchema NamedSwaggerDoc OtrMessage
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
      EventType
MLSMessageAdd -> Prism' EventData ByteString
-> SchemaP SwaggerDoc Value Value ByteString ByteString
-> SchemaP SwaggerDoc Value Value EventData EventData
forall b b' a a' ss v m.
Prism b b' a a' -> SchemaP ss v m a a' -> SchemaP ss v m b b'
tag p ByteString (f ByteString) -> p EventData (f EventData)
Prism' EventData ByteString
_EdMLSMessage SchemaP SwaggerDoc Value Value ByteString ByteString
base64Schema
      EventType
MLSWelcome -> Prism' EventData ByteString
-> SchemaP SwaggerDoc Value Value ByteString ByteString
-> SchemaP SwaggerDoc Value Value EventData EventData
forall b b' a a' ss v m.
Prism b b' a a' -> SchemaP ss v m a a' -> SchemaP ss v m b b'
tag p ByteString (f ByteString) -> p EventData (f EventData)
Prism' EventData ByteString
_EdMLSWelcome SchemaP SwaggerDoc Value Value ByteString ByteString
base64Schema
      EventType
Typing -> Prism' EventData TypingStatus
-> SchemaP SwaggerDoc Value Value TypingStatus TypingStatus
-> SchemaP SwaggerDoc Value Value EventData EventData
forall b b' a a' ss v m.
Prism b b' a a' -> SchemaP ss v m a a' -> SchemaP ss v m b b'
tag p TypingStatus (f TypingStatus) -> p EventData (f EventData)
Prism' EventData TypingStatus
_EdTyping (SchemaP NamedSwaggerDoc Value Value TypingStatus TypingStatus
-> SchemaP SwaggerDoc Value Value TypingStatus TypingStatus
forall doc doc' v m a b.
HasObject doc doc' =>
SchemaP doc' v m a b -> SchemaP doc v m a b
unnamed SchemaP NamedSwaggerDoc Value Value TypingStatus TypingStatus
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
      EventType
ConvCodeDelete -> Prism' EventData ()
-> SchemaP SwaggerDoc Value Value () ()
-> SchemaP SwaggerDoc Value Value EventData EventData
forall b b' a a' ss v m.
Prism b b' a a' -> SchemaP ss v m a a' -> SchemaP ss v m b b'
tag p () (f ()) -> p EventData (f EventData)
Prism' EventData ()
_EdConvCodeDelete SchemaP SwaggerDoc Value Value () ()
forall d. Monoid d => ValueSchemaP d () ()
null_
      EventType
ConvDelete -> Prism' EventData ()
-> SchemaP SwaggerDoc Value Value () ()
-> SchemaP SwaggerDoc Value Value EventData EventData
forall b b' a a' ss v m.
Prism b b' a a' -> SchemaP ss v m a a' -> SchemaP ss v m b b'
tag p () (f ()) -> p EventData (f EventData)
Prism' EventData ()
_EdConvDelete SchemaP SwaggerDoc Value Value () ()
forall d. Monoid d => ValueSchemaP d () ()
null_
      EventType
ProtocolUpdate -> Prism' EventData ProtocolTag
-> SchemaP SwaggerDoc Value Value ProtocolTag ProtocolTag
-> SchemaP SwaggerDoc Value Value EventData EventData
forall b b' a a' ss v m.
Prism b b' a a' -> SchemaP ss v m a a' -> SchemaP ss v m b b'
tag p ProtocolTag (f ProtocolTag) -> p EventData (f EventData)
Prism' EventData ProtocolTag
_EdProtocolUpdate (SchemaP NamedSwaggerDoc Value Value ProtocolTag ProtocolTag
-> SchemaP SwaggerDoc Value Value ProtocolTag ProtocolTag
forall doc doc' v m a b.
HasObject doc doc' =>
SchemaP doc' v m a b -> SchemaP doc v m a b
unnamed (ProtocolUpdate -> ProtocolTag
unProtocolUpdate (ProtocolUpdate -> ProtocolTag)
-> SchemaP NamedSwaggerDoc Value Value ProtocolTag ProtocolUpdate
-> SchemaP NamedSwaggerDoc Value Value ProtocolTag ProtocolTag
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ProtocolTag -> ProtocolUpdate
P.ProtocolUpdate (ProtocolTag -> ProtocolUpdate)
-> SchemaP
     NamedSwaggerDoc Value Value ProtocolUpdate ProtocolUpdate
-> SchemaP NamedSwaggerDoc Value Value ProtocolTag ProtocolUpdate
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP NamedSwaggerDoc Value Value ProtocolUpdate ProtocolUpdate
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema))

memberLeaveSchema :: ValueSchema NamedSwaggerDoc (EdMemberLeftReason, QualifiedUserIdList)
memberLeaveSchema :: SchemaP
  NamedSwaggerDoc
  Value
  Value
  (EdMemberLeftReason, QualifiedUserIdList)
  (EdMemberLeftReason, QualifiedUserIdList)
memberLeaveSchema =
  Text
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (EdMemberLeftReason, QualifiedUserIdList)
     (EdMemberLeftReason, QualifiedUserIdList)
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     (EdMemberLeftReason, QualifiedUserIdList)
     (EdMemberLeftReason, QualifiedUserIdList)
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"QualifiedUserIdList with EdMemberLeftReason" (SchemaP
   SwaggerDoc
   Object
   [Pair]
   (EdMemberLeftReason, QualifiedUserIdList)
   (EdMemberLeftReason, QualifiedUserIdList)
 -> SchemaP
      NamedSwaggerDoc
      Value
      Value
      (EdMemberLeftReason, QualifiedUserIdList)
      (EdMemberLeftReason, QualifiedUserIdList))
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (EdMemberLeftReason, QualifiedUserIdList)
     (EdMemberLeftReason, QualifiedUserIdList)
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     (EdMemberLeftReason, QualifiedUserIdList)
     (EdMemberLeftReason, QualifiedUserIdList)
forall a b. (a -> b) -> a -> b
$
    (,) (EdMemberLeftReason
 -> QualifiedUserIdList
 -> (EdMemberLeftReason, QualifiedUserIdList))
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (EdMemberLeftReason, QualifiedUserIdList)
     EdMemberLeftReason
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (EdMemberLeftReason, QualifiedUserIdList)
     (QualifiedUserIdList -> (EdMemberLeftReason, QualifiedUserIdList))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (EdMemberLeftReason, QualifiedUserIdList) -> EdMemberLeftReason
forall a b. (a, b) -> a
fst ((EdMemberLeftReason, QualifiedUserIdList) -> EdMemberLeftReason)
-> SchemaP
     SwaggerDoc Object [Pair] EdMemberLeftReason EdMemberLeftReason
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (EdMemberLeftReason, QualifiedUserIdList)
     EdMemberLeftReason
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP
     NamedSwaggerDoc Value Value EdMemberLeftReason EdMemberLeftReason
-> SchemaP
     SwaggerDoc Object [Pair] EdMemberLeftReason EdMemberLeftReason
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"reason" SchemaP
  NamedSwaggerDoc Value Value EdMemberLeftReason EdMemberLeftReason
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema SchemaP
  SwaggerDoc
  Object
  [Pair]
  (EdMemberLeftReason, QualifiedUserIdList)
  (QualifiedUserIdList -> (EdMemberLeftReason, QualifiedUserIdList))
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (EdMemberLeftReason, QualifiedUserIdList)
     QualifiedUserIdList
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (EdMemberLeftReason, QualifiedUserIdList)
     (EdMemberLeftReason, QualifiedUserIdList)
forall a b.
SchemaP
  SwaggerDoc
  Object
  [Pair]
  (EdMemberLeftReason, QualifiedUserIdList)
  (a -> b)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (EdMemberLeftReason, QualifiedUserIdList)
     a
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (EdMemberLeftReason, QualifiedUserIdList)
     b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (EdMemberLeftReason, QualifiedUserIdList) -> QualifiedUserIdList
forall a b. (a, b) -> b
snd ((EdMemberLeftReason, QualifiedUserIdList) -> QualifiedUserIdList)
-> SchemaP
     SwaggerDoc Object [Pair] QualifiedUserIdList QualifiedUserIdList
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (EdMemberLeftReason, QualifiedUserIdList)
     QualifiedUserIdList
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP
  SwaggerDoc Object [Pair] QualifiedUserIdList QualifiedUserIdList
qualifiedUserIdListObjectSchema

instance ToSchema Event where
  schema :: ValueSchema NamedSwaggerDoc Event
schema = Text
-> SchemaP SwaggerDoc Object [Pair] Event Event
-> ValueSchema NamedSwaggerDoc Event
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"Event" SchemaP SwaggerDoc Object [Pair] Event Event
eventObjectSchema

eventObjectSchema :: ObjectSchema SwaggerDoc Event
eventObjectSchema :: SchemaP SwaggerDoc Object [Pair] Event Event
eventObjectSchema =
  (EventType, EventData)
-> Qualified ConvId
-> Maybe SubConvId
-> Qualified UserId
-> UTCTime
-> Event
forall {a}.
(a, EventData)
-> Qualified ConvId
-> Maybe SubConvId
-> Qualified UserId
-> UTCTime
-> Event
mk
    ((EventType, EventData)
 -> Qualified ConvId
 -> Maybe SubConvId
 -> Qualified UserId
 -> UTCTime
 -> Event)
-> SchemaP SwaggerDoc Object [Pair] Event (EventType, EventData)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     Event
     (Qualified ConvId
      -> Maybe SubConvId -> Qualified UserId -> UTCTime -> Event)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Event -> EventType
evtType (Event -> EventType)
-> (Event -> EventData) -> Event -> (EventType, EventData)
forall b c c'. (b -> c) -> (b -> c') -> b -> (c, c')
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& Event -> EventData
evtData) (Event -> (EventType, EventData))
-> ObjectSchema SwaggerDoc (EventType, EventData)
-> SchemaP SwaggerDoc Object [Pair] Event (EventType, EventData)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= ObjectSchema SwaggerDoc (EventType, EventData)
taggedEventDataSchema
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  Event
  (Qualified ConvId
   -> Maybe SubConvId -> Qualified UserId -> UTCTime -> Event)
-> SchemaP SwaggerDoc Object [Pair] Event (Maybe ConvId)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     Event
     (Qualified ConvId
      -> Maybe SubConvId -> Qualified UserId -> UTCTime -> Event)
forall a b.
SchemaP SwaggerDoc Object [Pair] Event a
-> SchemaP SwaggerDoc Object [Pair] Event b
-> SchemaP SwaggerDoc Object [Pair] Event a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* (Qualified ConvId -> ConvId
forall a. Qualified a -> a
qUnqualified (Qualified ConvId -> ConvId)
-> (Event -> Qualified ConvId) -> Event -> ConvId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Event -> Qualified ConvId
evtConv) (Event -> ConvId)
-> SchemaP SwaggerDoc Object [Pair] ConvId (Maybe ConvId)
-> SchemaP SwaggerDoc Object [Pair] Event (Maybe ConvId)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] ConvId ConvId
-> SchemaP SwaggerDoc Object [Pair] ConvId (Maybe ConvId)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Text
-> SchemaP NamedSwaggerDoc Value Value ConvId ConvId
-> SchemaP SwaggerDoc Object [Pair] ConvId ConvId
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"conversation" SchemaP NamedSwaggerDoc Value Value ConvId ConvId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  Event
  (Qualified ConvId
   -> Maybe SubConvId -> Qualified UserId -> UTCTime -> Event)
-> SchemaP SwaggerDoc Object [Pair] Event (Qualified ConvId)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     Event
     (Maybe SubConvId -> Qualified UserId -> UTCTime -> Event)
forall a b.
SchemaP SwaggerDoc Object [Pair] Event (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Event a
-> SchemaP SwaggerDoc Object [Pair] Event b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Event -> Qualified ConvId
evtConv (Event -> Qualified ConvId)
-> SchemaP
     SwaggerDoc Object [Pair] (Qualified ConvId) (Qualified ConvId)
-> SchemaP SwaggerDoc Object [Pair] Event (Qualified ConvId)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP
     NamedSwaggerDoc Value Value (Qualified ConvId) (Qualified ConvId)
-> SchemaP
     SwaggerDoc Object [Pair] (Qualified ConvId) (Qualified ConvId)
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"qualified_conversation" SchemaP
  NamedSwaggerDoc Value Value (Qualified ConvId) (Qualified ConvId)
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  Event
  (Maybe SubConvId -> Qualified UserId -> UTCTime -> Event)
-> SchemaP SwaggerDoc Object [Pair] Event (Maybe SubConvId)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     Event
     (Qualified UserId -> UTCTime -> Event)
forall a b.
SchemaP SwaggerDoc Object [Pair] Event (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Event a
-> SchemaP SwaggerDoc Object [Pair] Event b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Event -> Maybe SubConvId
evtSubConv (Event -> Maybe SubConvId)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe SubConvId) (Maybe SubConvId)
-> SchemaP SwaggerDoc Object [Pair] Event (Maybe SubConvId)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] SubConvId (Maybe SubConvId)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe SubConvId) (Maybe SubConvId)
forall w d v a b.
Monoid w =>
SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybe_ (Text
-> SchemaP NamedSwaggerDoc Value Value SubConvId SubConvId
-> SchemaP SwaggerDoc Object [Pair] SubConvId (Maybe SubConvId)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optField Text
"subconv" SchemaP NamedSwaggerDoc Value Value SubConvId SubConvId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  Event
  (Qualified UserId -> UTCTime -> Event)
-> SchemaP SwaggerDoc Object [Pair] Event (Maybe UserId)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     Event
     (Qualified UserId -> UTCTime -> Event)
forall a b.
SchemaP SwaggerDoc Object [Pair] Event a
-> SchemaP SwaggerDoc Object [Pair] Event b
-> SchemaP SwaggerDoc Object [Pair] Event a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* (Qualified UserId -> UserId
forall a. Qualified a -> a
qUnqualified (Qualified UserId -> UserId)
-> (Event -> Qualified UserId) -> Event -> UserId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Event -> Qualified UserId
evtFrom) (Event -> UserId)
-> SchemaP SwaggerDoc Object [Pair] UserId (Maybe UserId)
-> SchemaP SwaggerDoc Object [Pair] Event (Maybe UserId)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] UserId UserId
-> SchemaP SwaggerDoc Object [Pair] UserId (Maybe UserId)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Text
-> ValueSchema NamedSwaggerDoc UserId
-> SchemaP SwaggerDoc Object [Pair] UserId UserId
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"from" ValueSchema NamedSwaggerDoc UserId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
    SchemaP
  SwaggerDoc
  Object
  [Pair]
  Event
  (Qualified UserId -> UTCTime -> Event)
-> SchemaP SwaggerDoc Object [Pair] Event (Qualified UserId)
-> SchemaP SwaggerDoc Object [Pair] Event (UTCTime -> Event)
forall a b.
SchemaP SwaggerDoc Object [Pair] Event (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Event a
-> SchemaP SwaggerDoc Object [Pair] Event b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Event -> Qualified UserId
evtFrom (Event -> Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] (Qualified UserId) (Qualified UserId)
-> SchemaP SwaggerDoc Object [Pair] Event (Qualified UserId)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP
     NamedSwaggerDoc Value Value (Qualified UserId) (Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] (Qualified UserId) (Qualified UserId)
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"qualified_from" SchemaP
  NamedSwaggerDoc Value Value (Qualified UserId) (Qualified UserId)
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
    SchemaP SwaggerDoc Object [Pair] Event (UTCTime -> Event)
-> SchemaP SwaggerDoc Object [Pair] Event UTCTime
-> SchemaP SwaggerDoc Object [Pair] Event Event
forall a b.
SchemaP SwaggerDoc Object [Pair] Event (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Event a
-> SchemaP SwaggerDoc Object [Pair] Event b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (UTCTime -> UTCTimeMillis
toUTCTimeMillis (UTCTime -> UTCTimeMillis)
-> (Event -> UTCTime) -> Event -> UTCTimeMillis
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Event -> UTCTime
evtTime) (Event -> UTCTimeMillis)
-> SchemaP SwaggerDoc Object [Pair] UTCTimeMillis UTCTime
-> SchemaP SwaggerDoc Object [Pair] Event UTCTime
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value UTCTimeMillis UTCTime
-> SchemaP SwaggerDoc Object [Pair] UTCTimeMillis UTCTime
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"time" (UTCTimeMillis -> UTCTime
fromUTCTimeMillis (UTCTimeMillis -> UTCTime)
-> SchemaP NamedSwaggerDoc Value Value UTCTimeMillis UTCTimeMillis
-> SchemaP NamedSwaggerDoc Value Value UTCTimeMillis UTCTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SchemaP NamedSwaggerDoc Value Value UTCTimeMillis UTCTimeMillis
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
  where
    mk :: (a, EventData)
-> Qualified ConvId
-> Maybe SubConvId
-> Qualified UserId
-> UTCTime
-> Event
mk (a
_, EventData
d) Qualified ConvId
cid Maybe SubConvId
sconvid Qualified UserId
uid UTCTime
tm = Qualified ConvId
-> Maybe SubConvId
-> Qualified UserId
-> UTCTime
-> EventData
-> Event
Event Qualified ConvId
cid Maybe SubConvId
sconvid Qualified UserId
uid UTCTime
tm EventData
d

instance ToJSONObject Event where
  toJSONObject :: Event -> Object
toJSONObject =
    [Pair] -> Object
forall v. [(Key, v)] -> KeyMap v
KeyMap.fromList
      ([Pair] -> Object) -> (Event -> [Pair]) -> Event -> Object
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Pair] -> Maybe [Pair] -> [Pair]
forall a. a -> Maybe a -> a
fromMaybe []
      (Maybe [Pair] -> [Pair])
-> (Event -> Maybe [Pair]) -> Event -> [Pair]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SchemaP SwaggerDoc Object [Pair] Event Event
-> Event -> Maybe [Pair]
forall ss v m a b. SchemaP ss v m a b -> a -> Maybe m
schemaOut SchemaP SwaggerDoc Object [Pair] Event Event
eventObjectSchema

instance FromJSON Event where
  parseJSON :: Value -> Parser Event
parseJSON = Value -> Parser Event
forall a. ToSchema a => Value -> Parser a
schemaParseJSON

instance ToJSON Event where
  toJSON :: Event -> Value
toJSON = Event -> Value
forall a. ToSchema a => a -> Value
schemaToJSON

instance S.ToSchema Event where
  declareNamedSchema :: Proxy Event -> Declare (Definitions Schema) NamedSchema
declareNamedSchema = Proxy Event -> Declare (Definitions Schema) NamedSchema
forall a.
ToSchema a =>
Proxy a -> Declare (Definitions Schema) NamedSchema
schemaToSwagger

--------------------------------------------------------------------------------
-- MultiVerb instances

instance
  (ResponseType r1 ~ ConversationCodeInfo, ResponseType r2 ~ Event) =>
  AsUnion '[r1, r2] AddCodeResult
  where
  toUnion :: AddCodeResult -> Union (ResponseTypes '[r1, r2])
toUnion (CodeAlreadyExisted ConversationCodeInfo
c) = I ConversationCodeInfo -> NS I '[ConversationCodeInfo, Event]
forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z (ConversationCodeInfo -> I ConversationCodeInfo
forall a. a -> I a
I ConversationCodeInfo
c)
  toUnion (CodeAdded Event
e) = NS I '[Event] -> NS I '[ConversationCodeInfo, Event]
forall {k} (a :: k -> *) (xs :: [k]) (x :: k).
NS a xs -> NS a (x : xs)
S (I Event -> NS I '[Event]
forall {k} (a :: k -> *) (x :: k) (xs :: [k]). a x -> NS a (x : xs)
Z (Event -> I Event
forall a. a -> I a
I Event
e))

  fromUnion :: Union (ResponseTypes '[r1, r2]) -> AddCodeResult
fromUnion (Z (I x
c)) = ConversationCodeInfo -> AddCodeResult
CodeAlreadyExisted x
ConversationCodeInfo
c
  fromUnion (S (Z (I x
e))) = Event -> AddCodeResult
CodeAdded x
Event
e
  fromUnion (S (S NS I xs
x)) = case NS I xs
x of {}