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

-- | Types used by the Wire server for outbound requests to a LegalHold service.
module Wire.API.Team.LegalHold.External
  ( -- * initiate
    RequestNewLegalHoldClientV0 (..),
    RequestNewLegalHoldClient (..),
    NewLegalHoldClient (..),

    -- * confirm
    LegalHoldServiceConfirmV0 (..),
    LegalHoldServiceConfirm (..),

    -- * remove
    LegalHoldServiceRemoveV0 (..),
    LegalHoldServiceRemove (..),

    -- * SupportedVersions
    SupportedVersions (..),
  )
where

import Data.Aeson qualified as A hiding (fieldLabelModifier)
import Data.Id
import Data.OpenApi qualified as OpenApi
import Data.Qualified
import Data.Schema
import Imports
import Wire.API.User.Client.Prekey
import Wire.Arbitrary (Arbitrary, GenericUniform (..))

--------------------------------------------------------------------------------
-- initiate

-- | Request payload that the LH service endpoint @/initiate@ expects
data RequestNewLegalHoldClientV0 = RequestNewLegalHoldClientV0
  { RequestNewLegalHoldClientV0 -> UserId
userId :: UserId,
    RequestNewLegalHoldClientV0 -> TeamId
teamId :: TeamId
  }
  deriving stock (Int -> RequestNewLegalHoldClientV0 -> ShowS
[RequestNewLegalHoldClientV0] -> ShowS
RequestNewLegalHoldClientV0 -> String
(Int -> RequestNewLegalHoldClientV0 -> ShowS)
-> (RequestNewLegalHoldClientV0 -> String)
-> ([RequestNewLegalHoldClientV0] -> ShowS)
-> Show RequestNewLegalHoldClientV0
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RequestNewLegalHoldClientV0 -> ShowS
showsPrec :: Int -> RequestNewLegalHoldClientV0 -> ShowS
$cshow :: RequestNewLegalHoldClientV0 -> String
show :: RequestNewLegalHoldClientV0 -> String
$cshowList :: [RequestNewLegalHoldClientV0] -> ShowS
showList :: [RequestNewLegalHoldClientV0] -> ShowS
Show, RequestNewLegalHoldClientV0 -> RequestNewLegalHoldClientV0 -> Bool
(RequestNewLegalHoldClientV0
 -> RequestNewLegalHoldClientV0 -> Bool)
-> (RequestNewLegalHoldClientV0
    -> RequestNewLegalHoldClientV0 -> Bool)
-> Eq RequestNewLegalHoldClientV0
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RequestNewLegalHoldClientV0 -> RequestNewLegalHoldClientV0 -> Bool
== :: RequestNewLegalHoldClientV0 -> RequestNewLegalHoldClientV0 -> Bool
$c/= :: RequestNewLegalHoldClientV0 -> RequestNewLegalHoldClientV0 -> Bool
/= :: RequestNewLegalHoldClientV0 -> RequestNewLegalHoldClientV0 -> Bool
Eq, (forall x.
 RequestNewLegalHoldClientV0 -> Rep RequestNewLegalHoldClientV0 x)
-> (forall x.
    Rep RequestNewLegalHoldClientV0 x -> RequestNewLegalHoldClientV0)
-> Generic RequestNewLegalHoldClientV0
forall x.
Rep RequestNewLegalHoldClientV0 x -> RequestNewLegalHoldClientV0
forall x.
RequestNewLegalHoldClientV0 -> Rep RequestNewLegalHoldClientV0 x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
RequestNewLegalHoldClientV0 -> Rep RequestNewLegalHoldClientV0 x
from :: forall x.
RequestNewLegalHoldClientV0 -> Rep RequestNewLegalHoldClientV0 x
$cto :: forall x.
Rep RequestNewLegalHoldClientV0 x -> RequestNewLegalHoldClientV0
to :: forall x.
Rep RequestNewLegalHoldClientV0 x -> RequestNewLegalHoldClientV0
Generic)
  deriving (Gen RequestNewLegalHoldClientV0
Gen RequestNewLegalHoldClientV0
-> (RequestNewLegalHoldClientV0 -> [RequestNewLegalHoldClientV0])
-> Arbitrary RequestNewLegalHoldClientV0
RequestNewLegalHoldClientV0 -> [RequestNewLegalHoldClientV0]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen RequestNewLegalHoldClientV0
arbitrary :: Gen RequestNewLegalHoldClientV0
$cshrink :: RequestNewLegalHoldClientV0 -> [RequestNewLegalHoldClientV0]
shrink :: RequestNewLegalHoldClientV0 -> [RequestNewLegalHoldClientV0]
Arbitrary) via (GenericUniform RequestNewLegalHoldClientV0)
  deriving ([RequestNewLegalHoldClientV0] -> Value
[RequestNewLegalHoldClientV0] -> Encoding
RequestNewLegalHoldClientV0 -> Value
RequestNewLegalHoldClientV0 -> Encoding
(RequestNewLegalHoldClientV0 -> Value)
-> (RequestNewLegalHoldClientV0 -> Encoding)
-> ([RequestNewLegalHoldClientV0] -> Value)
-> ([RequestNewLegalHoldClientV0] -> Encoding)
-> ToJSON RequestNewLegalHoldClientV0
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: RequestNewLegalHoldClientV0 -> Value
toJSON :: RequestNewLegalHoldClientV0 -> Value
$ctoEncoding :: RequestNewLegalHoldClientV0 -> Encoding
toEncoding :: RequestNewLegalHoldClientV0 -> Encoding
$ctoJSONList :: [RequestNewLegalHoldClientV0] -> Value
toJSONList :: [RequestNewLegalHoldClientV0] -> Value
$ctoEncodingList :: [RequestNewLegalHoldClientV0] -> Encoding
toEncodingList :: [RequestNewLegalHoldClientV0] -> Encoding
A.ToJSON, Value -> Parser [RequestNewLegalHoldClientV0]
Value -> Parser RequestNewLegalHoldClientV0
(Value -> Parser RequestNewLegalHoldClientV0)
-> (Value -> Parser [RequestNewLegalHoldClientV0])
-> FromJSON RequestNewLegalHoldClientV0
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser RequestNewLegalHoldClientV0
parseJSON :: Value -> Parser RequestNewLegalHoldClientV0
$cparseJSONList :: Value -> Parser [RequestNewLegalHoldClientV0]
parseJSONList :: Value -> Parser [RequestNewLegalHoldClientV0]
A.FromJSON) via (Schema RequestNewLegalHoldClientV0)

instance ToSchema RequestNewLegalHoldClientV0 where
  schema :: ValueSchema NamedSwaggerDoc RequestNewLegalHoldClientV0
schema =
    Text
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     RequestNewLegalHoldClientV0
     RequestNewLegalHoldClientV0
-> ValueSchema NamedSwaggerDoc RequestNewLegalHoldClientV0
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"RequestNewLegalHoldClientV0" (SchemaP
   SwaggerDoc
   Object
   [Pair]
   RequestNewLegalHoldClientV0
   RequestNewLegalHoldClientV0
 -> ValueSchema NamedSwaggerDoc RequestNewLegalHoldClientV0)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     RequestNewLegalHoldClientV0
     RequestNewLegalHoldClientV0
-> ValueSchema NamedSwaggerDoc RequestNewLegalHoldClientV0
forall a b. (a -> b) -> a -> b
$
      UserId -> TeamId -> RequestNewLegalHoldClientV0
RequestNewLegalHoldClientV0
        (UserId -> TeamId -> RequestNewLegalHoldClientV0)
-> SchemaP
     SwaggerDoc Object [Pair] RequestNewLegalHoldClientV0 UserId
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     RequestNewLegalHoldClientV0
     (TeamId -> RequestNewLegalHoldClientV0)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (.userId) (RequestNewLegalHoldClientV0 -> UserId)
-> SchemaP SwaggerDoc Object [Pair] UserId UserId
-> SchemaP
     SwaggerDoc Object [Pair] RequestNewLegalHoldClientV0 UserId
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value UserId UserId
-> SchemaP SwaggerDoc Object [Pair] UserId UserId
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"user_id" SchemaP NamedSwaggerDoc Value Value UserId UserId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  RequestNewLegalHoldClientV0
  (TeamId -> RequestNewLegalHoldClientV0)
-> SchemaP
     SwaggerDoc Object [Pair] RequestNewLegalHoldClientV0 TeamId
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     RequestNewLegalHoldClientV0
     RequestNewLegalHoldClientV0
forall a b.
SchemaP
  SwaggerDoc Object [Pair] RequestNewLegalHoldClientV0 (a -> b)
-> SchemaP SwaggerDoc Object [Pair] RequestNewLegalHoldClientV0 a
-> SchemaP SwaggerDoc Object [Pair] RequestNewLegalHoldClientV0 b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (.teamId) (RequestNewLegalHoldClientV0 -> TeamId)
-> SchemaP SwaggerDoc Object [Pair] TeamId TeamId
-> SchemaP
     SwaggerDoc Object [Pair] RequestNewLegalHoldClientV0 TeamId
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value TeamId TeamId
-> SchemaP SwaggerDoc Object [Pair] TeamId TeamId
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"team_id" SchemaP NamedSwaggerDoc Value Value TeamId TeamId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema

data RequestNewLegalHoldClient = RequestNewLegalHoldClient
  { RequestNewLegalHoldClient -> Qualified UserId
userId :: Qualified UserId,
    RequestNewLegalHoldClient -> TeamId
teamId :: TeamId
  }
  deriving stock (Int -> RequestNewLegalHoldClient -> ShowS
[RequestNewLegalHoldClient] -> ShowS
RequestNewLegalHoldClient -> String
(Int -> RequestNewLegalHoldClient -> ShowS)
-> (RequestNewLegalHoldClient -> String)
-> ([RequestNewLegalHoldClient] -> ShowS)
-> Show RequestNewLegalHoldClient
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RequestNewLegalHoldClient -> ShowS
showsPrec :: Int -> RequestNewLegalHoldClient -> ShowS
$cshow :: RequestNewLegalHoldClient -> String
show :: RequestNewLegalHoldClient -> String
$cshowList :: [RequestNewLegalHoldClient] -> ShowS
showList :: [RequestNewLegalHoldClient] -> ShowS
Show, RequestNewLegalHoldClient -> RequestNewLegalHoldClient -> Bool
(RequestNewLegalHoldClient -> RequestNewLegalHoldClient -> Bool)
-> (RequestNewLegalHoldClient -> RequestNewLegalHoldClient -> Bool)
-> Eq RequestNewLegalHoldClient
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RequestNewLegalHoldClient -> RequestNewLegalHoldClient -> Bool
== :: RequestNewLegalHoldClient -> RequestNewLegalHoldClient -> Bool
$c/= :: RequestNewLegalHoldClient -> RequestNewLegalHoldClient -> Bool
/= :: RequestNewLegalHoldClient -> RequestNewLegalHoldClient -> Bool
Eq, (forall x.
 RequestNewLegalHoldClient -> Rep RequestNewLegalHoldClient x)
-> (forall x.
    Rep RequestNewLegalHoldClient x -> RequestNewLegalHoldClient)
-> Generic RequestNewLegalHoldClient
forall x.
Rep RequestNewLegalHoldClient x -> RequestNewLegalHoldClient
forall x.
RequestNewLegalHoldClient -> Rep RequestNewLegalHoldClient x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
RequestNewLegalHoldClient -> Rep RequestNewLegalHoldClient x
from :: forall x.
RequestNewLegalHoldClient -> Rep RequestNewLegalHoldClient x
$cto :: forall x.
Rep RequestNewLegalHoldClient x -> RequestNewLegalHoldClient
to :: forall x.
Rep RequestNewLegalHoldClient x -> RequestNewLegalHoldClient
Generic)
  deriving ([RequestNewLegalHoldClient] -> Value
[RequestNewLegalHoldClient] -> Encoding
RequestNewLegalHoldClient -> Value
RequestNewLegalHoldClient -> Encoding
(RequestNewLegalHoldClient -> Value)
-> (RequestNewLegalHoldClient -> Encoding)
-> ([RequestNewLegalHoldClient] -> Value)
-> ([RequestNewLegalHoldClient] -> Encoding)
-> ToJSON RequestNewLegalHoldClient
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: RequestNewLegalHoldClient -> Value
toJSON :: RequestNewLegalHoldClient -> Value
$ctoEncoding :: RequestNewLegalHoldClient -> Encoding
toEncoding :: RequestNewLegalHoldClient -> Encoding
$ctoJSONList :: [RequestNewLegalHoldClient] -> Value
toJSONList :: [RequestNewLegalHoldClient] -> Value
$ctoEncodingList :: [RequestNewLegalHoldClient] -> Encoding
toEncodingList :: [RequestNewLegalHoldClient] -> Encoding
A.ToJSON, Value -> Parser [RequestNewLegalHoldClient]
Value -> Parser RequestNewLegalHoldClient
(Value -> Parser RequestNewLegalHoldClient)
-> (Value -> Parser [RequestNewLegalHoldClient])
-> FromJSON RequestNewLegalHoldClient
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser RequestNewLegalHoldClient
parseJSON :: Value -> Parser RequestNewLegalHoldClient
$cparseJSONList :: Value -> Parser [RequestNewLegalHoldClient]
parseJSONList :: Value -> Parser [RequestNewLegalHoldClient]
A.FromJSON) via (Schema RequestNewLegalHoldClient)
  deriving (Gen RequestNewLegalHoldClient
Gen RequestNewLegalHoldClient
-> (RequestNewLegalHoldClient -> [RequestNewLegalHoldClient])
-> Arbitrary RequestNewLegalHoldClient
RequestNewLegalHoldClient -> [RequestNewLegalHoldClient]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen RequestNewLegalHoldClient
arbitrary :: Gen RequestNewLegalHoldClient
$cshrink :: RequestNewLegalHoldClient -> [RequestNewLegalHoldClient]
shrink :: RequestNewLegalHoldClient -> [RequestNewLegalHoldClient]
Arbitrary) via (GenericUniform RequestNewLegalHoldClient)

instance ToSchema RequestNewLegalHoldClient where
  schema :: ValueSchema NamedSwaggerDoc RequestNewLegalHoldClient
schema =
    Text
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     RequestNewLegalHoldClient
     RequestNewLegalHoldClient
-> ValueSchema NamedSwaggerDoc RequestNewLegalHoldClient
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"RequestNewLegalHoldClient" (SchemaP
   SwaggerDoc
   Object
   [Pair]
   RequestNewLegalHoldClient
   RequestNewLegalHoldClient
 -> ValueSchema NamedSwaggerDoc RequestNewLegalHoldClient)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     RequestNewLegalHoldClient
     RequestNewLegalHoldClient
-> ValueSchema NamedSwaggerDoc RequestNewLegalHoldClient
forall a b. (a -> b) -> a -> b
$
      Qualified UserId -> TeamId -> RequestNewLegalHoldClient
RequestNewLegalHoldClient
        (Qualified UserId -> TeamId -> RequestNewLegalHoldClient)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     RequestNewLegalHoldClient
     (Qualified UserId)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     RequestNewLegalHoldClient
     (TeamId -> RequestNewLegalHoldClient)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (.userId) (RequestNewLegalHoldClient -> Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] (Qualified UserId) (Qualified UserId)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     RequestNewLegalHoldClient
     (Qualified UserId)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP
     NamedSwaggerDoc Value Value (Qualified UserId) (Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] (Qualified UserId) (Qualified UserId)
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"qualified_user_id" SchemaP
  NamedSwaggerDoc Value Value (Qualified UserId) (Qualified UserId)
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  RequestNewLegalHoldClient
  (TeamId -> RequestNewLegalHoldClient)
-> SchemaP
     SwaggerDoc Object [Pair] RequestNewLegalHoldClient TeamId
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     RequestNewLegalHoldClient
     RequestNewLegalHoldClient
forall a b.
SchemaP SwaggerDoc Object [Pair] RequestNewLegalHoldClient (a -> b)
-> SchemaP SwaggerDoc Object [Pair] RequestNewLegalHoldClient a
-> SchemaP SwaggerDoc Object [Pair] RequestNewLegalHoldClient b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (.teamId) (RequestNewLegalHoldClient -> TeamId)
-> SchemaP SwaggerDoc Object [Pair] TeamId TeamId
-> SchemaP
     SwaggerDoc Object [Pair] RequestNewLegalHoldClient TeamId
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value TeamId TeamId
-> SchemaP SwaggerDoc Object [Pair] TeamId TeamId
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"team_id" SchemaP NamedSwaggerDoc Value Value TeamId TeamId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema

-- | Response payload that the LH service returns upon calling @/initiate@
data NewLegalHoldClient = NewLegalHoldClient
  { NewLegalHoldClient -> [Prekey]
newLegalHoldClientPrekeys :: [Prekey],
    NewLegalHoldClient -> LastPrekey
newLegalHoldClientLastKey :: LastPrekey
  }
  deriving stock (NewLegalHoldClient -> NewLegalHoldClient -> Bool
(NewLegalHoldClient -> NewLegalHoldClient -> Bool)
-> (NewLegalHoldClient -> NewLegalHoldClient -> Bool)
-> Eq NewLegalHoldClient
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NewLegalHoldClient -> NewLegalHoldClient -> Bool
== :: NewLegalHoldClient -> NewLegalHoldClient -> Bool
$c/= :: NewLegalHoldClient -> NewLegalHoldClient -> Bool
/= :: NewLegalHoldClient -> NewLegalHoldClient -> Bool
Eq, Int -> NewLegalHoldClient -> ShowS
[NewLegalHoldClient] -> ShowS
NewLegalHoldClient -> String
(Int -> NewLegalHoldClient -> ShowS)
-> (NewLegalHoldClient -> String)
-> ([NewLegalHoldClient] -> ShowS)
-> Show NewLegalHoldClient
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NewLegalHoldClient -> ShowS
showsPrec :: Int -> NewLegalHoldClient -> ShowS
$cshow :: NewLegalHoldClient -> String
show :: NewLegalHoldClient -> String
$cshowList :: [NewLegalHoldClient] -> ShowS
showList :: [NewLegalHoldClient] -> ShowS
Show, (forall x. NewLegalHoldClient -> Rep NewLegalHoldClient x)
-> (forall x. Rep NewLegalHoldClient x -> NewLegalHoldClient)
-> Generic NewLegalHoldClient
forall x. Rep NewLegalHoldClient x -> NewLegalHoldClient
forall x. NewLegalHoldClient -> Rep NewLegalHoldClient x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NewLegalHoldClient -> Rep NewLegalHoldClient x
from :: forall x. NewLegalHoldClient -> Rep NewLegalHoldClient x
$cto :: forall x. Rep NewLegalHoldClient x -> NewLegalHoldClient
to :: forall x. Rep NewLegalHoldClient x -> NewLegalHoldClient
Generic)
  deriving (Gen NewLegalHoldClient
Gen NewLegalHoldClient
-> (NewLegalHoldClient -> [NewLegalHoldClient])
-> Arbitrary NewLegalHoldClient
NewLegalHoldClient -> [NewLegalHoldClient]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen NewLegalHoldClient
arbitrary :: Gen NewLegalHoldClient
$cshrink :: NewLegalHoldClient -> [NewLegalHoldClient]
shrink :: NewLegalHoldClient -> [NewLegalHoldClient]
Arbitrary) via (GenericUniform NewLegalHoldClient)
  deriving ([NewLegalHoldClient] -> Value
[NewLegalHoldClient] -> Encoding
NewLegalHoldClient -> Value
NewLegalHoldClient -> Encoding
(NewLegalHoldClient -> Value)
-> (NewLegalHoldClient -> Encoding)
-> ([NewLegalHoldClient] -> Value)
-> ([NewLegalHoldClient] -> Encoding)
-> ToJSON NewLegalHoldClient
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: NewLegalHoldClient -> Value
toJSON :: NewLegalHoldClient -> Value
$ctoEncoding :: NewLegalHoldClient -> Encoding
toEncoding :: NewLegalHoldClient -> Encoding
$ctoJSONList :: [NewLegalHoldClient] -> Value
toJSONList :: [NewLegalHoldClient] -> Value
$ctoEncodingList :: [NewLegalHoldClient] -> Encoding
toEncodingList :: [NewLegalHoldClient] -> Encoding
A.ToJSON, Value -> Parser [NewLegalHoldClient]
Value -> Parser NewLegalHoldClient
(Value -> Parser NewLegalHoldClient)
-> (Value -> Parser [NewLegalHoldClient])
-> FromJSON NewLegalHoldClient
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser NewLegalHoldClient
parseJSON :: Value -> Parser NewLegalHoldClient
$cparseJSONList :: Value -> Parser [NewLegalHoldClient]
parseJSONList :: Value -> Parser [NewLegalHoldClient]
A.FromJSON) via (Schema NewLegalHoldClient)

instance OpenApi.ToSchema NewLegalHoldClient where
  declareNamedSchema :: Proxy NewLegalHoldClient
-> Declare (Definitions Schema) NamedSchema
declareNamedSchema = SchemaOptions
-> Proxy NewLegalHoldClient
-> Declare (Definitions Schema) NamedSchema
forall a.
(Generic a, GToSchema (Rep a), Typeable a) =>
SchemaOptions
-> Proxy a -> Declare (Definitions Schema) NamedSchema
OpenApi.genericDeclareNamedSchema SchemaOptions
opts
    where
      opts :: SchemaOptions
opts =
        SchemaOptions
OpenApi.defaultSchemaOptions
          { OpenApi.fieldLabelModifier = \case
              String
"newLegalHoldClientPrekeys" -> String
"prekeys"
              String
"newLegalHoldClientLastKey" -> String
"last_prekey"
              String
_ -> String
""
          }

instance ToSchema NewLegalHoldClient where
  schema :: ValueSchema NamedSwaggerDoc NewLegalHoldClient
schema =
    Text
-> SchemaP
     SwaggerDoc Object [Pair] NewLegalHoldClient NewLegalHoldClient
-> ValueSchema NamedSwaggerDoc NewLegalHoldClient
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"NewLegalHoldClient" (SchemaP
   SwaggerDoc Object [Pair] NewLegalHoldClient NewLegalHoldClient
 -> ValueSchema NamedSwaggerDoc NewLegalHoldClient)
-> SchemaP
     SwaggerDoc Object [Pair] NewLegalHoldClient NewLegalHoldClient
-> ValueSchema NamedSwaggerDoc NewLegalHoldClient
forall a b. (a -> b) -> a -> b
$
      [Prekey] -> LastPrekey -> NewLegalHoldClient
NewLegalHoldClient
        ([Prekey] -> LastPrekey -> NewLegalHoldClient)
-> SchemaP SwaggerDoc Object [Pair] NewLegalHoldClient [Prekey]
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     NewLegalHoldClient
     (LastPrekey -> NewLegalHoldClient)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (.newLegalHoldClientPrekeys) (NewLegalHoldClient -> [Prekey])
-> SchemaP SwaggerDoc Object [Pair] [Prekey] [Prekey]
-> SchemaP SwaggerDoc Object [Pair] NewLegalHoldClient [Prekey]
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP SwaggerDoc Value Value [Prekey] [Prekey]
-> SchemaP SwaggerDoc Object [Pair] [Prekey] [Prekey]
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"prekeys" (ValueSchema NamedSwaggerDoc Prekey
-> SchemaP SwaggerDoc Value Value [Prekey] [Prekey]
forall ndoc doc a.
(HasArray ndoc doc, HasName ndoc) =>
ValueSchema ndoc a -> ValueSchema doc [a]
array ValueSchema NamedSwaggerDoc Prekey
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  NewLegalHoldClient
  (LastPrekey -> NewLegalHoldClient)
-> SchemaP SwaggerDoc Object [Pair] NewLegalHoldClient LastPrekey
-> SchemaP
     SwaggerDoc Object [Pair] NewLegalHoldClient NewLegalHoldClient
forall a b.
SchemaP SwaggerDoc Object [Pair] NewLegalHoldClient (a -> b)
-> SchemaP SwaggerDoc Object [Pair] NewLegalHoldClient a
-> SchemaP SwaggerDoc Object [Pair] NewLegalHoldClient b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (.newLegalHoldClientLastKey) (NewLegalHoldClient -> LastPrekey)
-> SchemaP SwaggerDoc Object [Pair] LastPrekey LastPrekey
-> SchemaP SwaggerDoc Object [Pair] NewLegalHoldClient LastPrekey
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value LastPrekey LastPrekey
-> SchemaP SwaggerDoc Object [Pair] LastPrekey LastPrekey
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"last_prekey" SchemaP NamedSwaggerDoc Value Value LastPrekey LastPrekey
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema

--------------------------------------------------------------------------------
-- confirm

-- Request payload for the @/confirm@ endpoint on the LegalHold Service
data LegalHoldServiceConfirm = LegalHoldServiceConfirm
  { LegalHoldServiceConfirm -> ClientId
clientId :: ClientId,
    LegalHoldServiceConfirm -> Qualified UserId
userId :: Qualified UserId,
    LegalHoldServiceConfirm -> TeamId
teamId :: TeamId,
    -- | Replace with Legal Hold Token Type
    LegalHoldServiceConfirm -> Text
refreshToken :: Text
  }
  deriving stock (LegalHoldServiceConfirm -> LegalHoldServiceConfirm -> Bool
(LegalHoldServiceConfirm -> LegalHoldServiceConfirm -> Bool)
-> (LegalHoldServiceConfirm -> LegalHoldServiceConfirm -> Bool)
-> Eq LegalHoldServiceConfirm
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LegalHoldServiceConfirm -> LegalHoldServiceConfirm -> Bool
== :: LegalHoldServiceConfirm -> LegalHoldServiceConfirm -> Bool
$c/= :: LegalHoldServiceConfirm -> LegalHoldServiceConfirm -> Bool
/= :: LegalHoldServiceConfirm -> LegalHoldServiceConfirm -> Bool
Eq, Int -> LegalHoldServiceConfirm -> ShowS
[LegalHoldServiceConfirm] -> ShowS
LegalHoldServiceConfirm -> String
(Int -> LegalHoldServiceConfirm -> ShowS)
-> (LegalHoldServiceConfirm -> String)
-> ([LegalHoldServiceConfirm] -> ShowS)
-> Show LegalHoldServiceConfirm
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LegalHoldServiceConfirm -> ShowS
showsPrec :: Int -> LegalHoldServiceConfirm -> ShowS
$cshow :: LegalHoldServiceConfirm -> String
show :: LegalHoldServiceConfirm -> String
$cshowList :: [LegalHoldServiceConfirm] -> ShowS
showList :: [LegalHoldServiceConfirm] -> ShowS
Show, (forall x.
 LegalHoldServiceConfirm -> Rep LegalHoldServiceConfirm x)
-> (forall x.
    Rep LegalHoldServiceConfirm x -> LegalHoldServiceConfirm)
-> Generic LegalHoldServiceConfirm
forall x. Rep LegalHoldServiceConfirm x -> LegalHoldServiceConfirm
forall x. LegalHoldServiceConfirm -> Rep LegalHoldServiceConfirm x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. LegalHoldServiceConfirm -> Rep LegalHoldServiceConfirm x
from :: forall x. LegalHoldServiceConfirm -> Rep LegalHoldServiceConfirm x
$cto :: forall x. Rep LegalHoldServiceConfirm x -> LegalHoldServiceConfirm
to :: forall x. Rep LegalHoldServiceConfirm x -> LegalHoldServiceConfirm
Generic)
  deriving (Gen LegalHoldServiceConfirm
Gen LegalHoldServiceConfirm
-> (LegalHoldServiceConfirm -> [LegalHoldServiceConfirm])
-> Arbitrary LegalHoldServiceConfirm
LegalHoldServiceConfirm -> [LegalHoldServiceConfirm]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen LegalHoldServiceConfirm
arbitrary :: Gen LegalHoldServiceConfirm
$cshrink :: LegalHoldServiceConfirm -> [LegalHoldServiceConfirm]
shrink :: LegalHoldServiceConfirm -> [LegalHoldServiceConfirm]
Arbitrary) via (GenericUniform LegalHoldServiceConfirm)
  deriving ([LegalHoldServiceConfirm] -> Value
[LegalHoldServiceConfirm] -> Encoding
LegalHoldServiceConfirm -> Value
LegalHoldServiceConfirm -> Encoding
(LegalHoldServiceConfirm -> Value)
-> (LegalHoldServiceConfirm -> Encoding)
-> ([LegalHoldServiceConfirm] -> Value)
-> ([LegalHoldServiceConfirm] -> Encoding)
-> ToJSON LegalHoldServiceConfirm
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: LegalHoldServiceConfirm -> Value
toJSON :: LegalHoldServiceConfirm -> Value
$ctoEncoding :: LegalHoldServiceConfirm -> Encoding
toEncoding :: LegalHoldServiceConfirm -> Encoding
$ctoJSONList :: [LegalHoldServiceConfirm] -> Value
toJSONList :: [LegalHoldServiceConfirm] -> Value
$ctoEncodingList :: [LegalHoldServiceConfirm] -> Encoding
toEncodingList :: [LegalHoldServiceConfirm] -> Encoding
A.ToJSON, Value -> Parser [LegalHoldServiceConfirm]
Value -> Parser LegalHoldServiceConfirm
(Value -> Parser LegalHoldServiceConfirm)
-> (Value -> Parser [LegalHoldServiceConfirm])
-> FromJSON LegalHoldServiceConfirm
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser LegalHoldServiceConfirm
parseJSON :: Value -> Parser LegalHoldServiceConfirm
$cparseJSONList :: Value -> Parser [LegalHoldServiceConfirm]
parseJSONList :: Value -> Parser [LegalHoldServiceConfirm]
A.FromJSON) via (Schema LegalHoldServiceConfirm)

instance ToSchema LegalHoldServiceConfirm where
  schema :: ValueSchema NamedSwaggerDoc LegalHoldServiceConfirm
schema =
    Text
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     LegalHoldServiceConfirm
     LegalHoldServiceConfirm
-> ValueSchema NamedSwaggerDoc LegalHoldServiceConfirm
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"LegalHoldServiceConfirm" (SchemaP
   SwaggerDoc
   Object
   [Pair]
   LegalHoldServiceConfirm
   LegalHoldServiceConfirm
 -> ValueSchema NamedSwaggerDoc LegalHoldServiceConfirm)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     LegalHoldServiceConfirm
     LegalHoldServiceConfirm
-> ValueSchema NamedSwaggerDoc LegalHoldServiceConfirm
forall a b. (a -> b) -> a -> b
$
      ClientId
-> Qualified UserId -> TeamId -> Text -> LegalHoldServiceConfirm
LegalHoldServiceConfirm
        (ClientId
 -> Qualified UserId -> TeamId -> Text -> LegalHoldServiceConfirm)
-> SchemaP
     SwaggerDoc Object [Pair] LegalHoldServiceConfirm ClientId
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     LegalHoldServiceConfirm
     (Qualified UserId -> TeamId -> Text -> LegalHoldServiceConfirm)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (.clientId) (LegalHoldServiceConfirm -> ClientId)
-> SchemaP SwaggerDoc Object [Pair] ClientId ClientId
-> SchemaP
     SwaggerDoc Object [Pair] LegalHoldServiceConfirm 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
"client_id" SchemaP NamedSwaggerDoc Value Value ClientId ClientId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  LegalHoldServiceConfirm
  (Qualified UserId -> TeamId -> Text -> LegalHoldServiceConfirm)
-> SchemaP
     SwaggerDoc Object [Pair] LegalHoldServiceConfirm (Qualified UserId)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     LegalHoldServiceConfirm
     (TeamId -> Text -> LegalHoldServiceConfirm)
forall a b.
SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirm (a -> b)
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirm a
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirm b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (.userId) (LegalHoldServiceConfirm -> Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] (Qualified UserId) (Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] LegalHoldServiceConfirm (Qualified UserId)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP
     NamedSwaggerDoc Value Value (Qualified UserId) (Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] (Qualified UserId) (Qualified UserId)
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"qualified_user_id" SchemaP
  NamedSwaggerDoc Value Value (Qualified UserId) (Qualified UserId)
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  LegalHoldServiceConfirm
  (TeamId -> Text -> LegalHoldServiceConfirm)
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirm TeamId
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     LegalHoldServiceConfirm
     (Text -> LegalHoldServiceConfirm)
forall a b.
SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirm (a -> b)
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirm a
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirm b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (.teamId) (LegalHoldServiceConfirm -> TeamId)
-> SchemaP SwaggerDoc Object [Pair] TeamId TeamId
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirm TeamId
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value TeamId TeamId
-> SchemaP SwaggerDoc Object [Pair] TeamId TeamId
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"team_id" SchemaP NamedSwaggerDoc Value Value TeamId TeamId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  LegalHoldServiceConfirm
  (Text -> LegalHoldServiceConfirm)
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirm Text
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     LegalHoldServiceConfirm
     LegalHoldServiceConfirm
forall a b.
SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirm (a -> b)
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirm a
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirm b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (.refreshToken) (LegalHoldServiceConfirm -> Text)
-> SchemaP SwaggerDoc Object [Pair] Text Text
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirm Text
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value Text Text
-> SchemaP SwaggerDoc Object [Pair] Text Text
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"refresh_token" SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema

data LegalHoldServiceConfirmV0 = LegalHoldServiceConfirmV0
  { LegalHoldServiceConfirmV0 -> ClientId
lhcClientId :: ClientId,
    LegalHoldServiceConfirmV0 -> UserId
lhcUserId :: UserId,
    LegalHoldServiceConfirmV0 -> TeamId
lhcTeamId :: TeamId,
    -- | Replace with Legal Hold Token Type
    LegalHoldServiceConfirmV0 -> Text
lhcRefreshToken :: Text
  }
  deriving stock (LegalHoldServiceConfirmV0 -> LegalHoldServiceConfirmV0 -> Bool
(LegalHoldServiceConfirmV0 -> LegalHoldServiceConfirmV0 -> Bool)
-> (LegalHoldServiceConfirmV0 -> LegalHoldServiceConfirmV0 -> Bool)
-> Eq LegalHoldServiceConfirmV0
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LegalHoldServiceConfirmV0 -> LegalHoldServiceConfirmV0 -> Bool
== :: LegalHoldServiceConfirmV0 -> LegalHoldServiceConfirmV0 -> Bool
$c/= :: LegalHoldServiceConfirmV0 -> LegalHoldServiceConfirmV0 -> Bool
/= :: LegalHoldServiceConfirmV0 -> LegalHoldServiceConfirmV0 -> Bool
Eq, Int -> LegalHoldServiceConfirmV0 -> ShowS
[LegalHoldServiceConfirmV0] -> ShowS
LegalHoldServiceConfirmV0 -> String
(Int -> LegalHoldServiceConfirmV0 -> ShowS)
-> (LegalHoldServiceConfirmV0 -> String)
-> ([LegalHoldServiceConfirmV0] -> ShowS)
-> Show LegalHoldServiceConfirmV0
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LegalHoldServiceConfirmV0 -> ShowS
showsPrec :: Int -> LegalHoldServiceConfirmV0 -> ShowS
$cshow :: LegalHoldServiceConfirmV0 -> String
show :: LegalHoldServiceConfirmV0 -> String
$cshowList :: [LegalHoldServiceConfirmV0] -> ShowS
showList :: [LegalHoldServiceConfirmV0] -> ShowS
Show, (forall x.
 LegalHoldServiceConfirmV0 -> Rep LegalHoldServiceConfirmV0 x)
-> (forall x.
    Rep LegalHoldServiceConfirmV0 x -> LegalHoldServiceConfirmV0)
-> Generic LegalHoldServiceConfirmV0
forall x.
Rep LegalHoldServiceConfirmV0 x -> LegalHoldServiceConfirmV0
forall x.
LegalHoldServiceConfirmV0 -> Rep LegalHoldServiceConfirmV0 x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
LegalHoldServiceConfirmV0 -> Rep LegalHoldServiceConfirmV0 x
from :: forall x.
LegalHoldServiceConfirmV0 -> Rep LegalHoldServiceConfirmV0 x
$cto :: forall x.
Rep LegalHoldServiceConfirmV0 x -> LegalHoldServiceConfirmV0
to :: forall x.
Rep LegalHoldServiceConfirmV0 x -> LegalHoldServiceConfirmV0
Generic)
  deriving (Gen LegalHoldServiceConfirmV0
Gen LegalHoldServiceConfirmV0
-> (LegalHoldServiceConfirmV0 -> [LegalHoldServiceConfirmV0])
-> Arbitrary LegalHoldServiceConfirmV0
LegalHoldServiceConfirmV0 -> [LegalHoldServiceConfirmV0]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen LegalHoldServiceConfirmV0
arbitrary :: Gen LegalHoldServiceConfirmV0
$cshrink :: LegalHoldServiceConfirmV0 -> [LegalHoldServiceConfirmV0]
shrink :: LegalHoldServiceConfirmV0 -> [LegalHoldServiceConfirmV0]
Arbitrary) via (GenericUniform LegalHoldServiceConfirmV0)
  deriving ([LegalHoldServiceConfirmV0] -> Value
[LegalHoldServiceConfirmV0] -> Encoding
LegalHoldServiceConfirmV0 -> Value
LegalHoldServiceConfirmV0 -> Encoding
(LegalHoldServiceConfirmV0 -> Value)
-> (LegalHoldServiceConfirmV0 -> Encoding)
-> ([LegalHoldServiceConfirmV0] -> Value)
-> ([LegalHoldServiceConfirmV0] -> Encoding)
-> ToJSON LegalHoldServiceConfirmV0
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: LegalHoldServiceConfirmV0 -> Value
toJSON :: LegalHoldServiceConfirmV0 -> Value
$ctoEncoding :: LegalHoldServiceConfirmV0 -> Encoding
toEncoding :: LegalHoldServiceConfirmV0 -> Encoding
$ctoJSONList :: [LegalHoldServiceConfirmV0] -> Value
toJSONList :: [LegalHoldServiceConfirmV0] -> Value
$ctoEncodingList :: [LegalHoldServiceConfirmV0] -> Encoding
toEncodingList :: [LegalHoldServiceConfirmV0] -> Encoding
A.ToJSON, Value -> Parser [LegalHoldServiceConfirmV0]
Value -> Parser LegalHoldServiceConfirmV0
(Value -> Parser LegalHoldServiceConfirmV0)
-> (Value -> Parser [LegalHoldServiceConfirmV0])
-> FromJSON LegalHoldServiceConfirmV0
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser LegalHoldServiceConfirmV0
parseJSON :: Value -> Parser LegalHoldServiceConfirmV0
$cparseJSONList :: Value -> Parser [LegalHoldServiceConfirmV0]
parseJSONList :: Value -> Parser [LegalHoldServiceConfirmV0]
A.FromJSON) via (Schema LegalHoldServiceConfirmV0)

instance ToSchema LegalHoldServiceConfirmV0 where
  schema :: ValueSchema NamedSwaggerDoc LegalHoldServiceConfirmV0
schema =
    Text
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     LegalHoldServiceConfirmV0
     LegalHoldServiceConfirmV0
-> ValueSchema NamedSwaggerDoc LegalHoldServiceConfirmV0
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"LegalHoldServiceConfirmV0" (SchemaP
   SwaggerDoc
   Object
   [Pair]
   LegalHoldServiceConfirmV0
   LegalHoldServiceConfirmV0
 -> ValueSchema NamedSwaggerDoc LegalHoldServiceConfirmV0)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     LegalHoldServiceConfirmV0
     LegalHoldServiceConfirmV0
-> ValueSchema NamedSwaggerDoc LegalHoldServiceConfirmV0
forall a b. (a -> b) -> a -> b
$
      ClientId -> UserId -> TeamId -> Text -> LegalHoldServiceConfirmV0
LegalHoldServiceConfirmV0
        (ClientId -> UserId -> TeamId -> Text -> LegalHoldServiceConfirmV0)
-> SchemaP
     SwaggerDoc Object [Pair] LegalHoldServiceConfirmV0 ClientId
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     LegalHoldServiceConfirmV0
     (UserId -> TeamId -> Text -> LegalHoldServiceConfirmV0)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (.lhcClientId) (LegalHoldServiceConfirmV0 -> ClientId)
-> SchemaP SwaggerDoc Object [Pair] ClientId ClientId
-> SchemaP
     SwaggerDoc Object [Pair] LegalHoldServiceConfirmV0 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
"client_id" SchemaP NamedSwaggerDoc Value Value ClientId ClientId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  LegalHoldServiceConfirmV0
  (UserId -> TeamId -> Text -> LegalHoldServiceConfirmV0)
-> SchemaP
     SwaggerDoc Object [Pair] LegalHoldServiceConfirmV0 UserId
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     LegalHoldServiceConfirmV0
     (TeamId -> Text -> LegalHoldServiceConfirmV0)
forall a b.
SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirmV0 (a -> b)
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirmV0 a
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirmV0 b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (.lhcUserId) (LegalHoldServiceConfirmV0 -> UserId)
-> SchemaP SwaggerDoc Object [Pair] UserId UserId
-> SchemaP
     SwaggerDoc Object [Pair] LegalHoldServiceConfirmV0 UserId
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value UserId UserId
-> SchemaP SwaggerDoc Object [Pair] UserId UserId
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"user_id" SchemaP NamedSwaggerDoc Value Value UserId UserId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  LegalHoldServiceConfirmV0
  (TeamId -> Text -> LegalHoldServiceConfirmV0)
-> SchemaP
     SwaggerDoc Object [Pair] LegalHoldServiceConfirmV0 TeamId
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     LegalHoldServiceConfirmV0
     (Text -> LegalHoldServiceConfirmV0)
forall a b.
SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirmV0 (a -> b)
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirmV0 a
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirmV0 b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (.lhcTeamId) (LegalHoldServiceConfirmV0 -> TeamId)
-> SchemaP SwaggerDoc Object [Pair] TeamId TeamId
-> SchemaP
     SwaggerDoc Object [Pair] LegalHoldServiceConfirmV0 TeamId
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value TeamId TeamId
-> SchemaP SwaggerDoc Object [Pair] TeamId TeamId
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"team_id" SchemaP NamedSwaggerDoc Value Value TeamId TeamId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  LegalHoldServiceConfirmV0
  (Text -> LegalHoldServiceConfirmV0)
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirmV0 Text
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     LegalHoldServiceConfirmV0
     LegalHoldServiceConfirmV0
forall a b.
SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirmV0 (a -> b)
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirmV0 a
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirmV0 b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (.lhcRefreshToken) (LegalHoldServiceConfirmV0 -> Text)
-> SchemaP SwaggerDoc Object [Pair] Text Text
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceConfirmV0 Text
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value Text Text
-> SchemaP SwaggerDoc Object [Pair] Text Text
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"refresh_token" SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema

--------------------------------------------------------------------------------
-- remove

-- Request payload for the @/remove@ endpoint on the LegalHold Service
data LegalHoldServiceRemove = LegalHoldServiceRemove
  { LegalHoldServiceRemove -> Qualified UserId
userId :: Qualified UserId,
    LegalHoldServiceRemove -> TeamId
teamId :: TeamId
  }
  deriving stock (LegalHoldServiceRemove -> LegalHoldServiceRemove -> Bool
(LegalHoldServiceRemove -> LegalHoldServiceRemove -> Bool)
-> (LegalHoldServiceRemove -> LegalHoldServiceRemove -> Bool)
-> Eq LegalHoldServiceRemove
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LegalHoldServiceRemove -> LegalHoldServiceRemove -> Bool
== :: LegalHoldServiceRemove -> LegalHoldServiceRemove -> Bool
$c/= :: LegalHoldServiceRemove -> LegalHoldServiceRemove -> Bool
/= :: LegalHoldServiceRemove -> LegalHoldServiceRemove -> Bool
Eq, Int -> LegalHoldServiceRemove -> ShowS
[LegalHoldServiceRemove] -> ShowS
LegalHoldServiceRemove -> String
(Int -> LegalHoldServiceRemove -> ShowS)
-> (LegalHoldServiceRemove -> String)
-> ([LegalHoldServiceRemove] -> ShowS)
-> Show LegalHoldServiceRemove
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LegalHoldServiceRemove -> ShowS
showsPrec :: Int -> LegalHoldServiceRemove -> ShowS
$cshow :: LegalHoldServiceRemove -> String
show :: LegalHoldServiceRemove -> String
$cshowList :: [LegalHoldServiceRemove] -> ShowS
showList :: [LegalHoldServiceRemove] -> ShowS
Show, (forall x. LegalHoldServiceRemove -> Rep LegalHoldServiceRemove x)
-> (forall x.
    Rep LegalHoldServiceRemove x -> LegalHoldServiceRemove)
-> Generic LegalHoldServiceRemove
forall x. Rep LegalHoldServiceRemove x -> LegalHoldServiceRemove
forall x. LegalHoldServiceRemove -> Rep LegalHoldServiceRemove x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. LegalHoldServiceRemove -> Rep LegalHoldServiceRemove x
from :: forall x. LegalHoldServiceRemove -> Rep LegalHoldServiceRemove x
$cto :: forall x. Rep LegalHoldServiceRemove x -> LegalHoldServiceRemove
to :: forall x. Rep LegalHoldServiceRemove x -> LegalHoldServiceRemove
Generic)
  deriving (Gen LegalHoldServiceRemove
Gen LegalHoldServiceRemove
-> (LegalHoldServiceRemove -> [LegalHoldServiceRemove])
-> Arbitrary LegalHoldServiceRemove
LegalHoldServiceRemove -> [LegalHoldServiceRemove]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen LegalHoldServiceRemove
arbitrary :: Gen LegalHoldServiceRemove
$cshrink :: LegalHoldServiceRemove -> [LegalHoldServiceRemove]
shrink :: LegalHoldServiceRemove -> [LegalHoldServiceRemove]
Arbitrary) via (GenericUniform LegalHoldServiceRemove)
  deriving ([LegalHoldServiceRemove] -> Value
[LegalHoldServiceRemove] -> Encoding
LegalHoldServiceRemove -> Value
LegalHoldServiceRemove -> Encoding
(LegalHoldServiceRemove -> Value)
-> (LegalHoldServiceRemove -> Encoding)
-> ([LegalHoldServiceRemove] -> Value)
-> ([LegalHoldServiceRemove] -> Encoding)
-> ToJSON LegalHoldServiceRemove
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: LegalHoldServiceRemove -> Value
toJSON :: LegalHoldServiceRemove -> Value
$ctoEncoding :: LegalHoldServiceRemove -> Encoding
toEncoding :: LegalHoldServiceRemove -> Encoding
$ctoJSONList :: [LegalHoldServiceRemove] -> Value
toJSONList :: [LegalHoldServiceRemove] -> Value
$ctoEncodingList :: [LegalHoldServiceRemove] -> Encoding
toEncodingList :: [LegalHoldServiceRemove] -> Encoding
A.ToJSON, Value -> Parser [LegalHoldServiceRemove]
Value -> Parser LegalHoldServiceRemove
(Value -> Parser LegalHoldServiceRemove)
-> (Value -> Parser [LegalHoldServiceRemove])
-> FromJSON LegalHoldServiceRemove
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser LegalHoldServiceRemove
parseJSON :: Value -> Parser LegalHoldServiceRemove
$cparseJSONList :: Value -> Parser [LegalHoldServiceRemove]
parseJSONList :: Value -> Parser [LegalHoldServiceRemove]
A.FromJSON) via (Schema LegalHoldServiceRemove)

instance ToSchema LegalHoldServiceRemove where
  schema :: ValueSchema NamedSwaggerDoc LegalHoldServiceRemove
schema =
    Text
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     LegalHoldServiceRemove
     LegalHoldServiceRemove
-> ValueSchema NamedSwaggerDoc LegalHoldServiceRemove
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"LegalHoldServiceRemove" (SchemaP
   SwaggerDoc
   Object
   [Pair]
   LegalHoldServiceRemove
   LegalHoldServiceRemove
 -> ValueSchema NamedSwaggerDoc LegalHoldServiceRemove)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     LegalHoldServiceRemove
     LegalHoldServiceRemove
-> ValueSchema NamedSwaggerDoc LegalHoldServiceRemove
forall a b. (a -> b) -> a -> b
$
      Qualified UserId -> TeamId -> LegalHoldServiceRemove
LegalHoldServiceRemove
        (Qualified UserId -> TeamId -> LegalHoldServiceRemove)
-> SchemaP
     SwaggerDoc Object [Pair] LegalHoldServiceRemove (Qualified UserId)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     LegalHoldServiceRemove
     (TeamId -> LegalHoldServiceRemove)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (.userId) (LegalHoldServiceRemove -> Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] (Qualified UserId) (Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] LegalHoldServiceRemove (Qualified UserId)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP
     NamedSwaggerDoc Value Value (Qualified UserId) (Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] (Qualified UserId) (Qualified UserId)
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"qualified_user_id" SchemaP
  NamedSwaggerDoc Value Value (Qualified UserId) (Qualified UserId)
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  LegalHoldServiceRemove
  (TeamId -> LegalHoldServiceRemove)
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceRemove TeamId
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     LegalHoldServiceRemove
     LegalHoldServiceRemove
forall a b.
SchemaP SwaggerDoc Object [Pair] LegalHoldServiceRemove (a -> b)
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceRemove a
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceRemove b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (.teamId) (LegalHoldServiceRemove -> TeamId)
-> SchemaP SwaggerDoc Object [Pair] TeamId TeamId
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceRemove TeamId
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value TeamId TeamId
-> SchemaP SwaggerDoc Object [Pair] TeamId TeamId
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"team_id" SchemaP NamedSwaggerDoc Value Value TeamId TeamId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema

data LegalHoldServiceRemoveV0 = LegalHoldServiceRemoveV0
  { LegalHoldServiceRemoveV0 -> UserId
lhrUserId :: UserId,
    LegalHoldServiceRemoveV0 -> TeamId
lhrTeamId :: TeamId
  }
  deriving stock (LegalHoldServiceRemoveV0 -> LegalHoldServiceRemoveV0 -> Bool
(LegalHoldServiceRemoveV0 -> LegalHoldServiceRemoveV0 -> Bool)
-> (LegalHoldServiceRemoveV0 -> LegalHoldServiceRemoveV0 -> Bool)
-> Eq LegalHoldServiceRemoveV0
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LegalHoldServiceRemoveV0 -> LegalHoldServiceRemoveV0 -> Bool
== :: LegalHoldServiceRemoveV0 -> LegalHoldServiceRemoveV0 -> Bool
$c/= :: LegalHoldServiceRemoveV0 -> LegalHoldServiceRemoveV0 -> Bool
/= :: LegalHoldServiceRemoveV0 -> LegalHoldServiceRemoveV0 -> Bool
Eq, Int -> LegalHoldServiceRemoveV0 -> ShowS
[LegalHoldServiceRemoveV0] -> ShowS
LegalHoldServiceRemoveV0 -> String
(Int -> LegalHoldServiceRemoveV0 -> ShowS)
-> (LegalHoldServiceRemoveV0 -> String)
-> ([LegalHoldServiceRemoveV0] -> ShowS)
-> Show LegalHoldServiceRemoveV0
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LegalHoldServiceRemoveV0 -> ShowS
showsPrec :: Int -> LegalHoldServiceRemoveV0 -> ShowS
$cshow :: LegalHoldServiceRemoveV0 -> String
show :: LegalHoldServiceRemoveV0 -> String
$cshowList :: [LegalHoldServiceRemoveV0] -> ShowS
showList :: [LegalHoldServiceRemoveV0] -> ShowS
Show, (forall x.
 LegalHoldServiceRemoveV0 -> Rep LegalHoldServiceRemoveV0 x)
-> (forall x.
    Rep LegalHoldServiceRemoveV0 x -> LegalHoldServiceRemoveV0)
-> Generic LegalHoldServiceRemoveV0
forall x.
Rep LegalHoldServiceRemoveV0 x -> LegalHoldServiceRemoveV0
forall x.
LegalHoldServiceRemoveV0 -> Rep LegalHoldServiceRemoveV0 x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
LegalHoldServiceRemoveV0 -> Rep LegalHoldServiceRemoveV0 x
from :: forall x.
LegalHoldServiceRemoveV0 -> Rep LegalHoldServiceRemoveV0 x
$cto :: forall x.
Rep LegalHoldServiceRemoveV0 x -> LegalHoldServiceRemoveV0
to :: forall x.
Rep LegalHoldServiceRemoveV0 x -> LegalHoldServiceRemoveV0
Generic)
  deriving (Gen LegalHoldServiceRemoveV0
Gen LegalHoldServiceRemoveV0
-> (LegalHoldServiceRemoveV0 -> [LegalHoldServiceRemoveV0])
-> Arbitrary LegalHoldServiceRemoveV0
LegalHoldServiceRemoveV0 -> [LegalHoldServiceRemoveV0]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen LegalHoldServiceRemoveV0
arbitrary :: Gen LegalHoldServiceRemoveV0
$cshrink :: LegalHoldServiceRemoveV0 -> [LegalHoldServiceRemoveV0]
shrink :: LegalHoldServiceRemoveV0 -> [LegalHoldServiceRemoveV0]
Arbitrary) via (GenericUniform LegalHoldServiceRemoveV0)
  deriving ([LegalHoldServiceRemoveV0] -> Value
[LegalHoldServiceRemoveV0] -> Encoding
LegalHoldServiceRemoveV0 -> Value
LegalHoldServiceRemoveV0 -> Encoding
(LegalHoldServiceRemoveV0 -> Value)
-> (LegalHoldServiceRemoveV0 -> Encoding)
-> ([LegalHoldServiceRemoveV0] -> Value)
-> ([LegalHoldServiceRemoveV0] -> Encoding)
-> ToJSON LegalHoldServiceRemoveV0
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: LegalHoldServiceRemoveV0 -> Value
toJSON :: LegalHoldServiceRemoveV0 -> Value
$ctoEncoding :: LegalHoldServiceRemoveV0 -> Encoding
toEncoding :: LegalHoldServiceRemoveV0 -> Encoding
$ctoJSONList :: [LegalHoldServiceRemoveV0] -> Value
toJSONList :: [LegalHoldServiceRemoveV0] -> Value
$ctoEncodingList :: [LegalHoldServiceRemoveV0] -> Encoding
toEncodingList :: [LegalHoldServiceRemoveV0] -> Encoding
A.ToJSON, Value -> Parser [LegalHoldServiceRemoveV0]
Value -> Parser LegalHoldServiceRemoveV0
(Value -> Parser LegalHoldServiceRemoveV0)
-> (Value -> Parser [LegalHoldServiceRemoveV0])
-> FromJSON LegalHoldServiceRemoveV0
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser LegalHoldServiceRemoveV0
parseJSON :: Value -> Parser LegalHoldServiceRemoveV0
$cparseJSONList :: Value -> Parser [LegalHoldServiceRemoveV0]
parseJSONList :: Value -> Parser [LegalHoldServiceRemoveV0]
A.FromJSON) via (Schema LegalHoldServiceRemoveV0)

instance ToSchema LegalHoldServiceRemoveV0 where
  schema :: ValueSchema NamedSwaggerDoc LegalHoldServiceRemoveV0
schema =
    Text
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     LegalHoldServiceRemoveV0
     LegalHoldServiceRemoveV0
-> ValueSchema NamedSwaggerDoc LegalHoldServiceRemoveV0
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"LegalHoldServiceRemoveV0" (SchemaP
   SwaggerDoc
   Object
   [Pair]
   LegalHoldServiceRemoveV0
   LegalHoldServiceRemoveV0
 -> ValueSchema NamedSwaggerDoc LegalHoldServiceRemoveV0)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     LegalHoldServiceRemoveV0
     LegalHoldServiceRemoveV0
-> ValueSchema NamedSwaggerDoc LegalHoldServiceRemoveV0
forall a b. (a -> b) -> a -> b
$
      UserId -> TeamId -> LegalHoldServiceRemoveV0
LegalHoldServiceRemoveV0
        (UserId -> TeamId -> LegalHoldServiceRemoveV0)
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceRemoveV0 UserId
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     LegalHoldServiceRemoveV0
     (TeamId -> LegalHoldServiceRemoveV0)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (.lhrUserId) (LegalHoldServiceRemoveV0 -> UserId)
-> SchemaP SwaggerDoc Object [Pair] UserId UserId
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceRemoveV0 UserId
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value UserId UserId
-> SchemaP SwaggerDoc Object [Pair] UserId UserId
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"user_id" SchemaP NamedSwaggerDoc Value Value UserId UserId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  LegalHoldServiceRemoveV0
  (TeamId -> LegalHoldServiceRemoveV0)
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceRemoveV0 TeamId
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     LegalHoldServiceRemoveV0
     LegalHoldServiceRemoveV0
forall a b.
SchemaP SwaggerDoc Object [Pair] LegalHoldServiceRemoveV0 (a -> b)
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceRemoveV0 a
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceRemoveV0 b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (.lhrTeamId) (LegalHoldServiceRemoveV0 -> TeamId)
-> SchemaP SwaggerDoc Object [Pair] TeamId TeamId
-> SchemaP SwaggerDoc Object [Pair] LegalHoldServiceRemoveV0 TeamId
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value TeamId TeamId
-> SchemaP SwaggerDoc Object [Pair] TeamId TeamId
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"team_id" SchemaP NamedSwaggerDoc Value Value TeamId TeamId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema

--------------------------------------------------------------------------------
-- SupportedVersions

newtype SupportedVersions = SupportedVersions {SupportedVersions -> [Int]
supported :: [Int]}
  deriving (Value -> Parser [SupportedVersions]
Value -> Parser SupportedVersions
(Value -> Parser SupportedVersions)
-> (Value -> Parser [SupportedVersions])
-> FromJSON SupportedVersions
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser SupportedVersions
parseJSON :: Value -> Parser SupportedVersions
$cparseJSONList :: Value -> Parser [SupportedVersions]
parseJSONList :: Value -> Parser [SupportedVersions]
A.FromJSON) via (Schema SupportedVersions)

instance ToSchema SupportedVersions where
  schema :: ValueSchema NamedSwaggerDoc SupportedVersions
schema =
    Text
-> SchemaP
     SwaggerDoc Object [Pair] SupportedVersions SupportedVersions
-> ValueSchema NamedSwaggerDoc SupportedVersions
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"SupportedVersions " (SchemaP
   SwaggerDoc Object [Pair] SupportedVersions SupportedVersions
 -> ValueSchema NamedSwaggerDoc SupportedVersions)
-> SchemaP
     SwaggerDoc Object [Pair] SupportedVersions SupportedVersions
-> ValueSchema NamedSwaggerDoc SupportedVersions
forall a b. (a -> b) -> a -> b
$
      [Int] -> SupportedVersions
SupportedVersions
        ([Int] -> SupportedVersions)
-> SchemaP SwaggerDoc Object [Pair] SupportedVersions [Int]
-> SchemaP
     SwaggerDoc Object [Pair] SupportedVersions SupportedVersions
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SupportedVersions -> [Int]
supported
          (SupportedVersions -> [Int])
-> SchemaP SwaggerDoc Object [Pair] [Int] [Int]
-> SchemaP SwaggerDoc Object [Pair] SupportedVersions [Int]
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP SwaggerDoc Value Value [Int] [Int]
-> SchemaP SwaggerDoc Object [Pair] [Int] [Int]
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"supported" (ValueSchema NamedSwaggerDoc Int
-> SchemaP SwaggerDoc Value Value [Int] [Int]
forall ndoc doc a.
(HasArray ndoc doc, HasName ndoc) =>
ValueSchema ndoc a -> ValueSchema doc [a]
array ValueSchema NamedSwaggerDoc Int
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)