{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# 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/>.

module Wire.API.User.Client
  ( -- * ClientCapability
    ClientCapability (..),
    ClientCapabilityList (..),

    -- * ClientInfo
    ClientInfo (..),

    -- * UserClients
    UserClientMap (..),
    UserClientPrekeyMap (..),
    mkUserClientPrekeyMap,
    QualifiedUserClientMap (..),
    QualifiedUserClientPrekeyMap (..),
    QualifiedUserClientPrekeyMapV4 (..),
    mkQualifiedUserClientPrekeyMap,
    qualifiedUserClientPrekeyMapFromList,
    UserClientsFull (..),
    UserClients (..),
    mkUserClients,
    QualifiedUserClients (..),
    qualifiedUserClientsValueSchema,
    filterClients,
    filterClientsFull,

    -- * Client
    Client (..),
    clientSchema,
    PubClient (..),
    ClientType (..),
    ClientClass (..),
    MLSPublicKeys,

    -- * New/Update/Remove Client
    NewClient (..),
    newClient,
    UpdateClient (..),
    defUpdateClient,
    RmClient (..),

    -- * re-exports
    Latitude (..),
    Longitude (..),

    -- * List of MLS client ids
    ClientList (..),
  )
where

import Cassandra qualified as C
import Control.Applicative
import Control.Lens hiding (element, enum, set, (#), (.=))
import Data.Aeson (FromJSON (..), ToJSON (..))
import Data.Aeson qualified as A
import Data.Aeson.Key qualified as Key
import Data.Aeson.KeyMap qualified as KeyMap
import Data.Bifunctor (second)
import Data.Code qualified as Code
import Data.Coerce
import Data.Domain (Domain)
import Data.Id
import Data.Json.Util
import Data.Map.Strict qualified as Map
import Data.Misc (Latitude (..), Longitude (..), PlainTextPassword6)
import Data.OpenApi hiding (Schema, ToSchema, nullable, schema)
import Data.OpenApi qualified as Swagger hiding (nullable)
import Data.Qualified
import Data.SOP hiding (fn)
import Data.Schema
import Data.Set qualified as Set
import Data.Text.Encoding qualified as T
import Data.Time.Clock
import Data.UUID (toASCIIBytes)
import Deriving.Swagger
  ( CustomSwagger,
    FieldLabelModifier,
    LowerCase,
    StripPrefix,
  )
import Imports
import Wire.API.MLS.CipherSuite
import Wire.API.Routes.MultiVerb
import Wire.API.Routes.Version
import Wire.API.Routes.Versioned
import Wire.API.User.Auth
import Wire.API.User.Client.Prekey as Prekey
import Wire.Arbitrary (Arbitrary (arbitrary), GenericUniform (..), generateExample, mapOf', setOf')

----------------------------------------------------------------------
-- ClientCapability, ClientCapabilityList

-- | Names of capabilities clients can claim to support in order to be treated differently by
-- the backend.
--
-- **The cost of capability keywords**
--
-- Avoid this wherever possible.  Adding capability keywords in the backend code makes testing
-- exponentially more expensive (in principle, you should always test all combinations of
-- supported capabilitiess.  But even if you only test those known to occur in the wild, it will
-- still make your life harder.)
--
-- Consider dropping support for clients without ancient capabilitiess if you have "enough" clients
-- that are younger.  This will always be disruptive for a minority of users, but maybe this
-- can be mitigated by giving those users clear feedback that they need to upgrade in order to
-- get their expected UX back.
--
-- **An alternative design**
--
-- Consider replacing 'ClientCapability' with platform and version in formation (I
-- played with @data Platform = Android | IOS | WebApp | TeamSettings | AccountPages@ and
-- @Version@ from the `semver` package in https://github.com/wireapp/wire-server/pull/1503,
-- but ended up deciding against it).  This data could be passed in a similar way as the
-- 'ClientCapabilityList' is now (similar end-point, different path, different body
-- type), and the two approaches could be used in parallel indefinitely.
--
-- Capability keywords reveal the minimum amount of information necessary to handle the client,
-- making it harder to fingerprint and track clients; they are straight-forward and
-- self-documenting (to an extent), and make it easier to release a capability on the backend and
-- clients independently.
--
-- Platform/version info is if you have many different capability keywords, even though it
-- doesn't solve the problem of having to explore the entire capability space in your tests.
-- They give you a better idea of the time line, and how to gently discontinue support for
-- ancient capabilities.
data ClientCapability
  = -- | Clients have minimum support for LH, but not for explicit consent.  Implicit consent
    -- is granted via the galley server config and cassandra table `galley.legalhold_whitelisted`.
    ClientSupportsLegalholdImplicitConsent
  | ClientSupportsConsumableNotifications
  deriving stock (ClientCapability -> ClientCapability -> Bool
(ClientCapability -> ClientCapability -> Bool)
-> (ClientCapability -> ClientCapability -> Bool)
-> Eq ClientCapability
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClientCapability -> ClientCapability -> Bool
== :: ClientCapability -> ClientCapability -> Bool
$c/= :: ClientCapability -> ClientCapability -> Bool
/= :: ClientCapability -> ClientCapability -> Bool
Eq, Eq ClientCapability
Eq ClientCapability =>
(ClientCapability -> ClientCapability -> Ordering)
-> (ClientCapability -> ClientCapability -> Bool)
-> (ClientCapability -> ClientCapability -> Bool)
-> (ClientCapability -> ClientCapability -> Bool)
-> (ClientCapability -> ClientCapability -> Bool)
-> (ClientCapability -> ClientCapability -> ClientCapability)
-> (ClientCapability -> ClientCapability -> ClientCapability)
-> Ord ClientCapability
ClientCapability -> ClientCapability -> Bool
ClientCapability -> ClientCapability -> Ordering
ClientCapability -> ClientCapability -> ClientCapability
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 :: ClientCapability -> ClientCapability -> Ordering
compare :: ClientCapability -> ClientCapability -> Ordering
$c< :: ClientCapability -> ClientCapability -> Bool
< :: ClientCapability -> ClientCapability -> Bool
$c<= :: ClientCapability -> ClientCapability -> Bool
<= :: ClientCapability -> ClientCapability -> Bool
$c> :: ClientCapability -> ClientCapability -> Bool
> :: ClientCapability -> ClientCapability -> Bool
$c>= :: ClientCapability -> ClientCapability -> Bool
>= :: ClientCapability -> ClientCapability -> Bool
$cmax :: ClientCapability -> ClientCapability -> ClientCapability
max :: ClientCapability -> ClientCapability -> ClientCapability
$cmin :: ClientCapability -> ClientCapability -> ClientCapability
min :: ClientCapability -> ClientCapability -> ClientCapability
Ord, ClientCapability
ClientCapability -> ClientCapability -> Bounded ClientCapability
forall a. a -> a -> Bounded a
$cminBound :: ClientCapability
minBound :: ClientCapability
$cmaxBound :: ClientCapability
maxBound :: ClientCapability
Bounded, Int -> ClientCapability
ClientCapability -> Int
ClientCapability -> [ClientCapability]
ClientCapability -> ClientCapability
ClientCapability -> ClientCapability -> [ClientCapability]
ClientCapability
-> ClientCapability -> ClientCapability -> [ClientCapability]
(ClientCapability -> ClientCapability)
-> (ClientCapability -> ClientCapability)
-> (Int -> ClientCapability)
-> (ClientCapability -> Int)
-> (ClientCapability -> [ClientCapability])
-> (ClientCapability -> ClientCapability -> [ClientCapability])
-> (ClientCapability -> ClientCapability -> [ClientCapability])
-> (ClientCapability
    -> ClientCapability -> ClientCapability -> [ClientCapability])
-> Enum ClientCapability
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 :: ClientCapability -> ClientCapability
succ :: ClientCapability -> ClientCapability
$cpred :: ClientCapability -> ClientCapability
pred :: ClientCapability -> ClientCapability
$ctoEnum :: Int -> ClientCapability
toEnum :: Int -> ClientCapability
$cfromEnum :: ClientCapability -> Int
fromEnum :: ClientCapability -> Int
$cenumFrom :: ClientCapability -> [ClientCapability]
enumFrom :: ClientCapability -> [ClientCapability]
$cenumFromThen :: ClientCapability -> ClientCapability -> [ClientCapability]
enumFromThen :: ClientCapability -> ClientCapability -> [ClientCapability]
$cenumFromTo :: ClientCapability -> ClientCapability -> [ClientCapability]
enumFromTo :: ClientCapability -> ClientCapability -> [ClientCapability]
$cenumFromThenTo :: ClientCapability
-> ClientCapability -> ClientCapability -> [ClientCapability]
enumFromThenTo :: ClientCapability
-> ClientCapability -> ClientCapability -> [ClientCapability]
Enum, Int -> ClientCapability -> ShowS
[ClientCapability] -> ShowS
ClientCapability -> [Char]
(Int -> ClientCapability -> ShowS)
-> (ClientCapability -> [Char])
-> ([ClientCapability] -> ShowS)
-> Show ClientCapability
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ClientCapability -> ShowS
showsPrec :: Int -> ClientCapability -> ShowS
$cshow :: ClientCapability -> [Char]
show :: ClientCapability -> [Char]
$cshowList :: [ClientCapability] -> ShowS
showList :: [ClientCapability] -> ShowS
Show, (forall x. ClientCapability -> Rep ClientCapability x)
-> (forall x. Rep ClientCapability x -> ClientCapability)
-> Generic ClientCapability
forall x. Rep ClientCapability x -> ClientCapability
forall x. ClientCapability -> Rep ClientCapability x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ClientCapability -> Rep ClientCapability x
from :: forall x. ClientCapability -> Rep ClientCapability x
$cto :: forall x. Rep ClientCapability x -> ClientCapability
to :: forall x. Rep ClientCapability x -> ClientCapability
Generic)
  deriving (Gen ClientCapability
Gen ClientCapability
-> (ClientCapability -> [ClientCapability])
-> Arbitrary ClientCapability
ClientCapability -> [ClientCapability]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen ClientCapability
arbitrary :: Gen ClientCapability
$cshrink :: ClientCapability -> [ClientCapability]
shrink :: ClientCapability -> [ClientCapability]
Arbitrary) via (GenericUniform ClientCapability)
  deriving ([ClientCapability] -> Value
[ClientCapability] -> Encoding
ClientCapability -> Value
ClientCapability -> Encoding
(ClientCapability -> Value)
-> (ClientCapability -> Encoding)
-> ([ClientCapability] -> Value)
-> ([ClientCapability] -> Encoding)
-> ToJSON ClientCapability
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: ClientCapability -> Value
toJSON :: ClientCapability -> Value
$ctoEncoding :: ClientCapability -> Encoding
toEncoding :: ClientCapability -> Encoding
$ctoJSONList :: [ClientCapability] -> Value
toJSONList :: [ClientCapability] -> Value
$ctoEncodingList :: [ClientCapability] -> Encoding
toEncodingList :: [ClientCapability] -> Encoding
ToJSON, Value -> Parser [ClientCapability]
Value -> Parser ClientCapability
(Value -> Parser ClientCapability)
-> (Value -> Parser [ClientCapability])
-> FromJSON ClientCapability
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser ClientCapability
parseJSON :: Value -> Parser ClientCapability
$cparseJSONList :: Value -> Parser [ClientCapability]
parseJSONList :: Value -> Parser [ClientCapability]
FromJSON, Typeable ClientCapability
Typeable ClientCapability =>
(Proxy ClientCapability
 -> Declare (Definitions Schema) NamedSchema)
-> ToSchema ClientCapability
Proxy ClientCapability -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy ClientCapability -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy ClientCapability -> Declare (Definitions Schema) NamedSchema
Swagger.ToSchema) via Schema ClientCapability

instance ToSchema ClientCapability where
  schema :: ValueSchema NamedSwaggerDoc ClientCapability
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
"ClientCapability" (SchemaP
   [Value] Text (Alt Maybe Text) ClientCapability ClientCapability
 -> ValueSchema NamedSwaggerDoc ClientCapability)
-> SchemaP
     [Value] Text (Alt Maybe Text) ClientCapability ClientCapability
-> ValueSchema NamedSwaggerDoc ClientCapability
forall a b. (a -> b) -> a -> b
$
      Text
-> ClientCapability
-> SchemaP
     [Value] Text (Alt Maybe Text) ClientCapability ClientCapability
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"legalhold-implicit-consent" ClientCapability
ClientSupportsLegalholdImplicitConsent
        SchemaP
  [Value] Text (Alt Maybe Text) ClientCapability ClientCapability
-> SchemaP
     [Value] Text (Alt Maybe Text) ClientCapability ClientCapability
-> SchemaP
     [Value] Text (Alt Maybe Text) ClientCapability ClientCapability
forall a. Semigroup a => a -> a -> a
<> Text
-> ClientCapability
-> SchemaP
     [Value] Text (Alt Maybe Text) ClientCapability ClientCapability
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"consumable-notifications" ClientCapability
ClientSupportsConsumableNotifications

instance C.Cql ClientCapability where
  ctype :: Tagged ClientCapability ColumnType
ctype = ColumnType -> Tagged ClientCapability ColumnType
forall a b. b -> Tagged a b
C.Tagged ColumnType
C.IntColumn

  toCql :: ClientCapability -> Value
toCql ClientCapability
ClientSupportsLegalholdImplicitConsent = Int32 -> Value
C.CqlInt Int32
1
  toCql ClientCapability
ClientSupportsConsumableNotifications = Int32 -> Value
C.CqlInt Int32
2

  fromCql :: Value -> Either [Char] ClientCapability
fromCql (C.CqlInt Int32
i) = case Int32
i of
    Int32
1 -> ClientCapability -> Either [Char] ClientCapability
forall a. a -> Either [Char] a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ClientCapability
ClientSupportsLegalholdImplicitConsent
    Int32
2 -> ClientCapability -> Either [Char] ClientCapability
forall a. a -> Either [Char] a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ClientCapability
ClientSupportsConsumableNotifications
    Int32
n -> [Char] -> Either [Char] ClientCapability
forall a b. a -> Either a b
Left ([Char] -> Either [Char] ClientCapability)
-> [Char] -> Either [Char] ClientCapability
forall a b. (a -> b) -> a -> b
$ [Char]
"Unexpected ClientCapability value: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int32 -> [Char]
forall a. Show a => a -> [Char]
show Int32
n
  fromCql Value
_ = [Char] -> Either [Char] ClientCapability
forall a b. a -> Either a b
Left [Char]
"ClientCapability value: int expected"

-- FUTUREWORK: add golden tests for this?
newtype ClientCapabilityList = ClientCapabilityList {ClientCapabilityList -> Set ClientCapability
fromClientCapabilityList :: Set ClientCapability}
  deriving stock (ClientCapabilityList -> ClientCapabilityList -> Bool
(ClientCapabilityList -> ClientCapabilityList -> Bool)
-> (ClientCapabilityList -> ClientCapabilityList -> Bool)
-> Eq ClientCapabilityList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClientCapabilityList -> ClientCapabilityList -> Bool
== :: ClientCapabilityList -> ClientCapabilityList -> Bool
$c/= :: ClientCapabilityList -> ClientCapabilityList -> Bool
/= :: ClientCapabilityList -> ClientCapabilityList -> Bool
Eq, Eq ClientCapabilityList
Eq ClientCapabilityList =>
(ClientCapabilityList -> ClientCapabilityList -> Ordering)
-> (ClientCapabilityList -> ClientCapabilityList -> Bool)
-> (ClientCapabilityList -> ClientCapabilityList -> Bool)
-> (ClientCapabilityList -> ClientCapabilityList -> Bool)
-> (ClientCapabilityList -> ClientCapabilityList -> Bool)
-> (ClientCapabilityList
    -> ClientCapabilityList -> ClientCapabilityList)
-> (ClientCapabilityList
    -> ClientCapabilityList -> ClientCapabilityList)
-> Ord ClientCapabilityList
ClientCapabilityList -> ClientCapabilityList -> Bool
ClientCapabilityList -> ClientCapabilityList -> Ordering
ClientCapabilityList
-> ClientCapabilityList -> ClientCapabilityList
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 :: ClientCapabilityList -> ClientCapabilityList -> Ordering
compare :: ClientCapabilityList -> ClientCapabilityList -> Ordering
$c< :: ClientCapabilityList -> ClientCapabilityList -> Bool
< :: ClientCapabilityList -> ClientCapabilityList -> Bool
$c<= :: ClientCapabilityList -> ClientCapabilityList -> Bool
<= :: ClientCapabilityList -> ClientCapabilityList -> Bool
$c> :: ClientCapabilityList -> ClientCapabilityList -> Bool
> :: ClientCapabilityList -> ClientCapabilityList -> Bool
$c>= :: ClientCapabilityList -> ClientCapabilityList -> Bool
>= :: ClientCapabilityList -> ClientCapabilityList -> Bool
$cmax :: ClientCapabilityList
-> ClientCapabilityList -> ClientCapabilityList
max :: ClientCapabilityList
-> ClientCapabilityList -> ClientCapabilityList
$cmin :: ClientCapabilityList
-> ClientCapabilityList -> ClientCapabilityList
min :: ClientCapabilityList
-> ClientCapabilityList -> ClientCapabilityList
Ord, Int -> ClientCapabilityList -> ShowS
[ClientCapabilityList] -> ShowS
ClientCapabilityList -> [Char]
(Int -> ClientCapabilityList -> ShowS)
-> (ClientCapabilityList -> [Char])
-> ([ClientCapabilityList] -> ShowS)
-> Show ClientCapabilityList
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ClientCapabilityList -> ShowS
showsPrec :: Int -> ClientCapabilityList -> ShowS
$cshow :: ClientCapabilityList -> [Char]
show :: ClientCapabilityList -> [Char]
$cshowList :: [ClientCapabilityList] -> ShowS
showList :: [ClientCapabilityList] -> ShowS
Show, (forall x. ClientCapabilityList -> Rep ClientCapabilityList x)
-> (forall x. Rep ClientCapabilityList x -> ClientCapabilityList)
-> Generic ClientCapabilityList
forall x. Rep ClientCapabilityList x -> ClientCapabilityList
forall x. ClientCapabilityList -> Rep ClientCapabilityList x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ClientCapabilityList -> Rep ClientCapabilityList x
from :: forall x. ClientCapabilityList -> Rep ClientCapabilityList x
$cto :: forall x. Rep ClientCapabilityList x -> ClientCapabilityList
to :: forall x. Rep ClientCapabilityList x -> ClientCapabilityList
Generic)
  deriving newtype (NonEmpty ClientCapabilityList -> ClientCapabilityList
ClientCapabilityList
-> ClientCapabilityList -> ClientCapabilityList
(ClientCapabilityList
 -> ClientCapabilityList -> ClientCapabilityList)
-> (NonEmpty ClientCapabilityList -> ClientCapabilityList)
-> (forall b.
    Integral b =>
    b -> ClientCapabilityList -> ClientCapabilityList)
-> Semigroup ClientCapabilityList
forall b.
Integral b =>
b -> ClientCapabilityList -> ClientCapabilityList
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: ClientCapabilityList
-> ClientCapabilityList -> ClientCapabilityList
<> :: ClientCapabilityList
-> ClientCapabilityList -> ClientCapabilityList
$csconcat :: NonEmpty ClientCapabilityList -> ClientCapabilityList
sconcat :: NonEmpty ClientCapabilityList -> ClientCapabilityList
$cstimes :: forall b.
Integral b =>
b -> ClientCapabilityList -> ClientCapabilityList
stimes :: forall b.
Integral b =>
b -> ClientCapabilityList -> ClientCapabilityList
Semigroup, Semigroup ClientCapabilityList
ClientCapabilityList
Semigroup ClientCapabilityList =>
ClientCapabilityList
-> (ClientCapabilityList
    -> ClientCapabilityList -> ClientCapabilityList)
-> ([ClientCapabilityList] -> ClientCapabilityList)
-> Monoid ClientCapabilityList
[ClientCapabilityList] -> ClientCapabilityList
ClientCapabilityList
-> ClientCapabilityList -> ClientCapabilityList
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
$cmempty :: ClientCapabilityList
mempty :: ClientCapabilityList
$cmappend :: ClientCapabilityList
-> ClientCapabilityList -> ClientCapabilityList
mappend :: ClientCapabilityList
-> ClientCapabilityList -> ClientCapabilityList
$cmconcat :: [ClientCapabilityList] -> ClientCapabilityList
mconcat :: [ClientCapabilityList] -> ClientCapabilityList
Monoid)
  deriving (Gen ClientCapabilityList
Gen ClientCapabilityList
-> (ClientCapabilityList -> [ClientCapabilityList])
-> Arbitrary ClientCapabilityList
ClientCapabilityList -> [ClientCapabilityList]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen ClientCapabilityList
arbitrary :: Gen ClientCapabilityList
$cshrink :: ClientCapabilityList -> [ClientCapabilityList]
shrink :: ClientCapabilityList -> [ClientCapabilityList]
Arbitrary) via (GenericUniform ClientCapabilityList)
  deriving ([ClientCapabilityList] -> Value
[ClientCapabilityList] -> Encoding
ClientCapabilityList -> Value
ClientCapabilityList -> Encoding
(ClientCapabilityList -> Value)
-> (ClientCapabilityList -> Encoding)
-> ([ClientCapabilityList] -> Value)
-> ([ClientCapabilityList] -> Encoding)
-> ToJSON ClientCapabilityList
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: ClientCapabilityList -> Value
toJSON :: ClientCapabilityList -> Value
$ctoEncoding :: ClientCapabilityList -> Encoding
toEncoding :: ClientCapabilityList -> Encoding
$ctoJSONList :: [ClientCapabilityList] -> Value
toJSONList :: [ClientCapabilityList] -> Value
$ctoEncodingList :: [ClientCapabilityList] -> Encoding
toEncodingList :: [ClientCapabilityList] -> Encoding
ToJSON, Value -> Parser [ClientCapabilityList]
Value -> Parser ClientCapabilityList
(Value -> Parser ClientCapabilityList)
-> (Value -> Parser [ClientCapabilityList])
-> FromJSON ClientCapabilityList
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser ClientCapabilityList
parseJSON :: Value -> Parser ClientCapabilityList
$cparseJSONList :: Value -> Parser [ClientCapabilityList]
parseJSONList :: Value -> Parser [ClientCapabilityList]
FromJSON, Typeable ClientCapabilityList
Typeable ClientCapabilityList =>
(Proxy ClientCapabilityList
 -> Declare (Definitions Schema) NamedSchema)
-> ToSchema ClientCapabilityList
Proxy ClientCapabilityList
-> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy ClientCapabilityList
-> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy ClientCapabilityList
-> Declare (Definitions Schema) NamedSchema
Swagger.ToSchema) via (Schema ClientCapabilityList)

instance ToSchema ClientCapabilityList where
  schema :: ValueSchema NamedSwaggerDoc ClientCapabilityList
schema = Maybe Version -> ValueSchema NamedSwaggerDoc ClientCapabilityList
capabilitiesSchema Maybe Version
forall a. Maybe a
Nothing

instance ToSchema (Versioned V6 ClientCapabilityList) where
  schema :: ValueSchema NamedSwaggerDoc (Versioned 'V6 ClientCapabilityList)
schema =
    Text
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Versioned 'V6 ClientCapabilityList)
     (Versioned 'V6 ClientCapabilityList)
-> ValueSchema NamedSwaggerDoc (Versioned 'V6 ClientCapabilityList)
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"ClientCapabilityListV6" (SchemaP
   SwaggerDoc
   Object
   [Pair]
   (Versioned 'V6 ClientCapabilityList)
   (Versioned 'V6 ClientCapabilityList)
 -> ValueSchema
      NamedSwaggerDoc (Versioned 'V6 ClientCapabilityList))
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Versioned 'V6 ClientCapabilityList)
     (Versioned 'V6 ClientCapabilityList)
-> ValueSchema NamedSwaggerDoc (Versioned 'V6 ClientCapabilityList)
forall a b. (a -> b) -> a -> b
$
      ClientCapabilityList -> Versioned 'V6 ClientCapabilityList
forall (v :: Version) a. a -> Versioned v a
Versioned
        (ClientCapabilityList -> Versioned 'V6 ClientCapabilityList)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Versioned 'V6 ClientCapabilityList)
     ClientCapabilityList
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Versioned 'V6 ClientCapabilityList)
     (Versioned 'V6 ClientCapabilityList)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Versioned 'V6 ClientCapabilityList -> ClientCapabilityList
forall (v :: Version) a. Versioned v a -> a
unVersioned (Versioned 'V6 ClientCapabilityList -> ClientCapabilityList)
-> SchemaP
     SwaggerDoc Object [Pair] ClientCapabilityList ClientCapabilityList
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Versioned 'V6 ClientCapabilityList)
     ClientCapabilityList
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> ValueSchema NamedSwaggerDoc ClientCapabilityList
-> SchemaP
     SwaggerDoc Object [Pair] ClientCapabilityList ClientCapabilityList
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"capabilities" (Maybe Version -> ValueSchema NamedSwaggerDoc ClientCapabilityList
capabilitiesSchema (Version -> Maybe Version
forall a. a -> Maybe a
Just Version
V6))

capabilitiesSchema ::
  Maybe Version ->
  ValueSchema NamedSwaggerDoc ClientCapabilityList
capabilitiesSchema :: Maybe Version -> ValueSchema NamedSwaggerDoc ClientCapabilityList
capabilitiesSchema Maybe Version
mVersion =
  Text
-> SchemaP
     SwaggerDoc Value Value ClientCapabilityList ClientCapabilityList
-> ValueSchema NamedSwaggerDoc ClientCapabilityList
forall doc doc' v m a b.
HasObject doc doc' =>
Text -> SchemaP doc v m a b -> SchemaP doc' v m a b
named Text
"ClientCapabilityList" (SchemaP
   SwaggerDoc Value Value ClientCapabilityList ClientCapabilityList
 -> ValueSchema NamedSwaggerDoc ClientCapabilityList)
-> SchemaP
     SwaggerDoc Value Value ClientCapabilityList ClientCapabilityList
-> ValueSchema NamedSwaggerDoc ClientCapabilityList
forall a b. (a -> b) -> a -> b
$
    Set ClientCapability -> ClientCapabilityList
ClientCapabilityList
      (Set ClientCapability -> ClientCapabilityList)
-> SchemaP
     SwaggerDoc Value Value ClientCapabilityList (Set ClientCapability)
-> SchemaP
     SwaggerDoc Value Value ClientCapabilityList ClientCapabilityList
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Set ClientCapability -> [ClientCapability]
forall a. Set a -> [a]
Set.toList (Set ClientCapability -> [ClientCapability])
-> (ClientCapabilityList -> Set ClientCapability)
-> ClientCapabilityList
-> [ClientCapability]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set ClientCapability -> Set ClientCapability
dropIncompatibleCapabilities (Set ClientCapability -> Set ClientCapability)
-> (ClientCapabilityList -> Set ClientCapability)
-> ClientCapabilityList
-> Set ClientCapability
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ClientCapabilityList -> Set ClientCapability
fromClientCapabilityList) (ClientCapabilityList -> [ClientCapability])
-> SchemaP
     SwaggerDoc Value Value [ClientCapability] (Set ClientCapability)
-> SchemaP
     SwaggerDoc Value Value ClientCapabilityList (Set ClientCapability)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= ([ClientCapability] -> Set ClientCapability
forall a. Ord a => [a] -> Set a
Set.fromList ([ClientCapability] -> Set ClientCapability)
-> SchemaP
     SwaggerDoc Value Value [ClientCapability] [ClientCapability]
-> SchemaP
     SwaggerDoc Value Value [ClientCapability] (Set ClientCapability)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ValueSchema NamedSwaggerDoc ClientCapability
-> SchemaP
     SwaggerDoc Value Value [ClientCapability] [ClientCapability]
forall ndoc doc a.
(HasArray ndoc doc, HasName ndoc) =>
ValueSchema ndoc a -> ValueSchema doc [a]
array ValueSchema NamedSwaggerDoc ClientCapability
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
  where
    dropIncompatibleCapabilities :: Set ClientCapability -> Set ClientCapability
    dropIncompatibleCapabilities :: Set ClientCapability -> Set ClientCapability
dropIncompatibleCapabilities Set ClientCapability
caps =
      case Maybe Version
mVersion of
        Just Version
v | Version
v Version -> Version -> Bool
forall a. Ord a => a -> a -> Bool
<= Version
V6 -> ClientCapability -> Set ClientCapability -> Set ClientCapability
forall a. Ord a => a -> Set a -> Set a
Set.delete ClientCapability
ClientSupportsConsumableNotifications Set ClientCapability
caps
        Maybe Version
_ -> Set ClientCapability
caps

--------------------------------------------------------------------------------
-- UserClientMap

newtype UserClientMap a = UserClientMap
  { forall a. UserClientMap a -> Map UserId (Map ClientId a)
userClientMap :: Map UserId (Map ClientId a)
  }
  deriving stock (UserClientMap a -> UserClientMap a -> Bool
(UserClientMap a -> UserClientMap a -> Bool)
-> (UserClientMap a -> UserClientMap a -> Bool)
-> Eq (UserClientMap a)
forall a. Eq a => UserClientMap a -> UserClientMap a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => UserClientMap a -> UserClientMap a -> Bool
== :: UserClientMap a -> UserClientMap a -> Bool
$c/= :: forall a. Eq a => UserClientMap a -> UserClientMap a -> Bool
/= :: UserClientMap a -> UserClientMap a -> Bool
Eq, Int -> UserClientMap a -> ShowS
[UserClientMap a] -> ShowS
UserClientMap a -> [Char]
(Int -> UserClientMap a -> ShowS)
-> (UserClientMap a -> [Char])
-> ([UserClientMap a] -> ShowS)
-> Show (UserClientMap a)
forall a. Show a => Int -> UserClientMap a -> ShowS
forall a. Show a => [UserClientMap a] -> ShowS
forall a. Show a => UserClientMap a -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> UserClientMap a -> ShowS
showsPrec :: Int -> UserClientMap a -> ShowS
$cshow :: forall a. Show a => UserClientMap a -> [Char]
show :: UserClientMap a -> [Char]
$cshowList :: forall a. Show a => [UserClientMap a] -> ShowS
showList :: [UserClientMap a] -> ShowS
Show, (forall a b. (a -> b) -> UserClientMap a -> UserClientMap b)
-> (forall a b. a -> UserClientMap b -> UserClientMap a)
-> Functor UserClientMap
forall a b. a -> UserClientMap b -> UserClientMap a
forall a b. (a -> b) -> UserClientMap a -> UserClientMap b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> UserClientMap a -> UserClientMap b
fmap :: forall a b. (a -> b) -> UserClientMap a -> UserClientMap b
$c<$ :: forall a b. a -> UserClientMap b -> UserClientMap a
<$ :: forall a b. a -> UserClientMap b -> UserClientMap a
Functor, (forall m. Monoid m => UserClientMap m -> m)
-> (forall m a. Monoid m => (a -> m) -> UserClientMap a -> m)
-> (forall m a. Monoid m => (a -> m) -> UserClientMap a -> m)
-> (forall a b. (a -> b -> b) -> b -> UserClientMap a -> b)
-> (forall a b. (a -> b -> b) -> b -> UserClientMap a -> b)
-> (forall b a. (b -> a -> b) -> b -> UserClientMap a -> b)
-> (forall b a. (b -> a -> b) -> b -> UserClientMap a -> b)
-> (forall a. (a -> a -> a) -> UserClientMap a -> a)
-> (forall a. (a -> a -> a) -> UserClientMap a -> a)
-> (forall a. UserClientMap a -> [a])
-> (forall a. UserClientMap a -> Bool)
-> (forall a. UserClientMap a -> Int)
-> (forall a. Eq a => a -> UserClientMap a -> Bool)
-> (forall a. Ord a => UserClientMap a -> a)
-> (forall a. Ord a => UserClientMap a -> a)
-> (forall a. Num a => UserClientMap a -> a)
-> (forall a. Num a => UserClientMap a -> a)
-> Foldable UserClientMap
forall a. Eq a => a -> UserClientMap a -> Bool
forall a. Num a => UserClientMap a -> a
forall a. Ord a => UserClientMap a -> a
forall m. Monoid m => UserClientMap m -> m
forall a. UserClientMap a -> Bool
forall a. UserClientMap a -> Int
forall a. UserClientMap a -> [a]
forall a. (a -> a -> a) -> UserClientMap a -> a
forall m a. Monoid m => (a -> m) -> UserClientMap a -> m
forall b a. (b -> a -> b) -> b -> UserClientMap a -> b
forall a b. (a -> b -> b) -> b -> UserClientMap a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => UserClientMap m -> m
fold :: forall m. Monoid m => UserClientMap m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> UserClientMap a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> UserClientMap a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> UserClientMap a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> UserClientMap a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> UserClientMap a -> b
foldr :: forall a b. (a -> b -> b) -> b -> UserClientMap a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> UserClientMap a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> UserClientMap a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> UserClientMap a -> b
foldl :: forall b a. (b -> a -> b) -> b -> UserClientMap a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> UserClientMap a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> UserClientMap a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> UserClientMap a -> a
foldr1 :: forall a. (a -> a -> a) -> UserClientMap a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> UserClientMap a -> a
foldl1 :: forall a. (a -> a -> a) -> UserClientMap a -> a
$ctoList :: forall a. UserClientMap a -> [a]
toList :: forall a. UserClientMap a -> [a]
$cnull :: forall a. UserClientMap a -> Bool
null :: forall a. UserClientMap a -> Bool
$clength :: forall a. UserClientMap a -> Int
length :: forall a. UserClientMap a -> Int
$celem :: forall a. Eq a => a -> UserClientMap a -> Bool
elem :: forall a. Eq a => a -> UserClientMap a -> Bool
$cmaximum :: forall a. Ord a => UserClientMap a -> a
maximum :: forall a. Ord a => UserClientMap a -> a
$cminimum :: forall a. Ord a => UserClientMap a -> a
minimum :: forall a. Ord a => UserClientMap a -> a
$csum :: forall a. Num a => UserClientMap a -> a
sum :: forall a. Num a => UserClientMap a -> a
$cproduct :: forall a. Num a => UserClientMap a -> a
product :: forall a. Num a => UserClientMap a -> a
Foldable, Functor UserClientMap
Foldable UserClientMap
(Functor UserClientMap, Foldable UserClientMap) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> UserClientMap a -> f (UserClientMap b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    UserClientMap (f a) -> f (UserClientMap a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> UserClientMap a -> m (UserClientMap b))
-> (forall (m :: * -> *) a.
    Monad m =>
    UserClientMap (m a) -> m (UserClientMap a))
-> Traversable UserClientMap
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
UserClientMap (m a) -> m (UserClientMap a)
forall (f :: * -> *) a.
Applicative f =>
UserClientMap (f a) -> f (UserClientMap a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> UserClientMap a -> m (UserClientMap b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> UserClientMap a -> f (UserClientMap b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> UserClientMap a -> f (UserClientMap b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> UserClientMap a -> f (UserClientMap b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
UserClientMap (f a) -> f (UserClientMap a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
UserClientMap (f a) -> f (UserClientMap a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> UserClientMap a -> m (UserClientMap b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> UserClientMap a -> m (UserClientMap b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
UserClientMap (m a) -> m (UserClientMap a)
sequence :: forall (m :: * -> *) a.
Monad m =>
UserClientMap (m a) -> m (UserClientMap a)
Traversable)
  deriving newtype (NonEmpty (UserClientMap a) -> UserClientMap a
UserClientMap a -> UserClientMap a -> UserClientMap a
(UserClientMap a -> UserClientMap a -> UserClientMap a)
-> (NonEmpty (UserClientMap a) -> UserClientMap a)
-> (forall b.
    Integral b =>
    b -> UserClientMap a -> UserClientMap a)
-> Semigroup (UserClientMap a)
forall b. Integral b => b -> UserClientMap a -> UserClientMap a
forall a. NonEmpty (UserClientMap a) -> UserClientMap a
forall a. UserClientMap a -> UserClientMap a -> UserClientMap a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall a b. Integral b => b -> UserClientMap a -> UserClientMap a
$c<> :: forall a. UserClientMap a -> UserClientMap a -> UserClientMap a
<> :: UserClientMap a -> UserClientMap a -> UserClientMap a
$csconcat :: forall a. NonEmpty (UserClientMap a) -> UserClientMap a
sconcat :: NonEmpty (UserClientMap a) -> UserClientMap a
$cstimes :: forall a b. Integral b => b -> UserClientMap a -> UserClientMap a
stimes :: forall b. Integral b => b -> UserClientMap a -> UserClientMap a
Semigroup, Semigroup (UserClientMap a)
UserClientMap a
Semigroup (UserClientMap a) =>
UserClientMap a
-> (UserClientMap a -> UserClientMap a -> UserClientMap a)
-> ([UserClientMap a] -> UserClientMap a)
-> Monoid (UserClientMap a)
[UserClientMap a] -> UserClientMap a
UserClientMap a -> UserClientMap a -> UserClientMap a
forall a. Semigroup (UserClientMap a)
forall a. UserClientMap a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. [UserClientMap a] -> UserClientMap a
forall a. UserClientMap a -> UserClientMap a -> UserClientMap a
$cmempty :: forall a. UserClientMap a
mempty :: UserClientMap a
$cmappend :: forall a. UserClientMap a -> UserClientMap a -> UserClientMap a
mappend :: UserClientMap a -> UserClientMap a -> UserClientMap a
$cmconcat :: forall a. [UserClientMap a] -> UserClientMap a
mconcat :: [UserClientMap a] -> UserClientMap a
Monoid)
  deriving (Value -> Parser [UserClientMap a]
Value -> Parser (UserClientMap a)
(Value -> Parser (UserClientMap a))
-> (Value -> Parser [UserClientMap a])
-> FromJSON (UserClientMap a)
forall a. ToSchema a => Value -> Parser [UserClientMap a]
forall a. ToSchema a => Value -> Parser (UserClientMap a)
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: forall a. ToSchema a => Value -> Parser (UserClientMap a)
parseJSON :: Value -> Parser (UserClientMap a)
$cparseJSONList :: forall a. ToSchema a => Value -> Parser [UserClientMap a]
parseJSONList :: Value -> Parser [UserClientMap a]
FromJSON, [UserClientMap a] -> Value
[UserClientMap a] -> Encoding
UserClientMap a -> Value
UserClientMap a -> Encoding
(UserClientMap a -> Value)
-> (UserClientMap a -> Encoding)
-> ([UserClientMap a] -> Value)
-> ([UserClientMap a] -> Encoding)
-> ToJSON (UserClientMap a)
forall a. ToSchema a => [UserClientMap a] -> Value
forall a. ToSchema a => [UserClientMap a] -> Encoding
forall a. ToSchema a => UserClientMap a -> Value
forall a. ToSchema a => UserClientMap a -> Encoding
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: forall a. ToSchema a => UserClientMap a -> Value
toJSON :: UserClientMap a -> Value
$ctoEncoding :: forall a. ToSchema a => UserClientMap a -> Encoding
toEncoding :: UserClientMap a -> Encoding
$ctoJSONList :: forall a. ToSchema a => [UserClientMap a] -> Value
toJSONList :: [UserClientMap a] -> Value
$ctoEncodingList :: forall a. ToSchema a => [UserClientMap a] -> Encoding
toEncodingList :: [UserClientMap a] -> Encoding
ToJSON, Typeable (UserClientMap a)
Typeable (UserClientMap a) =>
(Proxy (UserClientMap a)
 -> Declare (Definitions Schema) NamedSchema)
-> ToSchema (UserClientMap a)
Proxy (UserClientMap a) -> Declare (Definitions Schema) NamedSchema
forall a. (Typeable a, ToSchema a) => Typeable (UserClientMap a)
forall a.
(Typeable a, ToSchema a) =>
Proxy (UserClientMap a) -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: forall a.
(Typeable a, ToSchema a) =>
Proxy (UserClientMap a) -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy (UserClientMap a) -> Declare (Definitions Schema) NamedSchema
Swagger.ToSchema) via Schema (UserClientMap a)

instance (ToSchema a) => ToSchema (UserClientMap a) where
  schema :: ValueSchema NamedSwaggerDoc (UserClientMap a)
schema = ValueSchema NamedSwaggerDoc a
-> ValueSchema NamedSwaggerDoc (UserClientMap a)
forall doc a.
(WrapName doc, HasSchemaRef doc) =>
ValueSchema doc a -> ValueSchema doc (UserClientMap a)
userClientMapSchema ValueSchema NamedSwaggerDoc a
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema

class WrapName doc where
  wrapName :: doc -> (Text -> Text) -> SwaggerDoc -> doc

instance WrapName SwaggerDoc where
  wrapName :: SwaggerDoc -> (Text -> Text) -> SwaggerDoc -> SwaggerDoc
wrapName SwaggerDoc
_ Text -> Text
_ = SwaggerDoc -> SwaggerDoc
forall a. a -> a
id

instance WrapName NamedSwaggerDoc where
  wrapName :: NamedSwaggerDoc -> (Text -> Text) -> SwaggerDoc -> NamedSwaggerDoc
wrapName NamedSwaggerDoc
d Text -> Text
f = (Schema -> NamedSchema) -> SwaggerDoc -> NamedSwaggerDoc
forall a b. (a -> b) -> WithDeclare a -> WithDeclare b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Maybe Text -> Schema -> NamedSchema
Swagger.NamedSchema (Text -> Maybe Text
forall a. a -> Maybe a
Just (Text -> Text
f (Text -> (Text -> Text) -> Maybe Text -> Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Text
"" (Text
"_" <>) (NamedSwaggerDoc -> Maybe Text
forall doc. HasName doc => doc -> Maybe Text
getName NamedSwaggerDoc
d)))))

userClientMapSchema ::
  (WrapName doc, HasSchemaRef doc) =>
  ValueSchema doc a ->
  ValueSchema doc (UserClientMap a)
userClientMapSchema :: forall doc a.
(WrapName doc, HasSchemaRef doc) =>
ValueSchema doc a -> ValueSchema doc (UserClientMap a)
userClientMapSchema ValueSchema doc a
sch =
  ASetter
  (SchemaP
     SwaggerDoc Value Value (UserClientMap a) (UserClientMap a))
  (ValueSchema doc (UserClientMap a))
  SwaggerDoc
  doc
-> (SwaggerDoc -> doc)
-> SchemaP
     SwaggerDoc Value Value (UserClientMap a) (UserClientMap a)
-> ValueSchema doc (UserClientMap a)
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
over ASetter
  (SchemaP
     SwaggerDoc Value Value (UserClientMap a) (UserClientMap a))
  (ValueSchema doc (UserClientMap a))
  SwaggerDoc
  doc
forall a a' doc doc'. HasDoc a a' doc doc' => Lens a a' doc doc'
Lens
  (SchemaP
     SwaggerDoc Value Value (UserClientMap a) (UserClientMap a))
  (ValueSchema doc (UserClientMap a))
  SwaggerDoc
  doc
doc (doc -> (Text -> Text) -> SwaggerDoc -> doc
forall doc.
WrapName doc =>
doc -> (Text -> Text) -> SwaggerDoc -> doc
wrapName (ValueSchema doc a -> doc
forall ss v m a b. SchemaP ss v m a b -> ss
schemaDoc ValueSchema doc a
sch) (Text
"UserClientMap" <>)) (SchemaP SwaggerDoc Value Value (UserClientMap a) (UserClientMap a)
 -> ValueSchema doc (UserClientMap a))
-> SchemaP
     SwaggerDoc Value Value (UserClientMap a) (UserClientMap a)
-> ValueSchema doc (UserClientMap a)
forall a b. (a -> b) -> a -> b
$
    Map UserId (Map ClientId a) -> UserClientMap a
forall a. Map UserId (Map ClientId a) -> UserClientMap a
UserClientMap (Map UserId (Map ClientId a) -> UserClientMap a)
-> SchemaP
     SwaggerDoc
     Value
     Value
     (UserClientMap a)
     (Map UserId (Map ClientId a))
-> SchemaP
     SwaggerDoc Value Value (UserClientMap a) (UserClientMap a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> UserClientMap a -> Map UserId (Map ClientId a)
forall a. UserClientMap a -> Map UserId (Map ClientId a)
userClientMap (UserClientMap a -> Map UserId (Map ClientId a))
-> SchemaP
     SwaggerDoc
     Value
     Value
     (Map UserId (Map ClientId a))
     (Map UserId (Map ClientId a))
-> SchemaP
     SwaggerDoc
     Value
     Value
     (UserClientMap a)
     (Map UserId (Map ClientId a))
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= ValueSchema SwaggerDoc (Map ClientId a)
-> SchemaP
     SwaggerDoc
     Value
     Value
     (Map UserId (Map ClientId a))
     (Map UserId (Map ClientId a))
forall ndoc doc k a.
(HasMap ndoc doc, Ord k, FromJSONKey k, ToJSONKey k) =>
ValueSchema ndoc a -> ValueSchema doc (Map k a)
map_ (ValueSchema doc a -> ValueSchema SwaggerDoc (Map ClientId a)
forall ndoc doc k a.
(HasMap ndoc doc, Ord k, FromJSONKey k, ToJSONKey k) =>
ValueSchema ndoc a -> ValueSchema doc (Map k a)
map_ ValueSchema doc a
sch)

newtype UserClientPrekeyMap = UserClientPrekeyMap
  {UserClientPrekeyMap -> UserClientMap (Maybe Prekey)
getUserClientPrekeyMap :: UserClientMap (Maybe Prekey)}
  deriving stock (UserClientPrekeyMap -> UserClientPrekeyMap -> Bool
(UserClientPrekeyMap -> UserClientPrekeyMap -> Bool)
-> (UserClientPrekeyMap -> UserClientPrekeyMap -> Bool)
-> Eq UserClientPrekeyMap
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UserClientPrekeyMap -> UserClientPrekeyMap -> Bool
== :: UserClientPrekeyMap -> UserClientPrekeyMap -> Bool
$c/= :: UserClientPrekeyMap -> UserClientPrekeyMap -> Bool
/= :: UserClientPrekeyMap -> UserClientPrekeyMap -> Bool
Eq, Int -> UserClientPrekeyMap -> ShowS
[UserClientPrekeyMap] -> ShowS
UserClientPrekeyMap -> [Char]
(Int -> UserClientPrekeyMap -> ShowS)
-> (UserClientPrekeyMap -> [Char])
-> ([UserClientPrekeyMap] -> ShowS)
-> Show UserClientPrekeyMap
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UserClientPrekeyMap -> ShowS
showsPrec :: Int -> UserClientPrekeyMap -> ShowS
$cshow :: UserClientPrekeyMap -> [Char]
show :: UserClientPrekeyMap -> [Char]
$cshowList :: [UserClientPrekeyMap] -> ShowS
showList :: [UserClientPrekeyMap] -> ShowS
Show)
  deriving newtype (Gen UserClientPrekeyMap
Gen UserClientPrekeyMap
-> (UserClientPrekeyMap -> [UserClientPrekeyMap])
-> Arbitrary UserClientPrekeyMap
UserClientPrekeyMap -> [UserClientPrekeyMap]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen UserClientPrekeyMap
arbitrary :: Gen UserClientPrekeyMap
$cshrink :: UserClientPrekeyMap -> [UserClientPrekeyMap]
shrink :: UserClientPrekeyMap -> [UserClientPrekeyMap]
Arbitrary, NonEmpty UserClientPrekeyMap -> UserClientPrekeyMap
UserClientPrekeyMap -> UserClientPrekeyMap -> UserClientPrekeyMap
(UserClientPrekeyMap -> UserClientPrekeyMap -> UserClientPrekeyMap)
-> (NonEmpty UserClientPrekeyMap -> UserClientPrekeyMap)
-> (forall b.
    Integral b =>
    b -> UserClientPrekeyMap -> UserClientPrekeyMap)
-> Semigroup UserClientPrekeyMap
forall b.
Integral b =>
b -> UserClientPrekeyMap -> UserClientPrekeyMap
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: UserClientPrekeyMap -> UserClientPrekeyMap -> UserClientPrekeyMap
<> :: UserClientPrekeyMap -> UserClientPrekeyMap -> UserClientPrekeyMap
$csconcat :: NonEmpty UserClientPrekeyMap -> UserClientPrekeyMap
sconcat :: NonEmpty UserClientPrekeyMap -> UserClientPrekeyMap
$cstimes :: forall b.
Integral b =>
b -> UserClientPrekeyMap -> UserClientPrekeyMap
stimes :: forall b.
Integral b =>
b -> UserClientPrekeyMap -> UserClientPrekeyMap
Semigroup, Semigroup UserClientPrekeyMap
UserClientPrekeyMap
Semigroup UserClientPrekeyMap =>
UserClientPrekeyMap
-> (UserClientPrekeyMap
    -> UserClientPrekeyMap -> UserClientPrekeyMap)
-> ([UserClientPrekeyMap] -> UserClientPrekeyMap)
-> Monoid UserClientPrekeyMap
[UserClientPrekeyMap] -> UserClientPrekeyMap
UserClientPrekeyMap -> UserClientPrekeyMap -> UserClientPrekeyMap
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
$cmempty :: UserClientPrekeyMap
mempty :: UserClientPrekeyMap
$cmappend :: UserClientPrekeyMap -> UserClientPrekeyMap -> UserClientPrekeyMap
mappend :: UserClientPrekeyMap -> UserClientPrekeyMap -> UserClientPrekeyMap
$cmconcat :: [UserClientPrekeyMap] -> UserClientPrekeyMap
mconcat :: [UserClientPrekeyMap] -> UserClientPrekeyMap
Monoid)
  deriving (Value -> Parser [UserClientPrekeyMap]
Value -> Parser UserClientPrekeyMap
(Value -> Parser UserClientPrekeyMap)
-> (Value -> Parser [UserClientPrekeyMap])
-> FromJSON UserClientPrekeyMap
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser UserClientPrekeyMap
parseJSON :: Value -> Parser UserClientPrekeyMap
$cparseJSONList :: Value -> Parser [UserClientPrekeyMap]
parseJSONList :: Value -> Parser [UserClientPrekeyMap]
FromJSON, [UserClientPrekeyMap] -> Value
[UserClientPrekeyMap] -> Encoding
UserClientPrekeyMap -> Value
UserClientPrekeyMap -> Encoding
(UserClientPrekeyMap -> Value)
-> (UserClientPrekeyMap -> Encoding)
-> ([UserClientPrekeyMap] -> Value)
-> ([UserClientPrekeyMap] -> Encoding)
-> ToJSON UserClientPrekeyMap
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: UserClientPrekeyMap -> Value
toJSON :: UserClientPrekeyMap -> Value
$ctoEncoding :: UserClientPrekeyMap -> Encoding
toEncoding :: UserClientPrekeyMap -> Encoding
$ctoJSONList :: [UserClientPrekeyMap] -> Value
toJSONList :: [UserClientPrekeyMap] -> Value
$ctoEncodingList :: [UserClientPrekeyMap] -> Encoding
toEncodingList :: [UserClientPrekeyMap] -> Encoding
ToJSON, Typeable UserClientPrekeyMap
Typeable UserClientPrekeyMap =>
(Proxy UserClientPrekeyMap
 -> Declare (Definitions Schema) NamedSchema)
-> ToSchema UserClientPrekeyMap
Proxy UserClientPrekeyMap
-> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy UserClientPrekeyMap
-> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy UserClientPrekeyMap
-> Declare (Definitions Schema) NamedSchema
Swagger.ToSchema) via Schema UserClientPrekeyMap

mkUserClientPrekeyMap :: Map UserId (Map ClientId (Maybe Prekey)) -> UserClientPrekeyMap
mkUserClientPrekeyMap :: Map UserId (Map ClientId (Maybe Prekey)) -> UserClientPrekeyMap
mkUserClientPrekeyMap = Map UserId (Map ClientId (Maybe Prekey)) -> UserClientPrekeyMap
forall a b. Coercible a b => a -> b
coerce

instance ToSchema UserClientPrekeyMap where
  schema :: ValueSchema NamedSwaggerDoc UserClientPrekeyMap
schema = UserClientMap (Maybe Prekey) -> UserClientPrekeyMap
UserClientPrekeyMap (UserClientMap (Maybe Prekey) -> UserClientPrekeyMap)
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     UserClientPrekeyMap
     (UserClientMap (Maybe Prekey))
-> ValueSchema NamedSwaggerDoc UserClientPrekeyMap
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> UserClientPrekeyMap -> UserClientMap (Maybe Prekey)
getUserClientPrekeyMap (UserClientPrekeyMap -> UserClientMap (Maybe Prekey))
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     (UserClientMap (Maybe Prekey))
     (UserClientMap (Maybe Prekey))
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     UserClientPrekeyMap
     (UserClientMap (Maybe Prekey))
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP
  NamedSwaggerDoc
  Value
  Value
  (UserClientMap (Maybe Prekey))
  (UserClientMap (Maybe Prekey))
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     (UserClientMap (Maybe Prekey))
     (UserClientMap (Maybe Prekey))
addDoc SchemaP
  NamedSwaggerDoc
  Value
  Value
  (UserClientMap (Maybe Prekey))
  (UserClientMap (Maybe Prekey))
sch
    where
      sch :: SchemaP
  NamedSwaggerDoc
  Value
  Value
  (UserClientMap (Maybe Prekey))
  (UserClientMap (Maybe Prekey))
sch =
        Text
-> SchemaP
     SwaggerDoc
     Value
     Value
     (UserClientMap (Maybe Prekey))
     (UserClientMap (Maybe Prekey))
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     (UserClientMap (Maybe Prekey))
     (UserClientMap (Maybe Prekey))
forall doc doc' v m a b.
HasObject doc doc' =>
Text -> SchemaP doc v m a b -> SchemaP doc' v m a b
named Text
"UserClientPrekeyMap" (SchemaP
   SwaggerDoc
   Value
   Value
   (UserClientMap (Maybe Prekey))
   (UserClientMap (Maybe Prekey))
 -> SchemaP
      NamedSwaggerDoc
      Value
      Value
      (UserClientMap (Maybe Prekey))
      (UserClientMap (Maybe Prekey)))
-> SchemaP
     SwaggerDoc
     Value
     Value
     (UserClientMap (Maybe Prekey))
     (UserClientMap (Maybe Prekey))
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     (UserClientMap (Maybe Prekey))
     (UserClientMap (Maybe Prekey))
forall a b. (a -> b) -> a -> b
$
          ValueSchema SwaggerDoc (Maybe Prekey)
-> SchemaP
     SwaggerDoc
     Value
     Value
     (UserClientMap (Maybe Prekey))
     (UserClientMap (Maybe Prekey))
forall doc a.
(WrapName doc, HasSchemaRef doc) =>
ValueSchema doc a -> ValueSchema doc (UserClientMap a)
userClientMapSchema (ValueSchema SwaggerDoc Prekey
-> ValueSchema SwaggerDoc (Maybe Prekey)
forall d a. Monoid d => ValueSchema d a -> ValueSchema d (Maybe a)
nullable (SchemaP NamedSwaggerDoc Value Value Prekey Prekey
-> ValueSchema SwaggerDoc Prekey
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 Prekey Prekey
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema))
      addDoc :: SchemaP
  NamedSwaggerDoc
  Value
  Value
  (UserClientMap (Maybe Prekey))
  (UserClientMap (Maybe Prekey))
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     (UserClientMap (Maybe Prekey))
     (UserClientMap (Maybe Prekey))
addDoc =
        (Schema -> Identity Schema)
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     (UserClientMap (Maybe Prekey))
     (UserClientMap (Maybe Prekey))
-> Identity
     (SchemaP
        NamedSwaggerDoc
        Value
        Value
        (UserClientMap (Maybe Prekey))
        (UserClientMap (Maybe Prekey)))
forall s a. HasSchema s a => Lens' s a
Lens'
  (SchemaP
     NamedSwaggerDoc
     Value
     Value
     (UserClientMap (Maybe Prekey))
     (UserClientMap (Maybe Prekey)))
  Schema
Swagger.schema ((Schema -> Identity Schema)
 -> SchemaP
      NamedSwaggerDoc
      Value
      Value
      (UserClientMap (Maybe Prekey))
      (UserClientMap (Maybe Prekey))
 -> Identity
      (SchemaP
         NamedSwaggerDoc
         Value
         Value
         (UserClientMap (Maybe Prekey))
         (UserClientMap (Maybe Prekey))))
-> ((Maybe Value -> Identity (Maybe Value))
    -> Schema -> Identity Schema)
-> (Maybe Value -> Identity (Maybe Value))
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     (UserClientMap (Maybe Prekey))
     (UserClientMap (Maybe Prekey))
-> Identity
     (SchemaP
        NamedSwaggerDoc
        Value
        Value
        (UserClientMap (Maybe Prekey))
        (UserClientMap (Maybe Prekey)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Value -> Identity (Maybe Value))
-> Schema -> Identity Schema
forall s a. HasExample s a => Lens' s a
Lens' Schema (Maybe Value)
Swagger.example
          ((Maybe Value -> Identity (Maybe Value))
 -> SchemaP
      NamedSwaggerDoc
      Value
      Value
      (UserClientMap (Maybe Prekey))
      (UserClientMap (Maybe Prekey))
 -> Identity
      (SchemaP
         NamedSwaggerDoc
         Value
         Value
         (UserClientMap (Maybe Prekey))
         (UserClientMap (Maybe Prekey))))
-> Value
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     (UserClientMap (Maybe Prekey))
     (UserClientMap (Maybe Prekey))
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     (UserClientMap (Maybe Prekey))
     (UserClientMap (Maybe Prekey))
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Map UserId (Map ClientId (Maybe Prekey)) -> Value
forall a. ToJSON a => a -> Value
toJSON
            ( UserId
-> Map ClientId (Maybe Prekey)
-> Map UserId (Map ClientId (Maybe Prekey))
forall k a. k -> a -> Map k a
Map.singleton
                (forall a. Arbitrary a => a
generateExample @UserId)
                ( ClientId -> Maybe Prekey -> Map ClientId (Maybe Prekey)
forall k a. k -> a -> Map k a
Map.singleton
                    (Word64 -> ClientId
ClientId Word64
4940483633899001999)
                    (Prekey -> Maybe Prekey
forall a. a -> Maybe a
Just (PrekeyId -> Text -> Prekey
Prekey (Word16 -> PrekeyId
PrekeyId Word16
1) Text
"pQABAQECoQBYIOjl7hw0D8YRNq..."))
                )
            )

instance (Arbitrary a) => Arbitrary (UserClientMap a) where
  arbitrary :: Gen (UserClientMap a)
arbitrary = Map UserId (Map ClientId a) -> UserClientMap a
forall a. Map UserId (Map ClientId a) -> UserClientMap a
UserClientMap (Map UserId (Map ClientId a) -> UserClientMap a)
-> Gen (Map UserId (Map ClientId a)) -> Gen (UserClientMap a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen UserId
-> Gen (Map ClientId a) -> Gen (Map UserId (Map ClientId a))
forall k v. Ord k => Gen k -> Gen v -> Gen (Map k v)
mapOf' Gen UserId
forall a. Arbitrary a => Gen a
arbitrary (Gen ClientId -> Gen a -> Gen (Map ClientId a)
forall k v. Ord k => Gen k -> Gen v -> Gen (Map k v)
mapOf' Gen ClientId
forall a. Arbitrary a => Gen a
arbitrary Gen a
forall a. Arbitrary a => Gen a
arbitrary)

newtype QualifiedUserClientMap a = QualifiedUserClientMap
  { forall a.
QualifiedUserClientMap a
-> Map Domain (Map UserId (Map ClientId a))
qualifiedUserClientMap :: Map Domain (Map UserId (Map ClientId a))
  }
  deriving stock (QualifiedUserClientMap a -> QualifiedUserClientMap a -> Bool
(QualifiedUserClientMap a -> QualifiedUserClientMap a -> Bool)
-> (QualifiedUserClientMap a -> QualifiedUserClientMap a -> Bool)
-> Eq (QualifiedUserClientMap a)
forall a.
Eq a =>
QualifiedUserClientMap a -> QualifiedUserClientMap a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a.
Eq a =>
QualifiedUserClientMap a -> QualifiedUserClientMap a -> Bool
== :: QualifiedUserClientMap a -> QualifiedUserClientMap a -> Bool
$c/= :: forall a.
Eq a =>
QualifiedUserClientMap a -> QualifiedUserClientMap a -> Bool
/= :: QualifiedUserClientMap a -> QualifiedUserClientMap a -> Bool
Eq, Int -> QualifiedUserClientMap a -> ShowS
[QualifiedUserClientMap a] -> ShowS
QualifiedUserClientMap a -> [Char]
(Int -> QualifiedUserClientMap a -> ShowS)
-> (QualifiedUserClientMap a -> [Char])
-> ([QualifiedUserClientMap a] -> ShowS)
-> Show (QualifiedUserClientMap a)
forall a. Show a => Int -> QualifiedUserClientMap a -> ShowS
forall a. Show a => [QualifiedUserClientMap a] -> ShowS
forall a. Show a => QualifiedUserClientMap a -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> QualifiedUserClientMap a -> ShowS
showsPrec :: Int -> QualifiedUserClientMap a -> ShowS
$cshow :: forall a. Show a => QualifiedUserClientMap a -> [Char]
show :: QualifiedUserClientMap a -> [Char]
$cshowList :: forall a. Show a => [QualifiedUserClientMap a] -> ShowS
showList :: [QualifiedUserClientMap a] -> ShowS
Show, (forall a b.
 (a -> b) -> QualifiedUserClientMap a -> QualifiedUserClientMap b)
-> (forall a b.
    a -> QualifiedUserClientMap b -> QualifiedUserClientMap a)
-> Functor QualifiedUserClientMap
forall a b.
a -> QualifiedUserClientMap b -> QualifiedUserClientMap a
forall a b.
(a -> b) -> QualifiedUserClientMap a -> QualifiedUserClientMap b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b.
(a -> b) -> QualifiedUserClientMap a -> QualifiedUserClientMap b
fmap :: forall a b.
(a -> b) -> QualifiedUserClientMap a -> QualifiedUserClientMap b
$c<$ :: forall a b.
a -> QualifiedUserClientMap b -> QualifiedUserClientMap a
<$ :: forall a b.
a -> QualifiedUserClientMap b -> QualifiedUserClientMap a
Functor)
  deriving (Value -> Parser [QualifiedUserClientMap a]
Value -> Parser (QualifiedUserClientMap a)
(Value -> Parser (QualifiedUserClientMap a))
-> (Value -> Parser [QualifiedUserClientMap a])
-> FromJSON (QualifiedUserClientMap a)
forall a. ToSchema a => Value -> Parser [QualifiedUserClientMap a]
forall a. ToSchema a => Value -> Parser (QualifiedUserClientMap a)
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: forall a. ToSchema a => Value -> Parser (QualifiedUserClientMap a)
parseJSON :: Value -> Parser (QualifiedUserClientMap a)
$cparseJSONList :: forall a. ToSchema a => Value -> Parser [QualifiedUserClientMap a]
parseJSONList :: Value -> Parser [QualifiedUserClientMap a]
FromJSON, [QualifiedUserClientMap a] -> Value
[QualifiedUserClientMap a] -> Encoding
QualifiedUserClientMap a -> Value
QualifiedUserClientMap a -> Encoding
(QualifiedUserClientMap a -> Value)
-> (QualifiedUserClientMap a -> Encoding)
-> ([QualifiedUserClientMap a] -> Value)
-> ([QualifiedUserClientMap a] -> Encoding)
-> ToJSON (QualifiedUserClientMap a)
forall a. ToSchema a => [QualifiedUserClientMap a] -> Value
forall a. ToSchema a => [QualifiedUserClientMap a] -> Encoding
forall a. ToSchema a => QualifiedUserClientMap a -> Value
forall a. ToSchema a => QualifiedUserClientMap a -> Encoding
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: forall a. ToSchema a => QualifiedUserClientMap a -> Value
toJSON :: QualifiedUserClientMap a -> Value
$ctoEncoding :: forall a. ToSchema a => QualifiedUserClientMap a -> Encoding
toEncoding :: QualifiedUserClientMap a -> Encoding
$ctoJSONList :: forall a. ToSchema a => [QualifiedUserClientMap a] -> Value
toJSONList :: [QualifiedUserClientMap a] -> Value
$ctoEncodingList :: forall a. ToSchema a => [QualifiedUserClientMap a] -> Encoding
toEncodingList :: [QualifiedUserClientMap a] -> Encoding
ToJSON, Typeable (QualifiedUserClientMap a)
Typeable (QualifiedUserClientMap a) =>
(Proxy (QualifiedUserClientMap a)
 -> Declare (Definitions Schema) NamedSchema)
-> ToSchema (QualifiedUserClientMap a)
Proxy (QualifiedUserClientMap a)
-> Declare (Definitions Schema) NamedSchema
forall a.
(Typeable a, ToSchema a) =>
Typeable (QualifiedUserClientMap a)
forall a.
(Typeable a, ToSchema a) =>
Proxy (QualifiedUserClientMap a)
-> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: forall a.
(Typeable a, ToSchema a) =>
Proxy (QualifiedUserClientMap a)
-> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy (QualifiedUserClientMap a)
-> Declare (Definitions Schema) NamedSchema
Swagger.ToSchema) via Schema (QualifiedUserClientMap a)

instance (Semigroup a) => Semigroup (QualifiedUserClientMap a) where
  (QualifiedUserClientMap Map Domain (Map UserId (Map ClientId a))
m1) <> :: QualifiedUserClientMap a
-> QualifiedUserClientMap a -> QualifiedUserClientMap a
<> (QualifiedUserClientMap Map Domain (Map UserId (Map ClientId a))
m2) =
    Map Domain (Map UserId (Map ClientId a))
-> QualifiedUserClientMap a
forall a.
Map Domain (Map UserId (Map ClientId a))
-> QualifiedUserClientMap a
QualifiedUserClientMap (Map Domain (Map UserId (Map ClientId a))
 -> QualifiedUserClientMap a)
-> Map Domain (Map UserId (Map ClientId a))
-> QualifiedUserClientMap a
forall a b. (a -> b) -> a -> b
$ (Map UserId (Map ClientId a)
 -> Map UserId (Map ClientId a) -> Map UserId (Map ClientId a))
-> Map Domain (Map UserId (Map ClientId a))
-> Map Domain (Map UserId (Map ClientId a))
-> Map Domain (Map UserId (Map ClientId a))
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith ((Map ClientId a -> Map ClientId a -> Map ClientId a)
-> Map UserId (Map ClientId a)
-> Map UserId (Map ClientId a)
-> Map UserId (Map ClientId a)
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith ((a -> a -> a) -> Map ClientId a -> Map ClientId a -> Map ClientId a
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith a -> a -> a
forall a. Semigroup a => a -> a -> a
(<>))) Map Domain (Map UserId (Map ClientId a))
m1 Map Domain (Map UserId (Map ClientId a))
m2

instance (Semigroup (QualifiedUserClientMap a)) => Monoid (QualifiedUserClientMap a) where
  mempty :: QualifiedUserClientMap a
mempty = Map Domain (Map UserId (Map ClientId a))
-> QualifiedUserClientMap a
forall a.
Map Domain (Map UserId (Map ClientId a))
-> QualifiedUserClientMap a
QualifiedUserClientMap Map Domain (Map UserId (Map ClientId a))
forall a. Monoid a => a
mempty

instance (Arbitrary a) => Arbitrary (QualifiedUserClientMap a) where
  arbitrary :: Gen (QualifiedUserClientMap a)
arbitrary = Map Domain (Map UserId (Map ClientId a))
-> QualifiedUserClientMap a
forall a.
Map Domain (Map UserId (Map ClientId a))
-> QualifiedUserClientMap a
QualifiedUserClientMap (Map Domain (Map UserId (Map ClientId a))
 -> QualifiedUserClientMap a)
-> Gen (Map Domain (Map UserId (Map ClientId a)))
-> Gen (QualifiedUserClientMap a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Domain
-> Gen (Map UserId (Map ClientId a))
-> Gen (Map Domain (Map UserId (Map ClientId a)))
forall k v. Ord k => Gen k -> Gen v -> Gen (Map k v)
mapOf' Gen Domain
forall a. Arbitrary a => Gen a
arbitrary (Gen UserId
-> Gen (Map ClientId a) -> Gen (Map UserId (Map ClientId a))
forall k v. Ord k => Gen k -> Gen v -> Gen (Map k v)
mapOf' Gen UserId
forall a. Arbitrary a => Gen a
arbitrary (Gen ClientId -> Gen a -> Gen (Map ClientId a)
forall k v. Ord k => Gen k -> Gen v -> Gen (Map k v)
mapOf' Gen ClientId
forall a. Arbitrary a => Gen a
arbitrary Gen a
forall a. Arbitrary a => Gen a
arbitrary))

instance (ToSchema a) => ToSchema (QualifiedUserClientMap a) where
  schema :: ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)
schema = ValueSchema NamedSwaggerDoc a
-> ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)
forall a.
ValueSchema NamedSwaggerDoc a
-> ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)
qualifiedUserClientMapSchema ValueSchema NamedSwaggerDoc a
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema

qualifiedUserClientMapSchema ::
  ValueSchema NamedSwaggerDoc a ->
  ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)
qualifiedUserClientMapSchema :: forall a.
ValueSchema NamedSwaggerDoc a
-> ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)
qualifiedUserClientMapSchema ValueSchema NamedSwaggerDoc a
sch =
  ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)
-> ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)
addDoc (ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)
 -> ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a))
-> (SchemaP
      SwaggerDoc
      Value
      Value
      (QualifiedUserClientMap a)
      (QualifiedUserClientMap a)
    -> ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a))
-> SchemaP
     SwaggerDoc
     Value
     Value
     (QualifiedUserClientMap a)
     (QualifiedUserClientMap a)
-> ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text
-> SchemaP
     SwaggerDoc
     Value
     Value
     (QualifiedUserClientMap a)
     (QualifiedUserClientMap a)
-> ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)
forall doc doc' v m a b.
HasObject doc doc' =>
Text -> SchemaP doc v m a b -> SchemaP doc' v m a b
named Text
nm (SchemaP
   SwaggerDoc
   Value
   Value
   (QualifiedUserClientMap a)
   (QualifiedUserClientMap a)
 -> ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a))
-> SchemaP
     SwaggerDoc
     Value
     Value
     (QualifiedUserClientMap a)
     (QualifiedUserClientMap a)
-> ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)
forall a b. (a -> b) -> a -> b
$
    Map Domain (Map UserId (Map ClientId a))
-> QualifiedUserClientMap a
forall a.
Map Domain (Map UserId (Map ClientId a))
-> QualifiedUserClientMap a
QualifiedUserClientMap (Map Domain (Map UserId (Map ClientId a))
 -> QualifiedUserClientMap a)
-> SchemaP
     SwaggerDoc
     Value
     Value
     (QualifiedUserClientMap a)
     (Map Domain (Map UserId (Map ClientId a)))
-> SchemaP
     SwaggerDoc
     Value
     Value
     (QualifiedUserClientMap a)
     (QualifiedUserClientMap a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> QualifiedUserClientMap a
-> Map Domain (Map UserId (Map ClientId a))
forall a.
QualifiedUserClientMap a
-> Map Domain (Map UserId (Map ClientId a))
qualifiedUserClientMap (QualifiedUserClientMap a
 -> Map Domain (Map UserId (Map ClientId a)))
-> SchemaP
     SwaggerDoc
     Value
     Value
     (Map Domain (Map UserId (Map ClientId a)))
     (Map Domain (Map UserId (Map ClientId a)))
-> SchemaP
     SwaggerDoc
     Value
     Value
     (QualifiedUserClientMap a)
     (Map Domain (Map UserId (Map ClientId a)))
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= ValueSchema SwaggerDoc (Map UserId (Map ClientId a))
-> SchemaP
     SwaggerDoc
     Value
     Value
     (Map Domain (Map UserId (Map ClientId a)))
     (Map Domain (Map UserId (Map ClientId a)))
forall ndoc doc k a.
(HasMap ndoc doc, Ord k, FromJSONKey k, ToJSONKey k) =>
ValueSchema ndoc a -> ValueSchema doc (Map k a)
map_ (ValueSchema SwaggerDoc (Map ClientId a)
-> ValueSchema SwaggerDoc (Map UserId (Map ClientId a))
forall ndoc doc k a.
(HasMap ndoc doc, Ord k, FromJSONKey k, ToJSONKey k) =>
ValueSchema ndoc a -> ValueSchema doc (Map k a)
map_ (ValueSchema NamedSwaggerDoc a
-> ValueSchema SwaggerDoc (Map ClientId a)
forall ndoc doc k a.
(HasMap ndoc doc, Ord k, FromJSONKey k, ToJSONKey k) =>
ValueSchema ndoc a -> ValueSchema doc (Map k a)
map_ ValueSchema NamedSwaggerDoc a
sch))
  where
    innerSchema :: ValueSchema NamedSwaggerDoc (UserClientMap a)
innerSchema = ValueSchema NamedSwaggerDoc a
-> ValueSchema NamedSwaggerDoc (UserClientMap a)
forall doc a.
(WrapName doc, HasSchemaRef doc) =>
ValueSchema doc a -> ValueSchema doc (UserClientMap a)
userClientMapSchema ValueSchema NamedSwaggerDoc a
sch
    nm :: Text
nm = Text
"QualifiedUserClientMap" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text -> (Text -> Text) -> Maybe Text -> Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Text
"" (Text
"_" <>) (NamedSwaggerDoc -> Maybe Text
forall doc. HasName doc => doc -> Maybe Text
getName (ValueSchema NamedSwaggerDoc a -> NamedSwaggerDoc
forall ss v m a b. SchemaP ss v m a b -> ss
schemaDoc ValueSchema NamedSwaggerDoc a
sch))
    addDoc :: ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)
-> ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)
addDoc =
      (Schema -> Identity Schema)
-> ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)
-> Identity
     (ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a))
forall s a. HasSchema s a => Lens' s a
Lens'
  (ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)) Schema
Swagger.schema ((Schema -> Identity Schema)
 -> ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)
 -> Identity
      (ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)))
-> ((Maybe Value -> Identity (Maybe Value))
    -> Schema -> Identity Schema)
-> (Maybe Value -> Identity (Maybe Value))
-> ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)
-> Identity
     (ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Value -> Identity (Maybe Value))
-> Schema -> Identity Schema
forall s a. HasExample s a => Lens' s a
Lens' Schema (Maybe Value)
Swagger.example
        ((Maybe Value -> Identity (Maybe Value))
 -> ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)
 -> Identity
      (ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)))
-> Value
-> ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)
-> ValueSchema NamedSwaggerDoc (QualifiedUserClientMap a)
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Map Text (Maybe Value) -> Value
forall a. ToJSON a => a -> Value
toJSON
          ( Text -> Maybe Value -> Map Text (Maybe Value)
forall k a. k -> a -> Map k a
Map.singleton
              (Text
"domain1.example.com" :: Text)
              (ValueSchema NamedSwaggerDoc (UserClientMap a) -> NamedSwaggerDoc
forall ss v m a b. SchemaP ss v m a b -> ss
schemaDoc ValueSchema NamedSwaggerDoc (UserClientMap a)
innerSchema NamedSwaggerDoc
-> Getting (Maybe Value) NamedSwaggerDoc (Maybe Value)
-> Maybe Value
forall s a. s -> Getting a s a -> a
^. (Schema -> Const (Maybe Value) Schema)
-> NamedSwaggerDoc -> Const (Maybe Value) NamedSwaggerDoc
forall s a. HasSchema s a => Lens' s a
Lens' NamedSwaggerDoc Schema
Swagger.schema ((Schema -> Const (Maybe Value) Schema)
 -> NamedSwaggerDoc -> Const (Maybe Value) NamedSwaggerDoc)
-> ((Maybe Value -> Const (Maybe Value) (Maybe Value))
    -> Schema -> Const (Maybe Value) Schema)
-> Getting (Maybe Value) NamedSwaggerDoc (Maybe Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Value -> Const (Maybe Value) (Maybe Value))
-> Schema -> Const (Maybe Value) Schema
forall s a. HasExample s a => Lens' s a
Lens' Schema (Maybe Value)
Swagger.example)
          )

data QualifiedUserClientPrekeyMapV4 = QualifiedUserClientPrekeyMapV4
  { QualifiedUserClientPrekeyMapV4
-> QualifiedUserClientMap (Maybe Prekey)
qualifiedUserClientPrekeys :: QualifiedUserClientMap (Maybe Prekey),
    QualifiedUserClientPrekeyMapV4 -> Maybe [Qualified UserId]
failedToList :: Maybe [Qualified UserId]
  }
  deriving stock (QualifiedUserClientPrekeyMapV4
-> QualifiedUserClientPrekeyMapV4 -> Bool
(QualifiedUserClientPrekeyMapV4
 -> QualifiedUserClientPrekeyMapV4 -> Bool)
-> (QualifiedUserClientPrekeyMapV4
    -> QualifiedUserClientPrekeyMapV4 -> Bool)
-> Eq QualifiedUserClientPrekeyMapV4
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QualifiedUserClientPrekeyMapV4
-> QualifiedUserClientPrekeyMapV4 -> Bool
== :: QualifiedUserClientPrekeyMapV4
-> QualifiedUserClientPrekeyMapV4 -> Bool
$c/= :: QualifiedUserClientPrekeyMapV4
-> QualifiedUserClientPrekeyMapV4 -> Bool
/= :: QualifiedUserClientPrekeyMapV4
-> QualifiedUserClientPrekeyMapV4 -> Bool
Eq, Int -> QualifiedUserClientPrekeyMapV4 -> ShowS
[QualifiedUserClientPrekeyMapV4] -> ShowS
QualifiedUserClientPrekeyMapV4 -> [Char]
(Int -> QualifiedUserClientPrekeyMapV4 -> ShowS)
-> (QualifiedUserClientPrekeyMapV4 -> [Char])
-> ([QualifiedUserClientPrekeyMapV4] -> ShowS)
-> Show QualifiedUserClientPrekeyMapV4
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> QualifiedUserClientPrekeyMapV4 -> ShowS
showsPrec :: Int -> QualifiedUserClientPrekeyMapV4 -> ShowS
$cshow :: QualifiedUserClientPrekeyMapV4 -> [Char]
show :: QualifiedUserClientPrekeyMapV4 -> [Char]
$cshowList :: [QualifiedUserClientPrekeyMapV4] -> ShowS
showList :: [QualifiedUserClientPrekeyMapV4] -> ShowS
Show)
  deriving (Value -> Parser [QualifiedUserClientPrekeyMapV4]
Value -> Parser QualifiedUserClientPrekeyMapV4
(Value -> Parser QualifiedUserClientPrekeyMapV4)
-> (Value -> Parser [QualifiedUserClientPrekeyMapV4])
-> FromJSON QualifiedUserClientPrekeyMapV4
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser QualifiedUserClientPrekeyMapV4
parseJSON :: Value -> Parser QualifiedUserClientPrekeyMapV4
$cparseJSONList :: Value -> Parser [QualifiedUserClientPrekeyMapV4]
parseJSONList :: Value -> Parser [QualifiedUserClientPrekeyMapV4]
FromJSON, [QualifiedUserClientPrekeyMapV4] -> Value
[QualifiedUserClientPrekeyMapV4] -> Encoding
QualifiedUserClientPrekeyMapV4 -> Value
QualifiedUserClientPrekeyMapV4 -> Encoding
(QualifiedUserClientPrekeyMapV4 -> Value)
-> (QualifiedUserClientPrekeyMapV4 -> Encoding)
-> ([QualifiedUserClientPrekeyMapV4] -> Value)
-> ([QualifiedUserClientPrekeyMapV4] -> Encoding)
-> ToJSON QualifiedUserClientPrekeyMapV4
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: QualifiedUserClientPrekeyMapV4 -> Value
toJSON :: QualifiedUserClientPrekeyMapV4 -> Value
$ctoEncoding :: QualifiedUserClientPrekeyMapV4 -> Encoding
toEncoding :: QualifiedUserClientPrekeyMapV4 -> Encoding
$ctoJSONList :: [QualifiedUserClientPrekeyMapV4] -> Value
toJSONList :: [QualifiedUserClientPrekeyMapV4] -> Value
$ctoEncodingList :: [QualifiedUserClientPrekeyMapV4] -> Encoding
toEncodingList :: [QualifiedUserClientPrekeyMapV4] -> Encoding
ToJSON, Typeable QualifiedUserClientPrekeyMapV4
Typeable QualifiedUserClientPrekeyMapV4 =>
(Proxy QualifiedUserClientPrekeyMapV4
 -> Declare (Definitions Schema) NamedSchema)
-> ToSchema QualifiedUserClientPrekeyMapV4
Proxy QualifiedUserClientPrekeyMapV4
-> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy QualifiedUserClientPrekeyMapV4
-> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy QualifiedUserClientPrekeyMapV4
-> Declare (Definitions Schema) NamedSchema
Swagger.ToSchema) via Schema QualifiedUserClientPrekeyMapV4

instance Arbitrary QualifiedUserClientPrekeyMapV4 where
  arbitrary :: Gen QualifiedUserClientPrekeyMapV4
arbitrary =
    QualifiedUserClientMap (Maybe Prekey)
-> Maybe [Qualified UserId] -> QualifiedUserClientPrekeyMapV4
QualifiedUserClientPrekeyMapV4
      (QualifiedUserClientMap (Maybe Prekey)
 -> Maybe [Qualified UserId] -> QualifiedUserClientPrekeyMapV4)
-> Gen (QualifiedUserClientMap (Maybe Prekey))
-> Gen (Maybe [Qualified UserId] -> QualifiedUserClientPrekeyMapV4)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (QualifiedUserClientMap (Maybe Prekey))
forall a. Arbitrary a => Gen a
arbitrary
      Gen (Maybe [Qualified UserId] -> QualifiedUserClientPrekeyMapV4)
-> Gen (Maybe [Qualified UserId])
-> Gen QualifiedUserClientPrekeyMapV4
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 [Qualified UserId])
forall a. Arbitrary a => Gen a
arbitrary

instance ToSchema QualifiedUserClientPrekeyMapV4 where
  schema :: ValueSchema NamedSwaggerDoc QualifiedUserClientPrekeyMapV4
schema =
    Text
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     QualifiedUserClientPrekeyMapV4
     QualifiedUserClientPrekeyMapV4
-> ValueSchema NamedSwaggerDoc QualifiedUserClientPrekeyMapV4
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"QualifiedUserClientPrekeyMapV4" (SchemaP
   SwaggerDoc
   Object
   [Pair]
   QualifiedUserClientPrekeyMapV4
   QualifiedUserClientPrekeyMapV4
 -> ValueSchema NamedSwaggerDoc QualifiedUserClientPrekeyMapV4)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     QualifiedUserClientPrekeyMapV4
     QualifiedUserClientPrekeyMapV4
-> ValueSchema NamedSwaggerDoc QualifiedUserClientPrekeyMapV4
forall a b. (a -> b) -> a -> b
$
      QualifiedUserClientMap (Maybe Prekey)
-> Maybe [Qualified UserId] -> QualifiedUserClientPrekeyMapV4
QualifiedUserClientPrekeyMapV4
        (QualifiedUserClientMap (Maybe Prekey)
 -> Maybe [Qualified UserId] -> QualifiedUserClientPrekeyMapV4)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     QualifiedUserClientPrekeyMapV4
     (QualifiedUserClientMap (Maybe Prekey))
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     QualifiedUserClientPrekeyMapV4
     (Maybe [Qualified UserId] -> QualifiedUserClientPrekeyMapV4)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Map Domain UserClientPrekeyMap
 -> QualifiedUserClientMap (Maybe Prekey))
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     QualifiedUserClientPrekeyMapV4
     (Map Domain UserClientPrekeyMap)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     QualifiedUserClientPrekeyMapV4
     (QualifiedUserClientMap (Maybe Prekey))
forall a b.
(a -> b)
-> SchemaP
     SwaggerDoc Object [Pair] QualifiedUserClientPrekeyMapV4 a
-> SchemaP
     SwaggerDoc Object [Pair] QualifiedUserClientPrekeyMapV4 b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Map Domain UserClientPrekeyMap
-> QualifiedUserClientMap (Maybe Prekey)
to' (QualifiedUserClientPrekeyMapV4 -> Map Domain UserClientPrekeyMap
from' (QualifiedUserClientPrekeyMapV4 -> Map Domain UserClientPrekeyMap)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Map Domain UserClientPrekeyMap)
     (Map Domain UserClientPrekeyMap)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     QualifiedUserClientPrekeyMapV4
     (Map Domain UserClientPrekeyMap)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP
     SwaggerDoc
     Value
     Value
     (Map Domain UserClientPrekeyMap)
     (Map Domain UserClientPrekeyMap)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Map Domain UserClientPrekeyMap)
     (Map Domain UserClientPrekeyMap)
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"qualified_user_client_prekeys" (ValueSchema NamedSwaggerDoc UserClientPrekeyMap
-> SchemaP
     SwaggerDoc
     Value
     Value
     (Map Domain UserClientPrekeyMap)
     (Map Domain UserClientPrekeyMap)
forall ndoc doc k a.
(HasMap ndoc doc, Ord k, FromJSONKey k, ToJSONKey k) =>
ValueSchema ndoc a -> ValueSchema doc (Map k a)
map_ ValueSchema NamedSwaggerDoc UserClientPrekeyMap
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema))
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  QualifiedUserClientPrekeyMapV4
  (Maybe [Qualified UserId] -> QualifiedUserClientPrekeyMapV4)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     QualifiedUserClientPrekeyMapV4
     (Maybe [Qualified UserId])
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     QualifiedUserClientPrekeyMapV4
     QualifiedUserClientPrekeyMapV4
forall a b.
SchemaP
  SwaggerDoc Object [Pair] QualifiedUserClientPrekeyMapV4 (a -> b)
-> SchemaP
     SwaggerDoc Object [Pair] QualifiedUserClientPrekeyMapV4 a
-> SchemaP
     SwaggerDoc Object [Pair] QualifiedUserClientPrekeyMapV4 b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> QualifiedUserClientPrekeyMapV4 -> Maybe [Qualified UserId]
failedToList (QualifiedUserClientPrekeyMapV4 -> Maybe [Qualified UserId])
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe [Qualified UserId])
     (Maybe [Qualified UserId])
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     QualifiedUserClientPrekeyMapV4
     (Maybe [Qualified UserId])
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP
  SwaggerDoc
  Object
  [Pair]
  [Qualified UserId]
  (Maybe [Qualified UserId])
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe [Qualified UserId])
     (Maybe [Qualified UserId])
forall w d v a b.
Monoid w =>
SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybe_ (Text
-> SchemaP
     SwaggerDoc Value Value [Qualified UserId] [Qualified UserId]
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     [Qualified UserId]
     (Maybe [Qualified UserId])
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
"failed_to_list" (ValueSchema NamedSwaggerDoc (Qualified UserId)
-> SchemaP
     SwaggerDoc Value Value [Qualified UserId] [Qualified UserId]
forall ndoc doc a.
(HasArray ndoc doc, HasName ndoc) =>
ValueSchema ndoc a -> ValueSchema doc [a]
array ValueSchema NamedSwaggerDoc (Qualified UserId)
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema))
    where
      from' :: QualifiedUserClientPrekeyMapV4 -> Map Domain UserClientPrekeyMap
      from' :: QualifiedUserClientPrekeyMapV4 -> Map Domain UserClientPrekeyMap
from' = QualifiedUserClientMap (Maybe Prekey)
-> Map Domain UserClientPrekeyMap
forall a b. Coercible a b => a -> b
coerce (QualifiedUserClientMap (Maybe Prekey)
 -> Map Domain UserClientPrekeyMap)
-> (QualifiedUserClientPrekeyMapV4
    -> QualifiedUserClientMap (Maybe Prekey))
-> QualifiedUserClientPrekeyMapV4
-> Map Domain UserClientPrekeyMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QualifiedUserClientPrekeyMapV4
-> QualifiedUserClientMap (Maybe Prekey)
qualifiedUserClientPrekeys
      to' :: Map Domain UserClientPrekeyMap -> QualifiedUserClientMap (Maybe Prekey)
      to' :: Map Domain UserClientPrekeyMap
-> QualifiedUserClientMap (Maybe Prekey)
to' = Map Domain UserClientPrekeyMap
-> QualifiedUserClientMap (Maybe Prekey)
forall a b. Coercible a b => a -> b
coerce

newtype QualifiedUserClientPrekeyMap = QualifiedUserClientPrekeyMap
  { QualifiedUserClientPrekeyMap
-> QualifiedUserClientMap (Maybe Prekey)
getQualifiedUserClientPrekeyMap :: QualifiedUserClientMap (Maybe Prekey)
  }
  deriving stock (QualifiedUserClientPrekeyMap
-> QualifiedUserClientPrekeyMap -> Bool
(QualifiedUserClientPrekeyMap
 -> QualifiedUserClientPrekeyMap -> Bool)
-> (QualifiedUserClientPrekeyMap
    -> QualifiedUserClientPrekeyMap -> Bool)
-> Eq QualifiedUserClientPrekeyMap
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QualifiedUserClientPrekeyMap
-> QualifiedUserClientPrekeyMap -> Bool
== :: QualifiedUserClientPrekeyMap
-> QualifiedUserClientPrekeyMap -> Bool
$c/= :: QualifiedUserClientPrekeyMap
-> QualifiedUserClientPrekeyMap -> Bool
/= :: QualifiedUserClientPrekeyMap
-> QualifiedUserClientPrekeyMap -> Bool
Eq, Int -> QualifiedUserClientPrekeyMap -> ShowS
[QualifiedUserClientPrekeyMap] -> ShowS
QualifiedUserClientPrekeyMap -> [Char]
(Int -> QualifiedUserClientPrekeyMap -> ShowS)
-> (QualifiedUserClientPrekeyMap -> [Char])
-> ([QualifiedUserClientPrekeyMap] -> ShowS)
-> Show QualifiedUserClientPrekeyMap
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> QualifiedUserClientPrekeyMap -> ShowS
showsPrec :: Int -> QualifiedUserClientPrekeyMap -> ShowS
$cshow :: QualifiedUserClientPrekeyMap -> [Char]
show :: QualifiedUserClientPrekeyMap -> [Char]
$cshowList :: [QualifiedUserClientPrekeyMap] -> ShowS
showList :: [QualifiedUserClientPrekeyMap] -> ShowS
Show)
  deriving newtype (Gen QualifiedUserClientPrekeyMap
Gen QualifiedUserClientPrekeyMap
-> (QualifiedUserClientPrekeyMap -> [QualifiedUserClientPrekeyMap])
-> Arbitrary QualifiedUserClientPrekeyMap
QualifiedUserClientPrekeyMap -> [QualifiedUserClientPrekeyMap]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen QualifiedUserClientPrekeyMap
arbitrary :: Gen QualifiedUserClientPrekeyMap
$cshrink :: QualifiedUserClientPrekeyMap -> [QualifiedUserClientPrekeyMap]
shrink :: QualifiedUserClientPrekeyMap -> [QualifiedUserClientPrekeyMap]
Arbitrary)
  deriving (Value -> Parser [QualifiedUserClientPrekeyMap]
Value -> Parser QualifiedUserClientPrekeyMap
(Value -> Parser QualifiedUserClientPrekeyMap)
-> (Value -> Parser [QualifiedUserClientPrekeyMap])
-> FromJSON QualifiedUserClientPrekeyMap
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser QualifiedUserClientPrekeyMap
parseJSON :: Value -> Parser QualifiedUserClientPrekeyMap
$cparseJSONList :: Value -> Parser [QualifiedUserClientPrekeyMap]
parseJSONList :: Value -> Parser [QualifiedUserClientPrekeyMap]
FromJSON, [QualifiedUserClientPrekeyMap] -> Value
[QualifiedUserClientPrekeyMap] -> Encoding
QualifiedUserClientPrekeyMap -> Value
QualifiedUserClientPrekeyMap -> Encoding
(QualifiedUserClientPrekeyMap -> Value)
-> (QualifiedUserClientPrekeyMap -> Encoding)
-> ([QualifiedUserClientPrekeyMap] -> Value)
-> ([QualifiedUserClientPrekeyMap] -> Encoding)
-> ToJSON QualifiedUserClientPrekeyMap
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: QualifiedUserClientPrekeyMap -> Value
toJSON :: QualifiedUserClientPrekeyMap -> Value
$ctoEncoding :: QualifiedUserClientPrekeyMap -> Encoding
toEncoding :: QualifiedUserClientPrekeyMap -> Encoding
$ctoJSONList :: [QualifiedUserClientPrekeyMap] -> Value
toJSONList :: [QualifiedUserClientPrekeyMap] -> Value
$ctoEncodingList :: [QualifiedUserClientPrekeyMap] -> Encoding
toEncodingList :: [QualifiedUserClientPrekeyMap] -> Encoding
ToJSON, Typeable QualifiedUserClientPrekeyMap
Typeable QualifiedUserClientPrekeyMap =>
(Proxy QualifiedUserClientPrekeyMap
 -> Declare (Definitions Schema) NamedSchema)
-> ToSchema QualifiedUserClientPrekeyMap
Proxy QualifiedUserClientPrekeyMap
-> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy QualifiedUserClientPrekeyMap
-> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy QualifiedUserClientPrekeyMap
-> Declare (Definitions Schema) NamedSchema
Swagger.ToSchema) via Schema QualifiedUserClientPrekeyMap
  deriving (NonEmpty QualifiedUserClientPrekeyMap
-> QualifiedUserClientPrekeyMap
QualifiedUserClientPrekeyMap
-> QualifiedUserClientPrekeyMap -> QualifiedUserClientPrekeyMap
(QualifiedUserClientPrekeyMap
 -> QualifiedUserClientPrekeyMap -> QualifiedUserClientPrekeyMap)
-> (NonEmpty QualifiedUserClientPrekeyMap
    -> QualifiedUserClientPrekeyMap)
-> (forall b.
    Integral b =>
    b -> QualifiedUserClientPrekeyMap -> QualifiedUserClientPrekeyMap)
-> Semigroup QualifiedUserClientPrekeyMap
forall b.
Integral b =>
b -> QualifiedUserClientPrekeyMap -> QualifiedUserClientPrekeyMap
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: QualifiedUserClientPrekeyMap
-> QualifiedUserClientPrekeyMap -> QualifiedUserClientPrekeyMap
<> :: QualifiedUserClientPrekeyMap
-> QualifiedUserClientPrekeyMap -> QualifiedUserClientPrekeyMap
$csconcat :: NonEmpty QualifiedUserClientPrekeyMap
-> QualifiedUserClientPrekeyMap
sconcat :: NonEmpty QualifiedUserClientPrekeyMap
-> QualifiedUserClientPrekeyMap
$cstimes :: forall b.
Integral b =>
b -> QualifiedUserClientPrekeyMap -> QualifiedUserClientPrekeyMap
stimes :: forall b.
Integral b =>
b -> QualifiedUserClientPrekeyMap -> QualifiedUserClientPrekeyMap
Semigroup, Semigroup QualifiedUserClientPrekeyMap
QualifiedUserClientPrekeyMap
Semigroup QualifiedUserClientPrekeyMap =>
QualifiedUserClientPrekeyMap
-> (QualifiedUserClientPrekeyMap
    -> QualifiedUserClientPrekeyMap -> QualifiedUserClientPrekeyMap)
-> ([QualifiedUserClientPrekeyMap] -> QualifiedUserClientPrekeyMap)
-> Monoid QualifiedUserClientPrekeyMap
[QualifiedUserClientPrekeyMap] -> QualifiedUserClientPrekeyMap
QualifiedUserClientPrekeyMap
-> QualifiedUserClientPrekeyMap -> QualifiedUserClientPrekeyMap
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
$cmempty :: QualifiedUserClientPrekeyMap
mempty :: QualifiedUserClientPrekeyMap
$cmappend :: QualifiedUserClientPrekeyMap
-> QualifiedUserClientPrekeyMap -> QualifiedUserClientPrekeyMap
mappend :: QualifiedUserClientPrekeyMap
-> QualifiedUserClientPrekeyMap -> QualifiedUserClientPrekeyMap
$cmconcat :: [QualifiedUserClientPrekeyMap] -> QualifiedUserClientPrekeyMap
mconcat :: [QualifiedUserClientPrekeyMap] -> QualifiedUserClientPrekeyMap
Monoid) via (QualifiedUserClientMap (Alt Maybe Prekey))

instance ToSchema QualifiedUserClientPrekeyMap where
  schema :: ValueSchema NamedSwaggerDoc QualifiedUserClientPrekeyMap
schema =
    Text
-> SchemaP
     SwaggerDoc
     Value
     Value
     QualifiedUserClientPrekeyMap
     QualifiedUserClientPrekeyMap
-> ValueSchema NamedSwaggerDoc QualifiedUserClientPrekeyMap
forall doc doc' v m a b.
HasObject doc doc' =>
Text -> SchemaP doc v m a b -> SchemaP doc' v m a b
named Text
"QualifiedUserClientPrekeyMap" (SchemaP
   SwaggerDoc
   Value
   Value
   QualifiedUserClientPrekeyMap
   QualifiedUserClientPrekeyMap
 -> ValueSchema NamedSwaggerDoc QualifiedUserClientPrekeyMap)
-> SchemaP
     SwaggerDoc
     Value
     Value
     QualifiedUserClientPrekeyMap
     QualifiedUserClientPrekeyMap
-> ValueSchema NamedSwaggerDoc QualifiedUserClientPrekeyMap
forall a b. (a -> b) -> a -> b
$
      Map Domain UserClientPrekeyMap -> QualifiedUserClientPrekeyMap
mkQualifiedUserClientPrekeyMap (Map Domain UserClientPrekeyMap -> QualifiedUserClientPrekeyMap)
-> SchemaP
     SwaggerDoc
     Value
     Value
     QualifiedUserClientPrekeyMap
     (Map Domain UserClientPrekeyMap)
-> SchemaP
     SwaggerDoc
     Value
     Value
     QualifiedUserClientPrekeyMap
     QualifiedUserClientPrekeyMap
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> QualifiedUserClientPrekeyMap -> Map Domain UserClientPrekeyMap
unmk (QualifiedUserClientPrekeyMap -> Map Domain UserClientPrekeyMap)
-> SchemaP
     SwaggerDoc
     Value
     Value
     (Map Domain UserClientPrekeyMap)
     (Map Domain UserClientPrekeyMap)
-> SchemaP
     SwaggerDoc
     Value
     Value
     QualifiedUserClientPrekeyMap
     (Map Domain UserClientPrekeyMap)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= ValueSchema NamedSwaggerDoc UserClientPrekeyMap
-> SchemaP
     SwaggerDoc
     Value
     Value
     (Map Domain UserClientPrekeyMap)
     (Map Domain UserClientPrekeyMap)
forall ndoc doc k a.
(HasMap ndoc doc, Ord k, FromJSONKey k, ToJSONKey k) =>
ValueSchema ndoc a -> ValueSchema doc (Map k a)
map_ ValueSchema NamedSwaggerDoc UserClientPrekeyMap
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
    where
      unmk :: QualifiedUserClientPrekeyMap -> Map Domain UserClientPrekeyMap
      unmk :: QualifiedUserClientPrekeyMap -> Map Domain UserClientPrekeyMap
unmk = QualifiedUserClientPrekeyMap -> Map Domain UserClientPrekeyMap
forall a b. Coercible a b => a -> b
coerce

mkQualifiedUserClientPrekeyMap :: Map Domain UserClientPrekeyMap -> QualifiedUserClientPrekeyMap
mkQualifiedUserClientPrekeyMap :: Map Domain UserClientPrekeyMap -> QualifiedUserClientPrekeyMap
mkQualifiedUserClientPrekeyMap = Map Domain UserClientPrekeyMap -> QualifiedUserClientPrekeyMap
forall a b. Coercible a b => a -> b
coerce

qualifiedUserClientPrekeyMapFromList ::
  [Qualified UserClientPrekeyMap] ->
  QualifiedUserClientPrekeyMap
qualifiedUserClientPrekeyMapFromList :: [Qualified UserClientPrekeyMap] -> QualifiedUserClientPrekeyMap
qualifiedUserClientPrekeyMapFromList =
  Map Domain UserClientPrekeyMap -> QualifiedUserClientPrekeyMap
mkQualifiedUserClientPrekeyMap (Map Domain UserClientPrekeyMap -> QualifiedUserClientPrekeyMap)
-> ([Qualified UserClientPrekeyMap]
    -> Map Domain UserClientPrekeyMap)
-> [Qualified UserClientPrekeyMap]
-> QualifiedUserClientPrekeyMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Domain, UserClientPrekeyMap)] -> Map Domain UserClientPrekeyMap
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(Domain, UserClientPrekeyMap)] -> Map Domain UserClientPrekeyMap)
-> ([Qualified UserClientPrekeyMap]
    -> [(Domain, UserClientPrekeyMap)])
-> [Qualified UserClientPrekeyMap]
-> Map Domain UserClientPrekeyMap
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Qualified UserClientPrekeyMap -> (Domain, UserClientPrekeyMap))
-> [Qualified UserClientPrekeyMap]
-> [(Domain, UserClientPrekeyMap)]
forall a b. (a -> b) -> [a] -> [b]
map Qualified UserClientPrekeyMap -> (Domain, UserClientPrekeyMap)
forall a. Qualified a -> (Domain, a)
qToPair

--------------------------------------------------------------------------------
-- ClientInfo

-- | A client, together with extra information about it.
data ClientInfo = ClientInfo
  { -- | The ID of this client.
    ClientInfo -> ClientId
ciId :: ClientId,
    -- | Whether this client is MLS-capable.
    ClientInfo -> Bool
ciMLS :: Bool
  }
  deriving stock (ClientInfo -> ClientInfo -> Bool
(ClientInfo -> ClientInfo -> Bool)
-> (ClientInfo -> ClientInfo -> Bool) -> Eq ClientInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClientInfo -> ClientInfo -> Bool
== :: ClientInfo -> ClientInfo -> Bool
$c/= :: ClientInfo -> ClientInfo -> Bool
/= :: ClientInfo -> ClientInfo -> Bool
Eq, Eq ClientInfo
Eq ClientInfo =>
(ClientInfo -> ClientInfo -> Ordering)
-> (ClientInfo -> ClientInfo -> Bool)
-> (ClientInfo -> ClientInfo -> Bool)
-> (ClientInfo -> ClientInfo -> Bool)
-> (ClientInfo -> ClientInfo -> Bool)
-> (ClientInfo -> ClientInfo -> ClientInfo)
-> (ClientInfo -> ClientInfo -> ClientInfo)
-> Ord ClientInfo
ClientInfo -> ClientInfo -> Bool
ClientInfo -> ClientInfo -> Ordering
ClientInfo -> ClientInfo -> ClientInfo
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 :: ClientInfo -> ClientInfo -> Ordering
compare :: ClientInfo -> ClientInfo -> Ordering
$c< :: ClientInfo -> ClientInfo -> Bool
< :: ClientInfo -> ClientInfo -> Bool
$c<= :: ClientInfo -> ClientInfo -> Bool
<= :: ClientInfo -> ClientInfo -> Bool
$c> :: ClientInfo -> ClientInfo -> Bool
> :: ClientInfo -> ClientInfo -> Bool
$c>= :: ClientInfo -> ClientInfo -> Bool
>= :: ClientInfo -> ClientInfo -> Bool
$cmax :: ClientInfo -> ClientInfo -> ClientInfo
max :: ClientInfo -> ClientInfo -> ClientInfo
$cmin :: ClientInfo -> ClientInfo -> ClientInfo
min :: ClientInfo -> ClientInfo -> ClientInfo
Ord, Int -> ClientInfo -> ShowS
[ClientInfo] -> ShowS
ClientInfo -> [Char]
(Int -> ClientInfo -> ShowS)
-> (ClientInfo -> [Char])
-> ([ClientInfo] -> ShowS)
-> Show ClientInfo
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ClientInfo -> ShowS
showsPrec :: Int -> ClientInfo -> ShowS
$cshow :: ClientInfo -> [Char]
show :: ClientInfo -> [Char]
$cshowList :: [ClientInfo] -> ShowS
showList :: [ClientInfo] -> ShowS
Show)
  deriving (Typeable ClientInfo
Typeable ClientInfo =>
(Proxy ClientInfo -> Declare (Definitions Schema) NamedSchema)
-> ToSchema ClientInfo
Proxy ClientInfo -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy ClientInfo -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy ClientInfo -> Declare (Definitions Schema) NamedSchema
Swagger.ToSchema, Value -> Parser [ClientInfo]
Value -> Parser ClientInfo
(Value -> Parser ClientInfo)
-> (Value -> Parser [ClientInfo]) -> FromJSON ClientInfo
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser ClientInfo
parseJSON :: Value -> Parser ClientInfo
$cparseJSONList :: Value -> Parser [ClientInfo]
parseJSONList :: Value -> Parser [ClientInfo]
FromJSON, [ClientInfo] -> Value
[ClientInfo] -> Encoding
ClientInfo -> Value
ClientInfo -> Encoding
(ClientInfo -> Value)
-> (ClientInfo -> Encoding)
-> ([ClientInfo] -> Value)
-> ([ClientInfo] -> Encoding)
-> ToJSON ClientInfo
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: ClientInfo -> Value
toJSON :: ClientInfo -> Value
$ctoEncoding :: ClientInfo -> Encoding
toEncoding :: ClientInfo -> Encoding
$ctoJSONList :: [ClientInfo] -> Value
toJSONList :: [ClientInfo] -> Value
$ctoEncodingList :: [ClientInfo] -> Encoding
toEncodingList :: [ClientInfo] -> Encoding
ToJSON) via Schema ClientInfo

instance ToSchema ClientInfo where
  schema :: ValueSchema NamedSwaggerDoc ClientInfo
schema =
    Text
-> SchemaP SwaggerDoc Object [Pair] ClientInfo ClientInfo
-> ValueSchema NamedSwaggerDoc ClientInfo
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"ClientInfo" (SchemaP SwaggerDoc Object [Pair] ClientInfo ClientInfo
 -> ValueSchema NamedSwaggerDoc ClientInfo)
-> SchemaP SwaggerDoc Object [Pair] ClientInfo ClientInfo
-> ValueSchema NamedSwaggerDoc ClientInfo
forall a b. (a -> b) -> a -> b
$
      ClientId -> Bool -> ClientInfo
ClientInfo
        (ClientId -> Bool -> ClientInfo)
-> SchemaP SwaggerDoc Object [Pair] ClientInfo ClientId
-> SchemaP SwaggerDoc Object [Pair] ClientInfo (Bool -> ClientInfo)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ClientInfo -> ClientId
ciId (ClientInfo -> ClientId)
-> SchemaP SwaggerDoc Object [Pair] ClientId ClientId
-> SchemaP SwaggerDoc Object [Pair] ClientInfo 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
"id" SchemaP NamedSwaggerDoc Value Value ClientId ClientId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP SwaggerDoc Object [Pair] ClientInfo (Bool -> ClientInfo)
-> SchemaP SwaggerDoc Object [Pair] ClientInfo Bool
-> SchemaP SwaggerDoc Object [Pair] ClientInfo ClientInfo
forall a b.
SchemaP SwaggerDoc Object [Pair] ClientInfo (a -> b)
-> SchemaP SwaggerDoc Object [Pair] ClientInfo a
-> SchemaP SwaggerDoc Object [Pair] ClientInfo b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ClientInfo -> Bool
ciMLS (ClientInfo -> Bool)
-> SchemaP SwaggerDoc Object [Pair] Bool Bool
-> SchemaP SwaggerDoc Object [Pair] ClientInfo Bool
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value Bool Bool
-> SchemaP SwaggerDoc Object [Pair] Bool Bool
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"mls" SchemaP NamedSwaggerDoc Value Value Bool Bool
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema

--------------------------------------------------------------------------------
-- UserClients

newtype UserClientsFull = UserClientsFull
  { UserClientsFull -> Map UserId (Set Client)
userClientsFull :: Map UserId (Set Client)
  }
  deriving stock (UserClientsFull -> UserClientsFull -> Bool
(UserClientsFull -> UserClientsFull -> Bool)
-> (UserClientsFull -> UserClientsFull -> Bool)
-> Eq UserClientsFull
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UserClientsFull -> UserClientsFull -> Bool
== :: UserClientsFull -> UserClientsFull -> Bool
$c/= :: UserClientsFull -> UserClientsFull -> Bool
/= :: UserClientsFull -> UserClientsFull -> Bool
Eq, Int -> UserClientsFull -> ShowS
[UserClientsFull] -> ShowS
UserClientsFull -> [Char]
(Int -> UserClientsFull -> ShowS)
-> (UserClientsFull -> [Char])
-> ([UserClientsFull] -> ShowS)
-> Show UserClientsFull
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UserClientsFull -> ShowS
showsPrec :: Int -> UserClientsFull -> ShowS
$cshow :: UserClientsFull -> [Char]
show :: UserClientsFull -> [Char]
$cshowList :: [UserClientsFull] -> ShowS
showList :: [UserClientsFull] -> ShowS
Show, (forall x. UserClientsFull -> Rep UserClientsFull x)
-> (forall x. Rep UserClientsFull x -> UserClientsFull)
-> Generic UserClientsFull
forall x. Rep UserClientsFull x -> UserClientsFull
forall x. UserClientsFull -> Rep UserClientsFull x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. UserClientsFull -> Rep UserClientsFull x
from :: forall x. UserClientsFull -> Rep UserClientsFull x
$cto :: forall x. Rep UserClientsFull x -> UserClientsFull
to :: forall x. Rep UserClientsFull x -> UserClientsFull
Generic)
  deriving newtype (NonEmpty UserClientsFull -> UserClientsFull
UserClientsFull -> UserClientsFull -> UserClientsFull
(UserClientsFull -> UserClientsFull -> UserClientsFull)
-> (NonEmpty UserClientsFull -> UserClientsFull)
-> (forall b.
    Integral b =>
    b -> UserClientsFull -> UserClientsFull)
-> Semigroup UserClientsFull
forall b. Integral b => b -> UserClientsFull -> UserClientsFull
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: UserClientsFull -> UserClientsFull -> UserClientsFull
<> :: UserClientsFull -> UserClientsFull -> UserClientsFull
$csconcat :: NonEmpty UserClientsFull -> UserClientsFull
sconcat :: NonEmpty UserClientsFull -> UserClientsFull
$cstimes :: forall b. Integral b => b -> UserClientsFull -> UserClientsFull
stimes :: forall b. Integral b => b -> UserClientsFull -> UserClientsFull
Semigroup, Semigroup UserClientsFull
UserClientsFull
Semigroup UserClientsFull =>
UserClientsFull
-> (UserClientsFull -> UserClientsFull -> UserClientsFull)
-> ([UserClientsFull] -> UserClientsFull)
-> Monoid UserClientsFull
[UserClientsFull] -> UserClientsFull
UserClientsFull -> UserClientsFull -> UserClientsFull
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
$cmempty :: UserClientsFull
mempty :: UserClientsFull
$cmappend :: UserClientsFull -> UserClientsFull -> UserClientsFull
mappend :: UserClientsFull -> UserClientsFull -> UserClientsFull
$cmconcat :: [UserClientsFull] -> UserClientsFull
mconcat :: [UserClientsFull] -> UserClientsFull
Monoid)

-- | Json rendering of `UserClientsFull` is dynamic in the object fields, so it's unclear how
-- machine-generated swagger would look like.  We just leave the manual aeson instances in
-- place and write something in English into the docs here.
instance Swagger.ToSchema UserClientsFull where
  declareNamedSchema :: Proxy UserClientsFull -> Declare (Definitions Schema) NamedSchema
declareNamedSchema Proxy UserClientsFull
_ = do
    NamedSchema -> Declare (Definitions Schema) NamedSchema
forall a. a -> DeclareT (Definitions Schema) Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (NamedSchema -> Declare (Definitions Schema) NamedSchema)
-> NamedSchema -> Declare (Definitions Schema) NamedSchema
forall a b. (a -> b) -> a -> b
$
      Maybe Text -> Schema -> NamedSchema
NamedSchema (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"UserClientsFull") (Schema -> NamedSchema) -> Schema -> NamedSchema
forall a b. (a -> b) -> a -> b
$
        Schema
forall a. Monoid a => a
mempty
          Schema -> (Schema -> Schema) -> Schema
forall a b. a -> (a -> b) -> b
& (Maybe OpenApiType -> Identity (Maybe OpenApiType))
-> Schema -> Identity Schema
forall s a. HasType s a => Lens' s a
Lens' Schema (Maybe OpenApiType)
type_ ((Maybe OpenApiType -> Identity (Maybe OpenApiType))
 -> Schema -> Identity Schema)
-> OpenApiType -> Schema -> Schema
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ OpenApiType
OpenApiObject
          Schema -> (Schema -> Schema) -> Schema
forall a b. a -> (a -> b) -> b
& (Maybe Text -> Identity (Maybe Text)) -> Schema -> Identity Schema
forall s a. HasDescription s a => Lens' s a
Lens' Schema (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> Schema -> Identity Schema)
-> Text -> Schema -> Schema
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"Dictionary object of `Client` objects indexed by `UserId`."
          Schema -> (Schema -> Schema) -> Schema
forall a b. a -> (a -> b) -> b
& (Maybe Value -> Identity (Maybe Value))
-> Schema -> Identity Schema
forall s a. HasExample s a => Lens' s a
Lens' Schema (Maybe Value)
example ((Maybe Value -> Identity (Maybe Value))
 -> Schema -> Identity Schema)
-> Value -> Schema -> Schema
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Value
"{\"1355c55a-0ac8-11ee-97ee-db1a6351f093\": <Client object>, ...}"

instance ToJSON UserClientsFull where
  toJSON :: UserClientsFull -> Value
toJSON =
    Map Text (Set Client) -> Value
forall a. ToJSON a => a -> Value
toJSON (Map Text (Set Client) -> Value)
-> (UserClientsFull -> Map Text (Set Client))
-> UserClientsFull
-> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UserId
 -> Set Client -> Map Text (Set Client) -> Map Text (Set Client))
-> Map Text (Set Client)
-> Map UserId (Set Client)
-> Map Text (Set Client)
forall k a b. (k -> a -> b -> b) -> b -> Map k a -> b
Map.foldrWithKey' UserId
-> Set Client -> Map Text (Set Client) -> Map Text (Set Client)
forall {k} {a :: k} {a}. Id a -> a -> Map Text a -> Map Text a
fn Map Text (Set Client)
forall k a. Map k a
Map.empty (Map UserId (Set Client) -> Map Text (Set Client))
-> (UserClientsFull -> Map UserId (Set Client))
-> UserClientsFull
-> Map Text (Set Client)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UserClientsFull -> Map UserId (Set Client)
userClientsFull
    where
      fn :: Id a -> a -> Map Text a -> Map Text a
fn Id a
u a
c Map Text a
m =
        let k :: Text
k = ByteString -> Text
T.decodeLatin1 (UUID -> ByteString
toASCIIBytes (Id a -> UUID
forall {k} (a :: k). Id a -> UUID
toUUID Id a
u))
         in Text -> a -> Map Text a -> Map Text a
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert Text
k a
c Map Text a
m

instance FromJSON UserClientsFull where
  parseJSON :: Value -> Parser UserClientsFull
parseJSON =
    [Char]
-> (Object -> Parser UserClientsFull)
-> Value
-> Parser UserClientsFull
forall a. [Char] -> (Object -> Parser a) -> Value -> Parser a
A.withObject [Char]
"UserClientsFull" ((Map UserId (Set Client) -> UserClientsFull)
-> Parser (Map UserId (Set Client)) -> Parser UserClientsFull
forall a b. (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Map UserId (Set Client) -> UserClientsFull
UserClientsFull (Parser (Map UserId (Set Client)) -> Parser UserClientsFull)
-> (Object -> Parser (Map UserId (Set Client)))
-> Object
-> Parser UserClientsFull
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Pair
 -> Map UserId (Set Client) -> Parser (Map UserId (Set Client)))
-> Map UserId (Set Client)
-> [Pair]
-> Parser (Map UserId (Set Client))
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> b -> m b) -> b -> t a -> m b
foldrM Pair -> Map UserId (Set Client) -> Parser (Map UserId (Set Client))
forall {a} {a}.
(Ord a, FromJSON a, FromJSON a) =>
Pair -> Map a a -> Parser (Map a a)
fn Map UserId (Set Client)
forall k a. Map k a
Map.empty ([Pair] -> Parser (Map UserId (Set Client)))
-> (Object -> [Pair]) -> Object -> Parser (Map UserId (Set Client))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Object -> [Pair]
forall v. KeyMap v -> [(Key, v)]
KeyMap.toList)
    where
      fn :: Pair -> Map a a -> Parser (Map a a)
fn (Key
k, Value
v) Map a a
m = a -> a -> Map a a -> Map a a
forall k a. Ord k => k -> a -> Map k a -> Map k a
Map.insert (a -> a -> Map a a -> Map a a)
-> Parser a -> Parser (a -> Map a a -> Map a a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser a
forall a. FromJSON a => Value -> Parser a
parseJSON (Text -> Value
A.String (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ Key -> Text
Key.toText Key
k) Parser (a -> Map a a -> Map a a)
-> Parser a -> Parser (Map a a -> Map a a)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Value -> Parser a
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Map a a -> Map a a) -> Parser (Map a a) -> Parser (Map a a)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Map a a -> Parser (Map a a)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Map a a
m

instance Arbitrary UserClientsFull where
  arbitrary :: Gen UserClientsFull
arbitrary = Map UserId (Set Client) -> UserClientsFull
UserClientsFull (Map UserId (Set Client) -> UserClientsFull)
-> Gen (Map UserId (Set Client)) -> Gen UserClientsFull
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen UserId -> Gen (Set Client) -> Gen (Map UserId (Set Client))
forall k v. Ord k => Gen k -> Gen v -> Gen (Map k v)
mapOf' Gen UserId
forall a. Arbitrary a => Gen a
arbitrary (Gen Client -> Gen (Set Client)
forall a. Ord a => Gen a -> Gen (Set a)
setOf' Gen Client
forall a. Arbitrary a => Gen a
arbitrary)

newtype UserClients = UserClients
  { UserClients -> Map UserId (Set ClientId)
userClients :: Map UserId (Set ClientId)
  }
  deriving stock (UserClients -> UserClients -> Bool
(UserClients -> UserClients -> Bool)
-> (UserClients -> UserClients -> Bool) -> Eq UserClients
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UserClients -> UserClients -> Bool
== :: UserClients -> UserClients -> Bool
$c/= :: UserClients -> UserClients -> Bool
/= :: UserClients -> UserClients -> Bool
Eq, Int -> UserClients -> ShowS
[UserClients] -> ShowS
UserClients -> [Char]
(Int -> UserClients -> ShowS)
-> (UserClients -> [Char])
-> ([UserClients] -> ShowS)
-> Show UserClients
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UserClients -> ShowS
showsPrec :: Int -> UserClients -> ShowS
$cshow :: UserClients -> [Char]
show :: UserClients -> [Char]
$cshowList :: [UserClients] -> ShowS
showList :: [UserClients] -> ShowS
Show, (forall x. UserClients -> Rep UserClients x)
-> (forall x. Rep UserClients x -> UserClients)
-> Generic UserClients
forall x. Rep UserClients x -> UserClients
forall x. UserClients -> Rep UserClients x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. UserClients -> Rep UserClients x
from :: forall x. UserClients -> Rep UserClients x
$cto :: forall x. Rep UserClients x -> UserClients
to :: forall x. Rep UserClients x -> UserClients
Generic)
  deriving newtype (NonEmpty UserClients -> UserClients
UserClients -> UserClients -> UserClients
(UserClients -> UserClients -> UserClients)
-> (NonEmpty UserClients -> UserClients)
-> (forall b. Integral b => b -> UserClients -> UserClients)
-> Semigroup UserClients
forall b. Integral b => b -> UserClients -> UserClients
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: UserClients -> UserClients -> UserClients
<> :: UserClients -> UserClients -> UserClients
$csconcat :: NonEmpty UserClients -> UserClients
sconcat :: NonEmpty UserClients -> UserClients
$cstimes :: forall b. Integral b => b -> UserClients -> UserClients
stimes :: forall b. Integral b => b -> UserClients -> UserClients
Semigroup, Semigroup UserClients
UserClients
Semigroup UserClients =>
UserClients
-> (UserClients -> UserClients -> UserClients)
-> ([UserClients] -> UserClients)
-> Monoid UserClients
[UserClients] -> UserClients
UserClients -> UserClients -> UserClients
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
$cmempty :: UserClients
mempty :: UserClients
$cmappend :: UserClients -> UserClients -> UserClients
mappend :: UserClients -> UserClients -> UserClients
$cmconcat :: [UserClients] -> UserClients
mconcat :: [UserClients] -> UserClients
Monoid)
  deriving ([UserClients] -> Value
[UserClients] -> Encoding
UserClients -> Value
UserClients -> Encoding
(UserClients -> Value)
-> (UserClients -> Encoding)
-> ([UserClients] -> Value)
-> ([UserClients] -> Encoding)
-> ToJSON UserClients
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: UserClients -> Value
toJSON :: UserClients -> Value
$ctoEncoding :: UserClients -> Encoding
toEncoding :: UserClients -> Encoding
$ctoJSONList :: [UserClients] -> Value
toJSONList :: [UserClients] -> Value
$ctoEncodingList :: [UserClients] -> Encoding
toEncodingList :: [UserClients] -> Encoding
ToJSON, Value -> Parser [UserClients]
Value -> Parser UserClients
(Value -> Parser UserClients)
-> (Value -> Parser [UserClients]) -> FromJSON UserClients
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser UserClients
parseJSON :: Value -> Parser UserClients
$cparseJSONList :: Value -> Parser [UserClients]
parseJSONList :: Value -> Parser [UserClients]
FromJSON, Typeable UserClients
Typeable UserClients =>
(Proxy UserClients -> Declare (Definitions Schema) NamedSchema)
-> ToSchema UserClients
Proxy UserClients -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy UserClients -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy UserClients -> Declare (Definitions Schema) NamedSchema
Swagger.ToSchema) via Schema UserClients

mkUserClients :: [(UserId, [ClientId])] -> UserClients
mkUserClients :: [(UserId, [ClientId])] -> UserClients
mkUserClients [(UserId, [ClientId])]
xs = Map UserId (Set ClientId) -> UserClients
UserClients (Map UserId (Set ClientId) -> UserClients)
-> Map UserId (Set ClientId) -> UserClients
forall a b. (a -> b) -> a -> b
$ [(UserId, Set ClientId)] -> Map UserId (Set ClientId)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(UserId, [ClientId])]
xs [(UserId, [ClientId])]
-> ((UserId, [ClientId]) -> (UserId, Set ClientId))
-> [(UserId, Set ClientId)]
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> ([ClientId] -> Set ClientId)
-> (UserId, [ClientId]) -> (UserId, Set ClientId)
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second [ClientId] -> Set ClientId
forall a. Ord a => [a] -> Set a
Set.fromList)

instance ToSchema UserClients where
  schema :: ValueSchema NamedSwaggerDoc UserClients
schema =
    ValueSchema NamedSwaggerDoc UserClients
-> ValueSchema NamedSwaggerDoc UserClients
forall {b} {a} {b}.
(IsString b, HasDescription a (Maybe b), HasSchema b a,
 HasExample a (Maybe Value)) =>
b -> b
addDoc (ValueSchema NamedSwaggerDoc UserClients
 -> ValueSchema NamedSwaggerDoc UserClients)
-> (SchemaP SwaggerDoc Value Value UserClients UserClients
    -> ValueSchema NamedSwaggerDoc UserClients)
-> SchemaP SwaggerDoc Value Value UserClients UserClients
-> ValueSchema NamedSwaggerDoc UserClients
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text
-> SchemaP SwaggerDoc Value Value UserClients UserClients
-> ValueSchema NamedSwaggerDoc UserClients
forall doc doc' v m a b.
HasObject doc doc' =>
Text -> SchemaP doc v m a b -> SchemaP doc' v m a b
named Text
"UserClients" (SchemaP SwaggerDoc Value Value UserClients UserClients
 -> ValueSchema NamedSwaggerDoc UserClients)
-> SchemaP SwaggerDoc Value Value UserClients UserClients
-> ValueSchema NamedSwaggerDoc UserClients
forall a b. (a -> b) -> a -> b
$ Map UserId (Set ClientId) -> UserClients
UserClients (Map UserId (Set ClientId) -> UserClients)
-> SchemaP
     SwaggerDoc Value Value UserClients (Map UserId (Set ClientId))
-> SchemaP SwaggerDoc Value Value UserClients UserClients
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> UserClients -> Map UserId (Set ClientId)
userClients (UserClients -> Map UserId (Set ClientId))
-> SchemaP
     SwaggerDoc
     Value
     Value
     (Map UserId (Set ClientId))
     (Map UserId (Set ClientId))
-> SchemaP
     SwaggerDoc Value Value UserClients (Map UserId (Set ClientId))
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= ValueSchema SwaggerDoc (Set ClientId)
-> SchemaP
     SwaggerDoc
     Value
     Value
     (Map UserId (Set ClientId))
     (Map UserId (Set ClientId))
forall ndoc doc k a.
(HasMap ndoc doc, Ord k, FromJSONKey k, ToJSONKey k) =>
ValueSchema ndoc a -> ValueSchema doc (Map k a)
map_ (SchemaP NamedSwaggerDoc Value Value ClientId ClientId
-> ValueSchema SwaggerDoc (Set ClientId)
forall ndoc doc a.
(HasArray ndoc doc, HasName ndoc, Ord a) =>
ValueSchema ndoc a -> ValueSchema doc (Set a)
set SchemaP NamedSwaggerDoc Value Value ClientId ClientId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
    where
      addDoc :: b -> b
addDoc b
sch =
        b
sch
          b -> (b -> b) -> b
forall a b. a -> (a -> b) -> b
& (a -> Identity a) -> b -> Identity b
forall s a. HasSchema s a => Lens' s a
Lens' b a
Swagger.schema ((a -> Identity a) -> b -> Identity b)
-> ((Maybe b -> Identity (Maybe b)) -> a -> Identity a)
-> (Maybe b -> Identity (Maybe b))
-> b
-> Identity b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe b -> Identity (Maybe b)) -> a -> Identity a
forall s a. HasDescription s a => Lens' s a
Lens' a (Maybe b)
Swagger.description ((Maybe b -> Identity (Maybe b)) -> b -> Identity b) -> b -> b -> b
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ b
"Map of user id to list of client ids."
          b -> (b -> b) -> b
forall a b. a -> (a -> b) -> b
& (a -> Identity a) -> b -> Identity b
forall s a. HasSchema s a => Lens' s a
Lens' b a
Swagger.schema ((a -> Identity a) -> b -> Identity b)
-> ((Maybe Value -> Identity (Maybe Value)) -> a -> Identity a)
-> (Maybe Value -> Identity (Maybe Value))
-> b
-> Identity b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Value -> Identity (Maybe Value)) -> a -> Identity a
forall s a. HasExample s a => Lens' s a
Lens' a (Maybe Value)
Swagger.example
            ((Maybe Value -> Identity (Maybe Value)) -> b -> Identity b)
-> Value -> b -> b
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Map UserId [ClientId] -> Value
forall a. ToJSON a => a -> Value
toJSON
              ( [(UserId, [ClientId])] -> Map UserId [ClientId]
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
                  [ (forall a. Arbitrary a => a
generateExample @UserId, [Word64 -> ClientId
ClientId Word64
1684636986166846496, Word64 -> ClientId
ClientId Word64
4940483633899001999]),
                    (forall a. Arbitrary a => a
generateExample @UserId, [Word64 -> ClientId
ClientId Word64
6987438498444556166, Word64 -> ClientId
ClientId Word64
7940473633839002939])
                  ]
              )

instance Arbitrary UserClients where
  arbitrary :: Gen UserClients
arbitrary = Map UserId (Set ClientId) -> UserClients
UserClients (Map UserId (Set ClientId) -> UserClients)
-> Gen (Map UserId (Set ClientId)) -> Gen UserClients
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen UserId -> Gen (Set ClientId) -> Gen (Map UserId (Set ClientId))
forall k v. Ord k => Gen k -> Gen v -> Gen (Map k v)
mapOf' Gen UserId
forall a. Arbitrary a => Gen a
arbitrary (Gen ClientId -> Gen (Set ClientId)
forall a. Ord a => Gen a -> Gen (Set a)
setOf' Gen ClientId
forall a. Arbitrary a => Gen a
arbitrary)

filterClients :: (Set ClientId -> Bool) -> UserClients -> UserClients
filterClients :: (Set ClientId -> Bool) -> UserClients -> UserClients
filterClients Set ClientId -> Bool
p (UserClients Map UserId (Set ClientId)
c) = Map UserId (Set ClientId) -> UserClients
UserClients (Map UserId (Set ClientId) -> UserClients)
-> Map UserId (Set ClientId) -> UserClients
forall a b. (a -> b) -> a -> b
$ (Set ClientId -> Bool)
-> Map UserId (Set ClientId) -> Map UserId (Set ClientId)
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter Set ClientId -> Bool
p Map UserId (Set ClientId)
c

filterClientsFull :: (Set Client -> Bool) -> UserClientsFull -> UserClientsFull
filterClientsFull :: (Set Client -> Bool) -> UserClientsFull -> UserClientsFull
filterClientsFull Set Client -> Bool
p (UserClientsFull Map UserId (Set Client)
c) = Map UserId (Set Client) -> UserClientsFull
UserClientsFull (Map UserId (Set Client) -> UserClientsFull)
-> Map UserId (Set Client) -> UserClientsFull
forall a b. (a -> b) -> a -> b
$ (Set Client -> Bool)
-> Map UserId (Set Client) -> Map UserId (Set Client)
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter Set Client -> Bool
p Map UserId (Set Client)
c

newtype QualifiedUserClients = QualifiedUserClients
  { QualifiedUserClients -> Map Domain (Map UserId (Set ClientId))
qualifiedUserClients :: Map Domain (Map UserId (Set ClientId))
  }
  deriving stock (QualifiedUserClients -> QualifiedUserClients -> Bool
(QualifiedUserClients -> QualifiedUserClients -> Bool)
-> (QualifiedUserClients -> QualifiedUserClients -> Bool)
-> Eq QualifiedUserClients
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QualifiedUserClients -> QualifiedUserClients -> Bool
== :: QualifiedUserClients -> QualifiedUserClients -> Bool
$c/= :: QualifiedUserClients -> QualifiedUserClients -> Bool
/= :: QualifiedUserClients -> QualifiedUserClients -> Bool
Eq, Int -> QualifiedUserClients -> ShowS
[QualifiedUserClients] -> ShowS
QualifiedUserClients -> [Char]
(Int -> QualifiedUserClients -> ShowS)
-> (QualifiedUserClients -> [Char])
-> ([QualifiedUserClients] -> ShowS)
-> Show QualifiedUserClients
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> QualifiedUserClients -> ShowS
showsPrec :: Int -> QualifiedUserClients -> ShowS
$cshow :: QualifiedUserClients -> [Char]
show :: QualifiedUserClients -> [Char]
$cshowList :: [QualifiedUserClients] -> ShowS
showList :: [QualifiedUserClients] -> ShowS
Show, (forall x. QualifiedUserClients -> Rep QualifiedUserClients x)
-> (forall x. Rep QualifiedUserClients x -> QualifiedUserClients)
-> Generic QualifiedUserClients
forall x. Rep QualifiedUserClients x -> QualifiedUserClients
forall x. QualifiedUserClients -> Rep QualifiedUserClients x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. QualifiedUserClients -> Rep QualifiedUserClients x
from :: forall x. QualifiedUserClients -> Rep QualifiedUserClients x
$cto :: forall x. Rep QualifiedUserClients x -> QualifiedUserClients
to :: forall x. Rep QualifiedUserClients x -> QualifiedUserClients
Generic)
  deriving (Value -> Parser [QualifiedUserClients]
Value -> Parser QualifiedUserClients
(Value -> Parser QualifiedUserClients)
-> (Value -> Parser [QualifiedUserClients])
-> FromJSON QualifiedUserClients
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser QualifiedUserClients
parseJSON :: Value -> Parser QualifiedUserClients
$cparseJSONList :: Value -> Parser [QualifiedUserClients]
parseJSONList :: Value -> Parser [QualifiedUserClients]
FromJSON, [QualifiedUserClients] -> Value
[QualifiedUserClients] -> Encoding
QualifiedUserClients -> Value
QualifiedUserClients -> Encoding
(QualifiedUserClients -> Value)
-> (QualifiedUserClients -> Encoding)
-> ([QualifiedUserClients] -> Value)
-> ([QualifiedUserClients] -> Encoding)
-> ToJSON QualifiedUserClients
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: QualifiedUserClients -> Value
toJSON :: QualifiedUserClients -> Value
$ctoEncoding :: QualifiedUserClients -> Encoding
toEncoding :: QualifiedUserClients -> Encoding
$ctoJSONList :: [QualifiedUserClients] -> Value
toJSONList :: [QualifiedUserClients] -> Value
$ctoEncodingList :: [QualifiedUserClients] -> Encoding
toEncodingList :: [QualifiedUserClients] -> Encoding
ToJSON, Typeable QualifiedUserClients
Typeable QualifiedUserClients =>
(Proxy QualifiedUserClients
 -> Declare (Definitions Schema) NamedSchema)
-> ToSchema QualifiedUserClients
Proxy QualifiedUserClients
-> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy QualifiedUserClients
-> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy QualifiedUserClients
-> Declare (Definitions Schema) NamedSchema
Swagger.ToSchema) via (Schema QualifiedUserClients)

instance Semigroup QualifiedUserClients where
  (QualifiedUserClients Map Domain (Map UserId (Set ClientId))
m1) <> :: QualifiedUserClients
-> QualifiedUserClients -> QualifiedUserClients
<> (QualifiedUserClients Map Domain (Map UserId (Set ClientId))
m2) =
    Map Domain (Map UserId (Set ClientId)) -> QualifiedUserClients
QualifiedUserClients (Map Domain (Map UserId (Set ClientId)) -> QualifiedUserClients)
-> Map Domain (Map UserId (Set ClientId)) -> QualifiedUserClients
forall a b. (a -> b) -> a -> b
$ (Map UserId (Set ClientId)
 -> Map UserId (Set ClientId) -> Map UserId (Set ClientId))
-> Map Domain (Map UserId (Set ClientId))
-> Map Domain (Map UserId (Set ClientId))
-> Map Domain (Map UserId (Set ClientId))
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith ((Set ClientId -> Set ClientId -> Set ClientId)
-> Map UserId (Set ClientId)
-> Map UserId (Set ClientId)
-> Map UserId (Set ClientId)
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith Set ClientId -> Set ClientId -> Set ClientId
forall a. Semigroup a => a -> a -> a
(<>)) Map Domain (Map UserId (Set ClientId))
m1 Map Domain (Map UserId (Set ClientId))
m2

instance Monoid QualifiedUserClients where
  mempty :: QualifiedUserClients
mempty = Map Domain (Map UserId (Set ClientId)) -> QualifiedUserClients
QualifiedUserClients Map Domain (Map UserId (Set ClientId))
forall a. Monoid a => a
mempty

instance Arbitrary QualifiedUserClients where
  arbitrary :: Gen QualifiedUserClients
arbitrary = Map Domain (Map UserId (Set ClientId)) -> QualifiedUserClients
QualifiedUserClients (Map Domain (Map UserId (Set ClientId)) -> QualifiedUserClients)
-> Gen (Map Domain (Map UserId (Set ClientId)))
-> Gen QualifiedUserClients
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Domain
-> Gen (Map UserId (Set ClientId))
-> Gen (Map Domain (Map UserId (Set ClientId)))
forall k v. Ord k => Gen k -> Gen v -> Gen (Map k v)
mapOf' Gen Domain
forall a. Arbitrary a => Gen a
arbitrary (Gen UserId -> Gen (Set ClientId) -> Gen (Map UserId (Set ClientId))
forall k v. Ord k => Gen k -> Gen v -> Gen (Map k v)
mapOf' Gen UserId
forall a. Arbitrary a => Gen a
arbitrary (Gen ClientId -> Gen (Set ClientId)
forall a. Ord a => Gen a -> Gen (Set a)
setOf' Gen ClientId
forall a. Arbitrary a => Gen a
arbitrary))

qualifiedUserClientsValueSchema :: ValueSchema SwaggerDoc QualifiedUserClients
qualifiedUserClientsValueSchema :: ValueSchema SwaggerDoc QualifiedUserClients
qualifiedUserClientsValueSchema =
  Map Domain (Map UserId (Set ClientId)) -> QualifiedUserClients
QualifiedUserClients (Map Domain (Map UserId (Set ClientId)) -> QualifiedUserClients)
-> SchemaP
     SwaggerDoc
     Value
     Value
     QualifiedUserClients
     (Map Domain (Map UserId (Set ClientId)))
-> ValueSchema SwaggerDoc QualifiedUserClients
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> QualifiedUserClients -> Map Domain (Map UserId (Set ClientId))
qualifiedUserClients (QualifiedUserClients -> Map Domain (Map UserId (Set ClientId)))
-> SchemaP
     SwaggerDoc
     Value
     Value
     (Map Domain (Map UserId (Set ClientId)))
     (Map Domain (Map UserId (Set ClientId)))
-> SchemaP
     SwaggerDoc
     Value
     Value
     QualifiedUserClients
     (Map Domain (Map UserId (Set ClientId)))
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP
  SwaggerDoc
  Value
  Value
  (Map UserId (Set ClientId))
  (Map UserId (Set ClientId))
-> SchemaP
     SwaggerDoc
     Value
     Value
     (Map Domain (Map UserId (Set ClientId)))
     (Map Domain (Map UserId (Set ClientId)))
forall ndoc doc k a.
(HasMap ndoc doc, Ord k, FromJSONKey k, ToJSONKey k) =>
ValueSchema ndoc a -> ValueSchema doc (Map k a)
map_ (ValueSchema SwaggerDoc (Set ClientId)
-> SchemaP
     SwaggerDoc
     Value
     Value
     (Map UserId (Set ClientId))
     (Map UserId (Set ClientId))
forall ndoc doc k a.
(HasMap ndoc doc, Ord k, FromJSONKey k, ToJSONKey k) =>
ValueSchema ndoc a -> ValueSchema doc (Map k a)
map_ (SchemaP NamedSwaggerDoc Value Value ClientId ClientId
-> ValueSchema SwaggerDoc (Set ClientId)
forall ndoc doc a.
(HasArray ndoc doc, HasName ndoc, Ord a) =>
ValueSchema ndoc a -> ValueSchema doc (Set a)
set SchemaP NamedSwaggerDoc Value Value ClientId ClientId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema))

instance ToSchema QualifiedUserClients where
  schema :: ValueSchema NamedSwaggerDoc QualifiedUserClients
schema =
    ValueSchema NamedSwaggerDoc QualifiedUserClients
-> ValueSchema NamedSwaggerDoc QualifiedUserClients
forall {a} {b} {b}.
(HasExample a (Maybe Value), HasDescription a (Maybe b),
 IsString b, HasSchema b a) =>
b -> b
addDoc (ValueSchema NamedSwaggerDoc QualifiedUserClients
 -> ValueSchema NamedSwaggerDoc QualifiedUserClients)
-> (ValueSchema SwaggerDoc QualifiedUserClients
    -> ValueSchema NamedSwaggerDoc QualifiedUserClients)
-> ValueSchema SwaggerDoc QualifiedUserClients
-> ValueSchema NamedSwaggerDoc QualifiedUserClients
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text
-> ValueSchema SwaggerDoc QualifiedUserClients
-> ValueSchema NamedSwaggerDoc QualifiedUserClients
forall doc doc' v m a b.
HasObject doc doc' =>
Text -> SchemaP doc v m a b -> SchemaP doc' v m a b
named Text
"QualifiedUserClients" (ValueSchema SwaggerDoc QualifiedUserClients
 -> ValueSchema NamedSwaggerDoc QualifiedUserClients)
-> ValueSchema SwaggerDoc QualifiedUserClients
-> ValueSchema NamedSwaggerDoc QualifiedUserClients
forall a b. (a -> b) -> a -> b
$ ValueSchema SwaggerDoc QualifiedUserClients
qualifiedUserClientsValueSchema
    where
      addDoc :: b -> b
addDoc b
sch =
        b
sch
          b -> (b -> b) -> b
forall a b. a -> (a -> b) -> b
& (a -> Identity a) -> b -> Identity b
forall s a. HasSchema s a => Lens' s a
Lens' b a
Swagger.schema ((a -> Identity a) -> b -> Identity b)
-> ((Maybe b -> Identity (Maybe b)) -> a -> Identity a)
-> (Maybe b -> Identity (Maybe b))
-> b
-> Identity b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe b -> Identity (Maybe b)) -> a -> Identity a
forall s a. HasDescription s a => Lens' s a
Lens' a (Maybe b)
Swagger.description ((Maybe b -> Identity (Maybe b)) -> b -> Identity b) -> b -> b -> b
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ b
"Map of Domain to UserClients"
          b -> (b -> b) -> b
forall a b. a -> (a -> b) -> b
& (a -> Identity a) -> b -> Identity b
forall s a. HasSchema s a => Lens' s a
Lens' b a
Swagger.schema ((a -> Identity a) -> b -> Identity b)
-> ((Maybe Value -> Identity (Maybe Value)) -> a -> Identity a)
-> (Maybe Value -> Identity (Maybe Value))
-> b
-> Identity b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Value -> Identity (Maybe Value)) -> a -> Identity a
forall s a. HasExample s a => Lens' s a
Lens' a (Maybe Value)
Swagger.example
            ((Maybe Value -> Identity (Maybe Value)) -> b -> Identity b)
-> Value -> b -> b
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Map Text (Maybe Value) -> Value
forall a. ToJSON a => a -> Value
toJSON
              ( Text -> Maybe Value -> Map Text (Maybe Value)
forall k a. k -> a -> Map k a
Map.singleton
                  (Text
"domain1.example.com" :: Text)
                  (Getting
  (Maybe Value)
  (ValueSchema NamedSwaggerDoc UserClients)
  (Maybe Value)
-> ValueSchema NamedSwaggerDoc UserClients -> Maybe Value
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view ((Schema -> Const (Maybe Value) Schema)
-> ValueSchema NamedSwaggerDoc UserClients
-> Const (Maybe Value) (ValueSchema NamedSwaggerDoc UserClients)
forall s a. HasSchema s a => Lens' s a
Lens' (ValueSchema NamedSwaggerDoc UserClients) Schema
Swagger.schema ((Schema -> Const (Maybe Value) Schema)
 -> ValueSchema NamedSwaggerDoc UserClients
 -> Const (Maybe Value) (ValueSchema NamedSwaggerDoc UserClients))
-> ((Maybe Value -> Const (Maybe Value) (Maybe Value))
    -> Schema -> Const (Maybe Value) Schema)
-> Getting
     (Maybe Value)
     (ValueSchema NamedSwaggerDoc UserClients)
     (Maybe Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Value -> Const (Maybe Value) (Maybe Value))
-> Schema -> Const (Maybe Value) Schema
forall s a. HasExample s a => Lens' s a
Lens' Schema (Maybe Value)
Swagger.example) (forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema @UserClients))
              )

--------------------------------------------------------------------------------
-- Client

data Client = Client
  { Client -> ClientId
clientId :: ClientId,
    Client -> ClientType
clientType :: ClientType,
    Client -> UTCTimeMillis
clientTime :: UTCTimeMillis,
    Client -> Maybe ClientClass
clientClass :: Maybe ClientClass,
    Client -> Maybe Text
clientLabel :: Maybe Text,
    Client -> Maybe CookieLabel
clientCookie :: Maybe CookieLabel,
    Client -> Maybe Text
clientModel :: Maybe Text,
    Client -> ClientCapabilityList
clientCapabilities :: ClientCapabilityList,
    Client -> MLSPublicKeys
clientMLSPublicKeys :: MLSPublicKeys,
    Client -> Maybe UTCTime
clientLastActive :: Maybe UTCTime
  }
  deriving stock (Client -> Client -> Bool
(Client -> Client -> Bool)
-> (Client -> Client -> Bool) -> Eq Client
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Client -> Client -> Bool
== :: Client -> Client -> Bool
$c/= :: Client -> Client -> Bool
/= :: Client -> Client -> Bool
Eq, Int -> Client -> ShowS
[Client] -> ShowS
Client -> [Char]
(Int -> Client -> ShowS)
-> (Client -> [Char]) -> ([Client] -> ShowS) -> Show Client
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Client -> ShowS
showsPrec :: Int -> Client -> ShowS
$cshow :: Client -> [Char]
show :: Client -> [Char]
$cshowList :: [Client] -> ShowS
showList :: [Client] -> ShowS
Show, (forall x. Client -> Rep Client x)
-> (forall x. Rep Client x -> Client) -> Generic Client
forall x. Rep Client x -> Client
forall x. Client -> Rep Client x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Client -> Rep Client x
from :: forall x. Client -> Rep Client x
$cto :: forall x. Rep Client x -> Client
to :: forall x. Rep Client x -> Client
Generic, Eq Client
Eq Client =>
(Client -> Client -> Ordering)
-> (Client -> Client -> Bool)
-> (Client -> Client -> Bool)
-> (Client -> Client -> Bool)
-> (Client -> Client -> Bool)
-> (Client -> Client -> Client)
-> (Client -> Client -> Client)
-> Ord Client
Client -> Client -> Bool
Client -> Client -> Ordering
Client -> Client -> Client
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 :: Client -> Client -> Ordering
compare :: Client -> Client -> Ordering
$c< :: Client -> Client -> Bool
< :: Client -> Client -> Bool
$c<= :: Client -> Client -> Bool
<= :: Client -> Client -> Bool
$c> :: Client -> Client -> Bool
> :: Client -> Client -> Bool
$c>= :: Client -> Client -> Bool
>= :: Client -> Client -> Bool
$cmax :: Client -> Client -> Client
max :: Client -> Client -> Client
$cmin :: Client -> Client -> Client
min :: Client -> Client -> Client
Ord)
  deriving (Gen Client
Gen Client -> (Client -> [Client]) -> Arbitrary Client
Client -> [Client]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen Client
arbitrary :: Gen Client
$cshrink :: Client -> [Client]
shrink :: Client -> [Client]
Arbitrary) via (GenericUniform Client)
  deriving (Value -> Parser [Client]
Value -> Parser Client
(Value -> Parser Client)
-> (Value -> Parser [Client]) -> FromJSON Client
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser Client
parseJSON :: Value -> Parser Client
$cparseJSONList :: Value -> Parser [Client]
parseJSONList :: Value -> Parser [Client]
FromJSON, [Client] -> Value
[Client] -> Encoding
Client -> Value
Client -> Encoding
(Client -> Value)
-> (Client -> Encoding)
-> ([Client] -> Value)
-> ([Client] -> Encoding)
-> ToJSON Client
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: Client -> Value
toJSON :: Client -> Value
$ctoEncoding :: Client -> Encoding
toEncoding :: Client -> Encoding
$ctoJSONList :: [Client] -> Value
toJSONList :: [Client] -> Value
$ctoEncodingList :: [Client] -> Encoding
toEncodingList :: [Client] -> Encoding
ToJSON, Typeable Client
Typeable Client =>
(Proxy Client -> Declare (Definitions Schema) NamedSchema)
-> ToSchema Client
Proxy Client -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy Client -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy Client -> Declare (Definitions Schema) NamedSchema
Swagger.ToSchema) via Schema Client

type MLSPublicKeys = Map SignatureSchemeTag ByteString

mlsPublicKeysSchema :: ValueSchema NamedSwaggerDoc MLSPublicKeys
mlsPublicKeysSchema :: ValueSchema NamedSwaggerDoc MLSPublicKeys
mlsPublicKeysSchema =
  ValueSchema SwaggerDoc MLSPublicKeys
mapSchema
    ValueSchema SwaggerDoc MLSPublicKeys
-> (ValueSchema SwaggerDoc MLSPublicKeys
    -> ValueSchema SwaggerDoc MLSPublicKeys)
-> ValueSchema SwaggerDoc MLSPublicKeys
forall a b. a -> (a -> b) -> b
& (SwaggerDoc -> Identity SwaggerDoc)
-> ValueSchema SwaggerDoc MLSPublicKeys
-> Identity (ValueSchema SwaggerDoc MLSPublicKeys)
forall a a' doc doc'. HasDoc a a' doc doc' => Lens a a' doc doc'
Lens
  (ValueSchema SwaggerDoc MLSPublicKeys)
  (ValueSchema SwaggerDoc MLSPublicKeys)
  SwaggerDoc
  SwaggerDoc
doc
      ((SwaggerDoc -> Identity SwaggerDoc)
 -> ValueSchema SwaggerDoc MLSPublicKeys
 -> Identity (ValueSchema SwaggerDoc MLSPublicKeys))
-> (SwaggerDoc -> SwaggerDoc)
-> ValueSchema SwaggerDoc MLSPublicKeys
-> ValueSchema SwaggerDoc MLSPublicKeys
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ ( ((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
"Mapping from signature scheme (tags) to public key data")
             (SwaggerDoc -> SwaggerDoc)
-> (SwaggerDoc -> SwaggerDoc) -> SwaggerDoc -> SwaggerDoc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Maybe Value -> Identity (Maybe Value))
-> SwaggerDoc -> Identity SwaggerDoc
forall s a. HasExample s a => Lens' s a
Lens' SwaggerDoc (Maybe Value)
example ((Maybe Value -> Identity (Maybe Value))
 -> SwaggerDoc -> Identity SwaggerDoc)
-> Value -> SwaggerDoc -> SwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Map SignatureSchemeTag Value -> Value
forall a. ToJSON a => a -> Value
toJSON ([(SignatureSchemeTag, Value)] -> Map SignatureSchemeTag Value
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(SignatureSchemeTag, Value)] -> Map SignatureSchemeTag Value)
-> [(SignatureSchemeTag, Value)] -> Map SignatureSchemeTag Value
forall a b. (a -> b) -> a -> b
$ (SignatureSchemeTag -> (SignatureSchemeTag, Value))
-> [SignatureSchemeTag] -> [(SignatureSchemeTag, Value)]
forall a b. (a -> b) -> [a] -> [b]
map (,Value
exampleValue) [SignatureSchemeTag]
keys))
         )
    ValueSchema SwaggerDoc MLSPublicKeys
-> (ValueSchema SwaggerDoc MLSPublicKeys
    -> ValueSchema NamedSwaggerDoc MLSPublicKeys)
-> ValueSchema NamedSwaggerDoc MLSPublicKeys
forall a b. a -> (a -> b) -> b
& Text
-> ValueSchema SwaggerDoc MLSPublicKeys
-> ValueSchema NamedSwaggerDoc MLSPublicKeys
forall doc doc' v m a b.
HasObject doc doc' =>
Text -> SchemaP doc v m a b -> SchemaP doc' v m a b
named Text
"MLSPublicKeys"
  where
    keys :: [SignatureSchemeTag]
    keys :: [SignatureSchemeTag]
keys = [SignatureSchemeTag
forall a. Bounded a => a
minBound .. SignatureSchemeTag
forall a. Bounded a => a
maxBound]

    exampleValue :: A.Value
    exampleValue :: Value
exampleValue = Value -> Maybe Value -> Value
forall a. a -> Maybe a -> a
fromMaybe (Text -> Value
forall a. ToJSON a => a -> Value
toJSON (Text
"base64==" :: Text)) (ValueSchema SwaggerDoc ByteString
base64Schema ValueSchema SwaggerDoc ByteString
-> Getting
     (Maybe Value) (ValueSchema SwaggerDoc ByteString) (Maybe Value)
-> Maybe Value
forall s a. s -> Getting a s a -> a
^. (SwaggerDoc -> Const (Maybe Value) SwaggerDoc)
-> ValueSchema SwaggerDoc ByteString
-> Const (Maybe Value) (ValueSchema SwaggerDoc ByteString)
forall a a' doc doc'. HasDoc a a' doc doc' => Lens a a' doc doc'
Lens
  (ValueSchema SwaggerDoc ByteString)
  (ValueSchema SwaggerDoc ByteString)
  SwaggerDoc
  SwaggerDoc
doc ((SwaggerDoc -> Const (Maybe Value) SwaggerDoc)
 -> ValueSchema SwaggerDoc ByteString
 -> Const (Maybe Value) (ValueSchema SwaggerDoc ByteString))
-> ((Maybe Value -> Const (Maybe Value) (Maybe Value))
    -> SwaggerDoc -> Const (Maybe Value) SwaggerDoc)
-> Getting
     (Maybe Value) (ValueSchema SwaggerDoc ByteString) (Maybe Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Value -> Const (Maybe Value) (Maybe Value))
-> SwaggerDoc -> Const (Maybe Value) SwaggerDoc
forall s a. HasExample s a => Lens' s a
Lens' SwaggerDoc (Maybe Value)
example)

    mapSchema :: ValueSchema SwaggerDoc MLSPublicKeys
    mapSchema :: ValueSchema SwaggerDoc MLSPublicKeys
mapSchema = ValueSchema SwaggerDoc ByteString
-> ValueSchema SwaggerDoc MLSPublicKeys
forall ndoc doc k a.
(HasMap ndoc doc, Ord k, FromJSONKey k, ToJSONKey k) =>
ValueSchema ndoc a -> ValueSchema doc (Map k a)
map_ ValueSchema SwaggerDoc ByteString
base64Schema

clientSchema :: Maybe Version -> ValueSchema NamedSwaggerDoc Client
clientSchema :: Maybe Version -> ValueSchema NamedSwaggerDoc Client
clientSchema Maybe Version
mVersion =
  Text
-> SchemaP SwaggerDoc Object [Pair] Client Client
-> ValueSchema NamedSwaggerDoc Client
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"Client" (SchemaP SwaggerDoc Object [Pair] Client Client
 -> ValueSchema NamedSwaggerDoc Client)
-> SchemaP SwaggerDoc Object [Pair] Client Client
-> ValueSchema NamedSwaggerDoc Client
forall a b. (a -> b) -> a -> b
$
    ClientId
-> ClientType
-> UTCTimeMillis
-> Maybe ClientClass
-> Maybe Text
-> Maybe CookieLabel
-> Maybe Text
-> ClientCapabilityList
-> MLSPublicKeys
-> Maybe UTCTime
-> Client
Client
      (ClientId
 -> ClientType
 -> UTCTimeMillis
 -> Maybe ClientClass
 -> Maybe Text
 -> Maybe CookieLabel
 -> Maybe Text
 -> ClientCapabilityList
 -> MLSPublicKeys
 -> Maybe UTCTime
 -> Client)
-> SchemaP SwaggerDoc Object [Pair] Client ClientId
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     Client
     (ClientType
      -> UTCTimeMillis
      -> Maybe ClientClass
      -> Maybe Text
      -> Maybe CookieLabel
      -> Maybe Text
      -> ClientCapabilityList
      -> MLSPublicKeys
      -> Maybe UTCTime
      -> Client)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Client -> ClientId
clientId (Client -> ClientId)
-> SchemaP SwaggerDoc Object [Pair] ClientId ClientId
-> SchemaP SwaggerDoc Object [Pair] Client 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
"id" SchemaP NamedSwaggerDoc Value Value ClientId ClientId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
      SchemaP
  SwaggerDoc
  Object
  [Pair]
  Client
  (ClientType
   -> UTCTimeMillis
   -> Maybe ClientClass
   -> Maybe Text
   -> Maybe CookieLabel
   -> Maybe Text
   -> ClientCapabilityList
   -> MLSPublicKeys
   -> Maybe UTCTime
   -> Client)
-> SchemaP SwaggerDoc Object [Pair] Client ClientType
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     Client
     (UTCTimeMillis
      -> Maybe ClientClass
      -> Maybe Text
      -> Maybe CookieLabel
      -> Maybe Text
      -> ClientCapabilityList
      -> MLSPublicKeys
      -> Maybe UTCTime
      -> Client)
forall a b.
SchemaP SwaggerDoc Object [Pair] Client (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Client a
-> SchemaP SwaggerDoc Object [Pair] Client b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Client -> ClientType
clientType (Client -> ClientType)
-> SchemaP SwaggerDoc Object [Pair] ClientType ClientType
-> SchemaP SwaggerDoc Object [Pair] Client ClientType
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value ClientType ClientType
-> SchemaP SwaggerDoc Object [Pair] ClientType ClientType
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"type" SchemaP NamedSwaggerDoc Value Value ClientType ClientType
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
      SchemaP
  SwaggerDoc
  Object
  [Pair]
  Client
  (UTCTimeMillis
   -> Maybe ClientClass
   -> Maybe Text
   -> Maybe CookieLabel
   -> Maybe Text
   -> ClientCapabilityList
   -> MLSPublicKeys
   -> Maybe UTCTime
   -> Client)
-> SchemaP SwaggerDoc Object [Pair] Client UTCTimeMillis
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     Client
     (Maybe ClientClass
      -> Maybe Text
      -> Maybe CookieLabel
      -> Maybe Text
      -> ClientCapabilityList
      -> MLSPublicKeys
      -> Maybe UTCTime
      -> Client)
forall a b.
SchemaP SwaggerDoc Object [Pair] Client (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Client a
-> SchemaP SwaggerDoc Object [Pair] Client b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Client -> UTCTimeMillis
clientTime (Client -> UTCTimeMillis)
-> SchemaP SwaggerDoc Object [Pair] UTCTimeMillis UTCTimeMillis
-> SchemaP SwaggerDoc Object [Pair] Client UTCTimeMillis
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value UTCTimeMillis UTCTimeMillis
-> SchemaP SwaggerDoc Object [Pair] UTCTimeMillis UTCTimeMillis
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"time" SchemaP NamedSwaggerDoc Value Value UTCTimeMillis UTCTimeMillis
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
      SchemaP
  SwaggerDoc
  Object
  [Pair]
  Client
  (Maybe ClientClass
   -> Maybe Text
   -> Maybe CookieLabel
   -> Maybe Text
   -> ClientCapabilityList
   -> MLSPublicKeys
   -> Maybe UTCTime
   -> Client)
-> SchemaP SwaggerDoc Object [Pair] Client (Maybe ClientClass)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     Client
     (Maybe Text
      -> Maybe CookieLabel
      -> Maybe Text
      -> ClientCapabilityList
      -> MLSPublicKeys
      -> Maybe UTCTime
      -> Client)
forall a b.
SchemaP SwaggerDoc Object [Pair] Client (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Client a
-> SchemaP SwaggerDoc Object [Pair] Client b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Client -> Maybe ClientClass
clientClass (Client -> Maybe ClientClass)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe ClientClass) (Maybe ClientClass)
-> SchemaP SwaggerDoc Object [Pair] Client (Maybe ClientClass)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] ClientClass (Maybe ClientClass)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe ClientClass) (Maybe ClientClass)
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 ClientClass ClientClass
-> SchemaP SwaggerDoc Object [Pair] ClientClass (Maybe ClientClass)
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
"class" SchemaP NamedSwaggerDoc Value Value ClientClass ClientClass
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
      SchemaP
  SwaggerDoc
  Object
  [Pair]
  Client
  (Maybe Text
   -> Maybe CookieLabel
   -> Maybe Text
   -> ClientCapabilityList
   -> MLSPublicKeys
   -> Maybe UTCTime
   -> Client)
-> SchemaP SwaggerDoc Object [Pair] Client (Maybe Text)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     Client
     (Maybe CookieLabel
      -> Maybe Text
      -> ClientCapabilityList
      -> MLSPublicKeys
      -> Maybe UTCTime
      -> Client)
forall a b.
SchemaP SwaggerDoc Object [Pair] Client (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Client a
-> SchemaP SwaggerDoc Object [Pair] Client b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Client -> Maybe Text
clientLabel (Client -> Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] Client (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
"label" SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
      SchemaP
  SwaggerDoc
  Object
  [Pair]
  Client
  (Maybe CookieLabel
   -> Maybe Text
   -> ClientCapabilityList
   -> MLSPublicKeys
   -> Maybe UTCTime
   -> Client)
-> SchemaP SwaggerDoc Object [Pair] Client (Maybe CookieLabel)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     Client
     (Maybe Text
      -> ClientCapabilityList
      -> MLSPublicKeys
      -> Maybe UTCTime
      -> Client)
forall a b.
SchemaP SwaggerDoc Object [Pair] Client (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Client a
-> SchemaP SwaggerDoc Object [Pair] Client b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Client -> Maybe CookieLabel
clientCookie (Client -> Maybe CookieLabel)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe CookieLabel) (Maybe CookieLabel)
-> SchemaP SwaggerDoc Object [Pair] Client (Maybe CookieLabel)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] CookieLabel (Maybe CookieLabel)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe CookieLabel) (Maybe CookieLabel)
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 CookieLabel CookieLabel
-> SchemaP SwaggerDoc Object [Pair] CookieLabel (Maybe CookieLabel)
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
"cookie" SchemaP NamedSwaggerDoc Value Value CookieLabel CookieLabel
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
      SchemaP
  SwaggerDoc
  Object
  [Pair]
  Client
  (Maybe Text
   -> ClientCapabilityList
   -> MLSPublicKeys
   -> Maybe UTCTime
   -> Client)
-> SchemaP SwaggerDoc Object [Pair] Client (Maybe Text)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     Client
     (ClientCapabilityList -> MLSPublicKeys -> Maybe UTCTime -> Client)
forall a b.
SchemaP SwaggerDoc Object [Pair] Client (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Client a
-> SchemaP SwaggerDoc Object [Pair] Client b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Client -> Maybe Text
clientModel (Client -> Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] Client (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
"model" SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
      SchemaP
  SwaggerDoc
  Object
  [Pair]
  Client
  (ClientCapabilityList -> MLSPublicKeys -> Maybe UTCTime -> Client)
-> SchemaP SwaggerDoc Object [Pair] Client ClientCapabilityList
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     Client
     (MLSPublicKeys -> Maybe UTCTime -> Client)
forall a b.
SchemaP SwaggerDoc Object [Pair] Client (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Client a
-> SchemaP SwaggerDoc Object [Pair] Client b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Client -> ClientCapabilityList
clientCapabilities (Client -> ClientCapabilityList)
-> SchemaP
     SwaggerDoc Object [Pair] ClientCapabilityList ClientCapabilityList
-> SchemaP SwaggerDoc Object [Pair] Client ClientCapabilityList
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= (ClientCapabilityList
-> Maybe ClientCapabilityList -> ClientCapabilityList
forall a. a -> Maybe a -> a
fromMaybe ClientCapabilityList
forall a. Monoid a => a
mempty (Maybe ClientCapabilityList -> ClientCapabilityList)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     ClientCapabilityList
     (Maybe ClientCapabilityList)
-> SchemaP
     SwaggerDoc Object [Pair] ClientCapabilityList ClientCapabilityList
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> ValueSchema NamedSwaggerDoc ClientCapabilityList
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     ClientCapabilityList
     (Maybe ClientCapabilityList)
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
"capabilities" ValueSchema NamedSwaggerDoc ClientCapabilityList
caps)
      SchemaP
  SwaggerDoc
  Object
  [Pair]
  Client
  (MLSPublicKeys -> Maybe UTCTime -> Client)
-> SchemaP SwaggerDoc Object [Pair] Client MLSPublicKeys
-> SchemaP
     SwaggerDoc Object [Pair] Client (Maybe UTCTime -> Client)
forall a b.
SchemaP SwaggerDoc Object [Pair] Client (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Client a
-> SchemaP SwaggerDoc Object [Pair] Client b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Client -> MLSPublicKeys
clientMLSPublicKeys (Client -> MLSPublicKeys)
-> SchemaP SwaggerDoc Object [Pair] MLSPublicKeys MLSPublicKeys
-> SchemaP SwaggerDoc Object [Pair] Client MLSPublicKeys
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] MLSPublicKeys MLSPublicKeys
mlsPublicKeysFieldSchema
      SchemaP SwaggerDoc Object [Pair] Client (Maybe UTCTime -> Client)
-> SchemaP SwaggerDoc Object [Pair] Client (Maybe UTCTime)
-> SchemaP SwaggerDoc Object [Pair] Client Client
forall a b.
SchemaP SwaggerDoc Object [Pair] Client (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Client a
-> SchemaP SwaggerDoc Object [Pair] Client b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Client -> Maybe UTCTime
clientLastActive (Client -> Maybe UTCTime)
-> SchemaP SwaggerDoc Object [Pair] (Maybe UTCTime) (Maybe UTCTime)
-> SchemaP SwaggerDoc Object [Pair] Client (Maybe UTCTime)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] UTCTime (Maybe UTCTime)
-> SchemaP SwaggerDoc Object [Pair] (Maybe UTCTime) (Maybe UTCTime)
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 UTCTime UTCTime
-> SchemaP SwaggerDoc Object [Pair] UTCTime (Maybe UTCTime)
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
"last_active" SchemaP NamedSwaggerDoc Value Value UTCTime UTCTime
utcTimeSchema)
  where
    caps :: ValueSchema NamedSwaggerDoc ClientCapabilityList
    caps :: ValueSchema NamedSwaggerDoc ClientCapabilityList
caps = case Maybe Version
mVersion of
      -- broken capability serialisation for backwards compatibility
      Just Version
v
        | Version
v Version -> Version -> Bool
forall a. Ord a => a -> a -> Bool
<= Version
V6 ->
            (ClientCapabilityList -> Versioned 'V6 ClientCapabilityList)
-> (Versioned 'V6 ClientCapabilityList -> ClientCapabilityList)
-> ValueSchema NamedSwaggerDoc (Versioned 'V6 ClientCapabilityList)
-> ValueSchema NamedSwaggerDoc ClientCapabilityList
forall a b c d.
(a -> b)
-> (c -> d)
-> SchemaP NamedSwaggerDoc Value Value b c
-> SchemaP NamedSwaggerDoc Value Value a d
forall (p :: * -> * -> *) a b c d.
Profunctor p =>
(a -> b) -> (c -> d) -> p b c -> p a d
dimap ClientCapabilityList -> Versioned 'V6 ClientCapabilityList
forall (v :: Version) a. a -> Versioned v a
Versioned Versioned 'V6 ClientCapabilityList -> ClientCapabilityList
forall (v :: Version) a. Versioned v a -> a
unVersioned (ValueSchema NamedSwaggerDoc (Versioned 'V6 ClientCapabilityList)
 -> ValueSchema NamedSwaggerDoc ClientCapabilityList)
-> ValueSchema NamedSwaggerDoc (Versioned 'V6 ClientCapabilityList)
-> ValueSchema NamedSwaggerDoc ClientCapabilityList
forall a b. (a -> b) -> a -> b
$ forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema @(Versioned V6 ClientCapabilityList)
      Maybe Version
_ -> forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema @ClientCapabilityList

instance ToSchema Client where
  schema :: ValueSchema NamedSwaggerDoc Client
schema = Maybe Version -> ValueSchema NamedSwaggerDoc Client
clientSchema Maybe Version
forall a. Maybe a
Nothing

instance ToSchema (Versioned 'V6 Client) where
  schema :: ValueSchema NamedSwaggerDoc (Versioned 'V6 Client)
schema = Client -> Versioned 'V6 Client
forall (v :: Version) a. a -> Versioned v a
Versioned (Client -> Versioned 'V6 Client)
-> SchemaP
     NamedSwaggerDoc Value Value (Versioned 'V6 Client) Client
-> ValueSchema NamedSwaggerDoc (Versioned 'V6 Client)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Versioned 'V6 Client -> Client
forall (v :: Version) a. Versioned v a -> a
unVersioned (Versioned 'V6 Client -> Client)
-> ValueSchema NamedSwaggerDoc Client
-> SchemaP
     NamedSwaggerDoc Value Value (Versioned 'V6 Client) Client
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Maybe Version -> ValueSchema NamedSwaggerDoc Client
clientSchema (Version -> Maybe Version
forall a. a -> Maybe a
Just Version
V6)

instance {-# OVERLAPPING #-} ToSchema (Versioned 'V6 [Client]) where
  schema :: ValueSchema NamedSwaggerDoc (Versioned 'V6 [Client])
schema =
    [Client] -> Versioned 'V6 [Client]
forall (v :: Version) a. a -> Versioned v a
Versioned
      ([Client] -> Versioned 'V6 [Client])
-> SchemaP
     NamedSwaggerDoc Value Value (Versioned 'V6 [Client]) [Client]
-> ValueSchema NamedSwaggerDoc (Versioned 'V6 [Client])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Versioned 'V6 [Client] -> [Client]
forall (v :: Version) a. Versioned v a -> a
unVersioned
        (Versioned 'V6 [Client] -> [Client])
-> SchemaP NamedSwaggerDoc Value Value [Client] [Client]
-> SchemaP
     NamedSwaggerDoc Value Value (Versioned 'V6 [Client]) [Client]
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP SwaggerDoc Value Value [Client] [Client]
-> SchemaP NamedSwaggerDoc Value Value [Client] [Client]
forall doc doc' v m a b.
HasObject doc doc' =>
Text -> SchemaP doc v m a b -> SchemaP doc' v m a b
named Text
"ClientList" (ValueSchema NamedSwaggerDoc Client
-> SchemaP SwaggerDoc Value Value [Client] [Client]
forall ndoc doc a.
(HasArray ndoc doc, HasName ndoc) =>
ValueSchema ndoc a -> ValueSchema doc [a]
array (Maybe Version -> ValueSchema NamedSwaggerDoc Client
clientSchema (Version -> Maybe Version
forall a. a -> Maybe a
Just Version
V6)))

mlsPublicKeysFieldSchema :: ObjectSchema SwaggerDoc MLSPublicKeys
mlsPublicKeysFieldSchema :: SchemaP SwaggerDoc Object [Pair] MLSPublicKeys MLSPublicKeys
mlsPublicKeysFieldSchema = MLSPublicKeys -> Maybe MLSPublicKeys -> MLSPublicKeys
forall a. a -> Maybe a -> a
fromMaybe MLSPublicKeys
forall a. Monoid a => a
mempty (Maybe MLSPublicKeys -> MLSPublicKeys)
-> SchemaP
     SwaggerDoc Object [Pair] MLSPublicKeys (Maybe MLSPublicKeys)
-> SchemaP SwaggerDoc Object [Pair] MLSPublicKeys MLSPublicKeys
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> ValueSchema NamedSwaggerDoc MLSPublicKeys
-> SchemaP
     SwaggerDoc Object [Pair] MLSPublicKeys (Maybe MLSPublicKeys)
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
"mls_public_keys" ValueSchema NamedSwaggerDoc MLSPublicKeys
mlsPublicKeysSchema

instance AsHeaders '[ClientId] Client Client where
  toHeaders :: Client -> (NP I '[ClientId], Client)
toHeaders Client
c = (ClientId -> I ClientId
forall a. a -> I a
I (Client -> ClientId
clientId Client
c) I ClientId -> NP I '[] -> NP I '[ClientId]
forall {k} (a :: k -> *) (x :: k) (xs :: [k]).
a x -> NP a xs -> NP a (x : xs)
:* NP I '[]
forall {k} (a :: k -> *). NP a '[]
Nil, Client
c)
  fromHeaders :: (NP I '[ClientId], Client) -> Client
fromHeaders = (NP I '[ClientId], Client) -> Client
forall a b. (a, b) -> b
snd

--------------------------------------------------------------------------------
-- ClientList

-- | Client list for internal API.
data ClientList = ClientList {ClientList -> [ClientId]
clClients :: [ClientId]}
  deriving stock (ClientList -> ClientList -> Bool
(ClientList -> ClientList -> Bool)
-> (ClientList -> ClientList -> Bool) -> Eq ClientList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClientList -> ClientList -> Bool
== :: ClientList -> ClientList -> Bool
$c/= :: ClientList -> ClientList -> Bool
/= :: ClientList -> ClientList -> Bool
Eq, Int -> ClientList -> ShowS
[ClientList] -> ShowS
ClientList -> [Char]
(Int -> ClientList -> ShowS)
-> (ClientList -> [Char])
-> ([ClientList] -> ShowS)
-> Show ClientList
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ClientList -> ShowS
showsPrec :: Int -> ClientList -> ShowS
$cshow :: ClientList -> [Char]
show :: ClientList -> [Char]
$cshowList :: [ClientList] -> ShowS
showList :: [ClientList] -> ShowS
Show, (forall x. ClientList -> Rep ClientList x)
-> (forall x. Rep ClientList x -> ClientList) -> Generic ClientList
forall x. Rep ClientList x -> ClientList
forall x. ClientList -> Rep ClientList x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ClientList -> Rep ClientList x
from :: forall x. ClientList -> Rep ClientList x
$cto :: forall x. Rep ClientList x -> ClientList
to :: forall x. Rep ClientList x -> ClientList
Generic)
  deriving (Gen ClientList
Gen ClientList
-> (ClientList -> [ClientList]) -> Arbitrary ClientList
ClientList -> [ClientList]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen ClientList
arbitrary :: Gen ClientList
$cshrink :: ClientList -> [ClientList]
shrink :: ClientList -> [ClientList]
Arbitrary) via (GenericUniform ClientList)
  deriving (Value -> Parser [ClientList]
Value -> Parser ClientList
(Value -> Parser ClientList)
-> (Value -> Parser [ClientList]) -> FromJSON ClientList
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser ClientList
parseJSON :: Value -> Parser ClientList
$cparseJSONList :: Value -> Parser [ClientList]
parseJSONList :: Value -> Parser [ClientList]
FromJSON, [ClientList] -> Value
[ClientList] -> Encoding
ClientList -> Value
ClientList -> Encoding
(ClientList -> Value)
-> (ClientList -> Encoding)
-> ([ClientList] -> Value)
-> ([ClientList] -> Encoding)
-> ToJSON ClientList
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: ClientList -> Value
toJSON :: ClientList -> Value
$ctoEncoding :: ClientList -> Encoding
toEncoding :: ClientList -> Encoding
$ctoJSONList :: [ClientList] -> Value
toJSONList :: [ClientList] -> Value
$ctoEncodingList :: [ClientList] -> Encoding
toEncodingList :: [ClientList] -> Encoding
ToJSON, Typeable ClientList
Typeable ClientList =>
(Proxy ClientList -> Declare (Definitions Schema) NamedSchema)
-> ToSchema ClientList
Proxy ClientList -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy ClientList -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy ClientList -> Declare (Definitions Schema) NamedSchema
Swagger.ToSchema) via Schema ClientList

instance ToSchema ClientList where
  schema :: ValueSchema NamedSwaggerDoc ClientList
schema =
    Text
-> SchemaP SwaggerDoc Object [Pair] ClientList ClientList
-> ValueSchema NamedSwaggerDoc ClientList
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"ClientList" (SchemaP SwaggerDoc Object [Pair] ClientList ClientList
 -> ValueSchema NamedSwaggerDoc ClientList)
-> SchemaP SwaggerDoc Object [Pair] ClientList ClientList
-> ValueSchema NamedSwaggerDoc ClientList
forall a b. (a -> b) -> a -> b
$
      [ClientId] -> ClientList
ClientList
        ([ClientId] -> ClientList)
-> SchemaP SwaggerDoc Object [Pair] ClientList [ClientId]
-> SchemaP SwaggerDoc Object [Pair] ClientList ClientList
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ClientList -> [ClientId]
clClients
          (ClientList -> [ClientId])
-> SchemaP SwaggerDoc Object [Pair] [ClientId] [ClientId]
-> SchemaP SwaggerDoc Object [Pair] ClientList [ClientId]
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP SwaggerDoc 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
"client_ids" (SchemaP NamedSwaggerDoc Value Value ClientId ClientId
-> SchemaP SwaggerDoc Value Value [ClientId] [ClientId]
forall ndoc doc a.
(HasArray ndoc doc, HasName ndoc) =>
ValueSchema ndoc a -> ValueSchema doc [a]
array SchemaP NamedSwaggerDoc Value Value ClientId ClientId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)

--------------------------------------------------------------------------------
-- PubClient

data PubClient = PubClient
  { PubClient -> ClientId
pubClientId :: ClientId,
    PubClient -> Maybe ClientClass
pubClientClass :: Maybe ClientClass
  }
  deriving stock (PubClient -> PubClient -> Bool
(PubClient -> PubClient -> Bool)
-> (PubClient -> PubClient -> Bool) -> Eq PubClient
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PubClient -> PubClient -> Bool
== :: PubClient -> PubClient -> Bool
$c/= :: PubClient -> PubClient -> Bool
/= :: PubClient -> PubClient -> Bool
Eq, Int -> PubClient -> ShowS
[PubClient] -> ShowS
PubClient -> [Char]
(Int -> PubClient -> ShowS)
-> (PubClient -> [Char])
-> ([PubClient] -> ShowS)
-> Show PubClient
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PubClient -> ShowS
showsPrec :: Int -> PubClient -> ShowS
$cshow :: PubClient -> [Char]
show :: PubClient -> [Char]
$cshowList :: [PubClient] -> ShowS
showList :: [PubClient] -> ShowS
Show, (forall x. PubClient -> Rep PubClient x)
-> (forall x. Rep PubClient x -> PubClient) -> Generic PubClient
forall x. Rep PubClient x -> PubClient
forall x. PubClient -> Rep PubClient x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. PubClient -> Rep PubClient x
from :: forall x. PubClient -> Rep PubClient x
$cto :: forall x. Rep PubClient x -> PubClient
to :: forall x. Rep PubClient x -> PubClient
Generic, Eq PubClient
Eq PubClient =>
(PubClient -> PubClient -> Ordering)
-> (PubClient -> PubClient -> Bool)
-> (PubClient -> PubClient -> Bool)
-> (PubClient -> PubClient -> Bool)
-> (PubClient -> PubClient -> Bool)
-> (PubClient -> PubClient -> PubClient)
-> (PubClient -> PubClient -> PubClient)
-> Ord PubClient
PubClient -> PubClient -> Bool
PubClient -> PubClient -> Ordering
PubClient -> PubClient -> PubClient
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 :: PubClient -> PubClient -> Ordering
compare :: PubClient -> PubClient -> Ordering
$c< :: PubClient -> PubClient -> Bool
< :: PubClient -> PubClient -> Bool
$c<= :: PubClient -> PubClient -> Bool
<= :: PubClient -> PubClient -> Bool
$c> :: PubClient -> PubClient -> Bool
> :: PubClient -> PubClient -> Bool
$c>= :: PubClient -> PubClient -> Bool
>= :: PubClient -> PubClient -> Bool
$cmax :: PubClient -> PubClient -> PubClient
max :: PubClient -> PubClient -> PubClient
$cmin :: PubClient -> PubClient -> PubClient
min :: PubClient -> PubClient -> PubClient
Ord)
  deriving (Gen PubClient
Gen PubClient -> (PubClient -> [PubClient]) -> Arbitrary PubClient
PubClient -> [PubClient]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen PubClient
arbitrary :: Gen PubClient
$cshrink :: PubClient -> [PubClient]
shrink :: PubClient -> [PubClient]
Arbitrary) via (GenericUniform PubClient)
  deriving (Typeable PubClient
Typeable PubClient =>
(Proxy PubClient -> Declare (Definitions Schema) NamedSchema)
-> ToSchema PubClient
Proxy PubClient -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy PubClient -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy PubClient -> Declare (Definitions Schema) NamedSchema
Swagger.ToSchema) via (CustomSwagger '[FieldLabelModifier (StripPrefix "pubClient", LowerCase)] PubClient)
  deriving (Value -> Parser [PubClient]
Value -> Parser PubClient
(Value -> Parser PubClient)
-> (Value -> Parser [PubClient]) -> FromJSON PubClient
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser PubClient
parseJSON :: Value -> Parser PubClient
$cparseJSONList :: Value -> Parser [PubClient]
parseJSONList :: Value -> Parser [PubClient]
FromJSON, [PubClient] -> Value
[PubClient] -> Encoding
PubClient -> Value
PubClient -> Encoding
(PubClient -> Value)
-> (PubClient -> Encoding)
-> ([PubClient] -> Value)
-> ([PubClient] -> Encoding)
-> ToJSON PubClient
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: PubClient -> Value
toJSON :: PubClient -> Value
$ctoEncoding :: PubClient -> Encoding
toEncoding :: PubClient -> Encoding
$ctoJSONList :: [PubClient] -> Value
toJSONList :: [PubClient] -> Value
$ctoEncodingList :: [PubClient] -> Encoding
toEncodingList :: [PubClient] -> Encoding
ToJSON) via Schema PubClient

instance ToSchema PubClient where
  schema :: ValueSchema NamedSwaggerDoc PubClient
schema =
    Text
-> SchemaP SwaggerDoc Object [Pair] PubClient PubClient
-> ValueSchema NamedSwaggerDoc PubClient
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"PubClient" (SchemaP SwaggerDoc Object [Pair] PubClient PubClient
 -> ValueSchema NamedSwaggerDoc PubClient)
-> SchemaP SwaggerDoc Object [Pair] PubClient PubClient
-> ValueSchema NamedSwaggerDoc PubClient
forall a b. (a -> b) -> a -> b
$
      ClientId -> Maybe ClientClass -> PubClient
PubClient
        (ClientId -> Maybe ClientClass -> PubClient)
-> SchemaP SwaggerDoc Object [Pair] PubClient ClientId
-> SchemaP
     SwaggerDoc Object [Pair] PubClient (Maybe ClientClass -> PubClient)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PubClient -> ClientId
pubClientId (PubClient -> ClientId)
-> SchemaP SwaggerDoc Object [Pair] ClientId ClientId
-> SchemaP SwaggerDoc Object [Pair] PubClient 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
"id" SchemaP NamedSwaggerDoc Value Value ClientId ClientId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc Object [Pair] PubClient (Maybe ClientClass -> PubClient)
-> SchemaP SwaggerDoc Object [Pair] PubClient (Maybe ClientClass)
-> SchemaP SwaggerDoc Object [Pair] PubClient PubClient
forall a b.
SchemaP SwaggerDoc Object [Pair] PubClient (a -> b)
-> SchemaP SwaggerDoc Object [Pair] PubClient a
-> SchemaP SwaggerDoc Object [Pair] PubClient b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> PubClient -> Maybe ClientClass
pubClientClass (PubClient -> Maybe ClientClass)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe ClientClass) (Maybe ClientClass)
-> SchemaP SwaggerDoc Object [Pair] PubClient (Maybe ClientClass)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] ClientClass (Maybe ClientClass)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe ClientClass) (Maybe ClientClass)
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 ClientClass ClientClass
-> SchemaP SwaggerDoc Object [Pair] ClientClass (Maybe ClientClass)
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
"class" SchemaP NamedSwaggerDoc Value Value ClientClass ClientClass
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)

--------------------------------------------------------------------------------
-- Client Type/Class

-- [Note: LegalHold]
--
-- Short feature description:
-- LegalHold is an enterprise feature, enabled on a per-team basis, and within a
-- team on a per-user basis
--
-- A LegalHoldClient is a client outside that user's control (but under the
-- control of that team's business)
--
-- Users need to click "accept" before a LegalHoldClient is added to their
-- account.
--
-- Any user interacting with a user which has a LegalHoldClient will upon
-- first interaction receive a warning, have the option of cancelling the
-- interaction, and on an ongoing basis see a visual indication in all
-- conversations where such a device is active.

data ClientType
  = TemporaryClientType
  | PermanentClientType
  | LegalHoldClientType -- see Note [LegalHold]
  deriving stock (ClientType -> ClientType -> Bool
(ClientType -> ClientType -> Bool)
-> (ClientType -> ClientType -> Bool) -> Eq ClientType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClientType -> ClientType -> Bool
== :: ClientType -> ClientType -> Bool
$c/= :: ClientType -> ClientType -> Bool
/= :: ClientType -> ClientType -> Bool
Eq, Eq ClientType
Eq ClientType =>
(ClientType -> ClientType -> Ordering)
-> (ClientType -> ClientType -> Bool)
-> (ClientType -> ClientType -> Bool)
-> (ClientType -> ClientType -> Bool)
-> (ClientType -> ClientType -> Bool)
-> (ClientType -> ClientType -> ClientType)
-> (ClientType -> ClientType -> ClientType)
-> Ord ClientType
ClientType -> ClientType -> Bool
ClientType -> ClientType -> Ordering
ClientType -> ClientType -> ClientType
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 :: ClientType -> ClientType -> Ordering
compare :: ClientType -> ClientType -> Ordering
$c< :: ClientType -> ClientType -> Bool
< :: ClientType -> ClientType -> Bool
$c<= :: ClientType -> ClientType -> Bool
<= :: ClientType -> ClientType -> Bool
$c> :: ClientType -> ClientType -> Bool
> :: ClientType -> ClientType -> Bool
$c>= :: ClientType -> ClientType -> Bool
>= :: ClientType -> ClientType -> Bool
$cmax :: ClientType -> ClientType -> ClientType
max :: ClientType -> ClientType -> ClientType
$cmin :: ClientType -> ClientType -> ClientType
min :: ClientType -> ClientType -> ClientType
Ord, Int -> ClientType -> ShowS
[ClientType] -> ShowS
ClientType -> [Char]
(Int -> ClientType -> ShowS)
-> (ClientType -> [Char])
-> ([ClientType] -> ShowS)
-> Show ClientType
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ClientType -> ShowS
showsPrec :: Int -> ClientType -> ShowS
$cshow :: ClientType -> [Char]
show :: ClientType -> [Char]
$cshowList :: [ClientType] -> ShowS
showList :: [ClientType] -> ShowS
Show, (forall x. ClientType -> Rep ClientType x)
-> (forall x. Rep ClientType x -> ClientType) -> Generic ClientType
forall x. Rep ClientType x -> ClientType
forall x. ClientType -> Rep ClientType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ClientType -> Rep ClientType x
from :: forall x. ClientType -> Rep ClientType x
$cto :: forall x. Rep ClientType x -> ClientType
to :: forall x. Rep ClientType x -> ClientType
Generic)
  deriving (Gen ClientType
Gen ClientType
-> (ClientType -> [ClientType]) -> Arbitrary ClientType
ClientType -> [ClientType]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen ClientType
arbitrary :: Gen ClientType
$cshrink :: ClientType -> [ClientType]
shrink :: ClientType -> [ClientType]
Arbitrary) via (GenericUniform ClientType)
  deriving (Value -> Parser [ClientType]
Value -> Parser ClientType
(Value -> Parser ClientType)
-> (Value -> Parser [ClientType]) -> FromJSON ClientType
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser ClientType
parseJSON :: Value -> Parser ClientType
$cparseJSONList :: Value -> Parser [ClientType]
parseJSONList :: Value -> Parser [ClientType]
FromJSON, [ClientType] -> Value
[ClientType] -> Encoding
ClientType -> Value
ClientType -> Encoding
(ClientType -> Value)
-> (ClientType -> Encoding)
-> ([ClientType] -> Value)
-> ([ClientType] -> Encoding)
-> ToJSON ClientType
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: ClientType -> Value
toJSON :: ClientType -> Value
$ctoEncoding :: ClientType -> Encoding
toEncoding :: ClientType -> Encoding
$ctoJSONList :: [ClientType] -> Value
toJSONList :: [ClientType] -> Value
$ctoEncodingList :: [ClientType] -> Encoding
toEncodingList :: [ClientType] -> Encoding
ToJSON, Typeable ClientType
Typeable ClientType =>
(Proxy ClientType -> Declare (Definitions Schema) NamedSchema)
-> ToSchema ClientType
Proxy ClientType -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy ClientType -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy ClientType -> Declare (Definitions Schema) NamedSchema
Swagger.ToSchema) via Schema ClientType

instance ToSchema ClientType where
  schema :: SchemaP NamedSwaggerDoc Value Value ClientType ClientType
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
"ClientType" (SchemaP [Value] Text (Alt Maybe Text) ClientType ClientType
 -> SchemaP NamedSwaggerDoc Value Value ClientType ClientType)
-> SchemaP [Value] Text (Alt Maybe Text) ClientType ClientType
-> SchemaP NamedSwaggerDoc Value Value ClientType ClientType
forall a b. (a -> b) -> a -> b
$
      Text
-> ClientType
-> SchemaP [Value] Text (Alt Maybe Text) ClientType ClientType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"temporary" ClientType
TemporaryClientType
        SchemaP [Value] Text (Alt Maybe Text) ClientType ClientType
-> SchemaP [Value] Text (Alt Maybe Text) ClientType ClientType
-> SchemaP [Value] Text (Alt Maybe Text) ClientType ClientType
forall a. Semigroup a => a -> a -> a
<> Text
-> ClientType
-> SchemaP [Value] Text (Alt Maybe Text) ClientType ClientType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"permanent" ClientType
PermanentClientType
        SchemaP [Value] Text (Alt Maybe Text) ClientType ClientType
-> SchemaP [Value] Text (Alt Maybe Text) ClientType ClientType
-> SchemaP [Value] Text (Alt Maybe Text) ClientType ClientType
forall a. Semigroup a => a -> a -> a
<> Text
-> ClientType
-> SchemaP [Value] Text (Alt Maybe Text) ClientType ClientType
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"legalhold" ClientType
LegalHoldClientType

instance C.Cql ClientType where
  ctype :: Tagged ClientType ColumnType
ctype = ColumnType -> Tagged ClientType ColumnType
forall a b. b -> Tagged a b
C.Tagged ColumnType
C.IntColumn
  toCql :: ClientType -> Value
toCql ClientType
TemporaryClientType = Int32 -> Value
C.CqlInt Int32
0
  toCql ClientType
PermanentClientType = Int32 -> Value
C.CqlInt Int32
1
  toCql ClientType
LegalHoldClientType = Int32 -> Value
C.CqlInt Int32
2

  fromCql :: Value -> Either [Char] ClientType
fromCql (C.CqlInt Int32
0) = ClientType -> Either [Char] ClientType
forall a. a -> Either [Char] a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ClientType
TemporaryClientType
  fromCql (C.CqlInt Int32
1) = ClientType -> Either [Char] ClientType
forall a. a -> Either [Char] a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ClientType
PermanentClientType
  fromCql (C.CqlInt Int32
2) = ClientType -> Either [Char] ClientType
forall a. a -> Either [Char] a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ClientType
LegalHoldClientType
  fromCql Value
_ = [Char] -> Either [Char] ClientType
forall a b. a -> Either a b
Left [Char]
"ClientType: Int [0, 2] expected"

data ClientClass
  = PhoneClient
  | TabletClient
  | DesktopClient
  | LegalHoldClient -- see Note [LegalHold]
  deriving stock (ClientClass -> ClientClass -> Bool
(ClientClass -> ClientClass -> Bool)
-> (ClientClass -> ClientClass -> Bool) -> Eq ClientClass
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClientClass -> ClientClass -> Bool
== :: ClientClass -> ClientClass -> Bool
$c/= :: ClientClass -> ClientClass -> Bool
/= :: ClientClass -> ClientClass -> Bool
Eq, Eq ClientClass
Eq ClientClass =>
(ClientClass -> ClientClass -> Ordering)
-> (ClientClass -> ClientClass -> Bool)
-> (ClientClass -> ClientClass -> Bool)
-> (ClientClass -> ClientClass -> Bool)
-> (ClientClass -> ClientClass -> Bool)
-> (ClientClass -> ClientClass -> ClientClass)
-> (ClientClass -> ClientClass -> ClientClass)
-> Ord ClientClass
ClientClass -> ClientClass -> Bool
ClientClass -> ClientClass -> Ordering
ClientClass -> ClientClass -> ClientClass
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 :: ClientClass -> ClientClass -> Ordering
compare :: ClientClass -> ClientClass -> Ordering
$c< :: ClientClass -> ClientClass -> Bool
< :: ClientClass -> ClientClass -> Bool
$c<= :: ClientClass -> ClientClass -> Bool
<= :: ClientClass -> ClientClass -> Bool
$c> :: ClientClass -> ClientClass -> Bool
> :: ClientClass -> ClientClass -> Bool
$c>= :: ClientClass -> ClientClass -> Bool
>= :: ClientClass -> ClientClass -> Bool
$cmax :: ClientClass -> ClientClass -> ClientClass
max :: ClientClass -> ClientClass -> ClientClass
$cmin :: ClientClass -> ClientClass -> ClientClass
min :: ClientClass -> ClientClass -> ClientClass
Ord, Int -> ClientClass -> ShowS
[ClientClass] -> ShowS
ClientClass -> [Char]
(Int -> ClientClass -> ShowS)
-> (ClientClass -> [Char])
-> ([ClientClass] -> ShowS)
-> Show ClientClass
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ClientClass -> ShowS
showsPrec :: Int -> ClientClass -> ShowS
$cshow :: ClientClass -> [Char]
show :: ClientClass -> [Char]
$cshowList :: [ClientClass] -> ShowS
showList :: [ClientClass] -> ShowS
Show, (forall x. ClientClass -> Rep ClientClass x)
-> (forall x. Rep ClientClass x -> ClientClass)
-> Generic ClientClass
forall x. Rep ClientClass x -> ClientClass
forall x. ClientClass -> Rep ClientClass x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ClientClass -> Rep ClientClass x
from :: forall x. ClientClass -> Rep ClientClass x
$cto :: forall x. Rep ClientClass x -> ClientClass
to :: forall x. Rep ClientClass x -> ClientClass
Generic)
  deriving (Gen ClientClass
Gen ClientClass
-> (ClientClass -> [ClientClass]) -> Arbitrary ClientClass
ClientClass -> [ClientClass]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen ClientClass
arbitrary :: Gen ClientClass
$cshrink :: ClientClass -> [ClientClass]
shrink :: ClientClass -> [ClientClass]
Arbitrary) via (GenericUniform ClientClass)
  deriving (Value -> Parser [ClientClass]
Value -> Parser ClientClass
(Value -> Parser ClientClass)
-> (Value -> Parser [ClientClass]) -> FromJSON ClientClass
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser ClientClass
parseJSON :: Value -> Parser ClientClass
$cparseJSONList :: Value -> Parser [ClientClass]
parseJSONList :: Value -> Parser [ClientClass]
FromJSON, [ClientClass] -> Value
[ClientClass] -> Encoding
ClientClass -> Value
ClientClass -> Encoding
(ClientClass -> Value)
-> (ClientClass -> Encoding)
-> ([ClientClass] -> Value)
-> ([ClientClass] -> Encoding)
-> ToJSON ClientClass
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: ClientClass -> Value
toJSON :: ClientClass -> Value
$ctoEncoding :: ClientClass -> Encoding
toEncoding :: ClientClass -> Encoding
$ctoJSONList :: [ClientClass] -> Value
toJSONList :: [ClientClass] -> Value
$ctoEncodingList :: [ClientClass] -> Encoding
toEncodingList :: [ClientClass] -> Encoding
ToJSON, Typeable ClientClass
Typeable ClientClass =>
(Proxy ClientClass -> Declare (Definitions Schema) NamedSchema)
-> ToSchema ClientClass
Proxy ClientClass -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy ClientClass -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy ClientClass -> Declare (Definitions Schema) NamedSchema
Swagger.ToSchema) via Schema ClientClass

instance ToSchema ClientClass where
  schema :: SchemaP NamedSwaggerDoc Value Value ClientClass ClientClass
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
"ClientClass" (SchemaP [Value] Text (Alt Maybe Text) ClientClass ClientClass
 -> SchemaP NamedSwaggerDoc Value Value ClientClass ClientClass)
-> SchemaP [Value] Text (Alt Maybe Text) ClientClass ClientClass
-> SchemaP NamedSwaggerDoc Value Value ClientClass ClientClass
forall a b. (a -> b) -> a -> b
$
      Text
-> ClientClass
-> SchemaP [Value] Text (Alt Maybe Text) ClientClass ClientClass
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"phone" ClientClass
PhoneClient
        SchemaP [Value] Text (Alt Maybe Text) ClientClass ClientClass
-> SchemaP [Value] Text (Alt Maybe Text) ClientClass ClientClass
-> SchemaP [Value] Text (Alt Maybe Text) ClientClass ClientClass
forall a. Semigroup a => a -> a -> a
<> Text
-> ClientClass
-> SchemaP [Value] Text (Alt Maybe Text) ClientClass ClientClass
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"tablet" ClientClass
TabletClient
        SchemaP [Value] Text (Alt Maybe Text) ClientClass ClientClass
-> SchemaP [Value] Text (Alt Maybe Text) ClientClass ClientClass
-> SchemaP [Value] Text (Alt Maybe Text) ClientClass ClientClass
forall a. Semigroup a => a -> a -> a
<> Text
-> ClientClass
-> SchemaP [Value] Text (Alt Maybe Text) ClientClass ClientClass
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"desktop" ClientClass
DesktopClient
        SchemaP [Value] Text (Alt Maybe Text) ClientClass ClientClass
-> SchemaP [Value] Text (Alt Maybe Text) ClientClass ClientClass
-> SchemaP [Value] Text (Alt Maybe Text) ClientClass ClientClass
forall a. Semigroup a => a -> a -> a
<> Text
-> ClientClass
-> SchemaP [Value] Text (Alt Maybe Text) ClientClass ClientClass
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"legalhold" ClientClass
LegalHoldClient

instance C.Cql ClientClass where
  ctype :: Tagged ClientClass ColumnType
ctype = ColumnType -> Tagged ClientClass ColumnType
forall a b. b -> Tagged a b
C.Tagged ColumnType
C.IntColumn
  toCql :: ClientClass -> Value
toCql ClientClass
PhoneClient = Int32 -> Value
C.CqlInt Int32
0
  toCql ClientClass
TabletClient = Int32 -> Value
C.CqlInt Int32
1
  toCql ClientClass
DesktopClient = Int32 -> Value
C.CqlInt Int32
2
  toCql ClientClass
LegalHoldClient = Int32 -> Value
C.CqlInt Int32
3

  fromCql :: Value -> Either [Char] ClientClass
fromCql (C.CqlInt Int32
0) = ClientClass -> Either [Char] ClientClass
forall a. a -> Either [Char] a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ClientClass
PhoneClient
  fromCql (C.CqlInt Int32
1) = ClientClass -> Either [Char] ClientClass
forall a. a -> Either [Char] a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ClientClass
TabletClient
  fromCql (C.CqlInt Int32
2) = ClientClass -> Either [Char] ClientClass
forall a. a -> Either [Char] a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ClientClass
DesktopClient
  fromCql (C.CqlInt Int32
3) = ClientClass -> Either [Char] ClientClass
forall a. a -> Either [Char] a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ClientClass
LegalHoldClient
  fromCql Value
_ = [Char] -> Either [Char] ClientClass
forall a b. a -> Either a b
Left [Char]
"ClientClass: Int [0, 3] expected"

--------------------------------------------------------------------------------
-- NewClient

data NewClient = NewClient
  { NewClient -> [Prekey]
newClientPrekeys :: [Prekey],
    NewClient -> LastPrekey
newClientLastKey :: LastPrekey,
    NewClient -> ClientType
newClientType :: ClientType,
    NewClient -> Maybe Text
newClientLabel :: Maybe Text,
    NewClient -> Maybe ClientClass
newClientClass :: Maybe ClientClass,
    NewClient -> Maybe CookieLabel
newClientCookie :: Maybe CookieLabel,
    NewClient -> Maybe PlainTextPassword6
newClientPassword :: Maybe PlainTextPassword6,
    NewClient -> Maybe Text
newClientModel :: Maybe Text,
    NewClient -> Maybe ClientCapabilityList
newClientCapabilities :: Maybe ClientCapabilityList,
    NewClient -> MLSPublicKeys
newClientMLSPublicKeys :: MLSPublicKeys,
    NewClient -> Maybe Value
newClientVerificationCode :: Maybe Code.Value
  }
  deriving stock (NewClient -> NewClient -> Bool
(NewClient -> NewClient -> Bool)
-> (NewClient -> NewClient -> Bool) -> Eq NewClient
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NewClient -> NewClient -> Bool
== :: NewClient -> NewClient -> Bool
$c/= :: NewClient -> NewClient -> Bool
/= :: NewClient -> NewClient -> Bool
Eq, Int -> NewClient -> ShowS
[NewClient] -> ShowS
NewClient -> [Char]
(Int -> NewClient -> ShowS)
-> (NewClient -> [Char])
-> ([NewClient] -> ShowS)
-> Show NewClient
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NewClient -> ShowS
showsPrec :: Int -> NewClient -> ShowS
$cshow :: NewClient -> [Char]
show :: NewClient -> [Char]
$cshowList :: [NewClient] -> ShowS
showList :: [NewClient] -> ShowS
Show, (forall x. NewClient -> Rep NewClient x)
-> (forall x. Rep NewClient x -> NewClient) -> Generic NewClient
forall x. Rep NewClient x -> NewClient
forall x. NewClient -> Rep NewClient x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NewClient -> Rep NewClient x
from :: forall x. NewClient -> Rep NewClient x
$cto :: forall x. Rep NewClient x -> NewClient
to :: forall x. Rep NewClient x -> NewClient
Generic)
  deriving (Gen NewClient
Gen NewClient -> (NewClient -> [NewClient]) -> Arbitrary NewClient
NewClient -> [NewClient]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen NewClient
arbitrary :: Gen NewClient
$cshrink :: NewClient -> [NewClient]
shrink :: NewClient -> [NewClient]
Arbitrary) via (GenericUniform NewClient)
  deriving (Value -> Parser [NewClient]
Value -> Parser NewClient
(Value -> Parser NewClient)
-> (Value -> Parser [NewClient]) -> FromJSON NewClient
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser NewClient
parseJSON :: Value -> Parser NewClient
$cparseJSONList :: Value -> Parser [NewClient]
parseJSONList :: Value -> Parser [NewClient]
FromJSON, [NewClient] -> Value
[NewClient] -> Encoding
NewClient -> Value
NewClient -> Encoding
(NewClient -> Value)
-> (NewClient -> Encoding)
-> ([NewClient] -> Value)
-> ([NewClient] -> Encoding)
-> ToJSON NewClient
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: NewClient -> Value
toJSON :: NewClient -> Value
$ctoEncoding :: NewClient -> Encoding
toEncoding :: NewClient -> Encoding
$ctoJSONList :: [NewClient] -> Value
toJSONList :: [NewClient] -> Value
$ctoEncodingList :: [NewClient] -> Encoding
toEncodingList :: [NewClient] -> Encoding
ToJSON, Typeable NewClient
Typeable NewClient =>
(Proxy NewClient -> Declare (Definitions Schema) NamedSchema)
-> ToSchema NewClient
Proxy NewClient -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy NewClient -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy NewClient -> Declare (Definitions Schema) NamedSchema
Swagger.ToSchema) via Schema NewClient

instance ToSchema NewClient where
  schema :: ValueSchema NamedSwaggerDoc NewClient
schema =
    Text
-> SchemaP SwaggerDoc Object [Pair] NewClient NewClient
-> ValueSchema NamedSwaggerDoc NewClient
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"NewClient" (SchemaP SwaggerDoc Object [Pair] NewClient NewClient
 -> ValueSchema NamedSwaggerDoc NewClient)
-> SchemaP SwaggerDoc Object [Pair] NewClient NewClient
-> ValueSchema NamedSwaggerDoc NewClient
forall a b. (a -> b) -> a -> b
$
      [Prekey]
-> LastPrekey
-> ClientType
-> Maybe Text
-> Maybe ClientClass
-> Maybe CookieLabel
-> Maybe PlainTextPassword6
-> Maybe Text
-> Maybe ClientCapabilityList
-> MLSPublicKeys
-> Maybe Value
-> NewClient
NewClient
        ([Prekey]
 -> LastPrekey
 -> ClientType
 -> Maybe Text
 -> Maybe ClientClass
 -> Maybe CookieLabel
 -> Maybe PlainTextPassword6
 -> Maybe Text
 -> Maybe ClientCapabilityList
 -> MLSPublicKeys
 -> Maybe Value
 -> NewClient)
-> SchemaP SwaggerDoc Object [Pair] NewClient [Prekey]
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     NewClient
     (LastPrekey
      -> ClientType
      -> Maybe Text
      -> Maybe ClientClass
      -> Maybe CookieLabel
      -> Maybe PlainTextPassword6
      -> Maybe Text
      -> Maybe ClientCapabilityList
      -> MLSPublicKeys
      -> Maybe Value
      -> NewClient)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NewClient -> [Prekey]
newClientPrekeys
          (NewClient -> [Prekey])
-> SchemaP SwaggerDoc Object [Pair] [Prekey] [Prekey]
-> SchemaP SwaggerDoc Object [Pair] NewClient [Prekey]
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> (SwaggerDoc -> SwaggerDoc)
-> SchemaP SwaggerDoc Value Value [Prekey] [Prekey]
-> SchemaP SwaggerDoc Object [Pair] [Prekey] [Prekey]
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
"prekeys"
            ((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
"Prekeys for other clients to establish OTR sessions.")
            (SchemaP NamedSwaggerDoc Value Value Prekey Prekey
-> SchemaP SwaggerDoc Value Value [Prekey] [Prekey]
forall ndoc doc a.
(HasArray ndoc doc, HasName ndoc) =>
ValueSchema ndoc a -> ValueSchema doc [a]
array SchemaP NamedSwaggerDoc Value Value Prekey Prekey
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  NewClient
  (LastPrekey
   -> ClientType
   -> Maybe Text
   -> Maybe ClientClass
   -> Maybe CookieLabel
   -> Maybe PlainTextPassword6
   -> Maybe Text
   -> Maybe ClientCapabilityList
   -> MLSPublicKeys
   -> Maybe Value
   -> NewClient)
-> SchemaP SwaggerDoc Object [Pair] NewClient LastPrekey
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     NewClient
     (ClientType
      -> Maybe Text
      -> Maybe ClientClass
      -> Maybe CookieLabel
      -> Maybe PlainTextPassword6
      -> Maybe Text
      -> Maybe ClientCapabilityList
      -> MLSPublicKeys
      -> Maybe Value
      -> NewClient)
forall a b.
SchemaP SwaggerDoc Object [Pair] NewClient (a -> b)
-> SchemaP SwaggerDoc Object [Pair] NewClient a
-> SchemaP SwaggerDoc Object [Pair] NewClient b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NewClient -> LastPrekey
newClientLastKey
          (NewClient -> LastPrekey)
-> SchemaP SwaggerDoc Object [Pair] LastPrekey LastPrekey
-> SchemaP SwaggerDoc Object [Pair] NewClient LastPrekey
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> SchemaP NamedSwaggerDoc Value Value LastPrekey LastPrekey
-> SchemaP SwaggerDoc Object [Pair] LastPrekey LastPrekey
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
"lastkey"
            ( (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
"The last resort prekey for other clients to establish OTR sessions. \
                   \This key must have the ID 0xFFFF and is never deleted."
            )
            SchemaP NamedSwaggerDoc Value Value LastPrekey LastPrekey
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  NewClient
  (ClientType
   -> Maybe Text
   -> Maybe ClientClass
   -> Maybe CookieLabel
   -> Maybe PlainTextPassword6
   -> Maybe Text
   -> Maybe ClientCapabilityList
   -> MLSPublicKeys
   -> Maybe Value
   -> NewClient)
-> SchemaP SwaggerDoc Object [Pair] NewClient ClientType
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     NewClient
     (Maybe Text
      -> Maybe ClientClass
      -> Maybe CookieLabel
      -> Maybe PlainTextPassword6
      -> Maybe Text
      -> Maybe ClientCapabilityList
      -> MLSPublicKeys
      -> Maybe Value
      -> NewClient)
forall a b.
SchemaP SwaggerDoc Object [Pair] NewClient (a -> b)
-> SchemaP SwaggerDoc Object [Pair] NewClient a
-> SchemaP SwaggerDoc Object [Pair] NewClient b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NewClient -> ClientType
newClientType
          (NewClient -> ClientType)
-> SchemaP SwaggerDoc Object [Pair] ClientType ClientType
-> SchemaP SwaggerDoc Object [Pair] NewClient ClientType
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> SchemaP NamedSwaggerDoc Value Value ClientType ClientType
-> SchemaP SwaggerDoc Object [Pair] ClientType ClientType
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
"type"
            ( (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
"The type of client to register. A user may have no more than \
                   \7 (seven) permanent clients and 1 (one) temporary client. When the \
                   \limit of permanent clients is reached, an error is returned. \
                   \When a temporary client already exists, it is replaced."
            )
            SchemaP NamedSwaggerDoc Value Value ClientType ClientType
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  NewClient
  (Maybe Text
   -> Maybe ClientClass
   -> Maybe CookieLabel
   -> Maybe PlainTextPassword6
   -> Maybe Text
   -> Maybe ClientCapabilityList
   -> MLSPublicKeys
   -> Maybe Value
   -> NewClient)
-> SchemaP SwaggerDoc Object [Pair] NewClient (Maybe Text)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     NewClient
     (Maybe ClientClass
      -> Maybe CookieLabel
      -> Maybe PlainTextPassword6
      -> Maybe Text
      -> Maybe ClientCapabilityList
      -> MLSPublicKeys
      -> Maybe Value
      -> NewClient)
forall a b.
SchemaP SwaggerDoc Object [Pair] NewClient (a -> b)
-> SchemaP SwaggerDoc Object [Pair] NewClient a
-> SchemaP SwaggerDoc Object [Pair] NewClient b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NewClient -> Maybe Text
newClientLabel (NewClient -> Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] NewClient (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
"label" SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  NewClient
  (Maybe ClientClass
   -> Maybe CookieLabel
   -> Maybe PlainTextPassword6
   -> Maybe Text
   -> Maybe ClientCapabilityList
   -> MLSPublicKeys
   -> Maybe Value
   -> NewClient)
-> SchemaP SwaggerDoc Object [Pair] NewClient (Maybe ClientClass)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     NewClient
     (Maybe CookieLabel
      -> Maybe PlainTextPassword6
      -> Maybe Text
      -> Maybe ClientCapabilityList
      -> MLSPublicKeys
      -> Maybe Value
      -> NewClient)
forall a b.
SchemaP SwaggerDoc Object [Pair] NewClient (a -> b)
-> SchemaP SwaggerDoc Object [Pair] NewClient a
-> SchemaP SwaggerDoc Object [Pair] NewClient b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NewClient -> Maybe ClientClass
newClientClass
          (NewClient -> Maybe ClientClass)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe ClientClass) (Maybe ClientClass)
-> SchemaP SwaggerDoc Object [Pair] NewClient (Maybe ClientClass)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] ClientClass (Maybe ClientClass)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe ClientClass) (Maybe ClientClass)
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 ClientClass ClientClass
-> SchemaP SwaggerDoc Object [Pair] ClientClass (Maybe ClientClass)
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
"class"
                ( (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
"The device class this client belongs to. \
                       \Either 'phone', 'tablet', or 'desktop'."
                )
                SchemaP NamedSwaggerDoc Value Value ClientClass ClientClass
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
            )
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  NewClient
  (Maybe CookieLabel
   -> Maybe PlainTextPassword6
   -> Maybe Text
   -> Maybe ClientCapabilityList
   -> MLSPublicKeys
   -> Maybe Value
   -> NewClient)
-> SchemaP SwaggerDoc Object [Pair] NewClient (Maybe CookieLabel)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     NewClient
     (Maybe PlainTextPassword6
      -> Maybe Text
      -> Maybe ClientCapabilityList
      -> MLSPublicKeys
      -> Maybe Value
      -> NewClient)
forall a b.
SchemaP SwaggerDoc Object [Pair] NewClient (a -> b)
-> SchemaP SwaggerDoc Object [Pair] NewClient a
-> SchemaP SwaggerDoc Object [Pair] NewClient b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NewClient -> Maybe CookieLabel
newClientCookie
          (NewClient -> Maybe CookieLabel)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe CookieLabel) (Maybe CookieLabel)
-> SchemaP SwaggerDoc Object [Pair] NewClient (Maybe CookieLabel)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] CookieLabel (Maybe CookieLabel)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe CookieLabel) (Maybe CookieLabel)
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 CookieLabel CookieLabel
-> SchemaP SwaggerDoc Object [Pair] CookieLabel (Maybe CookieLabel)
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
"cookie"
                ((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
"The cookie label, i.e. the label used when logging in.")
                SchemaP NamedSwaggerDoc Value Value CookieLabel CookieLabel
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
            )
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  NewClient
  (Maybe PlainTextPassword6
   -> Maybe Text
   -> Maybe ClientCapabilityList
   -> MLSPublicKeys
   -> Maybe Value
   -> NewClient)
-> SchemaP
     SwaggerDoc Object [Pair] NewClient (Maybe PlainTextPassword6)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     NewClient
     (Maybe Text
      -> Maybe ClientCapabilityList
      -> MLSPublicKeys
      -> Maybe Value
      -> NewClient)
forall a b.
SchemaP SwaggerDoc Object [Pair] NewClient (a -> b)
-> SchemaP SwaggerDoc Object [Pair] NewClient a
-> SchemaP SwaggerDoc Object [Pair] NewClient b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NewClient -> Maybe PlainTextPassword6
newClientPassword
          (NewClient -> Maybe PlainTextPassword6)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe PlainTextPassword6)
     (Maybe PlainTextPassword6)
-> SchemaP
     SwaggerDoc Object [Pair] NewClient (Maybe PlainTextPassword6)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP
  SwaggerDoc
  Object
  [Pair]
  PlainTextPassword6
  (Maybe PlainTextPassword6)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe PlainTextPassword6)
     (Maybe PlainTextPassword6)
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 PlainTextPassword6 PlainTextPassword6
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     PlainTextPassword6
     (Maybe PlainTextPassword6)
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
"password"
                ( (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
"The password of the authenticated user for verification. \
                       \Note: Required for registration of the 2nd, 3rd, ... client."
                )
                SchemaP
  NamedSwaggerDoc Value Value PlainTextPassword6 PlainTextPassword6
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
            )
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  NewClient
  (Maybe Text
   -> Maybe ClientCapabilityList
   -> MLSPublicKeys
   -> Maybe Value
   -> NewClient)
-> SchemaP SwaggerDoc Object [Pair] NewClient (Maybe Text)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     NewClient
     (Maybe ClientCapabilityList
      -> MLSPublicKeys -> Maybe Value -> NewClient)
forall a b.
SchemaP SwaggerDoc Object [Pair] NewClient (a -> b)
-> SchemaP SwaggerDoc Object [Pair] NewClient a
-> SchemaP SwaggerDoc Object [Pair] NewClient b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NewClient -> Maybe Text
newClientModel (NewClient -> Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] NewClient (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
"model" SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  NewClient
  (Maybe ClientCapabilityList
   -> MLSPublicKeys -> Maybe Value -> NewClient)
-> SchemaP
     SwaggerDoc Object [Pair] NewClient (Maybe ClientCapabilityList)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     NewClient
     (MLSPublicKeys -> Maybe Value -> NewClient)
forall a b.
SchemaP SwaggerDoc Object [Pair] NewClient (a -> b)
-> SchemaP SwaggerDoc Object [Pair] NewClient a
-> SchemaP SwaggerDoc Object [Pair] NewClient b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NewClient -> Maybe ClientCapabilityList
newClientCapabilities
          (NewClient -> Maybe ClientCapabilityList)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe ClientCapabilityList)
     (Maybe ClientCapabilityList)
-> SchemaP
     SwaggerDoc Object [Pair] NewClient (Maybe ClientCapabilityList)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP
  SwaggerDoc
  Object
  [Pair]
  ClientCapabilityList
  (Maybe ClientCapabilityList)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe ClientCapabilityList)
     (Maybe ClientCapabilityList)
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)
-> ValueSchema NamedSwaggerDoc ClientCapabilityList
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     ClientCapabilityList
     (Maybe ClientCapabilityList)
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
"capabilities"
                ( (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
"Hints provided by the client for the backend so it can \
                       \behave in a backwards-compatible way."
                )
                ValueSchema NamedSwaggerDoc ClientCapabilityList
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
            )
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  NewClient
  (MLSPublicKeys -> Maybe Value -> NewClient)
-> SchemaP SwaggerDoc Object [Pair] NewClient MLSPublicKeys
-> SchemaP
     SwaggerDoc Object [Pair] NewClient (Maybe Value -> NewClient)
forall a b.
SchemaP SwaggerDoc Object [Pair] NewClient (a -> b)
-> SchemaP SwaggerDoc Object [Pair] NewClient a
-> SchemaP SwaggerDoc Object [Pair] NewClient b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NewClient -> MLSPublicKeys
newClientMLSPublicKeys (NewClient -> MLSPublicKeys)
-> SchemaP SwaggerDoc Object [Pair] MLSPublicKeys MLSPublicKeys
-> SchemaP SwaggerDoc Object [Pair] NewClient MLSPublicKeys
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] MLSPublicKeys MLSPublicKeys
mlsPublicKeysFieldSchema
        SchemaP
  SwaggerDoc Object [Pair] NewClient (Maybe Value -> NewClient)
-> SchemaP SwaggerDoc Object [Pair] NewClient (Maybe Value)
-> SchemaP SwaggerDoc Object [Pair] NewClient NewClient
forall a b.
SchemaP SwaggerDoc Object [Pair] NewClient (a -> b)
-> SchemaP SwaggerDoc Object [Pair] NewClient a
-> SchemaP SwaggerDoc Object [Pair] NewClient b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NewClient -> Maybe Value
newClientVerificationCode (NewClient -> Maybe Value)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Value) (Maybe Value)
-> SchemaP SwaggerDoc Object [Pair] NewClient (Maybe Value)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] Value (Maybe Value)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Value) (Maybe Value)
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 Value Value
-> SchemaP SwaggerDoc Object [Pair] Value (Maybe Value)
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
"verification_code" SchemaP NamedSwaggerDoc Value Value Value Value
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)

newClient :: ClientType -> LastPrekey -> NewClient
newClient :: ClientType -> LastPrekey -> NewClient
newClient ClientType
t LastPrekey
k =
  NewClient
    { $sel:newClientPrekeys:NewClient :: [Prekey]
newClientPrekeys = [],
      $sel:newClientLastKey:NewClient :: LastPrekey
newClientLastKey = LastPrekey
k,
      $sel:newClientType:NewClient :: ClientType
newClientType = ClientType
t,
      $sel:newClientLabel:NewClient :: Maybe Text
newClientLabel = Maybe Text
forall a. Maybe a
Nothing,
      $sel:newClientClass:NewClient :: Maybe ClientClass
newClientClass = if ClientType
t ClientType -> ClientType -> Bool
forall a. Eq a => a -> a -> Bool
== ClientType
LegalHoldClientType then ClientClass -> Maybe ClientClass
forall a. a -> Maybe a
Just ClientClass
LegalHoldClient else Maybe ClientClass
forall a. Maybe a
Nothing,
      $sel:newClientCookie:NewClient :: Maybe CookieLabel
newClientCookie = Maybe CookieLabel
forall a. Maybe a
Nothing,
      $sel:newClientPassword:NewClient :: Maybe PlainTextPassword6
newClientPassword = Maybe PlainTextPassword6
forall a. Maybe a
Nothing,
      $sel:newClientModel:NewClient :: Maybe Text
newClientModel = Maybe Text
forall a. Maybe a
Nothing,
      $sel:newClientCapabilities:NewClient :: Maybe ClientCapabilityList
newClientCapabilities = Maybe ClientCapabilityList
forall a. Maybe a
Nothing,
      $sel:newClientMLSPublicKeys:NewClient :: MLSPublicKeys
newClientMLSPublicKeys = MLSPublicKeys
forall a. Monoid a => a
mempty,
      $sel:newClientVerificationCode:NewClient :: Maybe Value
newClientVerificationCode = Maybe Value
forall a. Maybe a
Nothing
    }

--------------------------------------------------------------------------------
-- UpdateClient

data UpdateClient = UpdateClient
  { UpdateClient -> [Prekey]
updateClientPrekeys :: [Prekey],
    UpdateClient -> Maybe LastPrekey
updateClientLastKey :: Maybe LastPrekey,
    UpdateClient -> Maybe Text
updateClientLabel :: Maybe Text,
    -- | see haddocks for 'ClientCapability'
    UpdateClient -> Maybe ClientCapabilityList
updateClientCapabilities :: Maybe ClientCapabilityList,
    UpdateClient -> MLSPublicKeys
updateClientMLSPublicKeys :: MLSPublicKeys
  }
  deriving stock (UpdateClient -> UpdateClient -> Bool
(UpdateClient -> UpdateClient -> Bool)
-> (UpdateClient -> UpdateClient -> Bool) -> Eq UpdateClient
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UpdateClient -> UpdateClient -> Bool
== :: UpdateClient -> UpdateClient -> Bool
$c/= :: UpdateClient -> UpdateClient -> Bool
/= :: UpdateClient -> UpdateClient -> Bool
Eq, Int -> UpdateClient -> ShowS
[UpdateClient] -> ShowS
UpdateClient -> [Char]
(Int -> UpdateClient -> ShowS)
-> (UpdateClient -> [Char])
-> ([UpdateClient] -> ShowS)
-> Show UpdateClient
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UpdateClient -> ShowS
showsPrec :: Int -> UpdateClient -> ShowS
$cshow :: UpdateClient -> [Char]
show :: UpdateClient -> [Char]
$cshowList :: [UpdateClient] -> ShowS
showList :: [UpdateClient] -> ShowS
Show, (forall x. UpdateClient -> Rep UpdateClient x)
-> (forall x. Rep UpdateClient x -> UpdateClient)
-> Generic UpdateClient
forall x. Rep UpdateClient x -> UpdateClient
forall x. UpdateClient -> Rep UpdateClient x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. UpdateClient -> Rep UpdateClient x
from :: forall x. UpdateClient -> Rep UpdateClient x
$cto :: forall x. Rep UpdateClient x -> UpdateClient
to :: forall x. Rep UpdateClient x -> UpdateClient
Generic)
  deriving (Gen UpdateClient
Gen UpdateClient
-> (UpdateClient -> [UpdateClient]) -> Arbitrary UpdateClient
UpdateClient -> [UpdateClient]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen UpdateClient
arbitrary :: Gen UpdateClient
$cshrink :: UpdateClient -> [UpdateClient]
shrink :: UpdateClient -> [UpdateClient]
Arbitrary) via (GenericUniform UpdateClient)
  deriving (Value -> Parser [UpdateClient]
Value -> Parser UpdateClient
(Value -> Parser UpdateClient)
-> (Value -> Parser [UpdateClient]) -> FromJSON UpdateClient
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser UpdateClient
parseJSON :: Value -> Parser UpdateClient
$cparseJSONList :: Value -> Parser [UpdateClient]
parseJSONList :: Value -> Parser [UpdateClient]
FromJSON, [UpdateClient] -> Value
[UpdateClient] -> Encoding
UpdateClient -> Value
UpdateClient -> Encoding
(UpdateClient -> Value)
-> (UpdateClient -> Encoding)
-> ([UpdateClient] -> Value)
-> ([UpdateClient] -> Encoding)
-> ToJSON UpdateClient
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: UpdateClient -> Value
toJSON :: UpdateClient -> Value
$ctoEncoding :: UpdateClient -> Encoding
toEncoding :: UpdateClient -> Encoding
$ctoJSONList :: [UpdateClient] -> Value
toJSONList :: [UpdateClient] -> Value
$ctoEncodingList :: [UpdateClient] -> Encoding
toEncodingList :: [UpdateClient] -> Encoding
ToJSON, Typeable UpdateClient
Typeable UpdateClient =>
(Proxy UpdateClient -> Declare (Definitions Schema) NamedSchema)
-> ToSchema UpdateClient
Proxy UpdateClient -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy UpdateClient -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy UpdateClient -> Declare (Definitions Schema) NamedSchema
Swagger.ToSchema) via Schema UpdateClient

defUpdateClient :: UpdateClient
defUpdateClient :: UpdateClient
defUpdateClient =
  UpdateClient
    { $sel:updateClientPrekeys:UpdateClient :: [Prekey]
updateClientPrekeys = [],
      $sel:updateClientLastKey:UpdateClient :: Maybe LastPrekey
updateClientLastKey = Maybe LastPrekey
forall a. Maybe a
Nothing,
      $sel:updateClientLabel:UpdateClient :: Maybe Text
updateClientLabel = Maybe Text
forall a. Maybe a
Nothing,
      $sel:updateClientCapabilities:UpdateClient :: Maybe ClientCapabilityList
updateClientCapabilities = Maybe ClientCapabilityList
forall a. Maybe a
Nothing,
      $sel:updateClientMLSPublicKeys:UpdateClient :: MLSPublicKeys
updateClientMLSPublicKeys = MLSPublicKeys
forall a. Monoid a => a
mempty
    }

instance ToSchema UpdateClient where
  schema :: ValueSchema NamedSwaggerDoc UpdateClient
schema =
    Text
-> SchemaP SwaggerDoc Object [Pair] UpdateClient UpdateClient
-> ValueSchema NamedSwaggerDoc UpdateClient
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"UpdateClient" (SchemaP SwaggerDoc Object [Pair] UpdateClient UpdateClient
 -> ValueSchema NamedSwaggerDoc UpdateClient)
-> SchemaP SwaggerDoc Object [Pair] UpdateClient UpdateClient
-> ValueSchema NamedSwaggerDoc UpdateClient
forall a b. (a -> b) -> a -> b
$
      [Prekey]
-> Maybe LastPrekey
-> Maybe Text
-> Maybe ClientCapabilityList
-> MLSPublicKeys
-> UpdateClient
UpdateClient
        ([Prekey]
 -> Maybe LastPrekey
 -> Maybe Text
 -> Maybe ClientCapabilityList
 -> MLSPublicKeys
 -> UpdateClient)
-> SchemaP SwaggerDoc Object [Pair] UpdateClient [Prekey]
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     UpdateClient
     (Maybe LastPrekey
      -> Maybe Text
      -> Maybe ClientCapabilityList
      -> MLSPublicKeys
      -> UpdateClient)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> UpdateClient -> [Prekey]
updateClientPrekeys
          (UpdateClient -> [Prekey])
-> SchemaP SwaggerDoc Object [Pair] [Prekey] [Prekey]
-> SchemaP SwaggerDoc Object [Pair] UpdateClient [Prekey]
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= ( [Prekey] -> Maybe [Prekey] -> [Prekey]
forall a. a -> Maybe a -> a
fromMaybe []
                 (Maybe [Prekey] -> [Prekey])
-> SchemaP SwaggerDoc Object [Pair] [Prekey] (Maybe [Prekey])
-> SchemaP SwaggerDoc Object [Pair] [Prekey] [Prekey]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text
-> (SwaggerDoc -> SwaggerDoc)
-> SchemaP SwaggerDoc Value Value [Prekey] [Prekey]
-> SchemaP SwaggerDoc Object [Pair] [Prekey] (Maybe [Prekey])
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
"prekeys"
                   ((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
"New prekeys for other clients to establish OTR sessions.")
                   (SchemaP NamedSwaggerDoc Value Value Prekey Prekey
-> SchemaP SwaggerDoc Value Value [Prekey] [Prekey]
forall ndoc doc a.
(HasArray ndoc doc, HasName ndoc) =>
ValueSchema ndoc a -> ValueSchema doc [a]
array SchemaP NamedSwaggerDoc Value Value Prekey Prekey
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
             )
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  UpdateClient
  (Maybe LastPrekey
   -> Maybe Text
   -> Maybe ClientCapabilityList
   -> MLSPublicKeys
   -> UpdateClient)
-> SchemaP SwaggerDoc Object [Pair] UpdateClient (Maybe LastPrekey)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     UpdateClient
     (Maybe Text
      -> Maybe ClientCapabilityList -> MLSPublicKeys -> UpdateClient)
forall a b.
SchemaP SwaggerDoc Object [Pair] UpdateClient (a -> b)
-> SchemaP SwaggerDoc Object [Pair] UpdateClient a
-> SchemaP SwaggerDoc Object [Pair] UpdateClient b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> UpdateClient -> Maybe LastPrekey
updateClientLastKey
          (UpdateClient -> Maybe LastPrekey)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe LastPrekey) (Maybe LastPrekey)
-> SchemaP SwaggerDoc Object [Pair] UpdateClient (Maybe LastPrekey)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] LastPrekey (Maybe LastPrekey)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe LastPrekey) (Maybe LastPrekey)
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 LastPrekey LastPrekey
-> SchemaP SwaggerDoc Object [Pair] LastPrekey (Maybe LastPrekey)
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
"lastkey"
                ((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
"New last-resort prekey.")
                SchemaP NamedSwaggerDoc Value Value LastPrekey LastPrekey
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
            )
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  UpdateClient
  (Maybe Text
   -> Maybe ClientCapabilityList -> MLSPublicKeys -> UpdateClient)
-> SchemaP SwaggerDoc Object [Pair] UpdateClient (Maybe Text)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     UpdateClient
     (Maybe ClientCapabilityList -> MLSPublicKeys -> UpdateClient)
forall a b.
SchemaP SwaggerDoc Object [Pair] UpdateClient (a -> b)
-> SchemaP SwaggerDoc Object [Pair] UpdateClient a
-> SchemaP SwaggerDoc Object [Pair] UpdateClient b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> UpdateClient -> Maybe Text
updateClientLabel
          (UpdateClient -> Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] UpdateClient (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
"label"
                ((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
"A new name for this client.")
                SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
            )
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  UpdateClient
  (Maybe ClientCapabilityList -> MLSPublicKeys -> UpdateClient)
-> SchemaP
     SwaggerDoc Object [Pair] UpdateClient (Maybe ClientCapabilityList)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     UpdateClient
     (MLSPublicKeys -> UpdateClient)
forall a b.
SchemaP SwaggerDoc Object [Pair] UpdateClient (a -> b)
-> SchemaP SwaggerDoc Object [Pair] UpdateClient a
-> SchemaP SwaggerDoc Object [Pair] UpdateClient b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> UpdateClient -> Maybe ClientCapabilityList
updateClientCapabilities
          (UpdateClient -> Maybe ClientCapabilityList)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe ClientCapabilityList)
     (Maybe ClientCapabilityList)
-> SchemaP
     SwaggerDoc Object [Pair] UpdateClient (Maybe ClientCapabilityList)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP
  SwaggerDoc
  Object
  [Pair]
  ClientCapabilityList
  (Maybe ClientCapabilityList)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe ClientCapabilityList)
     (Maybe ClientCapabilityList)
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)
-> ValueSchema NamedSwaggerDoc ClientCapabilityList
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     ClientCapabilityList
     (Maybe ClientCapabilityList)
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
"capabilities"
                ((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
"Hints provided by the client for the backend so it can behave in a backwards-compatible way.")
                ValueSchema NamedSwaggerDoc ClientCapabilityList
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
            )
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  UpdateClient
  (MLSPublicKeys -> UpdateClient)
-> SchemaP SwaggerDoc Object [Pair] UpdateClient MLSPublicKeys
-> SchemaP SwaggerDoc Object [Pair] UpdateClient UpdateClient
forall a b.
SchemaP SwaggerDoc Object [Pair] UpdateClient (a -> b)
-> SchemaP SwaggerDoc Object [Pair] UpdateClient a
-> SchemaP SwaggerDoc Object [Pair] UpdateClient b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> UpdateClient -> MLSPublicKeys
updateClientMLSPublicKeys (UpdateClient -> MLSPublicKeys)
-> SchemaP SwaggerDoc Object [Pair] MLSPublicKeys MLSPublicKeys
-> SchemaP SwaggerDoc Object [Pair] UpdateClient MLSPublicKeys
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] MLSPublicKeys MLSPublicKeys
mlsPublicKeysFieldSchema

--------------------------------------------------------------------------------
-- RmClient

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

instance ToSchema RmClient where
  schema :: ValueSchema NamedSwaggerDoc RmClient
schema =
    Text
-> SchemaP SwaggerDoc Object [Pair] RmClient RmClient
-> ValueSchema NamedSwaggerDoc RmClient
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"DeleteClient" (SchemaP SwaggerDoc Object [Pair] RmClient RmClient
 -> ValueSchema NamedSwaggerDoc RmClient)
-> SchemaP SwaggerDoc Object [Pair] RmClient RmClient
-> ValueSchema NamedSwaggerDoc RmClient
forall a b. (a -> b) -> a -> b
$
      Maybe PlainTextPassword6 -> RmClient
RmClient
        (Maybe PlainTextPassword6 -> RmClient)
-> SchemaP
     SwaggerDoc Object [Pair] RmClient (Maybe PlainTextPassword6)
-> SchemaP SwaggerDoc Object [Pair] RmClient RmClient
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RmClient -> Maybe PlainTextPassword6
rmPassword
          (RmClient -> Maybe PlainTextPassword6)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe PlainTextPassword6)
     (Maybe PlainTextPassword6)
-> SchemaP
     SwaggerDoc Object [Pair] RmClient (Maybe PlainTextPassword6)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     (Maybe PlainTextPassword6)
     PlainTextPassword6
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe PlainTextPassword6)
     (Maybe PlainTextPassword6)
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
"password"
            ( (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
"The password of the authenticated user for verification. \
                   \The password is not required for deleting temporary clients."
            )
            (Value
-> SchemaP
     NamedSwaggerDoc Value Value PlainTextPassword6 PlainTextPassword6
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     (Maybe PlainTextPassword6)
     PlainTextPassword6
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 PlainTextPassword6 PlainTextPassword6
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)