-- 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.MLS.Keys where

import Control.Lens ((?~))
import Crypto.ECC (Curve_P256R1, Curve_P384R1, Curve_P521R1)
import Crypto.PubKey.ECDSA qualified as ECDSA
import Data.Aeson (FromJSON (..), ToJSON (..))
import Data.Aeson qualified as A
import Data.Bifunctor
import Data.ByteArray (ByteArray)
import Data.ByteArray qualified as BA
import Data.Default
import Data.Json.Util
import Data.OpenApi qualified as S
import Data.Proxy
import Data.Schema hiding (HasField)
import Imports hiding (First, getFirst)
import Web.HttpApiData
import Wire.API.MLS.CipherSuite

data MLSKeysByPurpose a = MLSKeysByPurpose
  { forall a. MLSKeysByPurpose a -> a
removal :: a
  }
  deriving (MLSKeysByPurpose a -> MLSKeysByPurpose a -> Bool
(MLSKeysByPurpose a -> MLSKeysByPurpose a -> Bool)
-> (MLSKeysByPurpose a -> MLSKeysByPurpose a -> Bool)
-> Eq (MLSKeysByPurpose a)
forall a. Eq a => MLSKeysByPurpose a -> MLSKeysByPurpose a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => MLSKeysByPurpose a -> MLSKeysByPurpose a -> Bool
== :: MLSKeysByPurpose a -> MLSKeysByPurpose a -> Bool
$c/= :: forall a. Eq a => MLSKeysByPurpose a -> MLSKeysByPurpose a -> Bool
/= :: MLSKeysByPurpose a -> MLSKeysByPurpose a -> Bool
Eq, Int -> MLSKeysByPurpose a -> ShowS
[MLSKeysByPurpose a] -> ShowS
MLSKeysByPurpose a -> String
(Int -> MLSKeysByPurpose a -> ShowS)
-> (MLSKeysByPurpose a -> String)
-> ([MLSKeysByPurpose a] -> ShowS)
-> Show (MLSKeysByPurpose a)
forall a. Show a => Int -> MLSKeysByPurpose a -> ShowS
forall a. Show a => [MLSKeysByPurpose a] -> ShowS
forall a. Show a => MLSKeysByPurpose a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> MLSKeysByPurpose a -> ShowS
showsPrec :: Int -> MLSKeysByPurpose a -> ShowS
$cshow :: forall a. Show a => MLSKeysByPurpose a -> String
show :: MLSKeysByPurpose a -> String
$cshowList :: forall a. Show a => [MLSKeysByPurpose a] -> ShowS
showList :: [MLSKeysByPurpose a] -> ShowS
Show, (forall a b. (a -> b) -> MLSKeysByPurpose a -> MLSKeysByPurpose b)
-> (forall a b. a -> MLSKeysByPurpose b -> MLSKeysByPurpose a)
-> Functor MLSKeysByPurpose
forall a b. a -> MLSKeysByPurpose b -> MLSKeysByPurpose a
forall a b. (a -> b) -> MLSKeysByPurpose a -> MLSKeysByPurpose 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) -> MLSKeysByPurpose a -> MLSKeysByPurpose b
fmap :: forall a b. (a -> b) -> MLSKeysByPurpose a -> MLSKeysByPurpose b
$c<$ :: forall a b. a -> MLSKeysByPurpose b -> MLSKeysByPurpose a
<$ :: forall a b. a -> MLSKeysByPurpose b -> MLSKeysByPurpose a
Functor, (forall m. Monoid m => MLSKeysByPurpose m -> m)
-> (forall m a. Monoid m => (a -> m) -> MLSKeysByPurpose a -> m)
-> (forall m a. Monoid m => (a -> m) -> MLSKeysByPurpose a -> m)
-> (forall a b. (a -> b -> b) -> b -> MLSKeysByPurpose a -> b)
-> (forall a b. (a -> b -> b) -> b -> MLSKeysByPurpose a -> b)
-> (forall b a. (b -> a -> b) -> b -> MLSKeysByPurpose a -> b)
-> (forall b a. (b -> a -> b) -> b -> MLSKeysByPurpose a -> b)
-> (forall a. (a -> a -> a) -> MLSKeysByPurpose a -> a)
-> (forall a. (a -> a -> a) -> MLSKeysByPurpose a -> a)
-> (forall a. MLSKeysByPurpose a -> [a])
-> (forall a. MLSKeysByPurpose a -> Bool)
-> (forall a. MLSKeysByPurpose a -> Int)
-> (forall a. Eq a => a -> MLSKeysByPurpose a -> Bool)
-> (forall a. Ord a => MLSKeysByPurpose a -> a)
-> (forall a. Ord a => MLSKeysByPurpose a -> a)
-> (forall a. Num a => MLSKeysByPurpose a -> a)
-> (forall a. Num a => MLSKeysByPurpose a -> a)
-> Foldable MLSKeysByPurpose
forall a. Eq a => a -> MLSKeysByPurpose a -> Bool
forall a. Num a => MLSKeysByPurpose a -> a
forall a. Ord a => MLSKeysByPurpose a -> a
forall m. Monoid m => MLSKeysByPurpose m -> m
forall a. MLSKeysByPurpose a -> Bool
forall a. MLSKeysByPurpose a -> Int
forall a. MLSKeysByPurpose a -> [a]
forall a. (a -> a -> a) -> MLSKeysByPurpose a -> a
forall m a. Monoid m => (a -> m) -> MLSKeysByPurpose a -> m
forall b a. (b -> a -> b) -> b -> MLSKeysByPurpose a -> b
forall a b. (a -> b -> b) -> b -> MLSKeysByPurpose 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 => MLSKeysByPurpose m -> m
fold :: forall m. Monoid m => MLSKeysByPurpose m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> MLSKeysByPurpose a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> MLSKeysByPurpose a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> MLSKeysByPurpose a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> MLSKeysByPurpose a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> MLSKeysByPurpose a -> b
foldr :: forall a b. (a -> b -> b) -> b -> MLSKeysByPurpose a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> MLSKeysByPurpose a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> MLSKeysByPurpose a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> MLSKeysByPurpose a -> b
foldl :: forall b a. (b -> a -> b) -> b -> MLSKeysByPurpose a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> MLSKeysByPurpose a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> MLSKeysByPurpose a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> MLSKeysByPurpose a -> a
foldr1 :: forall a. (a -> a -> a) -> MLSKeysByPurpose a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> MLSKeysByPurpose a -> a
foldl1 :: forall a. (a -> a -> a) -> MLSKeysByPurpose a -> a
$ctoList :: forall a. MLSKeysByPurpose a -> [a]
toList :: forall a. MLSKeysByPurpose a -> [a]
$cnull :: forall a. MLSKeysByPurpose a -> Bool
null :: forall a. MLSKeysByPurpose a -> Bool
$clength :: forall a. MLSKeysByPurpose a -> Int
length :: forall a. MLSKeysByPurpose a -> Int
$celem :: forall a. Eq a => a -> MLSKeysByPurpose a -> Bool
elem :: forall a. Eq a => a -> MLSKeysByPurpose a -> Bool
$cmaximum :: forall a. Ord a => MLSKeysByPurpose a -> a
maximum :: forall a. Ord a => MLSKeysByPurpose a -> a
$cminimum :: forall a. Ord a => MLSKeysByPurpose a -> a
minimum :: forall a. Ord a => MLSKeysByPurpose a -> a
$csum :: forall a. Num a => MLSKeysByPurpose a -> a
sum :: forall a. Num a => MLSKeysByPurpose a -> a
$cproduct :: forall a. Num a => MLSKeysByPurpose a -> a
product :: forall a. Num a => MLSKeysByPurpose a -> a
Foldable, Functor MLSKeysByPurpose
Foldable MLSKeysByPurpose
(Functor MLSKeysByPurpose, Foldable MLSKeysByPurpose) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> MLSKeysByPurpose a -> f (MLSKeysByPurpose b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    MLSKeysByPurpose (f a) -> f (MLSKeysByPurpose a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> MLSKeysByPurpose a -> m (MLSKeysByPurpose b))
-> (forall (m :: * -> *) a.
    Monad m =>
    MLSKeysByPurpose (m a) -> m (MLSKeysByPurpose a))
-> Traversable MLSKeysByPurpose
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 =>
MLSKeysByPurpose (m a) -> m (MLSKeysByPurpose a)
forall (f :: * -> *) a.
Applicative f =>
MLSKeysByPurpose (f a) -> f (MLSKeysByPurpose a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> MLSKeysByPurpose a -> m (MLSKeysByPurpose b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> MLSKeysByPurpose a -> f (MLSKeysByPurpose b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> MLSKeysByPurpose a -> f (MLSKeysByPurpose b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> MLSKeysByPurpose a -> f (MLSKeysByPurpose b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
MLSKeysByPurpose (f a) -> f (MLSKeysByPurpose a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
MLSKeysByPurpose (f a) -> f (MLSKeysByPurpose a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> MLSKeysByPurpose a -> m (MLSKeysByPurpose b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> MLSKeysByPurpose a -> m (MLSKeysByPurpose b)
$csequence :: forall (m :: * -> *) a.
Monad m =>
MLSKeysByPurpose (m a) -> m (MLSKeysByPurpose a)
sequence :: forall (m :: * -> *) a.
Monad m =>
MLSKeysByPurpose (m a) -> m (MLSKeysByPurpose a)
Traversable)
  deriving (Value -> Parser [MLSKeysByPurpose a]
Value -> Parser (MLSKeysByPurpose a)
(Value -> Parser (MLSKeysByPurpose a))
-> (Value -> Parser [MLSKeysByPurpose a])
-> FromJSON (MLSKeysByPurpose a)
forall a. ToSchema a => Value -> Parser [MLSKeysByPurpose a]
forall a. ToSchema a => Value -> Parser (MLSKeysByPurpose a)
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: forall a. ToSchema a => Value -> Parser (MLSKeysByPurpose a)
parseJSON :: Value -> Parser (MLSKeysByPurpose a)
$cparseJSONList :: forall a. ToSchema a => Value -> Parser [MLSKeysByPurpose a]
parseJSONList :: Value -> Parser [MLSKeysByPurpose a]
FromJSON, [MLSKeysByPurpose a] -> Value
[MLSKeysByPurpose a] -> Encoding
MLSKeysByPurpose a -> Value
MLSKeysByPurpose a -> Encoding
(MLSKeysByPurpose a -> Value)
-> (MLSKeysByPurpose a -> Encoding)
-> ([MLSKeysByPurpose a] -> Value)
-> ([MLSKeysByPurpose a] -> Encoding)
-> ToJSON (MLSKeysByPurpose a)
forall a. ToSchema a => [MLSKeysByPurpose a] -> Value
forall a. ToSchema a => [MLSKeysByPurpose a] -> Encoding
forall a. ToSchema a => MLSKeysByPurpose a -> Value
forall a. ToSchema a => MLSKeysByPurpose a -> Encoding
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: forall a. ToSchema a => MLSKeysByPurpose a -> Value
toJSON :: MLSKeysByPurpose a -> Value
$ctoEncoding :: forall a. ToSchema a => MLSKeysByPurpose a -> Encoding
toEncoding :: MLSKeysByPurpose a -> Encoding
$ctoJSONList :: forall a. ToSchema a => [MLSKeysByPurpose a] -> Value
toJSONList :: [MLSKeysByPurpose a] -> Value
$ctoEncodingList :: forall a. ToSchema a => [MLSKeysByPurpose a] -> Encoding
toEncodingList :: [MLSKeysByPurpose a] -> Encoding
ToJSON, Typeable (MLSKeysByPurpose a)
Typeable (MLSKeysByPurpose a) =>
(Proxy (MLSKeysByPurpose a)
 -> Declare (Definitions Schema) NamedSchema)
-> ToSchema (MLSKeysByPurpose a)
Proxy (MLSKeysByPurpose a)
-> Declare (Definitions Schema) NamedSchema
forall a. (Typeable a, ToSchema a) => Typeable (MLSKeysByPurpose a)
forall a.
(Typeable a, ToSchema a) =>
Proxy (MLSKeysByPurpose 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 (MLSKeysByPurpose a)
-> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy (MLSKeysByPurpose a)
-> Declare (Definitions Schema) NamedSchema
S.ToSchema) via Schema (MLSKeysByPurpose a)

instance (ToSchema a) => ToSchema (MLSKeysByPurpose a) where
  schema :: ValueSchema NamedSwaggerDoc (MLSKeysByPurpose a)
schema =
    Text
-> SchemaP
     SwaggerDoc Object [Pair] (MLSKeysByPurpose a) (MLSKeysByPurpose a)
-> ValueSchema NamedSwaggerDoc (MLSKeysByPurpose a)
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"MLSKeysByPurpose" (SchemaP
   SwaggerDoc Object [Pair] (MLSKeysByPurpose a) (MLSKeysByPurpose a)
 -> ValueSchema NamedSwaggerDoc (MLSKeysByPurpose a))
-> SchemaP
     SwaggerDoc Object [Pair] (MLSKeysByPurpose a) (MLSKeysByPurpose a)
-> ValueSchema NamedSwaggerDoc (MLSKeysByPurpose a)
forall a b. (a -> b) -> a -> b
$
      a -> MLSKeysByPurpose a
forall a. a -> MLSKeysByPurpose a
MLSKeysByPurpose
        (a -> MLSKeysByPurpose a)
-> SchemaP SwaggerDoc Object [Pair] (MLSKeysByPurpose a) a
-> SchemaP
     SwaggerDoc Object [Pair] (MLSKeysByPurpose a) (MLSKeysByPurpose a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (.removal) (MLSKeysByPurpose a -> a)
-> SchemaP SwaggerDoc Object [Pair] a a
-> SchemaP SwaggerDoc Object [Pair] (MLSKeysByPurpose a) a
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value a a
-> SchemaP SwaggerDoc Object [Pair] a a
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"removal" SchemaP NamedSwaggerDoc Value Value a a
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema

data MLSKeys a = MLSKeys
  { forall a. MLSKeys a -> a
ed25519 :: a,
    forall a. MLSKeys a -> a
ecdsa_secp256r1_sha256 :: a,
    forall a. MLSKeys a -> a
ecdsa_secp384r1_sha384 :: a,
    forall a. MLSKeys a -> a
ecdsa_secp521r1_sha512 :: a
  }
  deriving (MLSKeys a -> MLSKeys a -> Bool
(MLSKeys a -> MLSKeys a -> Bool)
-> (MLSKeys a -> MLSKeys a -> Bool) -> Eq (MLSKeys a)
forall a. Eq a => MLSKeys a -> MLSKeys a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => MLSKeys a -> MLSKeys a -> Bool
== :: MLSKeys a -> MLSKeys a -> Bool
$c/= :: forall a. Eq a => MLSKeys a -> MLSKeys a -> Bool
/= :: MLSKeys a -> MLSKeys a -> Bool
Eq, Int -> MLSKeys a -> ShowS
[MLSKeys a] -> ShowS
MLSKeys a -> String
(Int -> MLSKeys a -> ShowS)
-> (MLSKeys a -> String)
-> ([MLSKeys a] -> ShowS)
-> Show (MLSKeys a)
forall a. Show a => Int -> MLSKeys a -> ShowS
forall a. Show a => [MLSKeys a] -> ShowS
forall a. Show a => MLSKeys a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> MLSKeys a -> ShowS
showsPrec :: Int -> MLSKeys a -> ShowS
$cshow :: forall a. Show a => MLSKeys a -> String
show :: MLSKeys a -> String
$cshowList :: forall a. Show a => [MLSKeys a] -> ShowS
showList :: [MLSKeys a] -> ShowS
Show, (forall a b. (a -> b) -> MLSKeys a -> MLSKeys b)
-> (forall a b. a -> MLSKeys b -> MLSKeys a) -> Functor MLSKeys
forall a b. a -> MLSKeys b -> MLSKeys a
forall a b. (a -> b) -> MLSKeys a -> MLSKeys 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) -> MLSKeys a -> MLSKeys b
fmap :: forall a b. (a -> b) -> MLSKeys a -> MLSKeys b
$c<$ :: forall a b. a -> MLSKeys b -> MLSKeys a
<$ :: forall a b. a -> MLSKeys b -> MLSKeys a
Functor, (forall m. Monoid m => MLSKeys m -> m)
-> (forall m a. Monoid m => (a -> m) -> MLSKeys a -> m)
-> (forall m a. Monoid m => (a -> m) -> MLSKeys a -> m)
-> (forall a b. (a -> b -> b) -> b -> MLSKeys a -> b)
-> (forall a b. (a -> b -> b) -> b -> MLSKeys a -> b)
-> (forall b a. (b -> a -> b) -> b -> MLSKeys a -> b)
-> (forall b a. (b -> a -> b) -> b -> MLSKeys a -> b)
-> (forall a. (a -> a -> a) -> MLSKeys a -> a)
-> (forall a. (a -> a -> a) -> MLSKeys a -> a)
-> (forall a. MLSKeys a -> [a])
-> (forall a. MLSKeys a -> Bool)
-> (forall a. MLSKeys a -> Int)
-> (forall a. Eq a => a -> MLSKeys a -> Bool)
-> (forall a. Ord a => MLSKeys a -> a)
-> (forall a. Ord a => MLSKeys a -> a)
-> (forall a. Num a => MLSKeys a -> a)
-> (forall a. Num a => MLSKeys a -> a)
-> Foldable MLSKeys
forall a. Eq a => a -> MLSKeys a -> Bool
forall a. Num a => MLSKeys a -> a
forall a. Ord a => MLSKeys a -> a
forall m. Monoid m => MLSKeys m -> m
forall a. MLSKeys a -> Bool
forall a. MLSKeys a -> Int
forall a. MLSKeys a -> [a]
forall a. (a -> a -> a) -> MLSKeys a -> a
forall m a. Monoid m => (a -> m) -> MLSKeys a -> m
forall b a. (b -> a -> b) -> b -> MLSKeys a -> b
forall a b. (a -> b -> b) -> b -> MLSKeys 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 => MLSKeys m -> m
fold :: forall m. Monoid m => MLSKeys m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> MLSKeys a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> MLSKeys a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> MLSKeys a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> MLSKeys a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> MLSKeys a -> b
foldr :: forall a b. (a -> b -> b) -> b -> MLSKeys a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> MLSKeys a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> MLSKeys a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> MLSKeys a -> b
foldl :: forall b a. (b -> a -> b) -> b -> MLSKeys a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> MLSKeys a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> MLSKeys a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> MLSKeys a -> a
foldr1 :: forall a. (a -> a -> a) -> MLSKeys a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> MLSKeys a -> a
foldl1 :: forall a. (a -> a -> a) -> MLSKeys a -> a
$ctoList :: forall a. MLSKeys a -> [a]
toList :: forall a. MLSKeys a -> [a]
$cnull :: forall a. MLSKeys a -> Bool
null :: forall a. MLSKeys a -> Bool
$clength :: forall a. MLSKeys a -> Int
length :: forall a. MLSKeys a -> Int
$celem :: forall a. Eq a => a -> MLSKeys a -> Bool
elem :: forall a. Eq a => a -> MLSKeys a -> Bool
$cmaximum :: forall a. Ord a => MLSKeys a -> a
maximum :: forall a. Ord a => MLSKeys a -> a
$cminimum :: forall a. Ord a => MLSKeys a -> a
minimum :: forall a. Ord a => MLSKeys a -> a
$csum :: forall a. Num a => MLSKeys a -> a
sum :: forall a. Num a => MLSKeys a -> a
$cproduct :: forall a. Num a => MLSKeys a -> a
product :: forall a. Num a => MLSKeys a -> a
Foldable, Functor MLSKeys
Foldable MLSKeys
(Functor MLSKeys, Foldable MLSKeys) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> MLSKeys a -> f (MLSKeys b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    MLSKeys (f a) -> f (MLSKeys a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> MLSKeys a -> m (MLSKeys b))
-> (forall (m :: * -> *) a.
    Monad m =>
    MLSKeys (m a) -> m (MLSKeys a))
-> Traversable MLSKeys
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 => MLSKeys (m a) -> m (MLSKeys a)
forall (f :: * -> *) a.
Applicative f =>
MLSKeys (f a) -> f (MLSKeys a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> MLSKeys a -> m (MLSKeys b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> MLSKeys a -> f (MLSKeys b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> MLSKeys a -> f (MLSKeys b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> MLSKeys a -> f (MLSKeys b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
MLSKeys (f a) -> f (MLSKeys a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
MLSKeys (f a) -> f (MLSKeys a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> MLSKeys a -> m (MLSKeys b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> MLSKeys a -> m (MLSKeys b)
$csequence :: forall (m :: * -> *) a. Monad m => MLSKeys (m a) -> m (MLSKeys a)
sequence :: forall (m :: * -> *) a. Monad m => MLSKeys (m a) -> m (MLSKeys a)
Traversable)
  deriving (Value -> Parser [MLSKeys a]
Value -> Parser (MLSKeys a)
(Value -> Parser (MLSKeys a))
-> (Value -> Parser [MLSKeys a]) -> FromJSON (MLSKeys a)
forall a. ToSchema a => Value -> Parser [MLSKeys a]
forall a. ToSchema a => Value -> Parser (MLSKeys a)
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: forall a. ToSchema a => Value -> Parser (MLSKeys a)
parseJSON :: Value -> Parser (MLSKeys a)
$cparseJSONList :: forall a. ToSchema a => Value -> Parser [MLSKeys a]
parseJSONList :: Value -> Parser [MLSKeys a]
FromJSON, [MLSKeys a] -> Value
[MLSKeys a] -> Encoding
MLSKeys a -> Value
MLSKeys a -> Encoding
(MLSKeys a -> Value)
-> (MLSKeys a -> Encoding)
-> ([MLSKeys a] -> Value)
-> ([MLSKeys a] -> Encoding)
-> ToJSON (MLSKeys a)
forall a. ToSchema a => [MLSKeys a] -> Value
forall a. ToSchema a => [MLSKeys a] -> Encoding
forall a. ToSchema a => MLSKeys a -> Value
forall a. ToSchema a => MLSKeys a -> Encoding
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: forall a. ToSchema a => MLSKeys a -> Value
toJSON :: MLSKeys a -> Value
$ctoEncoding :: forall a. ToSchema a => MLSKeys a -> Encoding
toEncoding :: MLSKeys a -> Encoding
$ctoJSONList :: forall a. ToSchema a => [MLSKeys a] -> Value
toJSONList :: [MLSKeys a] -> Value
$ctoEncodingList :: forall a. ToSchema a => [MLSKeys a] -> Encoding
toEncodingList :: [MLSKeys a] -> Encoding
ToJSON, Typeable (MLSKeys a)
Typeable (MLSKeys a) =>
(Proxy (MLSKeys a) -> Declare (Definitions Schema) NamedSchema)
-> ToSchema (MLSKeys a)
Proxy (MLSKeys a) -> Declare (Definitions Schema) NamedSchema
forall a. (Typeable a, ToSchema a) => Typeable (MLSKeys a)
forall a.
(Typeable a, ToSchema a) =>
Proxy (MLSKeys 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 (MLSKeys a) -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy (MLSKeys a) -> Declare (Definitions Schema) NamedSchema
S.ToSchema) via Schema (MLSKeys a)

instance (ToSchema a) => ToSchema (MLSKeys a) where
  schema :: ValueSchema NamedSwaggerDoc (MLSKeys a)
schema =
    Text
-> SchemaP SwaggerDoc Object [Pair] (MLSKeys a) (MLSKeys a)
-> ValueSchema NamedSwaggerDoc (MLSKeys a)
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"MLSKeys" (SchemaP SwaggerDoc Object [Pair] (MLSKeys a) (MLSKeys a)
 -> ValueSchema NamedSwaggerDoc (MLSKeys a))
-> SchemaP SwaggerDoc Object [Pair] (MLSKeys a) (MLSKeys a)
-> ValueSchema NamedSwaggerDoc (MLSKeys a)
forall a b. (a -> b) -> a -> b
$
      a -> a -> a -> a -> MLSKeys a
forall a. a -> a -> a -> a -> MLSKeys a
MLSKeys
        (a -> a -> a -> a -> MLSKeys a)
-> SchemaP SwaggerDoc Object [Pair] (MLSKeys a) a
-> SchemaP
     SwaggerDoc Object [Pair] (MLSKeys a) (a -> a -> a -> MLSKeys a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MLSKeys a -> a
forall a. MLSKeys a -> a
ed25519 (MLSKeys a -> a)
-> SchemaP SwaggerDoc Object [Pair] a a
-> SchemaP SwaggerDoc Object [Pair] (MLSKeys a) a
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value a a
-> SchemaP SwaggerDoc Object [Pair] a a
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"ed25519" SchemaP NamedSwaggerDoc Value Value a a
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc Object [Pair] (MLSKeys a) (a -> a -> a -> MLSKeys a)
-> SchemaP SwaggerDoc Object [Pair] (MLSKeys a) a
-> SchemaP
     SwaggerDoc Object [Pair] (MLSKeys a) (a -> a -> MLSKeys a)
forall a b.
SchemaP SwaggerDoc Object [Pair] (MLSKeys a) (a -> b)
-> SchemaP SwaggerDoc Object [Pair] (MLSKeys a) a
-> SchemaP SwaggerDoc Object [Pair] (MLSKeys a) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> MLSKeys a -> a
forall a. MLSKeys a -> a
ecdsa_secp256r1_sha256 (MLSKeys a -> a)
-> SchemaP SwaggerDoc Object [Pair] a a
-> SchemaP SwaggerDoc Object [Pair] (MLSKeys a) a
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value a a
-> SchemaP SwaggerDoc Object [Pair] a a
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"ecdsa_secp256r1_sha256" SchemaP NamedSwaggerDoc Value Value a a
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP SwaggerDoc Object [Pair] (MLSKeys a) (a -> a -> MLSKeys a)
-> SchemaP SwaggerDoc Object [Pair] (MLSKeys a) a
-> SchemaP SwaggerDoc Object [Pair] (MLSKeys a) (a -> MLSKeys a)
forall a b.
SchemaP SwaggerDoc Object [Pair] (MLSKeys a) (a -> b)
-> SchemaP SwaggerDoc Object [Pair] (MLSKeys a) a
-> SchemaP SwaggerDoc Object [Pair] (MLSKeys a) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> MLSKeys a -> a
forall a. MLSKeys a -> a
ecdsa_secp384r1_sha384 (MLSKeys a -> a)
-> SchemaP SwaggerDoc Object [Pair] a a
-> SchemaP SwaggerDoc Object [Pair] (MLSKeys a) a
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value a a
-> SchemaP SwaggerDoc Object [Pair] a a
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"ecdsa_secp384r1_sha384" SchemaP NamedSwaggerDoc Value Value a a
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP SwaggerDoc Object [Pair] (MLSKeys a) (a -> MLSKeys a)
-> SchemaP SwaggerDoc Object [Pair] (MLSKeys a) a
-> SchemaP SwaggerDoc Object [Pair] (MLSKeys a) (MLSKeys a)
forall a b.
SchemaP SwaggerDoc Object [Pair] (MLSKeys a) (a -> b)
-> SchemaP SwaggerDoc Object [Pair] (MLSKeys a) a
-> SchemaP SwaggerDoc Object [Pair] (MLSKeys a) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> MLSKeys a -> a
forall a. MLSKeys a -> a
ecdsa_secp521r1_sha512 (MLSKeys a -> a)
-> SchemaP SwaggerDoc Object [Pair] a a
-> SchemaP SwaggerDoc Object [Pair] (MLSKeys a) a
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value a a
-> SchemaP SwaggerDoc Object [Pair] a a
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"ecdsa_secp521r1_sha512" SchemaP NamedSwaggerDoc Value Value a a
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema

data MLSPrivateKeys = MLSPrivateKeys
  { MLSPrivateKeys -> KeyPair 'Ed25519
mlsKeyPair_ed25519 :: KeyPair Ed25519,
    MLSPrivateKeys -> KeyPair 'Ecdsa_secp256r1_sha256
mlsKeyPair_ecdsa_secp256r1_sha256 :: KeyPair Ecdsa_secp256r1_sha256,
    MLSPrivateKeys -> KeyPair 'Ecdsa_secp384r1_sha384
mlsKeyPair_ecdsa_secp384r1_sha384 :: KeyPair Ecdsa_secp384r1_sha384,
    MLSPrivateKeys -> KeyPair 'Ecdsa_secp521r1_sha512
mlsKeyPair_ecdsa_secp521r1_sha512 :: KeyPair Ecdsa_secp521r1_sha512
  }

type MLSPublicKeys = MLSKeys MLSPublicKey

newtype MLSPublicKey = MLSPublicKey {MLSPublicKey -> ByteString
unwrapMLSPublicKey :: ByteString}
  deriving (MLSPublicKey -> MLSPublicKey -> Bool
(MLSPublicKey -> MLSPublicKey -> Bool)
-> (MLSPublicKey -> MLSPublicKey -> Bool) -> Eq MLSPublicKey
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MLSPublicKey -> MLSPublicKey -> Bool
== :: MLSPublicKey -> MLSPublicKey -> Bool
$c/= :: MLSPublicKey -> MLSPublicKey -> Bool
/= :: MLSPublicKey -> MLSPublicKey -> Bool
Eq, Int -> MLSPublicKey -> ShowS
[MLSPublicKey] -> ShowS
MLSPublicKey -> String
(Int -> MLSPublicKey -> ShowS)
-> (MLSPublicKey -> String)
-> ([MLSPublicKey] -> ShowS)
-> Show MLSPublicKey
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MLSPublicKey -> ShowS
showsPrec :: Int -> MLSPublicKey -> ShowS
$cshow :: MLSPublicKey -> String
show :: MLSPublicKey -> String
$cshowList :: [MLSPublicKey] -> ShowS
showList :: [MLSPublicKey] -> ShowS
Show)
  deriving ([MLSPublicKey] -> Value
[MLSPublicKey] -> Encoding
MLSPublicKey -> Value
MLSPublicKey -> Encoding
(MLSPublicKey -> Value)
-> (MLSPublicKey -> Encoding)
-> ([MLSPublicKey] -> Value)
-> ([MLSPublicKey] -> Encoding)
-> ToJSON MLSPublicKey
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: MLSPublicKey -> Value
toJSON :: MLSPublicKey -> Value
$ctoEncoding :: MLSPublicKey -> Encoding
toEncoding :: MLSPublicKey -> Encoding
$ctoJSONList :: [MLSPublicKey] -> Value
toJSONList :: [MLSPublicKey] -> Value
$ctoEncodingList :: [MLSPublicKey] -> Encoding
toEncodingList :: [MLSPublicKey] -> Encoding
ToJSON) via Schema MLSPublicKey

instance ToSchema MLSPublicKey where
  schema :: ValueSchema NamedSwaggerDoc MLSPublicKey
schema = Text
-> SchemaP SwaggerDoc Value Value MLSPublicKey MLSPublicKey
-> ValueSchema NamedSwaggerDoc MLSPublicKey
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
"MLSPublicKey" (SchemaP SwaggerDoc Value Value MLSPublicKey MLSPublicKey
 -> ValueSchema NamedSwaggerDoc MLSPublicKey)
-> SchemaP SwaggerDoc Value Value MLSPublicKey MLSPublicKey
-> ValueSchema NamedSwaggerDoc MLSPublicKey
forall a b. (a -> b) -> a -> b
$ ByteString -> MLSPublicKey
MLSPublicKey (ByteString -> MLSPublicKey)
-> SchemaP SwaggerDoc Value Value MLSPublicKey ByteString
-> SchemaP SwaggerDoc Value Value MLSPublicKey MLSPublicKey
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MLSPublicKey -> ByteString
unwrapMLSPublicKey (MLSPublicKey -> ByteString)
-> SchemaP SwaggerDoc Value Value ByteString ByteString
-> SchemaP SwaggerDoc Value Value MLSPublicKey ByteString
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Value Value ByteString ByteString
base64Schema

mlsKeysToPublic :: MLSPrivateKeys -> MLSPublicKeys
mlsKeysToPublic :: MLSPrivateKeys -> MLSPublicKeys
mlsKeysToPublic (MLSPrivateKeys (PrivateKey 'Ed25519
_, PublicKey 'Ed25519
ed) (PrivateKey 'Ecdsa_secp256r1_sha256
_, PublicKey 'Ecdsa_secp256r1_sha256
ec256) (PrivateKey 'Ecdsa_secp384r1_sha384
_, PublicKey 'Ecdsa_secp384r1_sha384
ec384) (PrivateKey 'Ecdsa_secp521r1_sha512
_, PublicKey 'Ecdsa_secp521r1_sha512
ec521)) =
  MLSKeys
    { $sel:ed25519:MLSKeys :: MLSPublicKey
ed25519 = ByteString -> MLSPublicKey
MLSPublicKey (ByteString -> MLSPublicKey) -> ByteString -> MLSPublicKey
forall a b. (a -> b) -> a -> b
$ PublicKey -> ByteString
forall bin bout.
(ByteArrayAccess bin, ByteArray bout) =>
bin -> bout
BA.convert PublicKey
PublicKey 'Ed25519
ed,
      $sel:ecdsa_secp256r1_sha256:MLSKeys :: MLSPublicKey
ecdsa_secp256r1_sha256 = ByteString -> MLSPublicKey
MLSPublicKey (ByteString -> MLSPublicKey) -> ByteString -> MLSPublicKey
forall a b. (a -> b) -> a -> b
$ Proxy Curve_P256R1 -> PublicKey Curve_P256R1 -> ByteString
forall curve bs (proxy :: * -> *).
(EllipticCurve curve, ByteArray bs) =>
proxy curve -> PublicKey curve -> bs
ECDSA.encodePublic (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @Curve_P256R1) PublicKey Curve_P256R1
PublicKey 'Ecdsa_secp256r1_sha256
ec256,
      $sel:ecdsa_secp384r1_sha384:MLSKeys :: MLSPublicKey
ecdsa_secp384r1_sha384 = ByteString -> MLSPublicKey
MLSPublicKey (ByteString -> MLSPublicKey) -> ByteString -> MLSPublicKey
forall a b. (a -> b) -> a -> b
$ Proxy Curve_P384R1 -> PublicKey Curve_P384R1 -> ByteString
forall curve bs (proxy :: * -> *).
(EllipticCurve curve, ByteArray bs) =>
proxy curve -> PublicKey curve -> bs
ECDSA.encodePublic (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @Curve_P384R1) PublicKey Curve_P384R1
PublicKey 'Ecdsa_secp384r1_sha384
ec384,
      $sel:ecdsa_secp521r1_sha512:MLSKeys :: MLSPublicKey
ecdsa_secp521r1_sha512 = ByteString -> MLSPublicKey
MLSPublicKey (ByteString -> MLSPublicKey) -> ByteString -> MLSPublicKey
forall a b. (a -> b) -> a -> b
$ Proxy Curve_P521R1 -> PublicKey Curve_P521R1 -> ByteString
forall curve bs (proxy :: * -> *).
(EllipticCurve curve, ByteArray bs) =>
proxy curve -> PublicKey curve -> bs
ECDSA.encodePublic (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @Curve_P521R1) PublicKey Curve_P521R1
PublicKey 'Ecdsa_secp521r1_sha512
ec521
    }

data MLSPublicKeyFormat = MLSPublicKeyFormatRaw | MLSPublicKeyFormatJWK
  deriving (MLSPublicKeyFormat -> MLSPublicKeyFormat -> Bool
(MLSPublicKeyFormat -> MLSPublicKeyFormat -> Bool)
-> (MLSPublicKeyFormat -> MLSPublicKeyFormat -> Bool)
-> Eq MLSPublicKeyFormat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MLSPublicKeyFormat -> MLSPublicKeyFormat -> Bool
== :: MLSPublicKeyFormat -> MLSPublicKeyFormat -> Bool
$c/= :: MLSPublicKeyFormat -> MLSPublicKeyFormat -> Bool
/= :: MLSPublicKeyFormat -> MLSPublicKeyFormat -> Bool
Eq, Eq MLSPublicKeyFormat
Eq MLSPublicKeyFormat =>
(MLSPublicKeyFormat -> MLSPublicKeyFormat -> Ordering)
-> (MLSPublicKeyFormat -> MLSPublicKeyFormat -> Bool)
-> (MLSPublicKeyFormat -> MLSPublicKeyFormat -> Bool)
-> (MLSPublicKeyFormat -> MLSPublicKeyFormat -> Bool)
-> (MLSPublicKeyFormat -> MLSPublicKeyFormat -> Bool)
-> (MLSPublicKeyFormat -> MLSPublicKeyFormat -> MLSPublicKeyFormat)
-> (MLSPublicKeyFormat -> MLSPublicKeyFormat -> MLSPublicKeyFormat)
-> Ord MLSPublicKeyFormat
MLSPublicKeyFormat -> MLSPublicKeyFormat -> Bool
MLSPublicKeyFormat -> MLSPublicKeyFormat -> Ordering
MLSPublicKeyFormat -> MLSPublicKeyFormat -> MLSPublicKeyFormat
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 :: MLSPublicKeyFormat -> MLSPublicKeyFormat -> Ordering
compare :: MLSPublicKeyFormat -> MLSPublicKeyFormat -> Ordering
$c< :: MLSPublicKeyFormat -> MLSPublicKeyFormat -> Bool
< :: MLSPublicKeyFormat -> MLSPublicKeyFormat -> Bool
$c<= :: MLSPublicKeyFormat -> MLSPublicKeyFormat -> Bool
<= :: MLSPublicKeyFormat -> MLSPublicKeyFormat -> Bool
$c> :: MLSPublicKeyFormat -> MLSPublicKeyFormat -> Bool
> :: MLSPublicKeyFormat -> MLSPublicKeyFormat -> Bool
$c>= :: MLSPublicKeyFormat -> MLSPublicKeyFormat -> Bool
>= :: MLSPublicKeyFormat -> MLSPublicKeyFormat -> Bool
$cmax :: MLSPublicKeyFormat -> MLSPublicKeyFormat -> MLSPublicKeyFormat
max :: MLSPublicKeyFormat -> MLSPublicKeyFormat -> MLSPublicKeyFormat
$cmin :: MLSPublicKeyFormat -> MLSPublicKeyFormat -> MLSPublicKeyFormat
min :: MLSPublicKeyFormat -> MLSPublicKeyFormat -> MLSPublicKeyFormat
Ord, Int -> MLSPublicKeyFormat -> ShowS
[MLSPublicKeyFormat] -> ShowS
MLSPublicKeyFormat -> String
(Int -> MLSPublicKeyFormat -> ShowS)
-> (MLSPublicKeyFormat -> String)
-> ([MLSPublicKeyFormat] -> ShowS)
-> Show MLSPublicKeyFormat
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MLSPublicKeyFormat -> ShowS
showsPrec :: Int -> MLSPublicKeyFormat -> ShowS
$cshow :: MLSPublicKeyFormat -> String
show :: MLSPublicKeyFormat -> String
$cshowList :: [MLSPublicKeyFormat] -> ShowS
showList :: [MLSPublicKeyFormat] -> ShowS
Show)

instance Default MLSPublicKeyFormat where
  def :: MLSPublicKeyFormat
def = MLSPublicKeyFormat
MLSPublicKeyFormatRaw

instance FromHttpApiData MLSPublicKeyFormat where
  parseQueryParam :: Text -> Either Text MLSPublicKeyFormat
parseQueryParam Text
"raw" = MLSPublicKeyFormat -> Either Text MLSPublicKeyFormat
forall a. a -> Either Text a
forall (f :: * -> *) a. Applicative f => a -> f a
pure MLSPublicKeyFormat
MLSPublicKeyFormatRaw
  parseQueryParam Text
"jwk" = MLSPublicKeyFormat -> Either Text MLSPublicKeyFormat
forall a. a -> Either Text a
forall (f :: * -> *) a. Applicative f => a -> f a
pure MLSPublicKeyFormat
MLSPublicKeyFormatJWK
  parseQueryParam Text
_ = Text -> Either Text MLSPublicKeyFormat
forall a b. a -> Either a b
Left Text
"invalid MLSPublicKeyFormat"

instance ToHttpApiData MLSPublicKeyFormat where
  toQueryParam :: MLSPublicKeyFormat -> Text
toQueryParam MLSPublicKeyFormat
MLSPublicKeyFormatRaw = Text
"raw"
  toQueryParam MLSPublicKeyFormat
MLSPublicKeyFormatJWK = Text
"jwk"

instance S.ToParamSchema MLSPublicKeyFormat where
  toParamSchema :: Proxy MLSPublicKeyFormat -> Schema
toParamSchema Proxy MLSPublicKeyFormat
_ =
    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)
S.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
S.OpenApiString
      Schema -> (Schema -> Schema) -> Schema
forall a b. a -> (a -> b) -> b
& (Maybe [Value] -> Identity (Maybe [Value]))
-> Schema -> Identity Schema
forall s a. HasEnum s a => Lens' s a
Lens' Schema (Maybe [Value])
S.enum_
        ((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
?~ (MLSPublicKeyFormat -> Value) -> [MLSPublicKeyFormat] -> [Value]
forall a b. (a -> b) -> [a] -> [b]
map
          (Text -> Value
forall a. ToJSON a => a -> Value
toJSON (Text -> Value)
-> (MLSPublicKeyFormat -> Text) -> MLSPublicKeyFormat -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MLSPublicKeyFormat -> Text
forall a. ToHttpApiData a => a -> Text
toQueryParam)
          [MLSPublicKeyFormat
MLSPublicKeyFormatRaw, MLSPublicKeyFormat
MLSPublicKeyFormatJWK]

data JWK = JWK
  { JWK -> String
keyType :: String,
    JWK -> String
curve :: String,
    JWK -> ByteString
pubX :: ByteString,
    JWK -> Maybe ByteString
pubY :: Maybe ByteString
  }
  deriving (Int -> JWK -> ShowS
[JWK] -> ShowS
JWK -> String
(Int -> JWK -> ShowS)
-> (JWK -> String) -> ([JWK] -> ShowS) -> Show JWK
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> JWK -> ShowS
showsPrec :: Int -> JWK -> ShowS
$cshow :: JWK -> String
show :: JWK -> String
$cshowList :: [JWK] -> ShowS
showList :: [JWK] -> ShowS
Show, Eq JWK
Eq JWK =>
(JWK -> JWK -> Ordering)
-> (JWK -> JWK -> Bool)
-> (JWK -> JWK -> Bool)
-> (JWK -> JWK -> Bool)
-> (JWK -> JWK -> Bool)
-> (JWK -> JWK -> JWK)
-> (JWK -> JWK -> JWK)
-> Ord JWK
JWK -> JWK -> Bool
JWK -> JWK -> Ordering
JWK -> JWK -> JWK
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 :: JWK -> JWK -> Ordering
compare :: JWK -> JWK -> Ordering
$c< :: JWK -> JWK -> Bool
< :: JWK -> JWK -> Bool
$c<= :: JWK -> JWK -> Bool
<= :: JWK -> JWK -> Bool
$c> :: JWK -> JWK -> Bool
> :: JWK -> JWK -> Bool
$c>= :: JWK -> JWK -> Bool
>= :: JWK -> JWK -> Bool
$cmax :: JWK -> JWK -> JWK
max :: JWK -> JWK -> JWK
$cmin :: JWK -> JWK -> JWK
min :: JWK -> JWK -> JWK
Ord, JWK -> JWK -> Bool
(JWK -> JWK -> Bool) -> (JWK -> JWK -> Bool) -> Eq JWK
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JWK -> JWK -> Bool
== :: JWK -> JWK -> Bool
$c/= :: JWK -> JWK -> Bool
/= :: JWK -> JWK -> Bool
Eq)
  deriving ([JWK] -> Value
[JWK] -> Encoding
JWK -> Value
JWK -> Encoding
(JWK -> Value)
-> (JWK -> Encoding)
-> ([JWK] -> Value)
-> ([JWK] -> Encoding)
-> ToJSON JWK
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: JWK -> Value
toJSON :: JWK -> Value
$ctoEncoding :: JWK -> Encoding
toEncoding :: JWK -> Encoding
$ctoJSONList :: [JWK] -> Value
toJSONList :: [JWK] -> Value
$ctoEncodingList :: [JWK] -> Encoding
toEncodingList :: [JWK] -> Encoding
ToJSON) via Schema JWK

instance ToSchema JWK where
  schema :: ValueSchema NamedSwaggerDoc JWK
schema =
    Text
-> SchemaP SwaggerDoc Object [Pair] JWK JWK
-> ValueSchema NamedSwaggerDoc JWK
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"JWK" (SchemaP SwaggerDoc Object [Pair] JWK JWK
 -> ValueSchema NamedSwaggerDoc JWK)
-> SchemaP SwaggerDoc Object [Pair] JWK JWK
-> ValueSchema NamedSwaggerDoc JWK
forall a b. (a -> b) -> a -> b
$
      String -> String -> ByteString -> Maybe ByteString -> JWK
JWK
        (String -> String -> ByteString -> Maybe ByteString -> JWK)
-> SchemaP SwaggerDoc Object [Pair] JWK String
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     JWK
     (String -> ByteString -> Maybe ByteString -> JWK)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (.keyType) (JWK -> String)
-> SchemaP SwaggerDoc Object [Pair] String String
-> SchemaP SwaggerDoc Object [Pair] JWK String
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value String String
-> SchemaP SwaggerDoc Object [Pair] String String
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"kty" SchemaP NamedSwaggerDoc Value Value String String
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  JWK
  (String -> ByteString -> Maybe ByteString -> JWK)
-> SchemaP SwaggerDoc Object [Pair] JWK String
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     JWK
     (ByteString -> Maybe ByteString -> JWK)
forall a b.
SchemaP SwaggerDoc Object [Pair] JWK (a -> b)
-> SchemaP SwaggerDoc Object [Pair] JWK a
-> SchemaP SwaggerDoc Object [Pair] JWK b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (.curve) (JWK -> String)
-> SchemaP SwaggerDoc Object [Pair] String String
-> SchemaP SwaggerDoc Object [Pair] JWK String
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value String String
-> SchemaP SwaggerDoc Object [Pair] String String
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"crv" SchemaP NamedSwaggerDoc Value Value String String
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  JWK
  (ByteString -> Maybe ByteString -> JWK)
-> SchemaP SwaggerDoc Object [Pair] JWK ByteString
-> SchemaP SwaggerDoc Object [Pair] JWK (Maybe ByteString -> JWK)
forall a b.
SchemaP SwaggerDoc Object [Pair] JWK (a -> b)
-> SchemaP SwaggerDoc Object [Pair] JWK a
-> SchemaP SwaggerDoc Object [Pair] JWK b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (.pubX) (JWK -> ByteString)
-> SchemaP SwaggerDoc Object [Pair] ByteString ByteString
-> SchemaP SwaggerDoc Object [Pair] JWK ByteString
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP SwaggerDoc Value Value ByteString ByteString
-> SchemaP SwaggerDoc Object [Pair] ByteString ByteString
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"x" SchemaP SwaggerDoc Value Value ByteString ByteString
base64URLSchema
        SchemaP SwaggerDoc Object [Pair] JWK (Maybe ByteString -> JWK)
-> SchemaP SwaggerDoc Object [Pair] JWK (Maybe ByteString)
-> SchemaP SwaggerDoc Object [Pair] JWK JWK
forall a b.
SchemaP SwaggerDoc Object [Pair] JWK (a -> b)
-> SchemaP SwaggerDoc Object [Pair] JWK a
-> SchemaP SwaggerDoc Object [Pair] JWK b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (.pubY) (JWK -> Maybe ByteString)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe ByteString) (Maybe ByteString)
-> SchemaP SwaggerDoc Object [Pair] JWK (Maybe ByteString)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] ByteString (Maybe ByteString)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe ByteString) (Maybe ByteString)
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 ByteString ByteString
-> SchemaP SwaggerDoc Object [Pair] ByteString (Maybe ByteString)
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
"y" SchemaP SwaggerDoc Value Value ByteString ByteString
base64URLSchema)

type MLSPublicKeysJWK = MLSKeys JWK

mlsPublicKeysToJWK :: MLSPublicKeys -> Maybe MLSPublicKeysJWK
mlsPublicKeysToJWK :: MLSPublicKeys -> Maybe MLSPublicKeysJWK
mlsPublicKeysToJWK (MLSKeys (MLSPublicKey ByteString
ed) (MLSPublicKey ByteString
ec256) (MLSPublicKey ByteString
ec384) (MLSPublicKey ByteString
ec521)) =
  -- The kty parameter for ECDSA is "EC", for Ed25519 it's "OKP" (octet key
  -- pair).
  -- https://www.rfc-editor.org/rfc/rfc7518.html#section-6.1

  -- The crv for P-256, P-384, and P-521 are their names.
  -- https://www.rfc-editor.org/rfc/rfc7518.html#section-6.2.1.1

  -- The x parameter is mandatory for all keys, the y parameter is mandatory for
  -- all ECDSA keys.
  -- https://www.rfc-editor.org/rfc/rfc7518.html#section-6.2.1
  JWK -> JWK -> JWK -> JWK -> MLSPublicKeysJWK
forall a. a -> a -> a -> a -> MLSKeys a
MLSKeys
    (String -> String -> ByteString -> Maybe ByteString -> JWK
JWK String
"OKP" String
"Ed25519" (ByteString -> ByteString
forall bin bout.
(ByteArrayAccess bin, ByteArray bout) =>
bin -> bout
BA.convert ByteString
ed) Maybe ByteString
forall a. Maybe a
Nothing)
    (JWK -> JWK -> JWK -> MLSPublicKeysJWK)
-> Maybe JWK -> Maybe (JWK -> JWK -> MLSPublicKeysJWK)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((ByteString -> Maybe ByteString -> JWK)
-> (ByteString, Maybe ByteString) -> JWK
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (String -> String -> ByteString -> Maybe ByteString -> JWK
JWK String
"EC" String
"P-256") ((ByteString, Maybe ByteString) -> JWK)
-> ((ByteString, ByteString) -> (ByteString, Maybe ByteString))
-> (ByteString, ByteString)
-> JWK
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ByteString -> Maybe ByteString)
-> (ByteString, ByteString) -> (ByteString, Maybe ByteString)
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 ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just ((ByteString, ByteString) -> JWK)
-> Maybe (ByteString, ByteString) -> Maybe JWK
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> Maybe (ByteString, ByteString)
forall {bs}. ByteArray bs => bs -> Maybe (bs, bs)
splitXY ByteString
ec256)
    Maybe (JWK -> JWK -> MLSPublicKeysJWK)
-> Maybe JWK -> Maybe (JWK -> MLSPublicKeysJWK)
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((ByteString -> Maybe ByteString -> JWK)
-> (ByteString, Maybe ByteString) -> JWK
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (String -> String -> ByteString -> Maybe ByteString -> JWK
JWK String
"EC" String
"P-384") ((ByteString, Maybe ByteString) -> JWK)
-> ((ByteString, ByteString) -> (ByteString, Maybe ByteString))
-> (ByteString, ByteString)
-> JWK
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ByteString -> Maybe ByteString)
-> (ByteString, ByteString) -> (ByteString, Maybe ByteString)
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 ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just ((ByteString, ByteString) -> JWK)
-> Maybe (ByteString, ByteString) -> Maybe JWK
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> Maybe (ByteString, ByteString)
forall {bs}. ByteArray bs => bs -> Maybe (bs, bs)
splitXY ByteString
ec384)
    Maybe (JWK -> MLSPublicKeysJWK)
-> Maybe JWK -> Maybe MLSPublicKeysJWK
forall a b. Maybe (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((ByteString -> Maybe ByteString -> JWK)
-> (ByteString, Maybe ByteString) -> JWK
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (String -> String -> ByteString -> Maybe ByteString -> JWK
JWK String
"EC" String
"P-521") ((ByteString, Maybe ByteString) -> JWK)
-> ((ByteString, ByteString) -> (ByteString, Maybe ByteString))
-> (ByteString, ByteString)
-> JWK
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ByteString -> Maybe ByteString)
-> (ByteString, ByteString) -> (ByteString, Maybe ByteString)
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 ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just ((ByteString, ByteString) -> JWK)
-> Maybe (ByteString, ByteString) -> Maybe JWK
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteString -> Maybe (ByteString, ByteString)
forall {bs}. ByteArray bs => bs -> Maybe (bs, bs)
splitXY ByteString
ec521)
  where
    -- Obtaining X and Y from an encoded curve point follows the logic of
    -- Crypto.ECC's encodeECPoint and decodeECPoint (the module is not
    -- exported). Points need to be encoded in uncompressed representation. This
    -- is true for ECDSA.encodePublic.
    -- https://www.rfc-editor.org/rfc/rfc8422#section-5.4.1
    splitXY :: forall {bs}. (ByteArray bs) => bs -> Maybe (bs, bs)
    splitXY :: forall {bs}. ByteArray bs => bs -> Maybe (bs, bs)
splitXY bs
mxy = do
      (Word8
m, bs
xy) <- bs -> Maybe (Word8, bs)
forall a. ByteArray a => a -> Maybe (Word8, a)
BA.uncons bs
mxy
      -- The first Byte m is 4 for the uncompressed representation of curve points.
      Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Word8
m Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
4)
      -- The first half of the following Bytes belong to X and the second half
      -- to Y.
      let size :: Int
size = bs -> Int
forall ba. ByteArrayAccess ba => ba -> Int
BA.length bs
xy Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
2
      (bs, bs) -> Maybe (bs, bs)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((bs, bs) -> Maybe (bs, bs)) -> (bs, bs) -> Maybe (bs, bs)
forall a b. (a -> b) -> a -> b
$ Int -> bs -> (bs, bs)
forall bs. ByteArray bs => Int -> bs -> (bs, bs)
BA.splitAt Int
size bs
xy

data SomeKey = SomeKey A.Value

instance ToSchema SomeKey where
  schema :: ValueSchema NamedSwaggerDoc SomeKey
schema = NamedSwaggerDoc
-> (Value -> Parser SomeKey)
-> (SomeKey -> Maybe Value)
-> ValueSchema NamedSwaggerDoc SomeKey
forall doc v b a w.
doc -> (v -> Parser b) -> (a -> Maybe w) -> SchemaP doc v w a b
mkSchema NamedSwaggerDoc
d Value -> Parser SomeKey
r SomeKey -> Maybe Value
w
    where
      d :: NamedSwaggerDoc
d = NamedSchema -> NamedSwaggerDoc
forall a. a -> WithDeclare a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (NamedSchema -> NamedSwaggerDoc) -> NamedSchema -> NamedSwaggerDoc
forall a b. (a -> b) -> a -> b
$ Maybe Text -> Schema -> NamedSchema
S.NamedSchema (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"SomeKey") Schema
forall a. Monoid a => a
mempty
      r :: Value -> Parser SomeKey
r = (Value -> SomeKey) -> Parser Value -> Parser SomeKey
forall a b. (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Value -> SomeKey
SomeKey (Parser Value -> Parser SomeKey)
-> (Value -> Parser Value) -> Value -> Parser SomeKey
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Parser Value
forall a. FromJSON a => Value -> Parser a
parseJSON
      w :: SomeKey -> Maybe Value
w (SomeKey Value
x) = Value -> Maybe Value
forall a. a -> Maybe a
Just (Value -> Value
forall a. ToJSON a => a -> Value
toJSON Value
x)

mkSomeKey :: (ToJSON a) => a -> SomeKey
mkSomeKey :: forall a. ToJSON a => a -> SomeKey
mkSomeKey = Value -> SomeKey
SomeKey (Value -> SomeKey) -> (a -> Value) -> a -> SomeKey
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Value
forall a. ToJSON a => a -> Value
toJSON