{-# LANGUAGE ApplicativeDo #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE StrictData #-}

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

module Wire.API.User.Search
  ( SearchResult (..),
    Contact (..),
    TeamContact (..),
    RoleFilter (..),
    Sso (..),
    TeamUserSearchSortOrder (..),
    TeamUserSearchSortBy (..),
    FederatedUserSearchPolicy (..),
    PagingState (..),
  )
where

import Cassandra qualified as C
import Control.Error
import Control.Lens ((?~))
import Data.Aeson hiding (object, (.=))
import Data.Aeson qualified as Aeson
import Data.Attoparsec.ByteString (sepBy)
import Data.Attoparsec.ByteString.Char8 (char, string)
import Data.ByteString.Conversion (FromByteString (..), ToByteString (..))
import Data.Id (TeamId, UserId)
import Data.Json.Util (UTCTimeMillis)
import Data.OpenApi (ToParamSchema (..))
import Data.OpenApi qualified as S
import Data.Proxy
import Data.Qualified
import Data.Schema
import Data.Text qualified as T
import Data.Text.Ascii (AsciiBase64Url, toText, validateBase64Url)
import Imports
import Servant.API (FromHttpApiData, ToHttpApiData (..))
import Web.Internal.HttpApiData (parseQueryParam)
import Wire.API.Team.Role (Role)
import Wire.API.User (ManagedBy)
import Wire.API.User.Identity (EmailAddress)
import Wire.Arbitrary (Arbitrary, GenericUniform (..))

-------------------------------------------------------------------------------
-- PagingState

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

instance ToSchema PagingState where
  schema :: ValueSchema NamedSwaggerDoc PagingState
schema = (AsciiBase64Url -> Text
forall {k} (c :: k). AsciiText c -> Text
toText (AsciiBase64Url -> Text)
-> (PagingState -> AsciiBase64Url) -> PagingState -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PagingState -> AsciiBase64Url
unPagingState) (PagingState -> Text)
-> SchemaP NamedSwaggerDoc Value Value Text PagingState
-> ValueSchema NamedSwaggerDoc PagingState
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> (Text -> Either String PagingState)
-> SchemaP NamedSwaggerDoc Value Value Text PagingState
forall a.
Text
-> (Text -> Either String a)
-> SchemaP NamedSwaggerDoc Value Value Text a
parsedText Text
"PagingState" ((AsciiBase64Url -> PagingState)
-> Either String AsciiBase64Url -> Either String PagingState
forall a b. (a -> b) -> Either String a -> Either String b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap AsciiBase64Url -> PagingState
PagingState (Either String AsciiBase64Url -> Either String PagingState)
-> (Text -> Either String AsciiBase64Url)
-> Text
-> Either String PagingState
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Either String AsciiBase64Url
validateBase64Url)

instance ToParamSchema PagingState where
  toParamSchema :: Proxy PagingState -> Schema
toParamSchema Proxy PagingState
_ = Proxy Text -> Schema
forall a. ToParamSchema a => Proxy a -> Schema
toParamSchema (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @Text)

instance FromHttpApiData PagingState where
  parseQueryParam :: Text -> Either Text PagingState
parseQueryParam Text
s = (String -> Text)
-> Either String PagingState -> Either Text PagingState
forall a c b. (a -> c) -> Either a b -> Either c b
mapLeft String -> Text
T.pack (Either String PagingState -> Either Text PagingState)
-> Either String PagingState -> Either Text PagingState
forall a b. (a -> b) -> a -> b
$ AsciiBase64Url -> PagingState
PagingState (AsciiBase64Url -> PagingState)
-> Either String AsciiBase64Url -> Either String PagingState
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> Either String AsciiBase64Url
validateBase64Url Text
s

instance ToHttpApiData PagingState where
  toQueryParam :: PagingState -> Text
toQueryParam = AsciiBase64Url -> Text
forall {k} (c :: k). AsciiText c -> Text
toText (AsciiBase64Url -> Text)
-> (PagingState -> AsciiBase64Url) -> PagingState -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PagingState -> AsciiBase64Url
unPagingState

instance ToByteString PagingState where
  builder :: PagingState -> Builder
builder = AsciiBase64Url -> Builder
forall a. ToByteString a => a -> Builder
builder (AsciiBase64Url -> Builder)
-> (PagingState -> AsciiBase64Url) -> PagingState -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PagingState -> AsciiBase64Url
unPagingState

instance FromByteString PagingState where
  parser :: Parser PagingState
parser = (AsciiBase64Url -> PagingState)
-> Parser ByteString AsciiBase64Url -> Parser PagingState
forall a b. (a -> b) -> Parser ByteString a -> Parser ByteString b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap AsciiBase64Url -> PagingState
PagingState Parser ByteString AsciiBase64Url
forall a. FromByteString a => Parser a
parser

--------------------------------------------------------------------------------
-- SearchResult

data SearchResult a = SearchResult
  { forall a. SearchResult a -> Int
searchFound :: Int,
    forall a. SearchResult a -> Int
searchReturned :: Int,
    forall a. SearchResult a -> Int
searchTook :: Int,
    forall a. SearchResult a -> [a]
searchResults :: [a],
    forall a. SearchResult a -> FederatedUserSearchPolicy
searchPolicy :: FederatedUserSearchPolicy,
    forall a. SearchResult a -> Maybe PagingState
searchPagingState :: Maybe PagingState,
    forall a. SearchResult a -> Maybe Bool
searchHasMore :: Maybe Bool
  }
  deriving stock (SearchResult a -> SearchResult a -> Bool
(SearchResult a -> SearchResult a -> Bool)
-> (SearchResult a -> SearchResult a -> Bool)
-> Eq (SearchResult a)
forall a. Eq a => SearchResult a -> SearchResult a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => SearchResult a -> SearchResult a -> Bool
== :: SearchResult a -> SearchResult a -> Bool
$c/= :: forall a. Eq a => SearchResult a -> SearchResult a -> Bool
/= :: SearchResult a -> SearchResult a -> Bool
Eq, Int -> SearchResult a -> ShowS
[SearchResult a] -> ShowS
SearchResult a -> String
(Int -> SearchResult a -> ShowS)
-> (SearchResult a -> String)
-> ([SearchResult a] -> ShowS)
-> Show (SearchResult a)
forall a. Show a => Int -> SearchResult a -> ShowS
forall a. Show a => [SearchResult a] -> ShowS
forall a. Show a => SearchResult a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> SearchResult a -> ShowS
showsPrec :: Int -> SearchResult a -> ShowS
$cshow :: forall a. Show a => SearchResult a -> String
show :: SearchResult a -> String
$cshowList :: forall a. Show a => [SearchResult a] -> ShowS
showList :: [SearchResult a] -> ShowS
Show, (forall x. SearchResult a -> Rep (SearchResult a) x)
-> (forall x. Rep (SearchResult a) x -> SearchResult a)
-> Generic (SearchResult a)
forall x. Rep (SearchResult a) x -> SearchResult a
forall x. SearchResult a -> Rep (SearchResult a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (SearchResult a) x -> SearchResult a
forall a x. SearchResult a -> Rep (SearchResult a) x
$cfrom :: forall a x. SearchResult a -> Rep (SearchResult a) x
from :: forall x. SearchResult a -> Rep (SearchResult a) x
$cto :: forall a x. Rep (SearchResult a) x -> SearchResult a
to :: forall x. Rep (SearchResult a) x -> SearchResult a
Generic, (forall a b. (a -> b) -> SearchResult a -> SearchResult b)
-> (forall a b. a -> SearchResult b -> SearchResult a)
-> Functor SearchResult
forall a b. a -> SearchResult b -> SearchResult a
forall a b. (a -> b) -> SearchResult a -> SearchResult 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) -> SearchResult a -> SearchResult b
fmap :: forall a b. (a -> b) -> SearchResult a -> SearchResult b
$c<$ :: forall a b. a -> SearchResult b -> SearchResult a
<$ :: forall a b. a -> SearchResult b -> SearchResult a
Functor)
  deriving (Gen (SearchResult a)
Gen (SearchResult a)
-> (SearchResult a -> [SearchResult a])
-> Arbitrary (SearchResult a)
SearchResult a -> [SearchResult a]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
forall a. Arbitrary a => Gen (SearchResult a)
forall a. Arbitrary a => SearchResult a -> [SearchResult a]
$carbitrary :: forall a. Arbitrary a => Gen (SearchResult a)
arbitrary :: Gen (SearchResult a)
$cshrink :: forall a. Arbitrary a => SearchResult a -> [SearchResult a]
shrink :: SearchResult a -> [SearchResult a]
Arbitrary) via (GenericUniform (SearchResult a))

instance Foldable SearchResult where
  foldMap :: forall m a. Monoid m => (a -> m) -> SearchResult a -> m
foldMap a -> m
f SearchResult a
r = (a -> m) -> [a] -> m
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap a -> m
f (SearchResult a -> [a]
forall a. SearchResult a -> [a]
searchResults SearchResult a
r)

instance Traversable SearchResult where
  traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SearchResult a -> f (SearchResult b)
traverse a -> f b
f SearchResult a
r = do
    [b]
newResults <- (a -> f b) -> [a] -> f [b]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse a -> f b
f (SearchResult a -> [a]
forall a. SearchResult a -> [a]
searchResults SearchResult a
r)
    pure $ SearchResult a
r {searchResults = newResults}

instance (ToSchema a) => ToSchema (SearchResult a) where
  schema :: ValueSchema NamedSwaggerDoc (SearchResult a)
schema =
    Text
-> SchemaP
     SwaggerDoc Object [Pair] (SearchResult a) (SearchResult a)
-> ValueSchema NamedSwaggerDoc (SearchResult a)
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"SearchResult" (SchemaP SwaggerDoc Object [Pair] (SearchResult a) (SearchResult a)
 -> ValueSchema NamedSwaggerDoc (SearchResult a))
-> SchemaP
     SwaggerDoc Object [Pair] (SearchResult a) (SearchResult a)
-> ValueSchema NamedSwaggerDoc (SearchResult a)
forall a b. (a -> b) -> a -> b
$
      Int
-> Int
-> Int
-> [a]
-> FederatedUserSearchPolicy
-> Maybe PagingState
-> Maybe Bool
-> SearchResult a
forall a.
Int
-> Int
-> Int
-> [a]
-> FederatedUserSearchPolicy
-> Maybe PagingState
-> Maybe Bool
-> SearchResult a
SearchResult
        (Int
 -> Int
 -> Int
 -> [a]
 -> FederatedUserSearchPolicy
 -> Maybe PagingState
 -> Maybe Bool
 -> SearchResult a)
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) Int
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (SearchResult a)
     (Int
      -> Int
      -> [a]
      -> FederatedUserSearchPolicy
      -> Maybe PagingState
      -> Maybe Bool
      -> SearchResult a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SearchResult a -> Int
forall a. SearchResult a -> Int
searchFound (SearchResult a -> Int)
-> SchemaP SwaggerDoc Object [Pair] Int Int
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) Int
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> SchemaP NamedSwaggerDoc Value Value Int Int
-> SchemaP SwaggerDoc Object [Pair] Int Int
forall doc' doc a b.
HasField doc' doc =>
Text
-> (doc' -> doc')
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a b
fieldWithDocModifier Text
"found" ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
S.description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"Total number of hits") SchemaP NamedSwaggerDoc Value Value Int Int
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  (SearchResult a)
  (Int
   -> Int
   -> [a]
   -> FederatedUserSearchPolicy
   -> Maybe PagingState
   -> Maybe Bool
   -> SearchResult a)
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) Int
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (SearchResult a)
     (Int
      -> [a]
      -> FederatedUserSearchPolicy
      -> Maybe PagingState
      -> Maybe Bool
      -> SearchResult a)
forall a b.
SchemaP SwaggerDoc Object [Pair] (SearchResult a) (a -> b)
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) a
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> SearchResult a -> Int
forall a. SearchResult a -> Int
searchReturned (SearchResult a -> Int)
-> SchemaP SwaggerDoc Object [Pair] Int Int
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) Int
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> SchemaP NamedSwaggerDoc Value Value Int Int
-> SchemaP SwaggerDoc Object [Pair] Int Int
forall doc' doc a b.
HasField doc' doc =>
Text
-> (doc' -> doc')
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a b
fieldWithDocModifier Text
"returned" ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
S.description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"Total number of hits returned") SchemaP NamedSwaggerDoc Value Value Int Int
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  (SearchResult a)
  (Int
   -> [a]
   -> FederatedUserSearchPolicy
   -> Maybe PagingState
   -> Maybe Bool
   -> SearchResult a)
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) Int
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (SearchResult a)
     ([a]
      -> FederatedUserSearchPolicy
      -> Maybe PagingState
      -> Maybe Bool
      -> SearchResult a)
forall a b.
SchemaP SwaggerDoc Object [Pair] (SearchResult a) (a -> b)
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) a
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> SearchResult a -> Int
forall a. SearchResult a -> Int
searchTook (SearchResult a -> Int)
-> SchemaP SwaggerDoc Object [Pair] Int Int
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) Int
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> SchemaP NamedSwaggerDoc Value Value Int Int
-> SchemaP SwaggerDoc Object [Pair] Int Int
forall doc' doc a b.
HasField doc' doc =>
Text
-> (doc' -> doc')
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a b
fieldWithDocModifier Text
"took" ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
S.description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"Search time in ms") SchemaP NamedSwaggerDoc Value Value Int Int
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  (SearchResult a)
  ([a]
   -> FederatedUserSearchPolicy
   -> Maybe PagingState
   -> Maybe Bool
   -> SearchResult a)
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) [a]
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (SearchResult a)
     (FederatedUserSearchPolicy
      -> Maybe PagingState -> Maybe Bool -> SearchResult a)
forall a b.
SchemaP SwaggerDoc Object [Pair] (SearchResult a) (a -> b)
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) a
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> SearchResult a -> [a]
forall a. SearchResult a -> [a]
searchResults (SearchResult a -> [a])
-> SchemaP SwaggerDoc Object [Pair] [a] [a]
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) [a]
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> (SwaggerDoc -> SwaggerDoc)
-> SchemaP SwaggerDoc Value Value [a] [a]
-> SchemaP SwaggerDoc Object [Pair] [a] [a]
forall doc' doc a b.
HasField doc' doc =>
Text
-> (doc' -> doc')
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a b
fieldWithDocModifier Text
"documents" ((Maybe Text -> Identity (Maybe Text))
-> SwaggerDoc -> Identity SwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' SwaggerDoc (Maybe Text)
S.description ((Maybe Text -> Identity (Maybe Text))
 -> SwaggerDoc -> Identity SwaggerDoc)
-> Text -> SwaggerDoc -> SwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"List of contacts found") (ValueSchema NamedSwaggerDoc a
-> SchemaP SwaggerDoc Value Value [a] [a]
forall ndoc doc a.
(HasArray ndoc doc, HasName ndoc) =>
ValueSchema ndoc a -> ValueSchema doc [a]
array ValueSchema NamedSwaggerDoc a
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  (SearchResult a)
  (FederatedUserSearchPolicy
   -> Maybe PagingState -> Maybe Bool -> SearchResult a)
-> SchemaP
     SwaggerDoc Object [Pair] (SearchResult a) FederatedUserSearchPolicy
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (SearchResult a)
     (Maybe PagingState -> Maybe Bool -> SearchResult a)
forall a b.
SchemaP SwaggerDoc Object [Pair] (SearchResult a) (a -> b)
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) a
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> SearchResult a -> FederatedUserSearchPolicy
forall a. SearchResult a -> FederatedUserSearchPolicy
searchPolicy (SearchResult a -> FederatedUserSearchPolicy)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     FederatedUserSearchPolicy
     FederatedUserSearchPolicy
-> SchemaP
     SwaggerDoc Object [Pair] (SearchResult a) FederatedUserSearchPolicy
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     FederatedUserSearchPolicy
     FederatedUserSearchPolicy
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     FederatedUserSearchPolicy
     FederatedUserSearchPolicy
forall doc' doc a b.
HasField doc' doc =>
Text
-> (doc' -> doc')
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a b
fieldWithDocModifier Text
"search_policy" ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
S.description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"Search policy that was applied when searching for users") SchemaP
  NamedSwaggerDoc
  Value
  Value
  FederatedUserSearchPolicy
  FederatedUserSearchPolicy
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  (SearchResult a)
  (Maybe PagingState -> Maybe Bool -> SearchResult a)
-> SchemaP
     SwaggerDoc Object [Pair] (SearchResult a) (Maybe PagingState)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (SearchResult a)
     (Maybe Bool -> SearchResult a)
forall a b.
SchemaP SwaggerDoc Object [Pair] (SearchResult a) (a -> b)
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) a
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> SearchResult a -> Maybe PagingState
forall a. SearchResult a -> Maybe PagingState
searchPagingState (SearchResult a -> Maybe PagingState)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe PagingState) (Maybe PagingState)
-> SchemaP
     SwaggerDoc Object [Pair] (SearchResult a) (Maybe PagingState)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] PagingState (Maybe PagingState)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe PagingState) (Maybe PagingState)
forall w d v a b.
Monoid w =>
SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybe_ (Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> ValueSchema NamedSwaggerDoc PagingState
-> SchemaP SwaggerDoc Object [Pair] PagingState (Maybe PagingState)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> (doc' -> doc')
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optFieldWithDocModifier Text
"paging_state" ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
S.description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"Paging state that should be supplied to retrieve the next page of results") ValueSchema NamedSwaggerDoc PagingState
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  (SearchResult a)
  (Maybe Bool -> SearchResult a)
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) (Maybe Bool)
-> SchemaP
     SwaggerDoc Object [Pair] (SearchResult a) (SearchResult a)
forall a b.
SchemaP SwaggerDoc Object [Pair] (SearchResult a) (a -> b)
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) a
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> SearchResult a -> Maybe Bool
forall a. SearchResult a -> Maybe Bool
searchHasMore (SearchResult a -> Maybe Bool)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Bool) (Maybe Bool)
-> SchemaP SwaggerDoc Object [Pair] (SearchResult a) (Maybe Bool)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= SchemaP SwaggerDoc Object [Pair] Bool (Maybe Bool)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Bool) (Maybe Bool)
forall w d v a b.
Monoid w =>
SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybe_ (Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> SchemaP NamedSwaggerDoc Value Value Bool Bool
-> SchemaP SwaggerDoc Object [Pair] Bool (Maybe Bool)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> (doc' -> doc')
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optFieldWithDocModifier Text
"has_more" ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
S.description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"Indicates whether there are more results to be fetched") SchemaP NamedSwaggerDoc Value Value Bool Bool
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)

deriving via (Schema (SearchResult Contact)) instance ToJSON (SearchResult Contact)

deriving via (Schema (SearchResult TeamContact)) instance ToJSON (SearchResult TeamContact)

deriving via (Schema (SearchResult Contact)) instance FromJSON (SearchResult Contact)

deriving via (Schema (SearchResult TeamContact)) instance FromJSON (SearchResult TeamContact)

deriving via (Schema (SearchResult Contact)) instance S.ToSchema (SearchResult Contact)

deriving via (Schema (SearchResult TeamContact)) instance S.ToSchema (SearchResult TeamContact)

--------------------------------------------------------------------------------
-- Contact

-- | Returned by 'searchIndex' under @/contacts/search@.
-- This is a subset of 'User' and json instances should reflect that.
data Contact = Contact
  { Contact -> Qualified UserId
contactQualifiedId :: Qualified UserId,
    Contact -> Text
contactName :: Text,
    Contact -> Maybe Int
contactColorId :: Maybe Int,
    Contact -> Maybe Text
contactHandle :: Maybe Text,
    Contact -> Maybe TeamId
contactTeam :: Maybe TeamId
  }
  deriving stock (Contact -> Contact -> Bool
(Contact -> Contact -> Bool)
-> (Contact -> Contact -> Bool) -> Eq Contact
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Contact -> Contact -> Bool
== :: Contact -> Contact -> Bool
$c/= :: Contact -> Contact -> Bool
/= :: Contact -> Contact -> Bool
Eq, Int -> Contact -> ShowS
[Contact] -> ShowS
Contact -> String
(Int -> Contact -> ShowS)
-> (Contact -> String) -> ([Contact] -> ShowS) -> Show Contact
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Contact -> ShowS
showsPrec :: Int -> Contact -> ShowS
$cshow :: Contact -> String
show :: Contact -> String
$cshowList :: [Contact] -> ShowS
showList :: [Contact] -> ShowS
Show, (forall x. Contact -> Rep Contact x)
-> (forall x. Rep Contact x -> Contact) -> Generic Contact
forall x. Rep Contact x -> Contact
forall x. Contact -> Rep Contact x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Contact -> Rep Contact x
from :: forall x. Contact -> Rep Contact x
$cto :: forall x. Rep Contact x -> Contact
to :: forall x. Rep Contact x -> Contact
Generic)
  deriving (Gen Contact
Gen Contact -> (Contact -> [Contact]) -> Arbitrary Contact
Contact -> [Contact]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen Contact
arbitrary :: Gen Contact
$cshrink :: Contact -> [Contact]
shrink :: Contact -> [Contact]
Arbitrary) via (GenericUniform Contact)
  deriving ([Contact] -> Value
[Contact] -> Encoding
Contact -> Value
Contact -> Encoding
(Contact -> Value)
-> (Contact -> Encoding)
-> ([Contact] -> Value)
-> ([Contact] -> Encoding)
-> ToJSON Contact
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: Contact -> Value
toJSON :: Contact -> Value
$ctoEncoding :: Contact -> Encoding
toEncoding :: Contact -> Encoding
$ctoJSONList :: [Contact] -> Value
toJSONList :: [Contact] -> Value
$ctoEncodingList :: [Contact] -> Encoding
toEncodingList :: [Contact] -> Encoding
ToJSON, Value -> Parser [Contact]
Value -> Parser Contact
(Value -> Parser Contact)
-> (Value -> Parser [Contact]) -> FromJSON Contact
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser Contact
parseJSON :: Value -> Parser Contact
$cparseJSONList :: Value -> Parser [Contact]
parseJSONList :: Value -> Parser [Contact]
FromJSON, Typeable Contact
Typeable Contact =>
(Proxy Contact -> Declare (Definitions Schema) NamedSchema)
-> ToSchema Contact
Proxy Contact -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy Contact -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy Contact -> Declare (Definitions Schema) NamedSchema
S.ToSchema) via Schema Contact

instance ToSchema Contact where
  schema :: ValueSchema NamedSwaggerDoc Contact
schema =
    Text
-> (NamedSwaggerDoc -> NamedSwaggerDoc)
-> ObjectSchema SwaggerDoc Contact
-> ValueSchema NamedSwaggerDoc Contact
forall doc doc' a.
HasObject doc doc' =>
Text -> (doc' -> doc') -> ObjectSchema doc a -> ValueSchema doc' a
objectWithDocModifier Text
"Contact" ((Maybe Text -> Identity (Maybe Text))
-> NamedSwaggerDoc -> Identity NamedSwaggerDoc
forall s a. HasDescription s a => Lens' s a
Lens' NamedSwaggerDoc (Maybe Text)
description ((Maybe Text -> Identity (Maybe Text))
 -> NamedSwaggerDoc -> Identity NamedSwaggerDoc)
-> Text -> NamedSwaggerDoc -> NamedSwaggerDoc
forall s t a b. ASetter s t a (Maybe b) -> b -> s -> t
?~ Text
"Contact discovered through search") (ObjectSchema SwaggerDoc Contact
 -> ValueSchema NamedSwaggerDoc Contact)
-> ObjectSchema SwaggerDoc Contact
-> ValueSchema NamedSwaggerDoc Contact
forall a b. (a -> b) -> a -> b
$
      Qualified UserId
-> Text -> Maybe Int -> Maybe Text -> Maybe TeamId -> Contact
Contact
        (Qualified UserId
 -> Text -> Maybe Int -> Maybe Text -> Maybe TeamId -> Contact)
-> SchemaP SwaggerDoc Object [Pair] Contact (Qualified UserId)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     Contact
     (Text -> Maybe Int -> Maybe Text -> Maybe TeamId -> Contact)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Contact -> Qualified UserId
contactQualifiedId (Contact -> Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] (Qualified UserId) (Qualified UserId)
-> SchemaP SwaggerDoc Object [Pair] Contact (Qualified UserId)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP
     NamedSwaggerDoc Value Value (Qualified UserId) (Qualified UserId)
-> SchemaP
     SwaggerDoc Object [Pair] (Qualified UserId) (Qualified UserId)
forall doc' doc a b.
HasField doc' doc =>
Text
-> SchemaP doc' Value Value a b -> SchemaP doc Object [Pair] a b
field Text
"qualified_id" SchemaP
  NamedSwaggerDoc Value Value (Qualified UserId) (Qualified UserId)
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  Contact
  (Text -> Maybe Int -> Maybe Text -> Maybe TeamId -> Contact)
-> SchemaP SwaggerDoc Object [Pair] Contact (Maybe UserId)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     Contact
     (Text -> Maybe Int -> Maybe Text -> Maybe TeamId -> Contact)
forall a b.
SchemaP SwaggerDoc Object [Pair] Contact a
-> SchemaP SwaggerDoc Object [Pair] Contact b
-> SchemaP SwaggerDoc Object [Pair] Contact a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* (Qualified UserId -> UserId
forall a. Qualified a -> a
qUnqualified (Qualified UserId -> UserId)
-> (Contact -> Qualified UserId) -> Contact -> UserId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Contact -> Qualified UserId
contactQualifiedId) (Contact -> UserId)
-> SchemaP SwaggerDoc Object [Pair] UserId (Maybe UserId)
-> SchemaP SwaggerDoc Object [Pair] Contact (Maybe 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 (Maybe UserId)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optField Text
"id" SchemaP NamedSwaggerDoc Value Value UserId UserId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  Contact
  (Text -> Maybe Int -> Maybe Text -> Maybe TeamId -> Contact)
-> SchemaP SwaggerDoc Object [Pair] Contact Text
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     Contact
     (Maybe Int -> Maybe Text -> Maybe TeamId -> Contact)
forall a b.
SchemaP SwaggerDoc Object [Pair] Contact (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Contact a
-> SchemaP SwaggerDoc Object [Pair] Contact b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Contact -> Text
contactName (Contact -> Text)
-> SchemaP SwaggerDoc Object [Pair] Text Text
-> SchemaP SwaggerDoc Object [Pair] Contact 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
"name" SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  Contact
  (Maybe Int -> Maybe Text -> Maybe TeamId -> Contact)
-> SchemaP SwaggerDoc Object [Pair] Contact (Maybe Int)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     Contact
     (Maybe Text -> Maybe TeamId -> Contact)
forall a b.
SchemaP SwaggerDoc Object [Pair] Contact (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Contact a
-> SchemaP SwaggerDoc Object [Pair] Contact b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Contact -> Maybe Int
contactColorId (Contact -> Maybe Int)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Int) (Maybe Int)
-> SchemaP SwaggerDoc Object [Pair] Contact (Maybe Int)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe Int) Int
-> SchemaP SwaggerDoc Object [Pair] (Maybe Int) (Maybe Int)
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
"accent_id" (Value
-> SchemaP NamedSwaggerDoc Value Value Int Int
-> SchemaP NamedSwaggerDoc Value Value (Maybe Int) Int
forall w d v a b.
w -> SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybeWithDefault Value
Aeson.Null SchemaP NamedSwaggerDoc Value Value Int Int
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  Contact
  (Maybe Text -> Maybe TeamId -> Contact)
-> SchemaP SwaggerDoc Object [Pair] Contact (Maybe Text)
-> SchemaP
     SwaggerDoc Object [Pair] Contact (Maybe TeamId -> Contact)
forall a b.
SchemaP SwaggerDoc Object [Pair] Contact (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Contact a
-> SchemaP SwaggerDoc Object [Pair] Contact b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Contact -> Maybe Text
contactHandle (Contact -> Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] Contact (Maybe Text)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe Text) Text
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optField Text
"handle" (Value
-> SchemaP NamedSwaggerDoc Value Value Text Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe Text) Text
forall w d v a b.
w -> SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybeWithDefault Value
Aeson.Null SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP SwaggerDoc Object [Pair] Contact (Maybe TeamId -> Contact)
-> SchemaP SwaggerDoc Object [Pair] Contact (Maybe TeamId)
-> ObjectSchema SwaggerDoc Contact
forall a b.
SchemaP SwaggerDoc Object [Pair] Contact (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Contact a
-> SchemaP SwaggerDoc Object [Pair] Contact b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Contact -> Maybe TeamId
contactTeam (Contact -> Maybe TeamId)
-> SchemaP SwaggerDoc Object [Pair] (Maybe TeamId) (Maybe TeamId)
-> SchemaP SwaggerDoc Object [Pair] Contact (Maybe TeamId)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe TeamId) TeamId
-> SchemaP SwaggerDoc Object [Pair] (Maybe TeamId) (Maybe TeamId)
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
"team" (Value
-> SchemaP NamedSwaggerDoc Value Value TeamId TeamId
-> SchemaP NamedSwaggerDoc Value Value (Maybe TeamId) TeamId
forall w d v a b.
w -> SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybeWithDefault Value
Aeson.Null SchemaP NamedSwaggerDoc Value Value TeamId TeamId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)

--------------------------------------------------------------------------------
-- TeamContact

-- | Related to `UserSSOId`, but more straight-forward because it does not take SCIM externalId into account.
data Sso = Sso
  { Sso -> Text
ssoIssuer :: Text,
    Sso -> Text
ssoNameId :: Text
  }
  deriving stock (Sso -> Sso -> Bool
(Sso -> Sso -> Bool) -> (Sso -> Sso -> Bool) -> Eq Sso
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Sso -> Sso -> Bool
== :: Sso -> Sso -> Bool
$c/= :: Sso -> Sso -> Bool
/= :: Sso -> Sso -> Bool
Eq, Int -> Sso -> ShowS
[Sso] -> ShowS
Sso -> String
(Int -> Sso -> ShowS)
-> (Sso -> String) -> ([Sso] -> ShowS) -> Show Sso
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Sso -> ShowS
showsPrec :: Int -> Sso -> ShowS
$cshow :: Sso -> String
show :: Sso -> String
$cshowList :: [Sso] -> ShowS
showList :: [Sso] -> ShowS
Show, (forall x. Sso -> Rep Sso x)
-> (forall x. Rep Sso x -> Sso) -> Generic Sso
forall x. Rep Sso x -> Sso
forall x. Sso -> Rep Sso x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Sso -> Rep Sso x
from :: forall x. Sso -> Rep Sso x
$cto :: forall x. Rep Sso x -> Sso
to :: forall x. Rep Sso x -> Sso
Generic)
  deriving (Gen Sso
Gen Sso -> (Sso -> [Sso]) -> Arbitrary Sso
Sso -> [Sso]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen Sso
arbitrary :: Gen Sso
$cshrink :: Sso -> [Sso]
shrink :: Sso -> [Sso]
Arbitrary) via (GenericUniform Sso)
  deriving ([Sso] -> Value
[Sso] -> Encoding
Sso -> Value
Sso -> Encoding
(Sso -> Value)
-> (Sso -> Encoding)
-> ([Sso] -> Value)
-> ([Sso] -> Encoding)
-> ToJSON Sso
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: Sso -> Value
toJSON :: Sso -> Value
$ctoEncoding :: Sso -> Encoding
toEncoding :: Sso -> Encoding
$ctoJSONList :: [Sso] -> Value
toJSONList :: [Sso] -> Value
$ctoEncodingList :: [Sso] -> Encoding
toEncodingList :: [Sso] -> Encoding
ToJSON, Value -> Parser [Sso]
Value -> Parser Sso
(Value -> Parser Sso) -> (Value -> Parser [Sso]) -> FromJSON Sso
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser Sso
parseJSON :: Value -> Parser Sso
$cparseJSONList :: Value -> Parser [Sso]
parseJSONList :: Value -> Parser [Sso]
FromJSON, Typeable Sso
Typeable Sso =>
(Proxy Sso -> Declare (Definitions Schema) NamedSchema)
-> ToSchema Sso
Proxy Sso -> Declare (Definitions Schema) NamedSchema
forall a.
Typeable a =>
(Proxy a -> Declare (Definitions Schema) NamedSchema) -> ToSchema a
$cdeclareNamedSchema :: Proxy Sso -> Declare (Definitions Schema) NamedSchema
declareNamedSchema :: Proxy Sso -> Declare (Definitions Schema) NamedSchema
S.ToSchema) via (Schema Sso)

instance ToSchema Sso where
  schema :: ValueSchema NamedSwaggerDoc Sso
schema =
    Text
-> SchemaP SwaggerDoc Object [Pair] Sso Sso
-> ValueSchema NamedSwaggerDoc Sso
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"Sso" (SchemaP SwaggerDoc Object [Pair] Sso Sso
 -> ValueSchema NamedSwaggerDoc Sso)
-> SchemaP SwaggerDoc Object [Pair] Sso Sso
-> ValueSchema NamedSwaggerDoc Sso
forall a b. (a -> b) -> a -> b
$
      Text -> Text -> Sso
Sso
        (Text -> Text -> Sso)
-> SchemaP SwaggerDoc Object [Pair] Sso Text
-> SchemaP SwaggerDoc Object [Pair] Sso (Text -> Sso)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Sso -> Text
ssoIssuer (Sso -> Text)
-> SchemaP SwaggerDoc Object [Pair] Text Text
-> SchemaP SwaggerDoc Object [Pair] Sso 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
"issuer" SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP SwaggerDoc Object [Pair] Sso (Text -> Sso)
-> SchemaP SwaggerDoc Object [Pair] Sso Text
-> SchemaP SwaggerDoc Object [Pair] Sso Sso
forall a b.
SchemaP SwaggerDoc Object [Pair] Sso (a -> b)
-> SchemaP SwaggerDoc Object [Pair] Sso a
-> SchemaP SwaggerDoc Object [Pair] Sso b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Sso -> Text
ssoNameId (Sso -> Text)
-> SchemaP SwaggerDoc Object [Pair] Text Text
-> SchemaP SwaggerDoc Object [Pair] Sso 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
"nameid" SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema

-- | Returned by 'browseTeam' under @/teams/:tid/search@.
data TeamContact = TeamContact
  { TeamContact -> UserId
teamContactUserId :: UserId,
    TeamContact -> Text
teamContactName :: Text,
    TeamContact -> Maybe Int
teamContactColorId :: Maybe Int,
    TeamContact -> Maybe Text
teamContactHandle :: Maybe Text,
    TeamContact -> Maybe TeamId
teamContactTeam :: Maybe TeamId,
    TeamContact -> Maybe EmailAddress
teamContactEmail :: Maybe EmailAddress,
    TeamContact -> Maybe UTCTimeMillis
teamContactCreatedAt :: Maybe UTCTimeMillis,
    TeamContact -> Maybe ManagedBy
teamContactManagedBy :: Maybe ManagedBy,
    TeamContact -> Maybe Text
teamContactSAMLIdp :: Maybe Text,
    TeamContact -> Maybe Role
teamContactRole :: Maybe Role,
    TeamContact -> Maybe Text
teamContactScimExternalId :: Maybe Text,
    TeamContact -> Maybe Sso
teamContactSso :: Maybe Sso,
    TeamContact -> Maybe EmailAddress
teamContactEmailUnvalidated :: Maybe EmailAddress
  }
  deriving stock (TeamContact -> TeamContact -> Bool
(TeamContact -> TeamContact -> Bool)
-> (TeamContact -> TeamContact -> Bool) -> Eq TeamContact
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TeamContact -> TeamContact -> Bool
== :: TeamContact -> TeamContact -> Bool
$c/= :: TeamContact -> TeamContact -> Bool
/= :: TeamContact -> TeamContact -> Bool
Eq, Int -> TeamContact -> ShowS
[TeamContact] -> ShowS
TeamContact -> String
(Int -> TeamContact -> ShowS)
-> (TeamContact -> String)
-> ([TeamContact] -> ShowS)
-> Show TeamContact
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TeamContact -> ShowS
showsPrec :: Int -> TeamContact -> ShowS
$cshow :: TeamContact -> String
show :: TeamContact -> String
$cshowList :: [TeamContact] -> ShowS
showList :: [TeamContact] -> ShowS
Show, (forall x. TeamContact -> Rep TeamContact x)
-> (forall x. Rep TeamContact x -> TeamContact)
-> Generic TeamContact
forall x. Rep TeamContact x -> TeamContact
forall x. TeamContact -> Rep TeamContact x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TeamContact -> Rep TeamContact x
from :: forall x. TeamContact -> Rep TeamContact x
$cto :: forall x. Rep TeamContact x -> TeamContact
to :: forall x. Rep TeamContact x -> TeamContact
Generic)
  deriving (Gen TeamContact
Gen TeamContact
-> (TeamContact -> [TeamContact]) -> Arbitrary TeamContact
TeamContact -> [TeamContact]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen TeamContact
arbitrary :: Gen TeamContact
$cshrink :: TeamContact -> [TeamContact]
shrink :: TeamContact -> [TeamContact]
Arbitrary) via (GenericUniform TeamContact)
  deriving ([TeamContact] -> Value
[TeamContact] -> Encoding
TeamContact -> Value
TeamContact -> Encoding
(TeamContact -> Value)
-> (TeamContact -> Encoding)
-> ([TeamContact] -> Value)
-> ([TeamContact] -> Encoding)
-> ToJSON TeamContact
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
$ctoJSON :: TeamContact -> Value
toJSON :: TeamContact -> Value
$ctoEncoding :: TeamContact -> Encoding
toEncoding :: TeamContact -> Encoding
$ctoJSONList :: [TeamContact] -> Value
toJSONList :: [TeamContact] -> Value
$ctoEncodingList :: [TeamContact] -> Encoding
toEncodingList :: [TeamContact] -> Encoding
ToJSON, Value -> Parser [TeamContact]
Value -> Parser TeamContact
(Value -> Parser TeamContact)
-> (Value -> Parser [TeamContact]) -> FromJSON TeamContact
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
$cparseJSON :: Value -> Parser TeamContact
parseJSON :: Value -> Parser TeamContact
$cparseJSONList :: Value -> Parser [TeamContact]
parseJSONList :: Value -> Parser [TeamContact]
FromJSON) via (Schema TeamContact)

instance ToSchema TeamContact where
  schema :: ValueSchema NamedSwaggerDoc TeamContact
schema =
    Text
-> SchemaP SwaggerDoc Object [Pair] TeamContact TeamContact
-> ValueSchema NamedSwaggerDoc TeamContact
forall doc doc' a b.
HasObject doc doc' =>
Text
-> SchemaP doc Object [Pair] a b -> SchemaP doc' Value Value a b
object Text
"TeamContact" (SchemaP SwaggerDoc Object [Pair] TeamContact TeamContact
 -> ValueSchema NamedSwaggerDoc TeamContact)
-> SchemaP SwaggerDoc Object [Pair] TeamContact TeamContact
-> ValueSchema NamedSwaggerDoc TeamContact
forall a b. (a -> b) -> a -> b
$
      UserId
-> Text
-> Maybe Int
-> Maybe Text
-> Maybe TeamId
-> Maybe EmailAddress
-> Maybe UTCTimeMillis
-> Maybe ManagedBy
-> Maybe Text
-> Maybe Role
-> Maybe Text
-> Maybe Sso
-> Maybe EmailAddress
-> TeamContact
TeamContact
        (UserId
 -> Text
 -> Maybe Int
 -> Maybe Text
 -> Maybe TeamId
 -> Maybe EmailAddress
 -> Maybe UTCTimeMillis
 -> Maybe ManagedBy
 -> Maybe Text
 -> Maybe Role
 -> Maybe Text
 -> Maybe Sso
 -> Maybe EmailAddress
 -> TeamContact)
-> SchemaP SwaggerDoc Object [Pair] TeamContact UserId
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     TeamContact
     (Text
      -> Maybe Int
      -> Maybe Text
      -> Maybe TeamId
      -> Maybe EmailAddress
      -> Maybe UTCTimeMillis
      -> Maybe ManagedBy
      -> Maybe Text
      -> Maybe Role
      -> Maybe Text
      -> Maybe Sso
      -> Maybe EmailAddress
      -> TeamContact)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TeamContact -> UserId
teamContactUserId (TeamContact -> UserId)
-> SchemaP SwaggerDoc Object [Pair] UserId UserId
-> SchemaP SwaggerDoc Object [Pair] TeamContact 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
"id" SchemaP NamedSwaggerDoc Value Value UserId UserId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  TeamContact
  (Text
   -> Maybe Int
   -> Maybe Text
   -> Maybe TeamId
   -> Maybe EmailAddress
   -> Maybe UTCTimeMillis
   -> Maybe ManagedBy
   -> Maybe Text
   -> Maybe Role
   -> Maybe Text
   -> Maybe Sso
   -> Maybe EmailAddress
   -> TeamContact)
-> SchemaP SwaggerDoc Object [Pair] TeamContact Text
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     TeamContact
     (Maybe Int
      -> Maybe Text
      -> Maybe TeamId
      -> Maybe EmailAddress
      -> Maybe UTCTimeMillis
      -> Maybe ManagedBy
      -> Maybe Text
      -> Maybe Role
      -> Maybe Text
      -> Maybe Sso
      -> Maybe EmailAddress
      -> TeamContact)
forall a b.
SchemaP SwaggerDoc Object [Pair] TeamContact (a -> b)
-> SchemaP SwaggerDoc Object [Pair] TeamContact a
-> SchemaP SwaggerDoc Object [Pair] TeamContact b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TeamContact -> Text
teamContactName (TeamContact -> Text)
-> SchemaP SwaggerDoc Object [Pair] Text Text
-> SchemaP SwaggerDoc Object [Pair] TeamContact 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
"name" SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  TeamContact
  (Maybe Int
   -> Maybe Text
   -> Maybe TeamId
   -> Maybe EmailAddress
   -> Maybe UTCTimeMillis
   -> Maybe ManagedBy
   -> Maybe Text
   -> Maybe Role
   -> Maybe Text
   -> Maybe Sso
   -> Maybe EmailAddress
   -> TeamContact)
-> SchemaP SwaggerDoc Object [Pair] TeamContact (Maybe Int)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     TeamContact
     (Maybe Text
      -> Maybe TeamId
      -> Maybe EmailAddress
      -> Maybe UTCTimeMillis
      -> Maybe ManagedBy
      -> Maybe Text
      -> Maybe Role
      -> Maybe Text
      -> Maybe Sso
      -> Maybe EmailAddress
      -> TeamContact)
forall a b.
SchemaP SwaggerDoc Object [Pair] TeamContact (a -> b)
-> SchemaP SwaggerDoc Object [Pair] TeamContact a
-> SchemaP SwaggerDoc Object [Pair] TeamContact b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TeamContact -> Maybe Int
teamContactColorId (TeamContact -> Maybe Int)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Int) (Maybe Int)
-> SchemaP SwaggerDoc Object [Pair] TeamContact (Maybe Int)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe Int) Int
-> SchemaP SwaggerDoc Object [Pair] (Maybe Int) (Maybe Int)
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
"accent_id" (Value
-> SchemaP NamedSwaggerDoc Value Value Int Int
-> SchemaP NamedSwaggerDoc Value Value (Maybe Int) Int
forall w d v a b.
w -> SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybeWithDefault Value
Aeson.Null SchemaP NamedSwaggerDoc Value Value Int Int
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  TeamContact
  (Maybe Text
   -> Maybe TeamId
   -> Maybe EmailAddress
   -> Maybe UTCTimeMillis
   -> Maybe ManagedBy
   -> Maybe Text
   -> Maybe Role
   -> Maybe Text
   -> Maybe Sso
   -> Maybe EmailAddress
   -> TeamContact)
-> SchemaP SwaggerDoc Object [Pair] TeamContact (Maybe Text)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     TeamContact
     (Maybe TeamId
      -> Maybe EmailAddress
      -> Maybe UTCTimeMillis
      -> Maybe ManagedBy
      -> Maybe Text
      -> Maybe Role
      -> Maybe Text
      -> Maybe Sso
      -> Maybe EmailAddress
      -> TeamContact)
forall a b.
SchemaP SwaggerDoc Object [Pair] TeamContact (a -> b)
-> SchemaP SwaggerDoc Object [Pair] TeamContact a
-> SchemaP SwaggerDoc Object [Pair] TeamContact b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TeamContact -> Maybe Text
teamContactHandle (TeamContact -> Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] TeamContact (Maybe Text)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe Text) Text
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optField Text
"handle" (Value
-> SchemaP NamedSwaggerDoc Value Value Text Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe Text) Text
forall w d v a b.
w -> SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybeWithDefault Value
Aeson.Null SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  TeamContact
  (Maybe TeamId
   -> Maybe EmailAddress
   -> Maybe UTCTimeMillis
   -> Maybe ManagedBy
   -> Maybe Text
   -> Maybe Role
   -> Maybe Text
   -> Maybe Sso
   -> Maybe EmailAddress
   -> TeamContact)
-> SchemaP SwaggerDoc Object [Pair] TeamContact (Maybe TeamId)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     TeamContact
     (Maybe EmailAddress
      -> Maybe UTCTimeMillis
      -> Maybe ManagedBy
      -> Maybe Text
      -> Maybe Role
      -> Maybe Text
      -> Maybe Sso
      -> Maybe EmailAddress
      -> TeamContact)
forall a b.
SchemaP SwaggerDoc Object [Pair] TeamContact (a -> b)
-> SchemaP SwaggerDoc Object [Pair] TeamContact a
-> SchemaP SwaggerDoc Object [Pair] TeamContact b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TeamContact -> Maybe TeamId
teamContactTeam (TeamContact -> Maybe TeamId)
-> SchemaP SwaggerDoc Object [Pair] (Maybe TeamId) (Maybe TeamId)
-> SchemaP SwaggerDoc Object [Pair] TeamContact (Maybe TeamId)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe TeamId) TeamId
-> SchemaP SwaggerDoc Object [Pair] (Maybe TeamId) (Maybe TeamId)
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
"team" (Value
-> SchemaP NamedSwaggerDoc Value Value TeamId TeamId
-> SchemaP NamedSwaggerDoc Value Value (Maybe TeamId) TeamId
forall w d v a b.
w -> SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybeWithDefault Value
Aeson.Null SchemaP NamedSwaggerDoc Value Value TeamId TeamId
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  TeamContact
  (Maybe EmailAddress
   -> Maybe UTCTimeMillis
   -> Maybe ManagedBy
   -> Maybe Text
   -> Maybe Role
   -> Maybe Text
   -> Maybe Sso
   -> Maybe EmailAddress
   -> TeamContact)
-> SchemaP
     SwaggerDoc Object [Pair] TeamContact (Maybe EmailAddress)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     TeamContact
     (Maybe UTCTimeMillis
      -> Maybe ManagedBy
      -> Maybe Text
      -> Maybe Role
      -> Maybe Text
      -> Maybe Sso
      -> Maybe EmailAddress
      -> TeamContact)
forall a b.
SchemaP SwaggerDoc Object [Pair] TeamContact (a -> b)
-> SchemaP SwaggerDoc Object [Pair] TeamContact a
-> SchemaP SwaggerDoc Object [Pair] TeamContact b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TeamContact -> Maybe EmailAddress
teamContactEmail (TeamContact -> Maybe EmailAddress)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe EmailAddress) (Maybe EmailAddress)
-> SchemaP
     SwaggerDoc Object [Pair] TeamContact (Maybe EmailAddress)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP
     NamedSwaggerDoc Value Value (Maybe EmailAddress) EmailAddress
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe EmailAddress) (Maybe EmailAddress)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optField Text
"email" (Value
-> SchemaP NamedSwaggerDoc Value Value EmailAddress EmailAddress
-> SchemaP
     NamedSwaggerDoc Value Value (Maybe EmailAddress) EmailAddress
forall w d v a b.
w -> SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybeWithDefault Value
Aeson.Null SchemaP NamedSwaggerDoc Value Value EmailAddress EmailAddress
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  TeamContact
  (Maybe UTCTimeMillis
   -> Maybe ManagedBy
   -> Maybe Text
   -> Maybe Role
   -> Maybe Text
   -> Maybe Sso
   -> Maybe EmailAddress
   -> TeamContact)
-> SchemaP
     SwaggerDoc Object [Pair] TeamContact (Maybe UTCTimeMillis)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     TeamContact
     (Maybe ManagedBy
      -> Maybe Text
      -> Maybe Role
      -> Maybe Text
      -> Maybe Sso
      -> Maybe EmailAddress
      -> TeamContact)
forall a b.
SchemaP SwaggerDoc Object [Pair] TeamContact (a -> b)
-> SchemaP SwaggerDoc Object [Pair] TeamContact a
-> SchemaP SwaggerDoc Object [Pair] TeamContact b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TeamContact -> Maybe UTCTimeMillis
teamContactCreatedAt (TeamContact -> Maybe UTCTimeMillis)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe UTCTimeMillis)
     (Maybe UTCTimeMillis)
-> SchemaP
     SwaggerDoc Object [Pair] TeamContact (Maybe UTCTimeMillis)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP
     NamedSwaggerDoc Value Value (Maybe UTCTimeMillis) UTCTimeMillis
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     (Maybe UTCTimeMillis)
     (Maybe UTCTimeMillis)
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
"created_at" (Value
-> SchemaP NamedSwaggerDoc Value Value UTCTimeMillis UTCTimeMillis
-> SchemaP
     NamedSwaggerDoc Value Value (Maybe UTCTimeMillis) UTCTimeMillis
forall w d v a b.
w -> SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybeWithDefault Value
Aeson.Null SchemaP NamedSwaggerDoc Value Value UTCTimeMillis UTCTimeMillis
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  TeamContact
  (Maybe ManagedBy
   -> Maybe Text
   -> Maybe Role
   -> Maybe Text
   -> Maybe Sso
   -> Maybe EmailAddress
   -> TeamContact)
-> SchemaP SwaggerDoc Object [Pair] TeamContact (Maybe ManagedBy)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     TeamContact
     (Maybe Text
      -> Maybe Role
      -> Maybe Text
      -> Maybe Sso
      -> Maybe EmailAddress
      -> TeamContact)
forall a b.
SchemaP SwaggerDoc Object [Pair] TeamContact (a -> b)
-> SchemaP SwaggerDoc Object [Pair] TeamContact a
-> SchemaP SwaggerDoc Object [Pair] TeamContact b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TeamContact -> Maybe ManagedBy
teamContactManagedBy (TeamContact -> Maybe ManagedBy)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe ManagedBy) (Maybe ManagedBy)
-> SchemaP SwaggerDoc Object [Pair] TeamContact (Maybe ManagedBy)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe ManagedBy) ManagedBy
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe ManagedBy) (Maybe ManagedBy)
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
"managed_by" (Value
-> SchemaP NamedSwaggerDoc Value Value ManagedBy ManagedBy
-> SchemaP NamedSwaggerDoc Value Value (Maybe ManagedBy) ManagedBy
forall w d v a b.
w -> SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybeWithDefault Value
Aeson.Null SchemaP NamedSwaggerDoc Value Value ManagedBy ManagedBy
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  TeamContact
  (Maybe Text
   -> Maybe Role
   -> Maybe Text
   -> Maybe Sso
   -> Maybe EmailAddress
   -> TeamContact)
-> SchemaP SwaggerDoc Object [Pair] TeamContact (Maybe Text)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     TeamContact
     (Maybe Role
      -> Maybe Text -> Maybe Sso -> Maybe EmailAddress -> TeamContact)
forall a b.
SchemaP SwaggerDoc Object [Pair] TeamContact (a -> b)
-> SchemaP SwaggerDoc Object [Pair] TeamContact a
-> SchemaP SwaggerDoc Object [Pair] TeamContact b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TeamContact -> Maybe Text
teamContactSAMLIdp (TeamContact -> Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] TeamContact (Maybe Text)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe Text) Text
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optField Text
"saml_idp" (Value
-> SchemaP NamedSwaggerDoc Value Value Text Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe Text) Text
forall w d v a b.
w -> SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybeWithDefault Value
Aeson.Null SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  TeamContact
  (Maybe Role
   -> Maybe Text -> Maybe Sso -> Maybe EmailAddress -> TeamContact)
-> SchemaP SwaggerDoc Object [Pair] TeamContact (Maybe Role)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     TeamContact
     (Maybe Text -> Maybe Sso -> Maybe EmailAddress -> TeamContact)
forall a b.
SchemaP SwaggerDoc Object [Pair] TeamContact (a -> b)
-> SchemaP SwaggerDoc Object [Pair] TeamContact a
-> SchemaP SwaggerDoc Object [Pair] TeamContact b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TeamContact -> Maybe Role
teamContactRole (TeamContact -> Maybe Role)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Role) (Maybe Role)
-> SchemaP SwaggerDoc Object [Pair] TeamContact (Maybe Role)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe Role) Role
-> SchemaP SwaggerDoc Object [Pair] (Maybe Role) (Maybe Role)
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
"role" (Value
-> SchemaP NamedSwaggerDoc Value Value Role Role
-> SchemaP NamedSwaggerDoc Value Value (Maybe Role) Role
forall w d v a b.
w -> SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybeWithDefault Value
Aeson.Null SchemaP NamedSwaggerDoc Value Value Role Role
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  TeamContact
  (Maybe Text -> Maybe Sso -> Maybe EmailAddress -> TeamContact)
-> SchemaP SwaggerDoc Object [Pair] TeamContact (Maybe Text)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     TeamContact
     (Maybe Sso -> Maybe EmailAddress -> TeamContact)
forall a b.
SchemaP SwaggerDoc Object [Pair] TeamContact (a -> b)
-> SchemaP SwaggerDoc Object [Pair] TeamContact a
-> SchemaP SwaggerDoc Object [Pair] TeamContact b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TeamContact -> Maybe Text
teamContactScimExternalId (TeamContact -> Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
-> SchemaP SwaggerDoc Object [Pair] TeamContact (Maybe Text)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe Text) Text
-> SchemaP SwaggerDoc Object [Pair] (Maybe Text) (Maybe Text)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optField Text
"scim_external_id" (Value
-> SchemaP NamedSwaggerDoc Value Value Text Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe Text) Text
forall w d v a b.
w -> SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybeWithDefault Value
Aeson.Null SchemaP NamedSwaggerDoc Value Value Text Text
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  TeamContact
  (Maybe Sso -> Maybe EmailAddress -> TeamContact)
-> SchemaP SwaggerDoc Object [Pair] TeamContact (Maybe Sso)
-> SchemaP
     SwaggerDoc
     Object
     [Pair]
     TeamContact
     (Maybe EmailAddress -> TeamContact)
forall a b.
SchemaP SwaggerDoc Object [Pair] TeamContact (a -> b)
-> SchemaP SwaggerDoc Object [Pair] TeamContact a
-> SchemaP SwaggerDoc Object [Pair] TeamContact b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TeamContact -> Maybe Sso
teamContactSso (TeamContact -> Maybe Sso)
-> SchemaP SwaggerDoc Object [Pair] (Maybe Sso) (Maybe Sso)
-> SchemaP SwaggerDoc Object [Pair] TeamContact (Maybe Sso)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP NamedSwaggerDoc Value Value (Maybe Sso) Sso
-> SchemaP SwaggerDoc Object [Pair] (Maybe Sso) (Maybe Sso)
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
"sso" (Value
-> ValueSchema NamedSwaggerDoc Sso
-> SchemaP NamedSwaggerDoc Value Value (Maybe Sso) Sso
forall w d v a b.
w -> SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybeWithDefault Value
Aeson.Null ValueSchema NamedSwaggerDoc Sso
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)
        SchemaP
  SwaggerDoc
  Object
  [Pair]
  TeamContact
  (Maybe EmailAddress -> TeamContact)
-> SchemaP
     SwaggerDoc Object [Pair] TeamContact (Maybe EmailAddress)
-> SchemaP SwaggerDoc Object [Pair] TeamContact TeamContact
forall a b.
SchemaP SwaggerDoc Object [Pair] TeamContact (a -> b)
-> SchemaP SwaggerDoc Object [Pair] TeamContact a
-> SchemaP SwaggerDoc Object [Pair] TeamContact b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TeamContact -> Maybe EmailAddress
teamContactEmailUnvalidated (TeamContact -> Maybe EmailAddress)
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe EmailAddress) (Maybe EmailAddress)
-> SchemaP
     SwaggerDoc Object [Pair] TeamContact (Maybe EmailAddress)
forall (p :: * -> * -> *) a a' b.
Profunctor p =>
(a -> a') -> p a' b -> p a b
.= Text
-> SchemaP
     NamedSwaggerDoc Value Value (Maybe EmailAddress) EmailAddress
-> SchemaP
     SwaggerDoc Object [Pair] (Maybe EmailAddress) (Maybe EmailAddress)
forall doc doc' a b.
(HasOpt doc, HasField doc' doc) =>
Text
-> SchemaP doc' Value Value a b
-> SchemaP doc Object [Pair] a (Maybe b)
optField Text
"email_unvalidated" (Value
-> SchemaP NamedSwaggerDoc Value Value EmailAddress EmailAddress
-> SchemaP
     NamedSwaggerDoc Value Value (Maybe EmailAddress) EmailAddress
forall w d v a b.
w -> SchemaP d v w a b -> SchemaP d v w (Maybe a) b
maybeWithDefault Value
Aeson.Null SchemaP NamedSwaggerDoc Value Value EmailAddress EmailAddress
forall a. ToSchema a => ValueSchema NamedSwaggerDoc a
schema)

data TeamUserSearchSortBy
  = SortByName
  | SortByHandle
  | SortByEmail
  | SortBySAMLIdp
  | SortByManagedBy
  | SortByRole
  | SortByCreatedAt
  deriving (Int -> TeamUserSearchSortBy -> ShowS
[TeamUserSearchSortBy] -> ShowS
TeamUserSearchSortBy -> String
(Int -> TeamUserSearchSortBy -> ShowS)
-> (TeamUserSearchSortBy -> String)
-> ([TeamUserSearchSortBy] -> ShowS)
-> Show TeamUserSearchSortBy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TeamUserSearchSortBy -> ShowS
showsPrec :: Int -> TeamUserSearchSortBy -> ShowS
$cshow :: TeamUserSearchSortBy -> String
show :: TeamUserSearchSortBy -> String
$cshowList :: [TeamUserSearchSortBy] -> ShowS
showList :: [TeamUserSearchSortBy] -> ShowS
Show, TeamUserSearchSortBy -> TeamUserSearchSortBy -> Bool
(TeamUserSearchSortBy -> TeamUserSearchSortBy -> Bool)
-> (TeamUserSearchSortBy -> TeamUserSearchSortBy -> Bool)
-> Eq TeamUserSearchSortBy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TeamUserSearchSortBy -> TeamUserSearchSortBy -> Bool
== :: TeamUserSearchSortBy -> TeamUserSearchSortBy -> Bool
$c/= :: TeamUserSearchSortBy -> TeamUserSearchSortBy -> Bool
/= :: TeamUserSearchSortBy -> TeamUserSearchSortBy -> Bool
Eq, Eq TeamUserSearchSortBy
Eq TeamUserSearchSortBy =>
(TeamUserSearchSortBy -> TeamUserSearchSortBy -> Ordering)
-> (TeamUserSearchSortBy -> TeamUserSearchSortBy -> Bool)
-> (TeamUserSearchSortBy -> TeamUserSearchSortBy -> Bool)
-> (TeamUserSearchSortBy -> TeamUserSearchSortBy -> Bool)
-> (TeamUserSearchSortBy -> TeamUserSearchSortBy -> Bool)
-> (TeamUserSearchSortBy
    -> TeamUserSearchSortBy -> TeamUserSearchSortBy)
-> (TeamUserSearchSortBy
    -> TeamUserSearchSortBy -> TeamUserSearchSortBy)
-> Ord TeamUserSearchSortBy
TeamUserSearchSortBy -> TeamUserSearchSortBy -> Bool
TeamUserSearchSortBy -> TeamUserSearchSortBy -> Ordering
TeamUserSearchSortBy
-> TeamUserSearchSortBy -> TeamUserSearchSortBy
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 :: TeamUserSearchSortBy -> TeamUserSearchSortBy -> Ordering
compare :: TeamUserSearchSortBy -> TeamUserSearchSortBy -> Ordering
$c< :: TeamUserSearchSortBy -> TeamUserSearchSortBy -> Bool
< :: TeamUserSearchSortBy -> TeamUserSearchSortBy -> Bool
$c<= :: TeamUserSearchSortBy -> TeamUserSearchSortBy -> Bool
<= :: TeamUserSearchSortBy -> TeamUserSearchSortBy -> Bool
$c> :: TeamUserSearchSortBy -> TeamUserSearchSortBy -> Bool
> :: TeamUserSearchSortBy -> TeamUserSearchSortBy -> Bool
$c>= :: TeamUserSearchSortBy -> TeamUserSearchSortBy -> Bool
>= :: TeamUserSearchSortBy -> TeamUserSearchSortBy -> Bool
$cmax :: TeamUserSearchSortBy
-> TeamUserSearchSortBy -> TeamUserSearchSortBy
max :: TeamUserSearchSortBy
-> TeamUserSearchSortBy -> TeamUserSearchSortBy
$cmin :: TeamUserSearchSortBy
-> TeamUserSearchSortBy -> TeamUserSearchSortBy
min :: TeamUserSearchSortBy
-> TeamUserSearchSortBy -> TeamUserSearchSortBy
Ord, (forall x. TeamUserSearchSortBy -> Rep TeamUserSearchSortBy x)
-> (forall x. Rep TeamUserSearchSortBy x -> TeamUserSearchSortBy)
-> Generic TeamUserSearchSortBy
forall x. Rep TeamUserSearchSortBy x -> TeamUserSearchSortBy
forall x. TeamUserSearchSortBy -> Rep TeamUserSearchSortBy x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TeamUserSearchSortBy -> Rep TeamUserSearchSortBy x
from :: forall x. TeamUserSearchSortBy -> Rep TeamUserSearchSortBy x
$cto :: forall x. Rep TeamUserSearchSortBy x -> TeamUserSearchSortBy
to :: forall x. Rep TeamUserSearchSortBy x -> TeamUserSearchSortBy
Generic, Int -> TeamUserSearchSortBy
TeamUserSearchSortBy -> Int
TeamUserSearchSortBy -> [TeamUserSearchSortBy]
TeamUserSearchSortBy -> TeamUserSearchSortBy
TeamUserSearchSortBy
-> TeamUserSearchSortBy -> [TeamUserSearchSortBy]
TeamUserSearchSortBy
-> TeamUserSearchSortBy
-> TeamUserSearchSortBy
-> [TeamUserSearchSortBy]
(TeamUserSearchSortBy -> TeamUserSearchSortBy)
-> (TeamUserSearchSortBy -> TeamUserSearchSortBy)
-> (Int -> TeamUserSearchSortBy)
-> (TeamUserSearchSortBy -> Int)
-> (TeamUserSearchSortBy -> [TeamUserSearchSortBy])
-> (TeamUserSearchSortBy
    -> TeamUserSearchSortBy -> [TeamUserSearchSortBy])
-> (TeamUserSearchSortBy
    -> TeamUserSearchSortBy -> [TeamUserSearchSortBy])
-> (TeamUserSearchSortBy
    -> TeamUserSearchSortBy
    -> TeamUserSearchSortBy
    -> [TeamUserSearchSortBy])
-> Enum TeamUserSearchSortBy
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: TeamUserSearchSortBy -> TeamUserSearchSortBy
succ :: TeamUserSearchSortBy -> TeamUserSearchSortBy
$cpred :: TeamUserSearchSortBy -> TeamUserSearchSortBy
pred :: TeamUserSearchSortBy -> TeamUserSearchSortBy
$ctoEnum :: Int -> TeamUserSearchSortBy
toEnum :: Int -> TeamUserSearchSortBy
$cfromEnum :: TeamUserSearchSortBy -> Int
fromEnum :: TeamUserSearchSortBy -> Int
$cenumFrom :: TeamUserSearchSortBy -> [TeamUserSearchSortBy]
enumFrom :: TeamUserSearchSortBy -> [TeamUserSearchSortBy]
$cenumFromThen :: TeamUserSearchSortBy
-> TeamUserSearchSortBy -> [TeamUserSearchSortBy]
enumFromThen :: TeamUserSearchSortBy
-> TeamUserSearchSortBy -> [TeamUserSearchSortBy]
$cenumFromTo :: TeamUserSearchSortBy
-> TeamUserSearchSortBy -> [TeamUserSearchSortBy]
enumFromTo :: TeamUserSearchSortBy
-> TeamUserSearchSortBy -> [TeamUserSearchSortBy]
$cenumFromThenTo :: TeamUserSearchSortBy
-> TeamUserSearchSortBy
-> TeamUserSearchSortBy
-> [TeamUserSearchSortBy]
enumFromThenTo :: TeamUserSearchSortBy
-> TeamUserSearchSortBy
-> TeamUserSearchSortBy
-> [TeamUserSearchSortBy]
Enum, TeamUserSearchSortBy
TeamUserSearchSortBy
-> TeamUserSearchSortBy -> Bounded TeamUserSearchSortBy
forall a. a -> a -> Bounded a
$cminBound :: TeamUserSearchSortBy
minBound :: TeamUserSearchSortBy
$cmaxBound :: TeamUserSearchSortBy
maxBound :: TeamUserSearchSortBy
Bounded)
  deriving (Gen TeamUserSearchSortBy
Gen TeamUserSearchSortBy
-> (TeamUserSearchSortBy -> [TeamUserSearchSortBy])
-> Arbitrary TeamUserSearchSortBy
TeamUserSearchSortBy -> [TeamUserSearchSortBy]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen TeamUserSearchSortBy
arbitrary :: Gen TeamUserSearchSortBy
$cshrink :: TeamUserSearchSortBy -> [TeamUserSearchSortBy]
shrink :: TeamUserSearchSortBy -> [TeamUserSearchSortBy]
Arbitrary) via (GenericUniform TeamUserSearchSortBy)

instance S.ToParamSchema TeamUserSearchSortBy where
  toParamSchema :: Proxy TeamUserSearchSortBy -> Schema
toParamSchema Proxy TeamUserSearchSortBy
_ =
    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
?~ (TeamUserSearchSortBy -> Value)
-> [TeamUserSearchSortBy] -> [Value]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TeamUserSearchSortBy -> Value
forall a. IsString a => TeamUserSearchSortBy -> a
teamUserSearchSortByName [TeamUserSearchSortBy
forall a. Bounded a => a
minBound .. TeamUserSearchSortBy
forall a. Bounded a => a
maxBound]

instance ToByteString TeamUserSearchSortBy where
  builder :: TeamUserSearchSortBy -> Builder
builder = TeamUserSearchSortBy -> Builder
forall a. IsString a => TeamUserSearchSortBy -> a
teamUserSearchSortByName

instance FromByteString TeamUserSearchSortBy where
  parser :: Parser TeamUserSearchSortBy
parser =
    [Parser TeamUserSearchSortBy] -> Parser TeamUserSearchSortBy
forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum ([Parser TeamUserSearchSortBy] -> Parser TeamUserSearchSortBy)
-> [Parser TeamUserSearchSortBy] -> Parser TeamUserSearchSortBy
forall a b. (a -> b) -> a -> b
$
      [TeamUserSearchSortBy
forall a. Bounded a => a
minBound .. TeamUserSearchSortBy
forall a. Bounded a => a
maxBound] [TeamUserSearchSortBy]
-> (TeamUserSearchSortBy -> Parser TeamUserSearchSortBy)
-> [Parser TeamUserSearchSortBy]
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \TeamUserSearchSortBy
ctor ->
        TeamUserSearchSortBy
ctor TeamUserSearchSortBy
-> Parser ByteString ByteString -> Parser TeamUserSearchSortBy
forall a b. a -> Parser ByteString b -> Parser ByteString a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ByteString -> Parser ByteString ByteString
string (TeamUserSearchSortBy -> ByteString
forall a. IsString a => TeamUserSearchSortBy -> a
teamUserSearchSortByName TeamUserSearchSortBy
ctor)

instance FromHttpApiData TeamUserSearchSortBy where
  parseQueryParam :: Text -> Either Text TeamUserSearchSortBy
parseQueryParam Text
name = Text
-> Maybe TeamUserSearchSortBy -> Either Text TeamUserSearchSortBy
forall a b. a -> Maybe b -> Either a b
note (Text
"Unknown search sort: " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
name) (Maybe TeamUserSearchSortBy -> Either Text TeamUserSearchSortBy)
-> Maybe TeamUserSearchSortBy -> Either Text TeamUserSearchSortBy
forall a b. (a -> b) -> a -> b
$
    Alt Maybe TeamUserSearchSortBy -> Maybe TeamUserSearchSortBy
forall {k} (f :: k -> *) (a :: k). Alt f a -> f a
getAlt (Alt Maybe TeamUserSearchSortBy -> Maybe TeamUserSearchSortBy)
-> Alt Maybe TeamUserSearchSortBy -> Maybe TeamUserSearchSortBy
forall a b. (a -> b) -> a -> b
$
      ((TeamUserSearchSortBy -> Alt Maybe TeamUserSearchSortBy)
 -> [TeamUserSearchSortBy] -> Alt Maybe TeamUserSearchSortBy)
-> [TeamUserSearchSortBy]
-> (TeamUserSearchSortBy -> Alt Maybe TeamUserSearchSortBy)
-> Alt Maybe TeamUserSearchSortBy
forall a b c. (a -> b -> c) -> b -> a -> c
flip (TeamUserSearchSortBy -> Alt Maybe TeamUserSearchSortBy)
-> [TeamUserSearchSortBy] -> Alt Maybe TeamUserSearchSortBy
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap [TeamUserSearchSortBy
forall a. Bounded a => a
minBound .. TeamUserSearchSortBy
forall a. Bounded a => a
maxBound] ((TeamUserSearchSortBy -> Alt Maybe TeamUserSearchSortBy)
 -> Alt Maybe TeamUserSearchSortBy)
-> (TeamUserSearchSortBy -> Alt Maybe TeamUserSearchSortBy)
-> Alt Maybe TeamUserSearchSortBy
forall a b. (a -> b) -> a -> b
$ \TeamUserSearchSortBy
s ->
        Bool -> Alt Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (TeamUserSearchSortBy -> Text
forall a. IsString a => TeamUserSearchSortBy -> a
teamUserSearchSortByName TeamUserSearchSortBy
s Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
name) Alt Maybe ()
-> TeamUserSearchSortBy -> Alt Maybe TeamUserSearchSortBy
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> TeamUserSearchSortBy
s

teamUserSearchSortByName :: (IsString a) => TeamUserSearchSortBy -> a
teamUserSearchSortByName :: forall a. IsString a => TeamUserSearchSortBy -> a
teamUserSearchSortByName TeamUserSearchSortBy
SortByName = a
"name"
teamUserSearchSortByName TeamUserSearchSortBy
SortByHandle = a
"handle"
teamUserSearchSortByName TeamUserSearchSortBy
SortByEmail = a
"email"
teamUserSearchSortByName TeamUserSearchSortBy
SortBySAMLIdp = a
"saml_idp"
teamUserSearchSortByName TeamUserSearchSortBy
SortByManagedBy = a
"managed_by"
teamUserSearchSortByName TeamUserSearchSortBy
SortByRole = a
"role"
teamUserSearchSortByName TeamUserSearchSortBy
SortByCreatedAt = a
"created_at"

data TeamUserSearchSortOrder
  = SortOrderAsc
  | SortOrderDesc
  deriving (Int -> TeamUserSearchSortOrder -> ShowS
[TeamUserSearchSortOrder] -> ShowS
TeamUserSearchSortOrder -> String
(Int -> TeamUserSearchSortOrder -> ShowS)
-> (TeamUserSearchSortOrder -> String)
-> ([TeamUserSearchSortOrder] -> ShowS)
-> Show TeamUserSearchSortOrder
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TeamUserSearchSortOrder -> ShowS
showsPrec :: Int -> TeamUserSearchSortOrder -> ShowS
$cshow :: TeamUserSearchSortOrder -> String
show :: TeamUserSearchSortOrder -> String
$cshowList :: [TeamUserSearchSortOrder] -> ShowS
showList :: [TeamUserSearchSortOrder] -> ShowS
Show, TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Bool
(TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Bool)
-> (TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Bool)
-> Eq TeamUserSearchSortOrder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Bool
== :: TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Bool
$c/= :: TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Bool
/= :: TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Bool
Eq, Eq TeamUserSearchSortOrder
Eq TeamUserSearchSortOrder =>
(TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Ordering)
-> (TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Bool)
-> (TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Bool)
-> (TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Bool)
-> (TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Bool)
-> (TeamUserSearchSortOrder
    -> TeamUserSearchSortOrder -> TeamUserSearchSortOrder)
-> (TeamUserSearchSortOrder
    -> TeamUserSearchSortOrder -> TeamUserSearchSortOrder)
-> Ord TeamUserSearchSortOrder
TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Bool
TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Ordering
TeamUserSearchSortOrder
-> TeamUserSearchSortOrder -> TeamUserSearchSortOrder
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 :: TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Ordering
compare :: TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Ordering
$c< :: TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Bool
< :: TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Bool
$c<= :: TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Bool
<= :: TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Bool
$c> :: TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Bool
> :: TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Bool
$c>= :: TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Bool
>= :: TeamUserSearchSortOrder -> TeamUserSearchSortOrder -> Bool
$cmax :: TeamUserSearchSortOrder
-> TeamUserSearchSortOrder -> TeamUserSearchSortOrder
max :: TeamUserSearchSortOrder
-> TeamUserSearchSortOrder -> TeamUserSearchSortOrder
$cmin :: TeamUserSearchSortOrder
-> TeamUserSearchSortOrder -> TeamUserSearchSortOrder
min :: TeamUserSearchSortOrder
-> TeamUserSearchSortOrder -> TeamUserSearchSortOrder
Ord, (forall x.
 TeamUserSearchSortOrder -> Rep TeamUserSearchSortOrder x)
-> (forall x.
    Rep TeamUserSearchSortOrder x -> TeamUserSearchSortOrder)
-> Generic TeamUserSearchSortOrder
forall x. Rep TeamUserSearchSortOrder x -> TeamUserSearchSortOrder
forall x. TeamUserSearchSortOrder -> Rep TeamUserSearchSortOrder x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TeamUserSearchSortOrder -> Rep TeamUserSearchSortOrder x
from :: forall x. TeamUserSearchSortOrder -> Rep TeamUserSearchSortOrder x
$cto :: forall x. Rep TeamUserSearchSortOrder x -> TeamUserSearchSortOrder
to :: forall x. Rep TeamUserSearchSortOrder x -> TeamUserSearchSortOrder
Generic, Int -> TeamUserSearchSortOrder
TeamUserSearchSortOrder -> Int
TeamUserSearchSortOrder -> [TeamUserSearchSortOrder]
TeamUserSearchSortOrder -> TeamUserSearchSortOrder
TeamUserSearchSortOrder
-> TeamUserSearchSortOrder -> [TeamUserSearchSortOrder]
TeamUserSearchSortOrder
-> TeamUserSearchSortOrder
-> TeamUserSearchSortOrder
-> [TeamUserSearchSortOrder]
(TeamUserSearchSortOrder -> TeamUserSearchSortOrder)
-> (TeamUserSearchSortOrder -> TeamUserSearchSortOrder)
-> (Int -> TeamUserSearchSortOrder)
-> (TeamUserSearchSortOrder -> Int)
-> (TeamUserSearchSortOrder -> [TeamUserSearchSortOrder])
-> (TeamUserSearchSortOrder
    -> TeamUserSearchSortOrder -> [TeamUserSearchSortOrder])
-> (TeamUserSearchSortOrder
    -> TeamUserSearchSortOrder -> [TeamUserSearchSortOrder])
-> (TeamUserSearchSortOrder
    -> TeamUserSearchSortOrder
    -> TeamUserSearchSortOrder
    -> [TeamUserSearchSortOrder])
-> Enum TeamUserSearchSortOrder
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: TeamUserSearchSortOrder -> TeamUserSearchSortOrder
succ :: TeamUserSearchSortOrder -> TeamUserSearchSortOrder
$cpred :: TeamUserSearchSortOrder -> TeamUserSearchSortOrder
pred :: TeamUserSearchSortOrder -> TeamUserSearchSortOrder
$ctoEnum :: Int -> TeamUserSearchSortOrder
toEnum :: Int -> TeamUserSearchSortOrder
$cfromEnum :: TeamUserSearchSortOrder -> Int
fromEnum :: TeamUserSearchSortOrder -> Int
$cenumFrom :: TeamUserSearchSortOrder -> [TeamUserSearchSortOrder]
enumFrom :: TeamUserSearchSortOrder -> [TeamUserSearchSortOrder]
$cenumFromThen :: TeamUserSearchSortOrder
-> TeamUserSearchSortOrder -> [TeamUserSearchSortOrder]
enumFromThen :: TeamUserSearchSortOrder
-> TeamUserSearchSortOrder -> [TeamUserSearchSortOrder]
$cenumFromTo :: TeamUserSearchSortOrder
-> TeamUserSearchSortOrder -> [TeamUserSearchSortOrder]
enumFromTo :: TeamUserSearchSortOrder
-> TeamUserSearchSortOrder -> [TeamUserSearchSortOrder]
$cenumFromThenTo :: TeamUserSearchSortOrder
-> TeamUserSearchSortOrder
-> TeamUserSearchSortOrder
-> [TeamUserSearchSortOrder]
enumFromThenTo :: TeamUserSearchSortOrder
-> TeamUserSearchSortOrder
-> TeamUserSearchSortOrder
-> [TeamUserSearchSortOrder]
Enum, TeamUserSearchSortOrder
TeamUserSearchSortOrder
-> TeamUserSearchSortOrder -> Bounded TeamUserSearchSortOrder
forall a. a -> a -> Bounded a
$cminBound :: TeamUserSearchSortOrder
minBound :: TeamUserSearchSortOrder
$cmaxBound :: TeamUserSearchSortOrder
maxBound :: TeamUserSearchSortOrder
Bounded)
  deriving (Gen TeamUserSearchSortOrder
Gen TeamUserSearchSortOrder
-> (TeamUserSearchSortOrder -> [TeamUserSearchSortOrder])
-> Arbitrary TeamUserSearchSortOrder
TeamUserSearchSortOrder -> [TeamUserSearchSortOrder]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen TeamUserSearchSortOrder
arbitrary :: Gen TeamUserSearchSortOrder
$cshrink :: TeamUserSearchSortOrder -> [TeamUserSearchSortOrder]
shrink :: TeamUserSearchSortOrder -> [TeamUserSearchSortOrder]
Arbitrary) via (GenericUniform TeamUserSearchSortOrder)

instance S.ToParamSchema TeamUserSearchSortOrder where
  toParamSchema :: Proxy TeamUserSearchSortOrder -> Schema
toParamSchema Proxy TeamUserSearchSortOrder
_ =
    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
?~ (TeamUserSearchSortOrder -> Value)
-> [TeamUserSearchSortOrder] -> [Value]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TeamUserSearchSortOrder -> Value
forall a. IsString a => TeamUserSearchSortOrder -> a
teamUserSearchSortOrderName [TeamUserSearchSortOrder
forall a. Bounded a => a
minBound .. TeamUserSearchSortOrder
forall a. Bounded a => a
maxBound]

instance ToByteString TeamUserSearchSortOrder where
  builder :: TeamUserSearchSortOrder -> Builder
builder = TeamUserSearchSortOrder -> Builder
forall a. IsString a => TeamUserSearchSortOrder -> a
teamUserSearchSortOrderName

instance FromByteString TeamUserSearchSortOrder where
  parser :: Parser TeamUserSearchSortOrder
parser =
    [Parser TeamUserSearchSortOrder] -> Parser TeamUserSearchSortOrder
forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum ([Parser TeamUserSearchSortOrder]
 -> Parser TeamUserSearchSortOrder)
-> [Parser TeamUserSearchSortOrder]
-> Parser TeamUserSearchSortOrder
forall a b. (a -> b) -> a -> b
$
      [TeamUserSearchSortOrder
forall a. Bounded a => a
minBound .. TeamUserSearchSortOrder
forall a. Bounded a => a
maxBound] [TeamUserSearchSortOrder]
-> (TeamUserSearchSortOrder -> Parser TeamUserSearchSortOrder)
-> [Parser TeamUserSearchSortOrder]
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \TeamUserSearchSortOrder
ctor ->
        TeamUserSearchSortOrder
ctor TeamUserSearchSortOrder
-> Parser ByteString ByteString -> Parser TeamUserSearchSortOrder
forall a b. a -> Parser ByteString b -> Parser ByteString a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ByteString -> Parser ByteString ByteString
string (TeamUserSearchSortOrder -> ByteString
forall a. IsString a => TeamUserSearchSortOrder -> a
teamUserSearchSortOrderName TeamUserSearchSortOrder
ctor)

instance FromHttpApiData TeamUserSearchSortOrder where
  parseQueryParam :: Text -> Either Text TeamUserSearchSortOrder
parseQueryParam Text
name = Text
-> Maybe TeamUserSearchSortOrder
-> Either Text TeamUserSearchSortOrder
forall a b. a -> Maybe b -> Either a b
note (Text
"Unknown search order: " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
name) (Maybe TeamUserSearchSortOrder
 -> Either Text TeamUserSearchSortOrder)
-> Maybe TeamUserSearchSortOrder
-> Either Text TeamUserSearchSortOrder
forall a b. (a -> b) -> a -> b
$
    Alt Maybe TeamUserSearchSortOrder -> Maybe TeamUserSearchSortOrder
forall {k} (f :: k -> *) (a :: k). Alt f a -> f a
getAlt (Alt Maybe TeamUserSearchSortOrder
 -> Maybe TeamUserSearchSortOrder)
-> Alt Maybe TeamUserSearchSortOrder
-> Maybe TeamUserSearchSortOrder
forall a b. (a -> b) -> a -> b
$
      ((TeamUserSearchSortOrder -> Alt Maybe TeamUserSearchSortOrder)
 -> [TeamUserSearchSortOrder] -> Alt Maybe TeamUserSearchSortOrder)
-> [TeamUserSearchSortOrder]
-> (TeamUserSearchSortOrder -> Alt Maybe TeamUserSearchSortOrder)
-> Alt Maybe TeamUserSearchSortOrder
forall a b c. (a -> b -> c) -> b -> a -> c
flip (TeamUserSearchSortOrder -> Alt Maybe TeamUserSearchSortOrder)
-> [TeamUserSearchSortOrder] -> Alt Maybe TeamUserSearchSortOrder
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap [TeamUserSearchSortOrder
forall a. Bounded a => a
minBound .. TeamUserSearchSortOrder
forall a. Bounded a => a
maxBound] ((TeamUserSearchSortOrder -> Alt Maybe TeamUserSearchSortOrder)
 -> Alt Maybe TeamUserSearchSortOrder)
-> (TeamUserSearchSortOrder -> Alt Maybe TeamUserSearchSortOrder)
-> Alt Maybe TeamUserSearchSortOrder
forall a b. (a -> b) -> a -> b
$ \TeamUserSearchSortOrder
s ->
        Bool -> Alt Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (TeamUserSearchSortOrder -> Text
forall a. IsString a => TeamUserSearchSortOrder -> a
teamUserSearchSortOrderName TeamUserSearchSortOrder
s Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
name) Alt Maybe ()
-> TeamUserSearchSortOrder -> Alt Maybe TeamUserSearchSortOrder
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> TeamUserSearchSortOrder
s

teamUserSearchSortOrderName :: (IsString a) => TeamUserSearchSortOrder -> a
teamUserSearchSortOrderName :: forall a. IsString a => TeamUserSearchSortOrder -> a
teamUserSearchSortOrderName TeamUserSearchSortOrder
SortOrderAsc = a
"asc"
teamUserSearchSortOrderName TeamUserSearchSortOrder
SortOrderDesc = a
"desc"

newtype RoleFilter = RoleFilter [Role]
  deriving (Int -> RoleFilter -> ShowS
[RoleFilter] -> ShowS
RoleFilter -> String
(Int -> RoleFilter -> ShowS)
-> (RoleFilter -> String)
-> ([RoleFilter] -> ShowS)
-> Show RoleFilter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RoleFilter -> ShowS
showsPrec :: Int -> RoleFilter -> ShowS
$cshow :: RoleFilter -> String
show :: RoleFilter -> String
$cshowList :: [RoleFilter] -> ShowS
showList :: [RoleFilter] -> ShowS
Show, RoleFilter -> RoleFilter -> Bool
(RoleFilter -> RoleFilter -> Bool)
-> (RoleFilter -> RoleFilter -> Bool) -> Eq RoleFilter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RoleFilter -> RoleFilter -> Bool
== :: RoleFilter -> RoleFilter -> Bool
$c/= :: RoleFilter -> RoleFilter -> Bool
/= :: RoleFilter -> RoleFilter -> Bool
Eq, (forall x. RoleFilter -> Rep RoleFilter x)
-> (forall x. Rep RoleFilter x -> RoleFilter) -> Generic RoleFilter
forall x. Rep RoleFilter x -> RoleFilter
forall x. RoleFilter -> Rep RoleFilter x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RoleFilter -> Rep RoleFilter x
from :: forall x. RoleFilter -> Rep RoleFilter x
$cto :: forall x. Rep RoleFilter x -> RoleFilter
to :: forall x. Rep RoleFilter x -> RoleFilter
Generic)
  deriving (Gen RoleFilter
Gen RoleFilter
-> (RoleFilter -> [RoleFilter]) -> Arbitrary RoleFilter
RoleFilter -> [RoleFilter]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen RoleFilter
arbitrary :: Gen RoleFilter
$cshrink :: RoleFilter -> [RoleFilter]
shrink :: RoleFilter -> [RoleFilter]
Arbitrary) via (GenericUniform RoleFilter)

instance S.ToParamSchema RoleFilter where
  toParamSchema :: Proxy RoleFilter -> Schema
toParamSchema Proxy RoleFilter
_ = Proxy [Role] -> Schema
forall a. ToParamSchema a => Proxy a -> Schema
S.toParamSchema (forall t. Proxy t
forall {k} (t :: k). Proxy t
Proxy @[Role])

instance ToByteString RoleFilter where
  builder :: RoleFilter -> Builder
builder (RoleFilter [Role]
roles) = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat ([Builder] -> Builder) -> [Builder] -> Builder
forall a b. (a -> b) -> a -> b
$ Builder -> [Builder] -> [Builder]
forall a. a -> [a] -> [a]
intersperse Builder
"," ((Role -> Builder) -> [Role] -> [Builder]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Role -> Builder
forall a. ToByteString a => a -> Builder
builder [Role]
roles)

instance FromByteString RoleFilter where
  parser :: Parser RoleFilter
parser = [Role] -> RoleFilter
RoleFilter ([Role] -> RoleFilter)
-> Parser ByteString [Role] -> Parser RoleFilter
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser Role
forall a. FromByteString a => Parser a
parser Parser Role -> Parser ByteString Char -> Parser ByteString [Role]
forall (f :: * -> *) a s. Alternative f => f a -> f s -> f [a]
`sepBy` Char -> Parser ByteString Char
char Char
','

instance FromHttpApiData RoleFilter where
  parseQueryParam :: Text -> Either Text RoleFilter
parseQueryParam = ([Role] -> RoleFilter)
-> Either Text [Role] -> Either Text RoleFilter
forall a b. (a -> b) -> Either Text a -> Either Text b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Role] -> RoleFilter
RoleFilter (Either Text [Role] -> Either Text RoleFilter)
-> (Text -> Either Text [Role]) -> Text -> Either Text RoleFilter
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Either Text Role) -> [Text] -> Either Text [Role]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse Text -> Either Text Role
forall a. FromHttpApiData a => Text -> Either Text a
parseQueryParam ([Text] -> Either Text [Role])
-> (Text -> [Text]) -> Text -> Either Text [Role]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> Text -> [Text]
T.split (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
',')

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

instance ToSchema FederatedUserSearchPolicy where
  schema :: SchemaP
  NamedSwaggerDoc
  Value
  Value
  FederatedUserSearchPolicy
  FederatedUserSearchPolicy
schema =
    forall v doc a b.
(With v, HasEnum v doc) =>
Text
-> SchemaP [Value] v (Alt Maybe v) a b
-> SchemaP doc Value Value a b
enum @Text Text
"FederatedUserSearchPolicy" (SchemaP
   [Value]
   Text
   (Alt Maybe Text)
   FederatedUserSearchPolicy
   FederatedUserSearchPolicy
 -> SchemaP
      NamedSwaggerDoc
      Value
      Value
      FederatedUserSearchPolicy
      FederatedUserSearchPolicy)
-> SchemaP
     [Value]
     Text
     (Alt Maybe Text)
     FederatedUserSearchPolicy
     FederatedUserSearchPolicy
-> SchemaP
     NamedSwaggerDoc
     Value
     Value
     FederatedUserSearchPolicy
     FederatedUserSearchPolicy
forall a b. (a -> b) -> a -> b
$
      Text
-> FederatedUserSearchPolicy
-> SchemaP
     [Value]
     Text
     (Alt Maybe Text)
     FederatedUserSearchPolicy
     FederatedUserSearchPolicy
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"no_search" FederatedUserSearchPolicy
NoSearch
        SchemaP
  [Value]
  Text
  (Alt Maybe Text)
  FederatedUserSearchPolicy
  FederatedUserSearchPolicy
-> SchemaP
     [Value]
     Text
     (Alt Maybe Text)
     FederatedUserSearchPolicy
     FederatedUserSearchPolicy
-> SchemaP
     [Value]
     Text
     (Alt Maybe Text)
     FederatedUserSearchPolicy
     FederatedUserSearchPolicy
forall a. Semigroup a => a -> a -> a
<> Text
-> FederatedUserSearchPolicy
-> SchemaP
     [Value]
     Text
     (Alt Maybe Text)
     FederatedUserSearchPolicy
     FederatedUserSearchPolicy
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"exact_handle_search" FederatedUserSearchPolicy
ExactHandleSearch
        SchemaP
  [Value]
  Text
  (Alt Maybe Text)
  FederatedUserSearchPolicy
  FederatedUserSearchPolicy
-> SchemaP
     [Value]
     Text
     (Alt Maybe Text)
     FederatedUserSearchPolicy
     FederatedUserSearchPolicy
-> SchemaP
     [Value]
     Text
     (Alt Maybe Text)
     FederatedUserSearchPolicy
     FederatedUserSearchPolicy
forall a. Semigroup a => a -> a -> a
<> Text
-> FederatedUserSearchPolicy
-> SchemaP
     [Value]
     Text
     (Alt Maybe Text)
     FederatedUserSearchPolicy
     FederatedUserSearchPolicy
forall a b.
(ToJSON a, Eq a, Eq b) =>
a -> b -> SchemaP [Value] a (Alt Maybe a) b b
element Text
"full_search" FederatedUserSearchPolicy
FullSearch

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

  toCql :: FederatedUserSearchPolicy -> Value
toCql FederatedUserSearchPolicy
NoSearch = Int32 -> Value
C.CqlInt Int32
0
  toCql FederatedUserSearchPolicy
ExactHandleSearch = Int32 -> Value
C.CqlInt Int32
1
  toCql FederatedUserSearchPolicy
FullSearch = Int32 -> Value
C.CqlInt Int32
2

  fromCql :: Value -> Either String FederatedUserSearchPolicy
fromCql (C.CqlInt Int32
0) = FederatedUserSearchPolicy
-> Either String FederatedUserSearchPolicy
forall a. a -> Either String a
forall (f :: * -> *) a. Applicative f => a -> f a
pure FederatedUserSearchPolicy
NoSearch
  fromCql (C.CqlInt Int32
1) = FederatedUserSearchPolicy
-> Either String FederatedUserSearchPolicy
forall a. a -> Either String a
forall (f :: * -> *) a. Applicative f => a -> f a
pure FederatedUserSearchPolicy
ExactHandleSearch
  fromCql (C.CqlInt Int32
2) = FederatedUserSearchPolicy
-> Either String FederatedUserSearchPolicy
forall a. a -> Either String a
forall (f :: * -> *) a. Applicative f => a -> f a
pure FederatedUserSearchPolicy
FullSearch
  fromCql Value
n = String -> Either String FederatedUserSearchPolicy
forall a b. a -> Either a b
Left (String -> Either String FederatedUserSearchPolicy)
-> String -> Either String FederatedUserSearchPolicy
forall a b. (a -> b) -> a -> b
$ String
"Unexpected SearchVisibilityInbound: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Value -> String
forall a. Show a => a -> String
show Value
n