{-# LANGUAGE StrictData #-}

-- 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/>.

-- | This module is deprecated and only used for old endpoints to send messages.
-- The new protobuf definitions are generated using proto-lens in the wire-message-proto-lens package.
module Wire.API.Message.Proto
  ( UserId,
    userId,
    fromUserId,
    ClientId,
    newClientId,
    fromClientId,
    toClientId,
    ClientEntry,
    clientEntry,
    clientEntryId,
    clientEntryMessage,
    UserEntry,
    userEntry,
    userEntryId,
    userEntryClients,
    Priority (..),
    NewOtrMessage,
    newOtrMessage,
    newOtrMessageSender,
    newOtrMessageRecipients,
    newOtrMessageNativePush,
    newOtrMessageNativePriority,
    newOtrMessageData,
    newOtrMessageTransient,
    newOtrMessageReportMissing,
  )
where

import Data.Id qualified as Id
import Data.ProtocolBuffers
import Imports

--------------------------------------------------------------------------------
-- UserId

newtype UserId = UserId
  { UserId -> Required 1 (Value (Id 'User))
_user :: Required 1 (Value Id.UserId)
  }
  deriving stock (UserId -> UserId -> Bool
(UserId -> UserId -> Bool)
-> (UserId -> UserId -> Bool) -> Eq UserId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UserId -> UserId -> Bool
== :: UserId -> UserId -> Bool
$c/= :: UserId -> UserId -> Bool
/= :: UserId -> UserId -> Bool
Eq, Int -> UserId -> ShowS
[UserId] -> ShowS
UserId -> String
(Int -> UserId -> ShowS)
-> (UserId -> String) -> ([UserId] -> ShowS) -> Show UserId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UserId -> ShowS
showsPrec :: Int -> UserId -> ShowS
$cshow :: UserId -> String
show :: UserId -> String
$cshowList :: [UserId] -> ShowS
showList :: [UserId] -> ShowS
Show, (forall x. UserId -> Rep UserId x)
-> (forall x. Rep UserId x -> UserId) -> Generic UserId
forall x. Rep UserId x -> UserId
forall x. UserId -> Rep UserId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. UserId -> Rep UserId x
from :: forall x. UserId -> Rep UserId x
$cto :: forall x. Rep UserId x -> UserId
to :: forall x. Rep UserId x -> UserId
Generic)

instance Encode UserId

instance Decode UserId

fromUserId :: Id.UserId -> UserId
fromUserId :: Id 'User -> UserId
fromUserId Id 'User
u = UserId {$sel:_user:UserId :: Required 1 (Value (Id 'User))
_user = FieldType (Field 1 (RequiredField (Always (Value (Id 'User)))))
-> Field 1 (RequiredField (Always (Value (Id 'User))))
forall a. HasField a => FieldType a -> a
putField FieldType (Field 1 (RequiredField (Always (Value (Id 'User)))))
Id 'User
u}

userId :: (Functor f) => (Id.UserId -> f Id.UserId) -> UserId -> f UserId
userId :: forall (f :: * -> *).
Functor f =>
(Id 'User -> f (Id 'User)) -> UserId -> f UserId
userId Id 'User -> f (Id 'User)
f UserId
c = (\Field 1 (RequiredField (Always (Value (Id 'User))))
x -> UserId
c {_user = x}) (Field 1 (RequiredField (Always (Value (Id 'User)))) -> UserId)
-> f (Field 1 (RequiredField (Always (Value (Id 'User)))))
-> f UserId
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (FieldType (Field 1 (RequiredField (Always (Value (Id 'User)))))
 -> f (FieldType
         (Field 1 (RequiredField (Always (Value (Id 'User)))))))
-> Field 1 (RequiredField (Always (Value (Id 'User))))
-> f (Field 1 (RequiredField (Always (Value (Id 'User)))))
forall a (f :: * -> *).
(HasField a, Functor f) =>
(FieldType a -> f (FieldType a)) -> a -> f a
forall (f :: * -> *).
Functor f =>
(FieldType (Field 1 (RequiredField (Always (Value (Id 'User)))))
 -> f (FieldType
         (Field 1 (RequiredField (Always (Value (Id 'User)))))))
-> Field 1 (RequiredField (Always (Value (Id 'User))))
-> f (Field 1 (RequiredField (Always (Value (Id 'User)))))
field FieldType (Field 1 (RequiredField (Always (Value (Id 'User)))))
-> f (FieldType
        (Field 1 (RequiredField (Always (Value (Id 'User))))))
Id 'User -> f (Id 'User)
f (UserId -> Required 1 (Value (Id 'User))
_user UserId
c)

--------------------------------------------------------------------------------
-- ClientId

newtype ClientId = ClientId
  { ClientId -> Required 1 (Value Word64)
_client :: Required 1 (Value Word64)
  }
  deriving stock (ClientId -> ClientId -> Bool
(ClientId -> ClientId -> Bool)
-> (ClientId -> ClientId -> Bool) -> Eq ClientId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClientId -> ClientId -> Bool
== :: ClientId -> ClientId -> Bool
$c/= :: ClientId -> ClientId -> Bool
/= :: ClientId -> ClientId -> Bool
Eq, Int -> ClientId -> ShowS
[ClientId] -> ShowS
ClientId -> String
(Int -> ClientId -> ShowS)
-> (ClientId -> String) -> ([ClientId] -> ShowS) -> Show ClientId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ClientId -> ShowS
showsPrec :: Int -> ClientId -> ShowS
$cshow :: ClientId -> String
show :: ClientId -> String
$cshowList :: [ClientId] -> ShowS
showList :: [ClientId] -> ShowS
Show, (forall x. ClientId -> Rep ClientId x)
-> (forall x. Rep ClientId x -> ClientId) -> Generic ClientId
forall x. Rep ClientId x -> ClientId
forall x. ClientId -> Rep ClientId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ClientId -> Rep ClientId x
from :: forall x. ClientId -> Rep ClientId x
$cto :: forall x. Rep ClientId x -> ClientId
to :: forall x. Rep ClientId x -> ClientId
Generic)

instance Encode ClientId

instance Decode ClientId

newClientId :: Word64 -> ClientId
newClientId :: Word64 -> ClientId
newClientId Word64
c = ClientId {$sel:_client:ClientId :: Required 1 (Value Word64)
_client = FieldType (Field 1 (RequiredField (Always (Value Word64))))
-> Field 1 (RequiredField (Always (Value Word64)))
forall a. HasField a => FieldType a -> a
putField Word64
FieldType (Field 1 (RequiredField (Always (Value Word64))))
c}

toClientId :: ClientId -> Id.ClientId
toClientId :: ClientId -> ClientId
toClientId ClientId
c = Word64 -> ClientId
Id.ClientId (Word64 -> ClientId) -> Word64 -> ClientId
forall a b. (a -> b) -> a -> b
$ Field 1 (RequiredField (Always (Value Word64)))
-> FieldType (Field 1 (RequiredField (Always (Value Word64))))
forall a. HasField a => a -> FieldType a
getField (ClientId -> Required 1 (Value Word64)
_client ClientId
c)

fromClientId :: Id.ClientId -> ClientId
fromClientId :: ClientId -> ClientId
fromClientId = Word64 -> ClientId
newClientId (Word64 -> ClientId)
-> (ClientId -> Word64) -> ClientId -> ClientId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ClientId -> Word64
Id.clientToWord64

--------------------------------------------------------------------------------
-- ClientEntry

data ClientEntry = ClientEntry
  { ClientEntry -> Required 1 (Message ClientId)
_clientId :: Required 1 (Message ClientId),
    ClientEntry -> Required 2 (Value ByteString)
_clientVal :: Required 2 (Value ByteString)
  }
  deriving stock (ClientEntry -> ClientEntry -> Bool
(ClientEntry -> ClientEntry -> Bool)
-> (ClientEntry -> ClientEntry -> Bool) -> Eq ClientEntry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClientEntry -> ClientEntry -> Bool
== :: ClientEntry -> ClientEntry -> Bool
$c/= :: ClientEntry -> ClientEntry -> Bool
/= :: ClientEntry -> ClientEntry -> Bool
Eq, Int -> ClientEntry -> ShowS
[ClientEntry] -> ShowS
ClientEntry -> String
(Int -> ClientEntry -> ShowS)
-> (ClientEntry -> String)
-> ([ClientEntry] -> ShowS)
-> Show ClientEntry
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ClientEntry -> ShowS
showsPrec :: Int -> ClientEntry -> ShowS
$cshow :: ClientEntry -> String
show :: ClientEntry -> String
$cshowList :: [ClientEntry] -> ShowS
showList :: [ClientEntry] -> ShowS
Show, (forall x. ClientEntry -> Rep ClientEntry x)
-> (forall x. Rep ClientEntry x -> ClientEntry)
-> Generic ClientEntry
forall x. Rep ClientEntry x -> ClientEntry
forall x. ClientEntry -> Rep ClientEntry x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ClientEntry -> Rep ClientEntry x
from :: forall x. ClientEntry -> Rep ClientEntry x
$cto :: forall x. Rep ClientEntry x -> ClientEntry
to :: forall x. Rep ClientEntry x -> ClientEntry
Generic)

instance Encode ClientEntry

instance Decode ClientEntry

clientEntry :: ClientId -> ByteString -> ClientEntry
clientEntry :: ClientId -> ByteString -> ClientEntry
clientEntry ClientId
c ByteString
t =
  ClientEntry
    { $sel:_clientId:ClientEntry :: Required 1 (Message ClientId)
_clientId = FieldType (Field 1 (RequiredField (Always (Message ClientId))))
-> Field 1 (RequiredField (Always (Message ClientId)))
forall a. HasField a => FieldType a -> a
putField FieldType (Field 1 (RequiredField (Always (Message ClientId))))
ClientId
c,
      $sel:_clientVal:ClientEntry :: Required 2 (Value ByteString)
_clientVal = FieldType (Field 2 (RequiredField (Always (Value ByteString))))
-> Field 2 (RequiredField (Always (Value ByteString)))
forall a. HasField a => FieldType a -> a
putField ByteString
FieldType (Field 2 (RequiredField (Always (Value ByteString))))
t
    }

clientEntryId :: (Functor f) => (ClientId -> f ClientId) -> ClientEntry -> f ClientEntry
clientEntryId :: forall (f :: * -> *).
Functor f =>
(ClientId -> f ClientId) -> ClientEntry -> f ClientEntry
clientEntryId ClientId -> f ClientId
f ClientEntry
c = (\Field 1 (RequiredField (Always (Message ClientId)))
x -> ClientEntry
c {_clientId = x}) (Field 1 (RequiredField (Always (Message ClientId)))
 -> ClientEntry)
-> f (Field 1 (RequiredField (Always (Message ClientId))))
-> f ClientEntry
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (FieldType (Field 1 (RequiredField (Always (Message ClientId))))
 -> f (FieldType
         (Field 1 (RequiredField (Always (Message ClientId))))))
-> Field 1 (RequiredField (Always (Message ClientId)))
-> f (Field 1 (RequiredField (Always (Message ClientId))))
forall a (f :: * -> *).
(HasField a, Functor f) =>
(FieldType a -> f (FieldType a)) -> a -> f a
forall (f :: * -> *).
Functor f =>
(FieldType (Field 1 (RequiredField (Always (Message ClientId))))
 -> f (FieldType
         (Field 1 (RequiredField (Always (Message ClientId))))))
-> Field 1 (RequiredField (Always (Message ClientId)))
-> f (Field 1 (RequiredField (Always (Message ClientId))))
field FieldType (Field 1 (RequiredField (Always (Message ClientId))))
-> f (FieldType
        (Field 1 (RequiredField (Always (Message ClientId)))))
ClientId -> f ClientId
f (ClientEntry -> Required 1 (Message ClientId)
_clientId ClientEntry
c)

clientEntryMessage :: (Functor f) => (ByteString -> f ByteString) -> ClientEntry -> f ClientEntry
clientEntryMessage :: forall (f :: * -> *).
Functor f =>
(ByteString -> f ByteString) -> ClientEntry -> f ClientEntry
clientEntryMessage ByteString -> f ByteString
f ClientEntry
c = (\Field 2 (RequiredField (Always (Value ByteString)))
x -> ClientEntry
c {_clientVal = x}) (Field 2 (RequiredField (Always (Value ByteString)))
 -> ClientEntry)
-> f (Field 2 (RequiredField (Always (Value ByteString))))
-> f ClientEntry
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (FieldType (Field 2 (RequiredField (Always (Value ByteString))))
 -> f (FieldType
         (Field 2 (RequiredField (Always (Value ByteString))))))
-> Field 2 (RequiredField (Always (Value ByteString)))
-> f (Field 2 (RequiredField (Always (Value ByteString))))
forall a (f :: * -> *).
(HasField a, Functor f) =>
(FieldType a -> f (FieldType a)) -> a -> f a
forall (f :: * -> *).
Functor f =>
(FieldType (Field 2 (RequiredField (Always (Value ByteString))))
 -> f (FieldType
         (Field 2 (RequiredField (Always (Value ByteString))))))
-> Field 2 (RequiredField (Always (Value ByteString)))
-> f (Field 2 (RequiredField (Always (Value ByteString))))
field ByteString -> f ByteString
FieldType (Field 2 (RequiredField (Always (Value ByteString))))
-> f (FieldType
        (Field 2 (RequiredField (Always (Value ByteString)))))
f (ClientEntry -> Required 2 (Value ByteString)
_clientVal ClientEntry
c)

--------------------------------------------------------------------------------
-- UserEntry

data UserEntry = UserEntry
  { UserEntry -> Required 1 (Message UserId)
_userId :: Required 1 (Message UserId),
    UserEntry -> Repeated 2 (Message ClientEntry)
_userVal :: Repeated 2 (Message ClientEntry)
  }
  deriving stock (UserEntry -> UserEntry -> Bool
(UserEntry -> UserEntry -> Bool)
-> (UserEntry -> UserEntry -> Bool) -> Eq UserEntry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UserEntry -> UserEntry -> Bool
== :: UserEntry -> UserEntry -> Bool
$c/= :: UserEntry -> UserEntry -> Bool
/= :: UserEntry -> UserEntry -> Bool
Eq, Int -> UserEntry -> ShowS
[UserEntry] -> ShowS
UserEntry -> String
(Int -> UserEntry -> ShowS)
-> (UserEntry -> String)
-> ([UserEntry] -> ShowS)
-> Show UserEntry
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UserEntry -> ShowS
showsPrec :: Int -> UserEntry -> ShowS
$cshow :: UserEntry -> String
show :: UserEntry -> String
$cshowList :: [UserEntry] -> ShowS
showList :: [UserEntry] -> ShowS
Show, (forall x. UserEntry -> Rep UserEntry x)
-> (forall x. Rep UserEntry x -> UserEntry) -> Generic UserEntry
forall x. Rep UserEntry x -> UserEntry
forall x. UserEntry -> Rep UserEntry x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. UserEntry -> Rep UserEntry x
from :: forall x. UserEntry -> Rep UserEntry x
$cto :: forall x. Rep UserEntry x -> UserEntry
to :: forall x. Rep UserEntry x -> UserEntry
Generic)

instance Encode UserEntry

instance Decode UserEntry

userEntry :: UserId -> [ClientEntry] -> UserEntry
userEntry :: UserId -> [ClientEntry] -> UserEntry
userEntry UserId
u [ClientEntry]
c =
  UserEntry
    { $sel:_userId:UserEntry :: Required 1 (Message UserId)
_userId = FieldType (Field 1 (RequiredField (Always (Message UserId))))
-> Field 1 (RequiredField (Always (Message UserId)))
forall a. HasField a => FieldType a -> a
putField FieldType (Field 1 (RequiredField (Always (Message UserId))))
UserId
u,
      $sel:_userVal:UserEntry :: Repeated 2 (Message ClientEntry)
_userVal = FieldType (Repeated 2 (Message ClientEntry))
-> Repeated 2 (Message ClientEntry)
forall a. HasField a => FieldType a -> a
putField [ClientEntry]
FieldType (Repeated 2 (Message ClientEntry))
c
    }

userEntryId :: (Functor f) => (UserId -> f UserId) -> UserEntry -> f UserEntry
userEntryId :: forall (f :: * -> *).
Functor f =>
(UserId -> f UserId) -> UserEntry -> f UserEntry
userEntryId UserId -> f UserId
f UserEntry
c = (\Field 1 (RequiredField (Always (Message UserId)))
x -> UserEntry
c {_userId = x}) (Field 1 (RequiredField (Always (Message UserId))) -> UserEntry)
-> f (Field 1 (RequiredField (Always (Message UserId))))
-> f UserEntry
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (FieldType (Field 1 (RequiredField (Always (Message UserId))))
 -> f (FieldType
         (Field 1 (RequiredField (Always (Message UserId))))))
-> Field 1 (RequiredField (Always (Message UserId)))
-> f (Field 1 (RequiredField (Always (Message UserId))))
forall a (f :: * -> *).
(HasField a, Functor f) =>
(FieldType a -> f (FieldType a)) -> a -> f a
forall (f :: * -> *).
Functor f =>
(FieldType (Field 1 (RequiredField (Always (Message UserId))))
 -> f (FieldType
         (Field 1 (RequiredField (Always (Message UserId))))))
-> Field 1 (RequiredField (Always (Message UserId)))
-> f (Field 1 (RequiredField (Always (Message UserId))))
field FieldType (Field 1 (RequiredField (Always (Message UserId))))
-> f (FieldType
        (Field 1 (RequiredField (Always (Message UserId)))))
UserId -> f UserId
f (UserEntry -> Required 1 (Message UserId)
_userId UserEntry
c)

userEntryClients :: (Functor f) => ([ClientEntry] -> f [ClientEntry]) -> UserEntry -> f UserEntry
userEntryClients :: forall (f :: * -> *).
Functor f =>
([ClientEntry] -> f [ClientEntry]) -> UserEntry -> f UserEntry
userEntryClients [ClientEntry] -> f [ClientEntry]
f UserEntry
c = (\Repeated 2 (Message ClientEntry)
x -> UserEntry
c {_userVal = x}) (Repeated 2 (Message ClientEntry) -> UserEntry)
-> f (Repeated 2 (Message ClientEntry)) -> f UserEntry
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (FieldType (Repeated 2 (Message ClientEntry))
 -> f (FieldType (Repeated 2 (Message ClientEntry))))
-> Repeated 2 (Message ClientEntry)
-> f (Repeated 2 (Message ClientEntry))
forall a (f :: * -> *).
(HasField a, Functor f) =>
(FieldType a -> f (FieldType a)) -> a -> f a
forall (f :: * -> *).
Functor f =>
(FieldType (Repeated 2 (Message ClientEntry))
 -> f (FieldType (Repeated 2 (Message ClientEntry))))
-> Repeated 2 (Message ClientEntry)
-> f (Repeated 2 (Message ClientEntry))
field [ClientEntry] -> f [ClientEntry]
FieldType (Repeated 2 (Message ClientEntry))
-> f (FieldType (Repeated 2 (Message ClientEntry)))
f (UserEntry -> Repeated 2 (Message ClientEntry)
_userVal UserEntry
c)

--------------------------------------------------------------------------------
-- Priority

-- | See also `Wire.API.Message.Priority`
data Priority = LowPriority | HighPriority
  deriving stock (Priority -> Priority -> Bool
(Priority -> Priority -> Bool)
-> (Priority -> Priority -> Bool) -> Eq Priority
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Priority -> Priority -> Bool
== :: Priority -> Priority -> Bool
$c/= :: Priority -> Priority -> Bool
/= :: Priority -> Priority -> Bool
Eq, Int -> Priority -> ShowS
[Priority] -> ShowS
Priority -> String
(Int -> Priority -> ShowS)
-> (Priority -> String) -> ([Priority] -> ShowS) -> Show Priority
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Priority -> ShowS
showsPrec :: Int -> Priority -> ShowS
$cshow :: Priority -> String
show :: Priority -> String
$cshowList :: [Priority] -> ShowS
showList :: [Priority] -> ShowS
Show, Eq Priority
Eq Priority =>
(Priority -> Priority -> Ordering)
-> (Priority -> Priority -> Bool)
-> (Priority -> Priority -> Bool)
-> (Priority -> Priority -> Bool)
-> (Priority -> Priority -> Bool)
-> (Priority -> Priority -> Priority)
-> (Priority -> Priority -> Priority)
-> Ord Priority
Priority -> Priority -> Bool
Priority -> Priority -> Ordering
Priority -> Priority -> Priority
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 :: Priority -> Priority -> Ordering
compare :: Priority -> Priority -> Ordering
$c< :: Priority -> Priority -> Bool
< :: Priority -> Priority -> Bool
$c<= :: Priority -> Priority -> Bool
<= :: Priority -> Priority -> Bool
$c> :: Priority -> Priority -> Bool
> :: Priority -> Priority -> Bool
$c>= :: Priority -> Priority -> Bool
>= :: Priority -> Priority -> Bool
$cmax :: Priority -> Priority -> Priority
max :: Priority -> Priority -> Priority
$cmin :: Priority -> Priority -> Priority
min :: Priority -> Priority -> Priority
Ord, (forall x. Priority -> Rep Priority x)
-> (forall x. Rep Priority x -> Priority) -> Generic Priority
forall x. Rep Priority x -> Priority
forall x. Priority -> Rep Priority x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Priority -> Rep Priority x
from :: forall x. Priority -> Rep Priority x
$cto :: forall x. Rep Priority x -> Priority
to :: forall x. Rep Priority x -> Priority
Generic)

instance Encode Priority

instance Decode Priority

instance Enum Priority where
  toEnum :: Int -> Priority
toEnum Int
1 = Priority
LowPriority
  toEnum Int
2 = Priority
HighPriority
  toEnum Int
x = String -> Priority
forall a. HasCallStack => String -> a
error (String -> Priority) -> String -> Priority
forall a b. (a -> b) -> a -> b
$ String
"Wire.API.Message.Proto.Priority: invalid enum value: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
x

  fromEnum :: Priority -> Int
fromEnum Priority
LowPriority = Int
1
  fromEnum Priority
HighPriority = Int
2

instance Bounded Priority where
  minBound :: Priority
minBound = Priority
LowPriority
  maxBound :: Priority
maxBound = Priority
HighPriority

--------------------------------------------------------------------------------
-- NewOtrMessage

data NewOtrMessage = NewOtrMessage
  { NewOtrMessage -> Required 1 (Message ClientId)
_newOtrSender :: Required 1 (Message ClientId),
    NewOtrMessage -> Repeated 2 (Message UserEntry)
_newOtrRecipients :: Repeated 2 (Message UserEntry),
    NewOtrMessage -> Optional 3 (Value Bool)
_newOtrNativePush :: Optional 3 (Value Bool),
    NewOtrMessage -> Optional 4 (Value ByteString)
_newOtrData :: Optional 4 (Value ByteString),
    NewOtrMessage -> Optional 5 (Enumeration Priority)
_newOtrNativePriority :: Optional 5 (Enumeration Priority), -- See note [orphans]
    NewOtrMessage -> Optional 6 (Value Bool)
_newOtrTransient :: Optional 6 (Value Bool),
    NewOtrMessage -> Repeated 7 (Message UserId)
_newOtrReportMissing :: Repeated 7 (Message UserId)
  }
  deriving stock (NewOtrMessage -> NewOtrMessage -> Bool
(NewOtrMessage -> NewOtrMessage -> Bool)
-> (NewOtrMessage -> NewOtrMessage -> Bool) -> Eq NewOtrMessage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NewOtrMessage -> NewOtrMessage -> Bool
== :: NewOtrMessage -> NewOtrMessage -> Bool
$c/= :: NewOtrMessage -> NewOtrMessage -> Bool
/= :: NewOtrMessage -> NewOtrMessage -> Bool
Eq, Int -> NewOtrMessage -> ShowS
[NewOtrMessage] -> ShowS
NewOtrMessage -> String
(Int -> NewOtrMessage -> ShowS)
-> (NewOtrMessage -> String)
-> ([NewOtrMessage] -> ShowS)
-> Show NewOtrMessage
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NewOtrMessage -> ShowS
showsPrec :: Int -> NewOtrMessage -> ShowS
$cshow :: NewOtrMessage -> String
show :: NewOtrMessage -> String
$cshowList :: [NewOtrMessage] -> ShowS
showList :: [NewOtrMessage] -> ShowS
Show, (forall x. NewOtrMessage -> Rep NewOtrMessage x)
-> (forall x. Rep NewOtrMessage x -> NewOtrMessage)
-> Generic NewOtrMessage
forall x. Rep NewOtrMessage x -> NewOtrMessage
forall x. NewOtrMessage -> Rep NewOtrMessage x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NewOtrMessage -> Rep NewOtrMessage x
from :: forall x. NewOtrMessage -> Rep NewOtrMessage x
$cto :: forall x. Rep NewOtrMessage x -> NewOtrMessage
to :: forall x. Rep NewOtrMessage x -> NewOtrMessage
Generic)

instance Encode NewOtrMessage

instance Decode NewOtrMessage

newOtrMessage :: ClientId -> [UserEntry] -> NewOtrMessage
newOtrMessage :: ClientId -> [UserEntry] -> NewOtrMessage
newOtrMessage ClientId
c [UserEntry]
us =
  NewOtrMessage
    { $sel:_newOtrSender:NewOtrMessage :: Required 1 (Message ClientId)
_newOtrSender = FieldType (Field 1 (RequiredField (Always (Message ClientId))))
-> Field 1 (RequiredField (Always (Message ClientId)))
forall a. HasField a => FieldType a -> a
putField FieldType (Field 1 (RequiredField (Always (Message ClientId))))
ClientId
c,
      $sel:_newOtrRecipients:NewOtrMessage :: Repeated 2 (Message UserEntry)
_newOtrRecipients = FieldType (Repeated 2 (Message UserEntry))
-> Repeated 2 (Message UserEntry)
forall a. HasField a => FieldType a -> a
putField [UserEntry]
FieldType (Repeated 2 (Message UserEntry))
us,
      $sel:_newOtrNativePush:NewOtrMessage :: Optional 3 (Value Bool)
_newOtrNativePush = FieldType (Field 3 (OptionalField (Last (Value Bool))))
-> Field 3 (OptionalField (Last (Value Bool)))
forall a. HasField a => FieldType a -> a
putField Maybe Bool
FieldType (Field 3 (OptionalField (Last (Value Bool))))
forall a. Maybe a
Nothing,
      $sel:_newOtrData:NewOtrMessage :: Optional 4 (Value ByteString)
_newOtrData = FieldType (Field 4 (OptionalField (Last (Value ByteString))))
-> Field 4 (OptionalField (Last (Value ByteString)))
forall a. HasField a => FieldType a -> a
putField Maybe ByteString
FieldType (Field 4 (OptionalField (Last (Value ByteString))))
forall a. Maybe a
Nothing,
      $sel:_newOtrNativePriority:NewOtrMessage :: Optional 5 (Enumeration Priority)
_newOtrNativePriority = FieldType (Field 5 (OptionalField (Last (Enumeration Priority))))
-> Field 5 (OptionalField (Last (Enumeration Priority)))
forall a. HasField a => FieldType a -> a
putField Maybe Priority
FieldType (Field 5 (OptionalField (Last (Enumeration Priority))))
forall a. Maybe a
Nothing,
      $sel:_newOtrTransient:NewOtrMessage :: Optional 6 (Value Bool)
_newOtrTransient = FieldType (Field 6 (OptionalField (Last (Value Bool))))
-> Field 6 (OptionalField (Last (Value Bool)))
forall a. HasField a => FieldType a -> a
putField Maybe Bool
FieldType (Field 6 (OptionalField (Last (Value Bool))))
forall a. Maybe a
Nothing,
      $sel:_newOtrReportMissing:NewOtrMessage :: Repeated 7 (Message UserId)
_newOtrReportMissing = FieldType (Repeated 7 (Message UserId))
-> Repeated 7 (Message UserId)
forall a. HasField a => FieldType a -> a
putField []
    }

newOtrMessageSender :: (Functor f) => (ClientId -> f ClientId) -> NewOtrMessage -> f NewOtrMessage
newOtrMessageSender :: forall (f :: * -> *).
Functor f =>
(ClientId -> f ClientId) -> NewOtrMessage -> f NewOtrMessage
newOtrMessageSender ClientId -> f ClientId
f NewOtrMessage
c = (\Field 1 (RequiredField (Always (Message ClientId)))
x -> NewOtrMessage
c {_newOtrSender = x}) (Field 1 (RequiredField (Always (Message ClientId)))
 -> NewOtrMessage)
-> f (Field 1 (RequiredField (Always (Message ClientId))))
-> f NewOtrMessage
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (FieldType (Field 1 (RequiredField (Always (Message ClientId))))
 -> f (FieldType
         (Field 1 (RequiredField (Always (Message ClientId))))))
-> Field 1 (RequiredField (Always (Message ClientId)))
-> f (Field 1 (RequiredField (Always (Message ClientId))))
forall a (f :: * -> *).
(HasField a, Functor f) =>
(FieldType a -> f (FieldType a)) -> a -> f a
forall (f :: * -> *).
Functor f =>
(FieldType (Field 1 (RequiredField (Always (Message ClientId))))
 -> f (FieldType
         (Field 1 (RequiredField (Always (Message ClientId))))))
-> Field 1 (RequiredField (Always (Message ClientId)))
-> f (Field 1 (RequiredField (Always (Message ClientId))))
field FieldType (Field 1 (RequiredField (Always (Message ClientId))))
-> f (FieldType
        (Field 1 (RequiredField (Always (Message ClientId)))))
ClientId -> f ClientId
f (NewOtrMessage -> Required 1 (Message ClientId)
_newOtrSender NewOtrMessage
c)

newOtrMessageRecipients :: (Functor f) => ([UserEntry] -> f [UserEntry]) -> NewOtrMessage -> f NewOtrMessage
newOtrMessageRecipients :: forall (f :: * -> *).
Functor f =>
([UserEntry] -> f [UserEntry]) -> NewOtrMessage -> f NewOtrMessage
newOtrMessageRecipients [UserEntry] -> f [UserEntry]
f NewOtrMessage
c = (\Repeated 2 (Message UserEntry)
x -> NewOtrMessage
c {_newOtrRecipients = x}) (Repeated 2 (Message UserEntry) -> NewOtrMessage)
-> f (Repeated 2 (Message UserEntry)) -> f NewOtrMessage
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (FieldType (Repeated 2 (Message UserEntry))
 -> f (FieldType (Repeated 2 (Message UserEntry))))
-> Repeated 2 (Message UserEntry)
-> f (Repeated 2 (Message UserEntry))
forall a (f :: * -> *).
(HasField a, Functor f) =>
(FieldType a -> f (FieldType a)) -> a -> f a
forall (f :: * -> *).
Functor f =>
(FieldType (Repeated 2 (Message UserEntry))
 -> f (FieldType (Repeated 2 (Message UserEntry))))
-> Repeated 2 (Message UserEntry)
-> f (Repeated 2 (Message UserEntry))
field [UserEntry] -> f [UserEntry]
FieldType (Repeated 2 (Message UserEntry))
-> f (FieldType (Repeated 2 (Message UserEntry)))
f (NewOtrMessage -> Repeated 2 (Message UserEntry)
_newOtrRecipients NewOtrMessage
c)

newOtrMessageNativePush :: (Functor f) => (Bool -> f Bool) -> NewOtrMessage -> f NewOtrMessage
newOtrMessageNativePush :: forall (f :: * -> *).
Functor f =>
(Bool -> f Bool) -> NewOtrMessage -> f NewOtrMessage
newOtrMessageNativePush Bool -> f Bool
f NewOtrMessage
c =
  let g :: Maybe Bool -> f (Maybe Bool)
g Maybe Bool
x = Bool -> Maybe Bool
forall a. a -> Maybe a
Just (Bool -> Maybe Bool) -> f Bool -> f (Maybe Bool)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> f Bool
f (Bool -> Maybe Bool -> Bool
forall a. a -> Maybe a -> a
fromMaybe Bool
True Maybe Bool
x)
   in (\Field 3 (OptionalField (Last (Value Bool)))
x -> NewOtrMessage
c {_newOtrNativePush = x}) (Field 3 (OptionalField (Last (Value Bool))) -> NewOtrMessage)
-> f (Field 3 (OptionalField (Last (Value Bool))))
-> f NewOtrMessage
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (FieldType (Field 3 (OptionalField (Last (Value Bool))))
 -> f (FieldType (Field 3 (OptionalField (Last (Value Bool))))))
-> Field 3 (OptionalField (Last (Value Bool)))
-> f (Field 3 (OptionalField (Last (Value Bool))))
forall a (f :: * -> *).
(HasField a, Functor f) =>
(FieldType a -> f (FieldType a)) -> a -> f a
forall (f :: * -> *).
Functor f =>
(FieldType (Field 3 (OptionalField (Last (Value Bool))))
 -> f (FieldType (Field 3 (OptionalField (Last (Value Bool))))))
-> Field 3 (OptionalField (Last (Value Bool)))
-> f (Field 3 (OptionalField (Last (Value Bool))))
field Maybe Bool -> f (Maybe Bool)
FieldType (Field 3 (OptionalField (Last (Value Bool))))
-> f (FieldType (Field 3 (OptionalField (Last (Value Bool)))))
g (NewOtrMessage -> Optional 3 (Value Bool)
_newOtrNativePush NewOtrMessage
c)

newOtrMessageTransient :: (Functor f) => (Bool -> f Bool) -> NewOtrMessage -> f NewOtrMessage
newOtrMessageTransient :: forall (f :: * -> *).
Functor f =>
(Bool -> f Bool) -> NewOtrMessage -> f NewOtrMessage
newOtrMessageTransient Bool -> f Bool
f NewOtrMessage
c =
  let g :: Maybe Bool -> f (Maybe Bool)
g Maybe Bool
x = Bool -> Maybe Bool
forall a. a -> Maybe a
Just (Bool -> Maybe Bool) -> f Bool -> f (Maybe Bool)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> f Bool
f (Bool -> Maybe Bool -> Bool
forall a. a -> Maybe a -> a
fromMaybe Bool
False Maybe Bool
x)
   in (\Field 6 (OptionalField (Last (Value Bool)))
x -> NewOtrMessage
c {_newOtrTransient = x}) (Field 6 (OptionalField (Last (Value Bool))) -> NewOtrMessage)
-> f (Field 6 (OptionalField (Last (Value Bool))))
-> f NewOtrMessage
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (FieldType (Field 6 (OptionalField (Last (Value Bool))))
 -> f (FieldType (Field 6 (OptionalField (Last (Value Bool))))))
-> Field 6 (OptionalField (Last (Value Bool)))
-> f (Field 6 (OptionalField (Last (Value Bool))))
forall a (f :: * -> *).
(HasField a, Functor f) =>
(FieldType a -> f (FieldType a)) -> a -> f a
forall (f :: * -> *).
Functor f =>
(FieldType (Field 6 (OptionalField (Last (Value Bool))))
 -> f (FieldType (Field 6 (OptionalField (Last (Value Bool))))))
-> Field 6 (OptionalField (Last (Value Bool)))
-> f (Field 6 (OptionalField (Last (Value Bool))))
field Maybe Bool -> f (Maybe Bool)
FieldType (Field 6 (OptionalField (Last (Value Bool))))
-> f (FieldType (Field 6 (OptionalField (Last (Value Bool)))))
g (NewOtrMessage -> Optional 6 (Value Bool)
_newOtrTransient NewOtrMessage
c)

newOtrMessageData :: (Functor f) => (Maybe ByteString -> f (Maybe ByteString)) -> NewOtrMessage -> f NewOtrMessage
newOtrMessageData :: forall (f :: * -> *).
Functor f =>
(Maybe ByteString -> f (Maybe ByteString))
-> NewOtrMessage -> f NewOtrMessage
newOtrMessageData Maybe ByteString -> f (Maybe ByteString)
f NewOtrMessage
c = (\Field 4 (OptionalField (Last (Value ByteString)))
x -> NewOtrMessage
c {_newOtrData = x}) (Field 4 (OptionalField (Last (Value ByteString)))
 -> NewOtrMessage)
-> f (Field 4 (OptionalField (Last (Value ByteString))))
-> f NewOtrMessage
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (FieldType (Field 4 (OptionalField (Last (Value ByteString))))
 -> f (FieldType
         (Field 4 (OptionalField (Last (Value ByteString))))))
-> Field 4 (OptionalField (Last (Value ByteString)))
-> f (Field 4 (OptionalField (Last (Value ByteString))))
forall a (f :: * -> *).
(HasField a, Functor f) =>
(FieldType a -> f (FieldType a)) -> a -> f a
forall (f :: * -> *).
Functor f =>
(FieldType (Field 4 (OptionalField (Last (Value ByteString))))
 -> f (FieldType
         (Field 4 (OptionalField (Last (Value ByteString))))))
-> Field 4 (OptionalField (Last (Value ByteString)))
-> f (Field 4 (OptionalField (Last (Value ByteString))))
field Maybe ByteString -> f (Maybe ByteString)
FieldType (Field 4 (OptionalField (Last (Value ByteString))))
-> f (FieldType
        (Field 4 (OptionalField (Last (Value ByteString)))))
f (NewOtrMessage -> Optional 4 (Value ByteString)
_newOtrData NewOtrMessage
c)

newOtrMessageNativePriority :: (Functor f) => (Maybe Priority -> f (Maybe Priority)) -> NewOtrMessage -> f NewOtrMessage
newOtrMessageNativePriority :: forall (f :: * -> *).
Functor f =>
(Maybe Priority -> f (Maybe Priority))
-> NewOtrMessage -> f NewOtrMessage
newOtrMessageNativePriority Maybe Priority -> f (Maybe Priority)
f NewOtrMessage
c = (\Field 5 (OptionalField (Last (Enumeration Priority)))
x -> NewOtrMessage
c {_newOtrNativePriority = x}) (Field 5 (OptionalField (Last (Enumeration Priority)))
 -> NewOtrMessage)
-> f (Field 5 (OptionalField (Last (Enumeration Priority))))
-> f NewOtrMessage
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (FieldType (Field 5 (OptionalField (Last (Enumeration Priority))))
 -> f (FieldType
         (Field 5 (OptionalField (Last (Enumeration Priority))))))
-> Field 5 (OptionalField (Last (Enumeration Priority)))
-> f (Field 5 (OptionalField (Last (Enumeration Priority))))
forall a (f :: * -> *).
(HasField a, Functor f) =>
(FieldType a -> f (FieldType a)) -> a -> f a
forall (f :: * -> *).
Functor f =>
(FieldType (Field 5 (OptionalField (Last (Enumeration Priority))))
 -> f (FieldType
         (Field 5 (OptionalField (Last (Enumeration Priority))))))
-> Field 5 (OptionalField (Last (Enumeration Priority)))
-> f (Field 5 (OptionalField (Last (Enumeration Priority))))
field Maybe Priority -> f (Maybe Priority)
FieldType (Field 5 (OptionalField (Last (Enumeration Priority))))
-> f (FieldType
        (Field 5 (OptionalField (Last (Enumeration Priority)))))
f (NewOtrMessage -> Optional 5 (Enumeration Priority)
_newOtrNativePriority NewOtrMessage
c)

newOtrMessageReportMissing :: (Functor f) => ([UserId] -> f [UserId]) -> NewOtrMessage -> f NewOtrMessage
newOtrMessageReportMissing :: forall (f :: * -> *).
Functor f =>
([UserId] -> f [UserId]) -> NewOtrMessage -> f NewOtrMessage
newOtrMessageReportMissing [UserId] -> f [UserId]
f NewOtrMessage
c = (\Repeated 7 (Message UserId)
x -> NewOtrMessage
c {_newOtrReportMissing = x}) (Repeated 7 (Message UserId) -> NewOtrMessage)
-> f (Repeated 7 (Message UserId)) -> f NewOtrMessage
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (FieldType (Repeated 7 (Message UserId))
 -> f (FieldType (Repeated 7 (Message UserId))))
-> Repeated 7 (Message UserId) -> f (Repeated 7 (Message UserId))
forall a (f :: * -> *).
(HasField a, Functor f) =>
(FieldType a -> f (FieldType a)) -> a -> f a
forall (f :: * -> *).
Functor f =>
(FieldType (Repeated 7 (Message UserId))
 -> f (FieldType (Repeated 7 (Message UserId))))
-> Repeated 7 (Message UserId) -> f (Repeated 7 (Message UserId))
field [UserId] -> f [UserId]
FieldType (Repeated 7 (Message UserId))
-> f (FieldType (Repeated 7 (Message UserId)))
f (NewOtrMessage -> Repeated 7 (Message UserId)
_newOtrReportMissing NewOtrMessage
c)