{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TemplateHaskellQuotes #-}

module Database.Bloodhound.Internal.Versions.Common.Types.Newtypes
  ( From (..),
    Size (..),
    HitFields (..),
    Score,
    ShardId (..),
    DocId (..),
    FieldName (..),
    RelationName (..),
    QueryString (..),
    CacheName (..),
    CacheKey (..),
    Existence (..),
    NullValue (..),
    CutoffFrequency (..),
    Analyzer (..),
    MaxExpansions (..),
    Lenient (..),
    Tiebreaker (..),
    MinimumMatch (..),
    DisableCoord (..),
    IgnoreTermFrequency (..),
    MinimumTermFrequency (..),
    MaxQueryTerms (..),
    PrefixLength (..),
    PercentMatch (..),
    StopWord (..),
    QueryPath (..),
    AllowLeadingWildcard (..),
    LowercaseExpanded (..),
    EnablePositionIncrements (..),
    AnalyzeWildcard (..),
    GeneratePhraseQueries (..),
    Locale (..),
    MaxWordLength (..),
    MinWordLength (..),
    PhraseSlop (..),
    MinDocFrequency (..),
    MaxDocFrequency (..),
    AggregateParentScore (..),
    IgnoreUnmapped (..),
    MinChildren (..),
    MaxChildren (..),
    POSIXMS (..),
    Boost (..),
    BoostTerms (..),
    ReplicaCount (..),
    ShardCount (..),
    IndexName,
    unIndexName,
    mkIndexName,
    qqIndexName,
    IndexAliasName (..),
    MaybeNA (..),
    SnapshotName (..),
    MS (..),
    unMS,
    TokenFilter (..),
    CharFilter (..),
  )
where

import Control.Exception (throwIO)
import qualified Data.ByteString as BS
import Data.Char (isLetter, isLower)
import qualified Data.Map.Strict as M
import qualified Data.Text as T
import qualified Data.Text.Encoding as T
import Database.Bloodhound.Internal.Utils.Imports
import GHC.Generics
import Language.Haskell.TH
import Language.Haskell.TH.Quote

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

newtype Size = Size Int deriving newtype (Size -> Size -> Bool
(Size -> Size -> Bool) -> (Size -> Size -> Bool) -> Eq Size
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Size -> Size -> Bool
== :: Size -> Size -> Bool
$c/= :: Size -> Size -> Bool
/= :: Size -> Size -> Bool
Eq, Int -> Size -> ShowS
[Size] -> ShowS
Size -> String
(Int -> Size -> ShowS)
-> (Size -> String) -> ([Size] -> ShowS) -> Show Size
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Size -> ShowS
showsPrec :: Int -> Size -> ShowS
$cshow :: Size -> String
show :: Size -> String
$cshowList :: [Size] -> ShowS
showList :: [Size] -> ShowS
Show, [Size] -> Value
[Size] -> Encoding
Size -> Bool
Size -> Value
Size -> Encoding
(Size -> Value)
-> (Size -> Encoding)
-> ([Size] -> Value)
-> ([Size] -> Encoding)
-> (Size -> Bool)
-> ToJSON Size
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: Size -> Value
toJSON :: Size -> Value
$ctoEncoding :: Size -> Encoding
toEncoding :: Size -> Encoding
$ctoJSONList :: [Size] -> Value
toJSONList :: [Size] -> Value
$ctoEncodingList :: [Size] -> Encoding
toEncodingList :: [Size] -> Encoding
$comitField :: Size -> Bool
omitField :: Size -> Bool
ToJSON, Maybe Size
Value -> Parser [Size]
Value -> Parser Size
(Value -> Parser Size)
-> (Value -> Parser [Size]) -> Maybe Size -> FromJSON Size
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser Size
parseJSON :: Value -> Parser Size
$cparseJSONList :: Value -> Parser [Size]
parseJSONList :: Value -> Parser [Size]
$comittedField :: Maybe Size
omittedField :: Maybe Size
FromJSON)

-- Used with scripts
newtype HitFields
  = HitFields (M.Map Text [Value])
  deriving newtype (HitFields -> HitFields -> Bool
(HitFields -> HitFields -> Bool)
-> (HitFields -> HitFields -> Bool) -> Eq HitFields
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HitFields -> HitFields -> Bool
== :: HitFields -> HitFields -> Bool
$c/= :: HitFields -> HitFields -> Bool
/= :: HitFields -> HitFields -> Bool
Eq, Int -> HitFields -> ShowS
[HitFields] -> ShowS
HitFields -> String
(Int -> HitFields -> ShowS)
-> (HitFields -> String)
-> ([HitFields] -> ShowS)
-> Show HitFields
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HitFields -> ShowS
showsPrec :: Int -> HitFields -> ShowS
$cshow :: HitFields -> String
show :: HitFields -> String
$cshowList :: [HitFields] -> ShowS
showList :: [HitFields] -> ShowS
Show)

instance FromJSON HitFields where
  parseJSON :: Value -> Parser HitFields
parseJSON Value
x =
    Map Text [Value] -> HitFields
HitFields (Map Text [Value] -> HitFields)
-> Parser (Map Text [Value]) -> Parser HitFields
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser (Map Text [Value])
forall a. FromJSON a => Value -> Parser a
parseJSON Value
x

-- Slight misnomer.
type Score = Maybe Double

newtype ShardId = ShardId {ShardId -> Int
shardId :: Int}
  deriving newtype (ShardId -> ShardId -> Bool
(ShardId -> ShardId -> Bool)
-> (ShardId -> ShardId -> Bool) -> Eq ShardId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShardId -> ShardId -> Bool
== :: ShardId -> ShardId -> Bool
$c/= :: ShardId -> ShardId -> Bool
/= :: ShardId -> ShardId -> Bool
Eq, Int -> ShardId -> ShowS
[ShardId] -> ShowS
ShardId -> String
(Int -> ShardId -> ShowS)
-> (ShardId -> String) -> ([ShardId] -> ShowS) -> Show ShardId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ShardId -> ShowS
showsPrec :: Int -> ShardId -> ShowS
$cshow :: ShardId -> String
show :: ShardId -> String
$cshowList :: [ShardId] -> ShowS
showList :: [ShardId] -> ShowS
Show, Maybe ShardId
Value -> Parser [ShardId]
Value -> Parser ShardId
(Value -> Parser ShardId)
-> (Value -> Parser [ShardId]) -> Maybe ShardId -> FromJSON ShardId
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser ShardId
parseJSON :: Value -> Parser ShardId
$cparseJSONList :: Value -> Parser [ShardId]
parseJSONList :: Value -> Parser [ShardId]
$comittedField :: Maybe ShardId
omittedField :: Maybe ShardId
FromJSON)

-- | 'DocId' is a generic wrapper value for expressing unique Document IDs.
--   Can be set by the user or created by ES itself. Often used in client
--   functions for poking at specific documents.
newtype DocId
  = DocId Text
  deriving newtype (DocId -> DocId -> Bool
(DocId -> DocId -> Bool) -> (DocId -> DocId -> Bool) -> Eq DocId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DocId -> DocId -> Bool
== :: DocId -> DocId -> Bool
$c/= :: DocId -> DocId -> Bool
/= :: DocId -> DocId -> Bool
Eq, Int -> DocId -> ShowS
[DocId] -> ShowS
DocId -> String
(Int -> DocId -> ShowS)
-> (DocId -> String) -> ([DocId] -> ShowS) -> Show DocId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DocId -> ShowS
showsPrec :: Int -> DocId -> ShowS
$cshow :: DocId -> String
show :: DocId -> String
$cshowList :: [DocId] -> ShowS
showList :: [DocId] -> ShowS
Show, [DocId] -> Value
[DocId] -> Encoding
DocId -> Bool
DocId -> Value
DocId -> Encoding
(DocId -> Value)
-> (DocId -> Encoding)
-> ([DocId] -> Value)
-> ([DocId] -> Encoding)
-> (DocId -> Bool)
-> ToJSON DocId
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: DocId -> Value
toJSON :: DocId -> Value
$ctoEncoding :: DocId -> Encoding
toEncoding :: DocId -> Encoding
$ctoJSONList :: [DocId] -> Value
toJSONList :: [DocId] -> Value
$ctoEncodingList :: [DocId] -> Encoding
toEncodingList :: [DocId] -> Encoding
$comitField :: DocId -> Bool
omitField :: DocId -> Bool
ToJSON, Maybe DocId
Value -> Parser [DocId]
Value -> Parser DocId
(Value -> Parser DocId)
-> (Value -> Parser [DocId]) -> Maybe DocId -> FromJSON DocId
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser DocId
parseJSON :: Value -> Parser DocId
$cparseJSONList :: Value -> Parser [DocId]
parseJSONList :: Value -> Parser [DocId]
$comittedField :: Maybe DocId
omittedField :: Maybe DocId
FromJSON)

-- | 'FieldName' is used all over the place wherever a specific field within
--    a document needs to be specified, usually in 'Query's or 'Filter's.
newtype FieldName
  = FieldName Text
  deriving newtype (FieldName -> FieldName -> Bool
(FieldName -> FieldName -> Bool)
-> (FieldName -> FieldName -> Bool) -> Eq FieldName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FieldName -> FieldName -> Bool
== :: FieldName -> FieldName -> Bool
$c/= :: FieldName -> FieldName -> Bool
/= :: FieldName -> FieldName -> Bool
Eq, ReadPrec [FieldName]
ReadPrec FieldName
Int -> ReadS FieldName
ReadS [FieldName]
(Int -> ReadS FieldName)
-> ReadS [FieldName]
-> ReadPrec FieldName
-> ReadPrec [FieldName]
-> Read FieldName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FieldName
readsPrec :: Int -> ReadS FieldName
$creadList :: ReadS [FieldName]
readList :: ReadS [FieldName]
$creadPrec :: ReadPrec FieldName
readPrec :: ReadPrec FieldName
$creadListPrec :: ReadPrec [FieldName]
readListPrec :: ReadPrec [FieldName]
Read, Int -> FieldName -> ShowS
[FieldName] -> ShowS
FieldName -> String
(Int -> FieldName -> ShowS)
-> (FieldName -> String)
-> ([FieldName] -> ShowS)
-> Show FieldName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FieldName -> ShowS
showsPrec :: Int -> FieldName -> ShowS
$cshow :: FieldName -> String
show :: FieldName -> String
$cshowList :: [FieldName] -> ShowS
showList :: [FieldName] -> ShowS
Show, [FieldName] -> Value
[FieldName] -> Encoding
FieldName -> Bool
FieldName -> Value
FieldName -> Encoding
(FieldName -> Value)
-> (FieldName -> Encoding)
-> ([FieldName] -> Value)
-> ([FieldName] -> Encoding)
-> (FieldName -> Bool)
-> ToJSON FieldName
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: FieldName -> Value
toJSON :: FieldName -> Value
$ctoEncoding :: FieldName -> Encoding
toEncoding :: FieldName -> Encoding
$ctoJSONList :: [FieldName] -> Value
toJSONList :: [FieldName] -> Value
$ctoEncodingList :: [FieldName] -> Encoding
toEncodingList :: [FieldName] -> Encoding
$comitField :: FieldName -> Bool
omitField :: FieldName -> Bool
ToJSON, Maybe FieldName
Value -> Parser [FieldName]
Value -> Parser FieldName
(Value -> Parser FieldName)
-> (Value -> Parser [FieldName])
-> Maybe FieldName
-> FromJSON FieldName
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser FieldName
parseJSON :: Value -> Parser FieldName
$cparseJSONList :: Value -> Parser [FieldName]
parseJSONList :: Value -> Parser [FieldName]
$comittedField :: Maybe FieldName
omittedField :: Maybe FieldName
FromJSON)

-- | 'RelationName' describes a relation role between parend and child Documents
--    in a Join relarionship: https://www.elastic.co/guide/en/elasticsearch/reference/current/parent-join.html
newtype RelationName
  = RelationName Text
  deriving newtype (RelationName -> RelationName -> Bool
(RelationName -> RelationName -> Bool)
-> (RelationName -> RelationName -> Bool) -> Eq RelationName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RelationName -> RelationName -> Bool
== :: RelationName -> RelationName -> Bool
$c/= :: RelationName -> RelationName -> Bool
/= :: RelationName -> RelationName -> Bool
Eq, ReadPrec [RelationName]
ReadPrec RelationName
Int -> ReadS RelationName
ReadS [RelationName]
(Int -> ReadS RelationName)
-> ReadS [RelationName]
-> ReadPrec RelationName
-> ReadPrec [RelationName]
-> Read RelationName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RelationName
readsPrec :: Int -> ReadS RelationName
$creadList :: ReadS [RelationName]
readList :: ReadS [RelationName]
$creadPrec :: ReadPrec RelationName
readPrec :: ReadPrec RelationName
$creadListPrec :: ReadPrec [RelationName]
readListPrec :: ReadPrec [RelationName]
Read, Int -> RelationName -> ShowS
[RelationName] -> ShowS
RelationName -> String
(Int -> RelationName -> ShowS)
-> (RelationName -> String)
-> ([RelationName] -> ShowS)
-> Show RelationName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RelationName -> ShowS
showsPrec :: Int -> RelationName -> ShowS
$cshow :: RelationName -> String
show :: RelationName -> String
$cshowList :: [RelationName] -> ShowS
showList :: [RelationName] -> ShowS
Show, [RelationName] -> Value
[RelationName] -> Encoding
RelationName -> Bool
RelationName -> Value
RelationName -> Encoding
(RelationName -> Value)
-> (RelationName -> Encoding)
-> ([RelationName] -> Value)
-> ([RelationName] -> Encoding)
-> (RelationName -> Bool)
-> ToJSON RelationName
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: RelationName -> Value
toJSON :: RelationName -> Value
$ctoEncoding :: RelationName -> Encoding
toEncoding :: RelationName -> Encoding
$ctoJSONList :: [RelationName] -> Value
toJSONList :: [RelationName] -> Value
$ctoEncodingList :: [RelationName] -> Encoding
toEncodingList :: [RelationName] -> Encoding
$comitField :: RelationName -> Bool
omitField :: RelationName -> Bool
ToJSON, Maybe RelationName
Value -> Parser [RelationName]
Value -> Parser RelationName
(Value -> Parser RelationName)
-> (Value -> Parser [RelationName])
-> Maybe RelationName
-> FromJSON RelationName
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser RelationName
parseJSON :: Value -> Parser RelationName
$cparseJSONList :: Value -> Parser [RelationName]
parseJSONList :: Value -> Parser [RelationName]
$comittedField :: Maybe RelationName
omittedField :: Maybe RelationName
FromJSON)

-- | 'QueryString' is used to wrap query text bodies, be they human written or not.
newtype QueryString
  = QueryString Text
  deriving newtype (QueryString -> QueryString -> Bool
(QueryString -> QueryString -> Bool)
-> (QueryString -> QueryString -> Bool) -> Eq QueryString
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QueryString -> QueryString -> Bool
== :: QueryString -> QueryString -> Bool
$c/= :: QueryString -> QueryString -> Bool
/= :: QueryString -> QueryString -> Bool
Eq, Int -> QueryString -> ShowS
[QueryString] -> ShowS
QueryString -> String
(Int -> QueryString -> ShowS)
-> (QueryString -> String)
-> ([QueryString] -> ShowS)
-> Show QueryString
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> QueryString -> ShowS
showsPrec :: Int -> QueryString -> ShowS
$cshow :: QueryString -> String
show :: QueryString -> String
$cshowList :: [QueryString] -> ShowS
showList :: [QueryString] -> ShowS
Show, [QueryString] -> Value
[QueryString] -> Encoding
QueryString -> Bool
QueryString -> Value
QueryString -> Encoding
(QueryString -> Value)
-> (QueryString -> Encoding)
-> ([QueryString] -> Value)
-> ([QueryString] -> Encoding)
-> (QueryString -> Bool)
-> ToJSON QueryString
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: QueryString -> Value
toJSON :: QueryString -> Value
$ctoEncoding :: QueryString -> Encoding
toEncoding :: QueryString -> Encoding
$ctoJSONList :: [QueryString] -> Value
toJSONList :: [QueryString] -> Value
$ctoEncodingList :: [QueryString] -> Encoding
toEncodingList :: [QueryString] -> Encoding
$comitField :: QueryString -> Bool
omitField :: QueryString -> Bool
ToJSON, Maybe QueryString
Value -> Parser [QueryString]
Value -> Parser QueryString
(Value -> Parser QueryString)
-> (Value -> Parser [QueryString])
-> Maybe QueryString
-> FromJSON QueryString
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser QueryString
parseJSON :: Value -> Parser QueryString
$cparseJSONList :: Value -> Parser [QueryString]
parseJSONList :: Value -> Parser [QueryString]
$comittedField :: Maybe QueryString
omittedField :: Maybe QueryString
FromJSON)

-- {-| 'Script' is often used in place of 'FieldName' to specify more
-- complex ways of extracting a value from a document.
-- -}
-- newtype Script =
--   Script { scriptText :: Text }
--   deriving newtype (Eq, Show)

-- | 'CacheName' is used in 'RegexpFilter' for describing the
--   'CacheKey' keyed caching behavior.
newtype CacheName
  = CacheName Text
  deriving newtype (CacheName -> CacheName -> Bool
(CacheName -> CacheName -> Bool)
-> (CacheName -> CacheName -> Bool) -> Eq CacheName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CacheName -> CacheName -> Bool
== :: CacheName -> CacheName -> Bool
$c/= :: CacheName -> CacheName -> Bool
/= :: CacheName -> CacheName -> Bool
Eq, Int -> CacheName -> ShowS
[CacheName] -> ShowS
CacheName -> String
(Int -> CacheName -> ShowS)
-> (CacheName -> String)
-> ([CacheName] -> ShowS)
-> Show CacheName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CacheName -> ShowS
showsPrec :: Int -> CacheName -> ShowS
$cshow :: CacheName -> String
show :: CacheName -> String
$cshowList :: [CacheName] -> ShowS
showList :: [CacheName] -> ShowS
Show, Maybe CacheName
Value -> Parser [CacheName]
Value -> Parser CacheName
(Value -> Parser CacheName)
-> (Value -> Parser [CacheName])
-> Maybe CacheName
-> FromJSON CacheName
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser CacheName
parseJSON :: Value -> Parser CacheName
$cparseJSONList :: Value -> Parser [CacheName]
parseJSONList :: Value -> Parser [CacheName]
$comittedField :: Maybe CacheName
omittedField :: Maybe CacheName
FromJSON, [CacheName] -> Value
[CacheName] -> Encoding
CacheName -> Bool
CacheName -> Value
CacheName -> Encoding
(CacheName -> Value)
-> (CacheName -> Encoding)
-> ([CacheName] -> Value)
-> ([CacheName] -> Encoding)
-> (CacheName -> Bool)
-> ToJSON CacheName
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: CacheName -> Value
toJSON :: CacheName -> Value
$ctoEncoding :: CacheName -> Encoding
toEncoding :: CacheName -> Encoding
$ctoJSONList :: [CacheName] -> Value
toJSONList :: [CacheName] -> Value
$ctoEncodingList :: [CacheName] -> Encoding
toEncodingList :: [CacheName] -> Encoding
$comitField :: CacheName -> Bool
omitField :: CacheName -> Bool
ToJSON)

-- | 'CacheKey' is used in 'RegexpFilter' to key regex caching.
newtype CacheKey
  = CacheKey Text
  deriving newtype (CacheKey -> CacheKey -> Bool
(CacheKey -> CacheKey -> Bool)
-> (CacheKey -> CacheKey -> Bool) -> Eq CacheKey
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CacheKey -> CacheKey -> Bool
== :: CacheKey -> CacheKey -> Bool
$c/= :: CacheKey -> CacheKey -> Bool
/= :: CacheKey -> CacheKey -> Bool
Eq, Int -> CacheKey -> ShowS
[CacheKey] -> ShowS
CacheKey -> String
(Int -> CacheKey -> ShowS)
-> (CacheKey -> String) -> ([CacheKey] -> ShowS) -> Show CacheKey
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CacheKey -> ShowS
showsPrec :: Int -> CacheKey -> ShowS
$cshow :: CacheKey -> String
show :: CacheKey -> String
$cshowList :: [CacheKey] -> ShowS
showList :: [CacheKey] -> ShowS
Show, Maybe CacheKey
Value -> Parser [CacheKey]
Value -> Parser CacheKey
(Value -> Parser CacheKey)
-> (Value -> Parser [CacheKey])
-> Maybe CacheKey
-> FromJSON CacheKey
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser CacheKey
parseJSON :: Value -> Parser CacheKey
$cparseJSONList :: Value -> Parser [CacheKey]
parseJSONList :: Value -> Parser [CacheKey]
$comittedField :: Maybe CacheKey
omittedField :: Maybe CacheKey
FromJSON, [CacheKey] -> Value
[CacheKey] -> Encoding
CacheKey -> Bool
CacheKey -> Value
CacheKey -> Encoding
(CacheKey -> Value)
-> (CacheKey -> Encoding)
-> ([CacheKey] -> Value)
-> ([CacheKey] -> Encoding)
-> (CacheKey -> Bool)
-> ToJSON CacheKey
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: CacheKey -> Value
toJSON :: CacheKey -> Value
$ctoEncoding :: CacheKey -> Encoding
toEncoding :: CacheKey -> Encoding
$ctoJSONList :: [CacheKey] -> Value
toJSONList :: [CacheKey] -> Value
$ctoEncodingList :: [CacheKey] -> Encoding
toEncodingList :: [CacheKey] -> Encoding
$comitField :: CacheKey -> Bool
omitField :: CacheKey -> Bool
ToJSON)

newtype Existence
  = Existence Bool
  deriving newtype (Existence -> Existence -> Bool
(Existence -> Existence -> Bool)
-> (Existence -> Existence -> Bool) -> Eq Existence
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Existence -> Existence -> Bool
== :: Existence -> Existence -> Bool
$c/= :: Existence -> Existence -> Bool
/= :: Existence -> Existence -> Bool
Eq, Int -> Existence -> ShowS
[Existence] -> ShowS
Existence -> String
(Int -> Existence -> ShowS)
-> (Existence -> String)
-> ([Existence] -> ShowS)
-> Show Existence
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Existence -> ShowS
showsPrec :: Int -> Existence -> ShowS
$cshow :: Existence -> String
show :: Existence -> String
$cshowList :: [Existence] -> ShowS
showList :: [Existence] -> ShowS
Show, Maybe Existence
Value -> Parser [Existence]
Value -> Parser Existence
(Value -> Parser Existence)
-> (Value -> Parser [Existence])
-> Maybe Existence
-> FromJSON Existence
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser Existence
parseJSON :: Value -> Parser Existence
$cparseJSONList :: Value -> Parser [Existence]
parseJSONList :: Value -> Parser [Existence]
$comittedField :: Maybe Existence
omittedField :: Maybe Existence
FromJSON, [Existence] -> Value
[Existence] -> Encoding
Existence -> Bool
Existence -> Value
Existence -> Encoding
(Existence -> Value)
-> (Existence -> Encoding)
-> ([Existence] -> Value)
-> ([Existence] -> Encoding)
-> (Existence -> Bool)
-> ToJSON Existence
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: Existence -> Value
toJSON :: Existence -> Value
$ctoEncoding :: Existence -> Encoding
toEncoding :: Existence -> Encoding
$ctoJSONList :: [Existence] -> Value
toJSONList :: [Existence] -> Value
$ctoEncodingList :: [Existence] -> Encoding
toEncodingList :: [Existence] -> Encoding
$comitField :: Existence -> Bool
omitField :: Existence -> Bool
ToJSON)

newtype NullValue
  = NullValue Bool
  deriving newtype (NullValue -> NullValue -> Bool
(NullValue -> NullValue -> Bool)
-> (NullValue -> NullValue -> Bool) -> Eq NullValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NullValue -> NullValue -> Bool
== :: NullValue -> NullValue -> Bool
$c/= :: NullValue -> NullValue -> Bool
/= :: NullValue -> NullValue -> Bool
Eq, Int -> NullValue -> ShowS
[NullValue] -> ShowS
NullValue -> String
(Int -> NullValue -> ShowS)
-> (NullValue -> String)
-> ([NullValue] -> ShowS)
-> Show NullValue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NullValue -> ShowS
showsPrec :: Int -> NullValue -> ShowS
$cshow :: NullValue -> String
show :: NullValue -> String
$cshowList :: [NullValue] -> ShowS
showList :: [NullValue] -> ShowS
Show, Maybe NullValue
Value -> Parser [NullValue]
Value -> Parser NullValue
(Value -> Parser NullValue)
-> (Value -> Parser [NullValue])
-> Maybe NullValue
-> FromJSON NullValue
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser NullValue
parseJSON :: Value -> Parser NullValue
$cparseJSONList :: Value -> Parser [NullValue]
parseJSONList :: Value -> Parser [NullValue]
$comittedField :: Maybe NullValue
omittedField :: Maybe NullValue
FromJSON, [NullValue] -> Value
[NullValue] -> Encoding
NullValue -> Bool
NullValue -> Value
NullValue -> Encoding
(NullValue -> Value)
-> (NullValue -> Encoding)
-> ([NullValue] -> Value)
-> ([NullValue] -> Encoding)
-> (NullValue -> Bool)
-> ToJSON NullValue
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: NullValue -> Value
toJSON :: NullValue -> Value
$ctoEncoding :: NullValue -> Encoding
toEncoding :: NullValue -> Encoding
$ctoJSONList :: [NullValue] -> Value
toJSONList :: [NullValue] -> Value
$ctoEncodingList :: [NullValue] -> Encoding
toEncodingList :: [NullValue] -> Encoding
$comitField :: NullValue -> Bool
omitField :: NullValue -> Bool
ToJSON)

newtype CutoffFrequency
  = CutoffFrequency Double
  deriving newtype (CutoffFrequency -> CutoffFrequency -> Bool
(CutoffFrequency -> CutoffFrequency -> Bool)
-> (CutoffFrequency -> CutoffFrequency -> Bool)
-> Eq CutoffFrequency
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CutoffFrequency -> CutoffFrequency -> Bool
== :: CutoffFrequency -> CutoffFrequency -> Bool
$c/= :: CutoffFrequency -> CutoffFrequency -> Bool
/= :: CutoffFrequency -> CutoffFrequency -> Bool
Eq, Int -> CutoffFrequency -> ShowS
[CutoffFrequency] -> ShowS
CutoffFrequency -> String
(Int -> CutoffFrequency -> ShowS)
-> (CutoffFrequency -> String)
-> ([CutoffFrequency] -> ShowS)
-> Show CutoffFrequency
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CutoffFrequency -> ShowS
showsPrec :: Int -> CutoffFrequency -> ShowS
$cshow :: CutoffFrequency -> String
show :: CutoffFrequency -> String
$cshowList :: [CutoffFrequency] -> ShowS
showList :: [CutoffFrequency] -> ShowS
Show, Maybe CutoffFrequency
Value -> Parser [CutoffFrequency]
Value -> Parser CutoffFrequency
(Value -> Parser CutoffFrequency)
-> (Value -> Parser [CutoffFrequency])
-> Maybe CutoffFrequency
-> FromJSON CutoffFrequency
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser CutoffFrequency
parseJSON :: Value -> Parser CutoffFrequency
$cparseJSONList :: Value -> Parser [CutoffFrequency]
parseJSONList :: Value -> Parser [CutoffFrequency]
$comittedField :: Maybe CutoffFrequency
omittedField :: Maybe CutoffFrequency
FromJSON, [CutoffFrequency] -> Value
[CutoffFrequency] -> Encoding
CutoffFrequency -> Bool
CutoffFrequency -> Value
CutoffFrequency -> Encoding
(CutoffFrequency -> Value)
-> (CutoffFrequency -> Encoding)
-> ([CutoffFrequency] -> Value)
-> ([CutoffFrequency] -> Encoding)
-> (CutoffFrequency -> Bool)
-> ToJSON CutoffFrequency
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: CutoffFrequency -> Value
toJSON :: CutoffFrequency -> Value
$ctoEncoding :: CutoffFrequency -> Encoding
toEncoding :: CutoffFrequency -> Encoding
$ctoJSONList :: [CutoffFrequency] -> Value
toJSONList :: [CutoffFrequency] -> Value
$ctoEncodingList :: [CutoffFrequency] -> Encoding
toEncodingList :: [CutoffFrequency] -> Encoding
$comitField :: CutoffFrequency -> Bool
omitField :: CutoffFrequency -> Bool
ToJSON)

newtype Analyzer
  = Analyzer Text
  deriving newtype (Analyzer -> Analyzer -> Bool
(Analyzer -> Analyzer -> Bool)
-> (Analyzer -> Analyzer -> Bool) -> Eq Analyzer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Analyzer -> Analyzer -> Bool
== :: Analyzer -> Analyzer -> Bool
$c/= :: Analyzer -> Analyzer -> Bool
/= :: Analyzer -> Analyzer -> Bool
Eq, Int -> Analyzer -> ShowS
[Analyzer] -> ShowS
Analyzer -> String
(Int -> Analyzer -> ShowS)
-> (Analyzer -> String) -> ([Analyzer] -> ShowS) -> Show Analyzer
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Analyzer -> ShowS
showsPrec :: Int -> Analyzer -> ShowS
$cshow :: Analyzer -> String
show :: Analyzer -> String
$cshowList :: [Analyzer] -> ShowS
showList :: [Analyzer] -> ShowS
Show, Maybe Analyzer
Value -> Parser [Analyzer]
Value -> Parser Analyzer
(Value -> Parser Analyzer)
-> (Value -> Parser [Analyzer])
-> Maybe Analyzer
-> FromJSON Analyzer
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser Analyzer
parseJSON :: Value -> Parser Analyzer
$cparseJSONList :: Value -> Parser [Analyzer]
parseJSONList :: Value -> Parser [Analyzer]
$comittedField :: Maybe Analyzer
omittedField :: Maybe Analyzer
FromJSON, [Analyzer] -> Value
[Analyzer] -> Encoding
Analyzer -> Bool
Analyzer -> Value
Analyzer -> Encoding
(Analyzer -> Value)
-> (Analyzer -> Encoding)
-> ([Analyzer] -> Value)
-> ([Analyzer] -> Encoding)
-> (Analyzer -> Bool)
-> ToJSON Analyzer
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: Analyzer -> Value
toJSON :: Analyzer -> Value
$ctoEncoding :: Analyzer -> Encoding
toEncoding :: Analyzer -> Encoding
$ctoJSONList :: [Analyzer] -> Value
toJSONList :: [Analyzer] -> Value
$ctoEncodingList :: [Analyzer] -> Encoding
toEncodingList :: [Analyzer] -> Encoding
$comitField :: Analyzer -> Bool
omitField :: Analyzer -> Bool
ToJSON)

newtype MaxExpansions
  = MaxExpansions Int
  deriving newtype (MaxExpansions -> MaxExpansions -> Bool
(MaxExpansions -> MaxExpansions -> Bool)
-> (MaxExpansions -> MaxExpansions -> Bool) -> Eq MaxExpansions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MaxExpansions -> MaxExpansions -> Bool
== :: MaxExpansions -> MaxExpansions -> Bool
$c/= :: MaxExpansions -> MaxExpansions -> Bool
/= :: MaxExpansions -> MaxExpansions -> Bool
Eq, Int -> MaxExpansions -> ShowS
[MaxExpansions] -> ShowS
MaxExpansions -> String
(Int -> MaxExpansions -> ShowS)
-> (MaxExpansions -> String)
-> ([MaxExpansions] -> ShowS)
-> Show MaxExpansions
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MaxExpansions -> ShowS
showsPrec :: Int -> MaxExpansions -> ShowS
$cshow :: MaxExpansions -> String
show :: MaxExpansions -> String
$cshowList :: [MaxExpansions] -> ShowS
showList :: [MaxExpansions] -> ShowS
Show, Maybe MaxExpansions
Value -> Parser [MaxExpansions]
Value -> Parser MaxExpansions
(Value -> Parser MaxExpansions)
-> (Value -> Parser [MaxExpansions])
-> Maybe MaxExpansions
-> FromJSON MaxExpansions
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser MaxExpansions
parseJSON :: Value -> Parser MaxExpansions
$cparseJSONList :: Value -> Parser [MaxExpansions]
parseJSONList :: Value -> Parser [MaxExpansions]
$comittedField :: Maybe MaxExpansions
omittedField :: Maybe MaxExpansions
FromJSON, [MaxExpansions] -> Value
[MaxExpansions] -> Encoding
MaxExpansions -> Bool
MaxExpansions -> Value
MaxExpansions -> Encoding
(MaxExpansions -> Value)
-> (MaxExpansions -> Encoding)
-> ([MaxExpansions] -> Value)
-> ([MaxExpansions] -> Encoding)
-> (MaxExpansions -> Bool)
-> ToJSON MaxExpansions
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: MaxExpansions -> Value
toJSON :: MaxExpansions -> Value
$ctoEncoding :: MaxExpansions -> Encoding
toEncoding :: MaxExpansions -> Encoding
$ctoJSONList :: [MaxExpansions] -> Value
toJSONList :: [MaxExpansions] -> Value
$ctoEncodingList :: [MaxExpansions] -> Encoding
toEncodingList :: [MaxExpansions] -> Encoding
$comitField :: MaxExpansions -> Bool
omitField :: MaxExpansions -> Bool
ToJSON)

-- | 'Lenient', if set to true, will cause format based failures to be
--   ignored. I don't know what the bloody default is, Elasticsearch
--   documentation didn't say what it was. Let me know if you figure it out.
newtype Lenient
  = Lenient Bool
  deriving newtype (Lenient -> Lenient -> Bool
(Lenient -> Lenient -> Bool)
-> (Lenient -> Lenient -> Bool) -> Eq Lenient
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Lenient -> Lenient -> Bool
== :: Lenient -> Lenient -> Bool
$c/= :: Lenient -> Lenient -> Bool
/= :: Lenient -> Lenient -> Bool
Eq, Int -> Lenient -> ShowS
[Lenient] -> ShowS
Lenient -> String
(Int -> Lenient -> ShowS)
-> (Lenient -> String) -> ([Lenient] -> ShowS) -> Show Lenient
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Lenient -> ShowS
showsPrec :: Int -> Lenient -> ShowS
$cshow :: Lenient -> String
show :: Lenient -> String
$cshowList :: [Lenient] -> ShowS
showList :: [Lenient] -> ShowS
Show, Maybe Lenient
Value -> Parser [Lenient]
Value -> Parser Lenient
(Value -> Parser Lenient)
-> (Value -> Parser [Lenient]) -> Maybe Lenient -> FromJSON Lenient
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser Lenient
parseJSON :: Value -> Parser Lenient
$cparseJSONList :: Value -> Parser [Lenient]
parseJSONList :: Value -> Parser [Lenient]
$comittedField :: Maybe Lenient
omittedField :: Maybe Lenient
FromJSON, [Lenient] -> Value
[Lenient] -> Encoding
Lenient -> Bool
Lenient -> Value
Lenient -> Encoding
(Lenient -> Value)
-> (Lenient -> Encoding)
-> ([Lenient] -> Value)
-> ([Lenient] -> Encoding)
-> (Lenient -> Bool)
-> ToJSON Lenient
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: Lenient -> Value
toJSON :: Lenient -> Value
$ctoEncoding :: Lenient -> Encoding
toEncoding :: Lenient -> Encoding
$ctoJSONList :: [Lenient] -> Value
toJSONList :: [Lenient] -> Value
$ctoEncodingList :: [Lenient] -> Encoding
toEncodingList :: [Lenient] -> Encoding
$comitField :: Lenient -> Bool
omitField :: Lenient -> Bool
ToJSON)

newtype Tiebreaker
  = Tiebreaker Double
  deriving newtype (Tiebreaker -> Tiebreaker -> Bool
(Tiebreaker -> Tiebreaker -> Bool)
-> (Tiebreaker -> Tiebreaker -> Bool) -> Eq Tiebreaker
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Tiebreaker -> Tiebreaker -> Bool
== :: Tiebreaker -> Tiebreaker -> Bool
$c/= :: Tiebreaker -> Tiebreaker -> Bool
/= :: Tiebreaker -> Tiebreaker -> Bool
Eq, Int -> Tiebreaker -> ShowS
[Tiebreaker] -> ShowS
Tiebreaker -> String
(Int -> Tiebreaker -> ShowS)
-> (Tiebreaker -> String)
-> ([Tiebreaker] -> ShowS)
-> Show Tiebreaker
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Tiebreaker -> ShowS
showsPrec :: Int -> Tiebreaker -> ShowS
$cshow :: Tiebreaker -> String
show :: Tiebreaker -> String
$cshowList :: [Tiebreaker] -> ShowS
showList :: [Tiebreaker] -> ShowS
Show, Maybe Tiebreaker
Value -> Parser [Tiebreaker]
Value -> Parser Tiebreaker
(Value -> Parser Tiebreaker)
-> (Value -> Parser [Tiebreaker])
-> Maybe Tiebreaker
-> FromJSON Tiebreaker
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser Tiebreaker
parseJSON :: Value -> Parser Tiebreaker
$cparseJSONList :: Value -> Parser [Tiebreaker]
parseJSONList :: Value -> Parser [Tiebreaker]
$comittedField :: Maybe Tiebreaker
omittedField :: Maybe Tiebreaker
FromJSON, [Tiebreaker] -> Value
[Tiebreaker] -> Encoding
Tiebreaker -> Bool
Tiebreaker -> Value
Tiebreaker -> Encoding
(Tiebreaker -> Value)
-> (Tiebreaker -> Encoding)
-> ([Tiebreaker] -> Value)
-> ([Tiebreaker] -> Encoding)
-> (Tiebreaker -> Bool)
-> ToJSON Tiebreaker
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: Tiebreaker -> Value
toJSON :: Tiebreaker -> Value
$ctoEncoding :: Tiebreaker -> Encoding
toEncoding :: Tiebreaker -> Encoding
$ctoJSONList :: [Tiebreaker] -> Value
toJSONList :: [Tiebreaker] -> Value
$ctoEncodingList :: [Tiebreaker] -> Encoding
toEncodingList :: [Tiebreaker] -> Encoding
$comitField :: Tiebreaker -> Bool
omitField :: Tiebreaker -> Bool
ToJSON)

-- | 'MinimumMatch' controls how many should clauses in the bool query should
--    match. Can be an absolute value (2) or a percentage (30%) or a
--    combination of both.
newtype MinimumMatch
  = MinimumMatch Int
  deriving newtype (MinimumMatch -> MinimumMatch -> Bool
(MinimumMatch -> MinimumMatch -> Bool)
-> (MinimumMatch -> MinimumMatch -> Bool) -> Eq MinimumMatch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MinimumMatch -> MinimumMatch -> Bool
== :: MinimumMatch -> MinimumMatch -> Bool
$c/= :: MinimumMatch -> MinimumMatch -> Bool
/= :: MinimumMatch -> MinimumMatch -> Bool
Eq, Int -> MinimumMatch -> ShowS
[MinimumMatch] -> ShowS
MinimumMatch -> String
(Int -> MinimumMatch -> ShowS)
-> (MinimumMatch -> String)
-> ([MinimumMatch] -> ShowS)
-> Show MinimumMatch
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MinimumMatch -> ShowS
showsPrec :: Int -> MinimumMatch -> ShowS
$cshow :: MinimumMatch -> String
show :: MinimumMatch -> String
$cshowList :: [MinimumMatch] -> ShowS
showList :: [MinimumMatch] -> ShowS
Show, Maybe MinimumMatch
Value -> Parser [MinimumMatch]
Value -> Parser MinimumMatch
(Value -> Parser MinimumMatch)
-> (Value -> Parser [MinimumMatch])
-> Maybe MinimumMatch
-> FromJSON MinimumMatch
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser MinimumMatch
parseJSON :: Value -> Parser MinimumMatch
$cparseJSONList :: Value -> Parser [MinimumMatch]
parseJSONList :: Value -> Parser [MinimumMatch]
$comittedField :: Maybe MinimumMatch
omittedField :: Maybe MinimumMatch
FromJSON, [MinimumMatch] -> Value
[MinimumMatch] -> Encoding
MinimumMatch -> Bool
MinimumMatch -> Value
MinimumMatch -> Encoding
(MinimumMatch -> Value)
-> (MinimumMatch -> Encoding)
-> ([MinimumMatch] -> Value)
-> ([MinimumMatch] -> Encoding)
-> (MinimumMatch -> Bool)
-> ToJSON MinimumMatch
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: MinimumMatch -> Value
toJSON :: MinimumMatch -> Value
$ctoEncoding :: MinimumMatch -> Encoding
toEncoding :: MinimumMatch -> Encoding
$ctoJSONList :: [MinimumMatch] -> Value
toJSONList :: [MinimumMatch] -> Value
$ctoEncodingList :: [MinimumMatch] -> Encoding
toEncodingList :: [MinimumMatch] -> Encoding
$comitField :: MinimumMatch -> Bool
omitField :: MinimumMatch -> Bool
ToJSON)

newtype DisableCoord
  = DisableCoord Bool
  deriving newtype (DisableCoord -> DisableCoord -> Bool
(DisableCoord -> DisableCoord -> Bool)
-> (DisableCoord -> DisableCoord -> Bool) -> Eq DisableCoord
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DisableCoord -> DisableCoord -> Bool
== :: DisableCoord -> DisableCoord -> Bool
$c/= :: DisableCoord -> DisableCoord -> Bool
/= :: DisableCoord -> DisableCoord -> Bool
Eq, Int -> DisableCoord -> ShowS
[DisableCoord] -> ShowS
DisableCoord -> String
(Int -> DisableCoord -> ShowS)
-> (DisableCoord -> String)
-> ([DisableCoord] -> ShowS)
-> Show DisableCoord
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DisableCoord -> ShowS
showsPrec :: Int -> DisableCoord -> ShowS
$cshow :: DisableCoord -> String
show :: DisableCoord -> String
$cshowList :: [DisableCoord] -> ShowS
showList :: [DisableCoord] -> ShowS
Show, Maybe DisableCoord
Value -> Parser [DisableCoord]
Value -> Parser DisableCoord
(Value -> Parser DisableCoord)
-> (Value -> Parser [DisableCoord])
-> Maybe DisableCoord
-> FromJSON DisableCoord
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser DisableCoord
parseJSON :: Value -> Parser DisableCoord
$cparseJSONList :: Value -> Parser [DisableCoord]
parseJSONList :: Value -> Parser [DisableCoord]
$comittedField :: Maybe DisableCoord
omittedField :: Maybe DisableCoord
FromJSON, [DisableCoord] -> Value
[DisableCoord] -> Encoding
DisableCoord -> Bool
DisableCoord -> Value
DisableCoord -> Encoding
(DisableCoord -> Value)
-> (DisableCoord -> Encoding)
-> ([DisableCoord] -> Value)
-> ([DisableCoord] -> Encoding)
-> (DisableCoord -> Bool)
-> ToJSON DisableCoord
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: DisableCoord -> Value
toJSON :: DisableCoord -> Value
$ctoEncoding :: DisableCoord -> Encoding
toEncoding :: DisableCoord -> Encoding
$ctoJSONList :: [DisableCoord] -> Value
toJSONList :: [DisableCoord] -> Value
$ctoEncodingList :: [DisableCoord] -> Encoding
toEncodingList :: [DisableCoord] -> Encoding
$comitField :: DisableCoord -> Bool
omitField :: DisableCoord -> Bool
ToJSON)

newtype IgnoreTermFrequency
  = IgnoreTermFrequency Bool
  deriving newtype (IgnoreTermFrequency -> IgnoreTermFrequency -> Bool
(IgnoreTermFrequency -> IgnoreTermFrequency -> Bool)
-> (IgnoreTermFrequency -> IgnoreTermFrequency -> Bool)
-> Eq IgnoreTermFrequency
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IgnoreTermFrequency -> IgnoreTermFrequency -> Bool
== :: IgnoreTermFrequency -> IgnoreTermFrequency -> Bool
$c/= :: IgnoreTermFrequency -> IgnoreTermFrequency -> Bool
/= :: IgnoreTermFrequency -> IgnoreTermFrequency -> Bool
Eq, Int -> IgnoreTermFrequency -> ShowS
[IgnoreTermFrequency] -> ShowS
IgnoreTermFrequency -> String
(Int -> IgnoreTermFrequency -> ShowS)
-> (IgnoreTermFrequency -> String)
-> ([IgnoreTermFrequency] -> ShowS)
-> Show IgnoreTermFrequency
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IgnoreTermFrequency -> ShowS
showsPrec :: Int -> IgnoreTermFrequency -> ShowS
$cshow :: IgnoreTermFrequency -> String
show :: IgnoreTermFrequency -> String
$cshowList :: [IgnoreTermFrequency] -> ShowS
showList :: [IgnoreTermFrequency] -> ShowS
Show, Maybe IgnoreTermFrequency
Value -> Parser [IgnoreTermFrequency]
Value -> Parser IgnoreTermFrequency
(Value -> Parser IgnoreTermFrequency)
-> (Value -> Parser [IgnoreTermFrequency])
-> Maybe IgnoreTermFrequency
-> FromJSON IgnoreTermFrequency
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser IgnoreTermFrequency
parseJSON :: Value -> Parser IgnoreTermFrequency
$cparseJSONList :: Value -> Parser [IgnoreTermFrequency]
parseJSONList :: Value -> Parser [IgnoreTermFrequency]
$comittedField :: Maybe IgnoreTermFrequency
omittedField :: Maybe IgnoreTermFrequency
FromJSON, [IgnoreTermFrequency] -> Value
[IgnoreTermFrequency] -> Encoding
IgnoreTermFrequency -> Bool
IgnoreTermFrequency -> Value
IgnoreTermFrequency -> Encoding
(IgnoreTermFrequency -> Value)
-> (IgnoreTermFrequency -> Encoding)
-> ([IgnoreTermFrequency] -> Value)
-> ([IgnoreTermFrequency] -> Encoding)
-> (IgnoreTermFrequency -> Bool)
-> ToJSON IgnoreTermFrequency
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: IgnoreTermFrequency -> Value
toJSON :: IgnoreTermFrequency -> Value
$ctoEncoding :: IgnoreTermFrequency -> Encoding
toEncoding :: IgnoreTermFrequency -> Encoding
$ctoJSONList :: [IgnoreTermFrequency] -> Value
toJSONList :: [IgnoreTermFrequency] -> Value
$ctoEncodingList :: [IgnoreTermFrequency] -> Encoding
toEncodingList :: [IgnoreTermFrequency] -> Encoding
$comitField :: IgnoreTermFrequency -> Bool
omitField :: IgnoreTermFrequency -> Bool
ToJSON)

newtype MinimumTermFrequency
  = MinimumTermFrequency Int
  deriving newtype (MinimumTermFrequency -> MinimumTermFrequency -> Bool
(MinimumTermFrequency -> MinimumTermFrequency -> Bool)
-> (MinimumTermFrequency -> MinimumTermFrequency -> Bool)
-> Eq MinimumTermFrequency
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MinimumTermFrequency -> MinimumTermFrequency -> Bool
== :: MinimumTermFrequency -> MinimumTermFrequency -> Bool
$c/= :: MinimumTermFrequency -> MinimumTermFrequency -> Bool
/= :: MinimumTermFrequency -> MinimumTermFrequency -> Bool
Eq, Int -> MinimumTermFrequency -> ShowS
[MinimumTermFrequency] -> ShowS
MinimumTermFrequency -> String
(Int -> MinimumTermFrequency -> ShowS)
-> (MinimumTermFrequency -> String)
-> ([MinimumTermFrequency] -> ShowS)
-> Show MinimumTermFrequency
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MinimumTermFrequency -> ShowS
showsPrec :: Int -> MinimumTermFrequency -> ShowS
$cshow :: MinimumTermFrequency -> String
show :: MinimumTermFrequency -> String
$cshowList :: [MinimumTermFrequency] -> ShowS
showList :: [MinimumTermFrequency] -> ShowS
Show, Maybe MinimumTermFrequency
Value -> Parser [MinimumTermFrequency]
Value -> Parser MinimumTermFrequency
(Value -> Parser MinimumTermFrequency)
-> (Value -> Parser [MinimumTermFrequency])
-> Maybe MinimumTermFrequency
-> FromJSON MinimumTermFrequency
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser MinimumTermFrequency
parseJSON :: Value -> Parser MinimumTermFrequency
$cparseJSONList :: Value -> Parser [MinimumTermFrequency]
parseJSONList :: Value -> Parser [MinimumTermFrequency]
$comittedField :: Maybe MinimumTermFrequency
omittedField :: Maybe MinimumTermFrequency
FromJSON, [MinimumTermFrequency] -> Value
[MinimumTermFrequency] -> Encoding
MinimumTermFrequency -> Bool
MinimumTermFrequency -> Value
MinimumTermFrequency -> Encoding
(MinimumTermFrequency -> Value)
-> (MinimumTermFrequency -> Encoding)
-> ([MinimumTermFrequency] -> Value)
-> ([MinimumTermFrequency] -> Encoding)
-> (MinimumTermFrequency -> Bool)
-> ToJSON MinimumTermFrequency
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: MinimumTermFrequency -> Value
toJSON :: MinimumTermFrequency -> Value
$ctoEncoding :: MinimumTermFrequency -> Encoding
toEncoding :: MinimumTermFrequency -> Encoding
$ctoJSONList :: [MinimumTermFrequency] -> Value
toJSONList :: [MinimumTermFrequency] -> Value
$ctoEncodingList :: [MinimumTermFrequency] -> Encoding
toEncodingList :: [MinimumTermFrequency] -> Encoding
$comitField :: MinimumTermFrequency -> Bool
omitField :: MinimumTermFrequency -> Bool
ToJSON)

newtype MaxQueryTerms
  = MaxQueryTerms Int
  deriving newtype (MaxQueryTerms -> MaxQueryTerms -> Bool
(MaxQueryTerms -> MaxQueryTerms -> Bool)
-> (MaxQueryTerms -> MaxQueryTerms -> Bool) -> Eq MaxQueryTerms
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MaxQueryTerms -> MaxQueryTerms -> Bool
== :: MaxQueryTerms -> MaxQueryTerms -> Bool
$c/= :: MaxQueryTerms -> MaxQueryTerms -> Bool
/= :: MaxQueryTerms -> MaxQueryTerms -> Bool
Eq, Int -> MaxQueryTerms -> ShowS
[MaxQueryTerms] -> ShowS
MaxQueryTerms -> String
(Int -> MaxQueryTerms -> ShowS)
-> (MaxQueryTerms -> String)
-> ([MaxQueryTerms] -> ShowS)
-> Show MaxQueryTerms
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MaxQueryTerms -> ShowS
showsPrec :: Int -> MaxQueryTerms -> ShowS
$cshow :: MaxQueryTerms -> String
show :: MaxQueryTerms -> String
$cshowList :: [MaxQueryTerms] -> ShowS
showList :: [MaxQueryTerms] -> ShowS
Show, Maybe MaxQueryTerms
Value -> Parser [MaxQueryTerms]
Value -> Parser MaxQueryTerms
(Value -> Parser MaxQueryTerms)
-> (Value -> Parser [MaxQueryTerms])
-> Maybe MaxQueryTerms
-> FromJSON MaxQueryTerms
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser MaxQueryTerms
parseJSON :: Value -> Parser MaxQueryTerms
$cparseJSONList :: Value -> Parser [MaxQueryTerms]
parseJSONList :: Value -> Parser [MaxQueryTerms]
$comittedField :: Maybe MaxQueryTerms
omittedField :: Maybe MaxQueryTerms
FromJSON, [MaxQueryTerms] -> Value
[MaxQueryTerms] -> Encoding
MaxQueryTerms -> Bool
MaxQueryTerms -> Value
MaxQueryTerms -> Encoding
(MaxQueryTerms -> Value)
-> (MaxQueryTerms -> Encoding)
-> ([MaxQueryTerms] -> Value)
-> ([MaxQueryTerms] -> Encoding)
-> (MaxQueryTerms -> Bool)
-> ToJSON MaxQueryTerms
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: MaxQueryTerms -> Value
toJSON :: MaxQueryTerms -> Value
$ctoEncoding :: MaxQueryTerms -> Encoding
toEncoding :: MaxQueryTerms -> Encoding
$ctoJSONList :: [MaxQueryTerms] -> Value
toJSONList :: [MaxQueryTerms] -> Value
$ctoEncodingList :: [MaxQueryTerms] -> Encoding
toEncodingList :: [MaxQueryTerms] -> Encoding
$comitField :: MaxQueryTerms -> Bool
omitField :: MaxQueryTerms -> Bool
ToJSON)

-- | 'PrefixLength' is the prefix length used in queries, defaults to 0.
newtype PrefixLength
  = PrefixLength Int
  deriving newtype (PrefixLength -> PrefixLength -> Bool
(PrefixLength -> PrefixLength -> Bool)
-> (PrefixLength -> PrefixLength -> Bool) -> Eq PrefixLength
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PrefixLength -> PrefixLength -> Bool
== :: PrefixLength -> PrefixLength -> Bool
$c/= :: PrefixLength -> PrefixLength -> Bool
/= :: PrefixLength -> PrefixLength -> Bool
Eq, Int -> PrefixLength -> ShowS
[PrefixLength] -> ShowS
PrefixLength -> String
(Int -> PrefixLength -> ShowS)
-> (PrefixLength -> String)
-> ([PrefixLength] -> ShowS)
-> Show PrefixLength
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PrefixLength -> ShowS
showsPrec :: Int -> PrefixLength -> ShowS
$cshow :: PrefixLength -> String
show :: PrefixLength -> String
$cshowList :: [PrefixLength] -> ShowS
showList :: [PrefixLength] -> ShowS
Show, Maybe PrefixLength
Value -> Parser [PrefixLength]
Value -> Parser PrefixLength
(Value -> Parser PrefixLength)
-> (Value -> Parser [PrefixLength])
-> Maybe PrefixLength
-> FromJSON PrefixLength
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser PrefixLength
parseJSON :: Value -> Parser PrefixLength
$cparseJSONList :: Value -> Parser [PrefixLength]
parseJSONList :: Value -> Parser [PrefixLength]
$comittedField :: Maybe PrefixLength
omittedField :: Maybe PrefixLength
FromJSON, [PrefixLength] -> Value
[PrefixLength] -> Encoding
PrefixLength -> Bool
PrefixLength -> Value
PrefixLength -> Encoding
(PrefixLength -> Value)
-> (PrefixLength -> Encoding)
-> ([PrefixLength] -> Value)
-> ([PrefixLength] -> Encoding)
-> (PrefixLength -> Bool)
-> ToJSON PrefixLength
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: PrefixLength -> Value
toJSON :: PrefixLength -> Value
$ctoEncoding :: PrefixLength -> Encoding
toEncoding :: PrefixLength -> Encoding
$ctoJSONList :: [PrefixLength] -> Value
toJSONList :: [PrefixLength] -> Value
$ctoEncodingList :: [PrefixLength] -> Encoding
toEncodingList :: [PrefixLength] -> Encoding
$comitField :: PrefixLength -> Bool
omitField :: PrefixLength -> Bool
ToJSON)

newtype PercentMatch
  = PercentMatch Double
  deriving newtype (PercentMatch -> PercentMatch -> Bool
(PercentMatch -> PercentMatch -> Bool)
-> (PercentMatch -> PercentMatch -> Bool) -> Eq PercentMatch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PercentMatch -> PercentMatch -> Bool
== :: PercentMatch -> PercentMatch -> Bool
$c/= :: PercentMatch -> PercentMatch -> Bool
/= :: PercentMatch -> PercentMatch -> Bool
Eq, Int -> PercentMatch -> ShowS
[PercentMatch] -> ShowS
PercentMatch -> String
(Int -> PercentMatch -> ShowS)
-> (PercentMatch -> String)
-> ([PercentMatch] -> ShowS)
-> Show PercentMatch
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PercentMatch -> ShowS
showsPrec :: Int -> PercentMatch -> ShowS
$cshow :: PercentMatch -> String
show :: PercentMatch -> String
$cshowList :: [PercentMatch] -> ShowS
showList :: [PercentMatch] -> ShowS
Show, Maybe PercentMatch
Value -> Parser [PercentMatch]
Value -> Parser PercentMatch
(Value -> Parser PercentMatch)
-> (Value -> Parser [PercentMatch])
-> Maybe PercentMatch
-> FromJSON PercentMatch
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser PercentMatch
parseJSON :: Value -> Parser PercentMatch
$cparseJSONList :: Value -> Parser [PercentMatch]
parseJSONList :: Value -> Parser [PercentMatch]
$comittedField :: Maybe PercentMatch
omittedField :: Maybe PercentMatch
FromJSON, [PercentMatch] -> Value
[PercentMatch] -> Encoding
PercentMatch -> Bool
PercentMatch -> Value
PercentMatch -> Encoding
(PercentMatch -> Value)
-> (PercentMatch -> Encoding)
-> ([PercentMatch] -> Value)
-> ([PercentMatch] -> Encoding)
-> (PercentMatch -> Bool)
-> ToJSON PercentMatch
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: PercentMatch -> Value
toJSON :: PercentMatch -> Value
$ctoEncoding :: PercentMatch -> Encoding
toEncoding :: PercentMatch -> Encoding
$ctoJSONList :: [PercentMatch] -> Value
toJSONList :: [PercentMatch] -> Value
$ctoEncodingList :: [PercentMatch] -> Encoding
toEncodingList :: [PercentMatch] -> Encoding
$comitField :: PercentMatch -> Bool
omitField :: PercentMatch -> Bool
ToJSON)

newtype StopWord
  = StopWord Text
  deriving newtype (StopWord -> StopWord -> Bool
(StopWord -> StopWord -> Bool)
-> (StopWord -> StopWord -> Bool) -> Eq StopWord
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StopWord -> StopWord -> Bool
== :: StopWord -> StopWord -> Bool
$c/= :: StopWord -> StopWord -> Bool
/= :: StopWord -> StopWord -> Bool
Eq, Int -> StopWord -> ShowS
[StopWord] -> ShowS
StopWord -> String
(Int -> StopWord -> ShowS)
-> (StopWord -> String) -> ([StopWord] -> ShowS) -> Show StopWord
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StopWord -> ShowS
showsPrec :: Int -> StopWord -> ShowS
$cshow :: StopWord -> String
show :: StopWord -> String
$cshowList :: [StopWord] -> ShowS
showList :: [StopWord] -> ShowS
Show, Maybe StopWord
Value -> Parser [StopWord]
Value -> Parser StopWord
(Value -> Parser StopWord)
-> (Value -> Parser [StopWord])
-> Maybe StopWord
-> FromJSON StopWord
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser StopWord
parseJSON :: Value -> Parser StopWord
$cparseJSONList :: Value -> Parser [StopWord]
parseJSONList :: Value -> Parser [StopWord]
$comittedField :: Maybe StopWord
omittedField :: Maybe StopWord
FromJSON, [StopWord] -> Value
[StopWord] -> Encoding
StopWord -> Bool
StopWord -> Value
StopWord -> Encoding
(StopWord -> Value)
-> (StopWord -> Encoding)
-> ([StopWord] -> Value)
-> ([StopWord] -> Encoding)
-> (StopWord -> Bool)
-> ToJSON StopWord
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: StopWord -> Value
toJSON :: StopWord -> Value
$ctoEncoding :: StopWord -> Encoding
toEncoding :: StopWord -> Encoding
$ctoJSONList :: [StopWord] -> Value
toJSONList :: [StopWord] -> Value
$ctoEncodingList :: [StopWord] -> Encoding
toEncodingList :: [StopWord] -> Encoding
$comitField :: StopWord -> Bool
omitField :: StopWord -> Bool
ToJSON)

newtype QueryPath
  = QueryPath Text
  deriving newtype (QueryPath -> QueryPath -> Bool
(QueryPath -> QueryPath -> Bool)
-> (QueryPath -> QueryPath -> Bool) -> Eq QueryPath
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QueryPath -> QueryPath -> Bool
== :: QueryPath -> QueryPath -> Bool
$c/= :: QueryPath -> QueryPath -> Bool
/= :: QueryPath -> QueryPath -> Bool
Eq, Int -> QueryPath -> ShowS
[QueryPath] -> ShowS
QueryPath -> String
(Int -> QueryPath -> ShowS)
-> (QueryPath -> String)
-> ([QueryPath] -> ShowS)
-> Show QueryPath
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> QueryPath -> ShowS
showsPrec :: Int -> QueryPath -> ShowS
$cshow :: QueryPath -> String
show :: QueryPath -> String
$cshowList :: [QueryPath] -> ShowS
showList :: [QueryPath] -> ShowS
Show, Maybe QueryPath
Value -> Parser [QueryPath]
Value -> Parser QueryPath
(Value -> Parser QueryPath)
-> (Value -> Parser [QueryPath])
-> Maybe QueryPath
-> FromJSON QueryPath
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser QueryPath
parseJSON :: Value -> Parser QueryPath
$cparseJSONList :: Value -> Parser [QueryPath]
parseJSONList :: Value -> Parser [QueryPath]
$comittedField :: Maybe QueryPath
omittedField :: Maybe QueryPath
FromJSON, [QueryPath] -> Value
[QueryPath] -> Encoding
QueryPath -> Bool
QueryPath -> Value
QueryPath -> Encoding
(QueryPath -> Value)
-> (QueryPath -> Encoding)
-> ([QueryPath] -> Value)
-> ([QueryPath] -> Encoding)
-> (QueryPath -> Bool)
-> ToJSON QueryPath
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: QueryPath -> Value
toJSON :: QueryPath -> Value
$ctoEncoding :: QueryPath -> Encoding
toEncoding :: QueryPath -> Encoding
$ctoJSONList :: [QueryPath] -> Value
toJSONList :: [QueryPath] -> Value
$ctoEncodingList :: [QueryPath] -> Encoding
toEncodingList :: [QueryPath] -> Encoding
$comitField :: QueryPath -> Bool
omitField :: QueryPath -> Bool
ToJSON)

-- | Allowing a wildcard at the beginning of a word (eg "*ing") is particularly
--   heavy, because all terms in the index need to be examined, just in case
--   they match. Leading wildcards can be disabled by setting
--   'AllowLeadingWildcard' to false.
newtype AllowLeadingWildcard
  = AllowLeadingWildcard Bool
  deriving newtype (AllowLeadingWildcard -> AllowLeadingWildcard -> Bool
(AllowLeadingWildcard -> AllowLeadingWildcard -> Bool)
-> (AllowLeadingWildcard -> AllowLeadingWildcard -> Bool)
-> Eq AllowLeadingWildcard
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AllowLeadingWildcard -> AllowLeadingWildcard -> Bool
== :: AllowLeadingWildcard -> AllowLeadingWildcard -> Bool
$c/= :: AllowLeadingWildcard -> AllowLeadingWildcard -> Bool
/= :: AllowLeadingWildcard -> AllowLeadingWildcard -> Bool
Eq, Int -> AllowLeadingWildcard -> ShowS
[AllowLeadingWildcard] -> ShowS
AllowLeadingWildcard -> String
(Int -> AllowLeadingWildcard -> ShowS)
-> (AllowLeadingWildcard -> String)
-> ([AllowLeadingWildcard] -> ShowS)
-> Show AllowLeadingWildcard
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AllowLeadingWildcard -> ShowS
showsPrec :: Int -> AllowLeadingWildcard -> ShowS
$cshow :: AllowLeadingWildcard -> String
show :: AllowLeadingWildcard -> String
$cshowList :: [AllowLeadingWildcard] -> ShowS
showList :: [AllowLeadingWildcard] -> ShowS
Show, Maybe AllowLeadingWildcard
Value -> Parser [AllowLeadingWildcard]
Value -> Parser AllowLeadingWildcard
(Value -> Parser AllowLeadingWildcard)
-> (Value -> Parser [AllowLeadingWildcard])
-> Maybe AllowLeadingWildcard
-> FromJSON AllowLeadingWildcard
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser AllowLeadingWildcard
parseJSON :: Value -> Parser AllowLeadingWildcard
$cparseJSONList :: Value -> Parser [AllowLeadingWildcard]
parseJSONList :: Value -> Parser [AllowLeadingWildcard]
$comittedField :: Maybe AllowLeadingWildcard
omittedField :: Maybe AllowLeadingWildcard
FromJSON, [AllowLeadingWildcard] -> Value
[AllowLeadingWildcard] -> Encoding
AllowLeadingWildcard -> Bool
AllowLeadingWildcard -> Value
AllowLeadingWildcard -> Encoding
(AllowLeadingWildcard -> Value)
-> (AllowLeadingWildcard -> Encoding)
-> ([AllowLeadingWildcard] -> Value)
-> ([AllowLeadingWildcard] -> Encoding)
-> (AllowLeadingWildcard -> Bool)
-> ToJSON AllowLeadingWildcard
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: AllowLeadingWildcard -> Value
toJSON :: AllowLeadingWildcard -> Value
$ctoEncoding :: AllowLeadingWildcard -> Encoding
toEncoding :: AllowLeadingWildcard -> Encoding
$ctoJSONList :: [AllowLeadingWildcard] -> Value
toJSONList :: [AllowLeadingWildcard] -> Value
$ctoEncodingList :: [AllowLeadingWildcard] -> Encoding
toEncodingList :: [AllowLeadingWildcard] -> Encoding
$comitField :: AllowLeadingWildcard -> Bool
omitField :: AllowLeadingWildcard -> Bool
ToJSON)

newtype LowercaseExpanded
  = LowercaseExpanded Bool
  deriving newtype (LowercaseExpanded -> LowercaseExpanded -> Bool
(LowercaseExpanded -> LowercaseExpanded -> Bool)
-> (LowercaseExpanded -> LowercaseExpanded -> Bool)
-> Eq LowercaseExpanded
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LowercaseExpanded -> LowercaseExpanded -> Bool
== :: LowercaseExpanded -> LowercaseExpanded -> Bool
$c/= :: LowercaseExpanded -> LowercaseExpanded -> Bool
/= :: LowercaseExpanded -> LowercaseExpanded -> Bool
Eq, Int -> LowercaseExpanded -> ShowS
[LowercaseExpanded] -> ShowS
LowercaseExpanded -> String
(Int -> LowercaseExpanded -> ShowS)
-> (LowercaseExpanded -> String)
-> ([LowercaseExpanded] -> ShowS)
-> Show LowercaseExpanded
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LowercaseExpanded -> ShowS
showsPrec :: Int -> LowercaseExpanded -> ShowS
$cshow :: LowercaseExpanded -> String
show :: LowercaseExpanded -> String
$cshowList :: [LowercaseExpanded] -> ShowS
showList :: [LowercaseExpanded] -> ShowS
Show, Maybe LowercaseExpanded
Value -> Parser [LowercaseExpanded]
Value -> Parser LowercaseExpanded
(Value -> Parser LowercaseExpanded)
-> (Value -> Parser [LowercaseExpanded])
-> Maybe LowercaseExpanded
-> FromJSON LowercaseExpanded
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser LowercaseExpanded
parseJSON :: Value -> Parser LowercaseExpanded
$cparseJSONList :: Value -> Parser [LowercaseExpanded]
parseJSONList :: Value -> Parser [LowercaseExpanded]
$comittedField :: Maybe LowercaseExpanded
omittedField :: Maybe LowercaseExpanded
FromJSON, [LowercaseExpanded] -> Value
[LowercaseExpanded] -> Encoding
LowercaseExpanded -> Bool
LowercaseExpanded -> Value
LowercaseExpanded -> Encoding
(LowercaseExpanded -> Value)
-> (LowercaseExpanded -> Encoding)
-> ([LowercaseExpanded] -> Value)
-> ([LowercaseExpanded] -> Encoding)
-> (LowercaseExpanded -> Bool)
-> ToJSON LowercaseExpanded
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: LowercaseExpanded -> Value
toJSON :: LowercaseExpanded -> Value
$ctoEncoding :: LowercaseExpanded -> Encoding
toEncoding :: LowercaseExpanded -> Encoding
$ctoJSONList :: [LowercaseExpanded] -> Value
toJSONList :: [LowercaseExpanded] -> Value
$ctoEncodingList :: [LowercaseExpanded] -> Encoding
toEncodingList :: [LowercaseExpanded] -> Encoding
$comitField :: LowercaseExpanded -> Bool
omitField :: LowercaseExpanded -> Bool
ToJSON)

newtype EnablePositionIncrements
  = EnablePositionIncrements Bool
  deriving newtype (EnablePositionIncrements -> EnablePositionIncrements -> Bool
(EnablePositionIncrements -> EnablePositionIncrements -> Bool)
-> (EnablePositionIncrements -> EnablePositionIncrements -> Bool)
-> Eq EnablePositionIncrements
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EnablePositionIncrements -> EnablePositionIncrements -> Bool
== :: EnablePositionIncrements -> EnablePositionIncrements -> Bool
$c/= :: EnablePositionIncrements -> EnablePositionIncrements -> Bool
/= :: EnablePositionIncrements -> EnablePositionIncrements -> Bool
Eq, Int -> EnablePositionIncrements -> ShowS
[EnablePositionIncrements] -> ShowS
EnablePositionIncrements -> String
(Int -> EnablePositionIncrements -> ShowS)
-> (EnablePositionIncrements -> String)
-> ([EnablePositionIncrements] -> ShowS)
-> Show EnablePositionIncrements
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EnablePositionIncrements -> ShowS
showsPrec :: Int -> EnablePositionIncrements -> ShowS
$cshow :: EnablePositionIncrements -> String
show :: EnablePositionIncrements -> String
$cshowList :: [EnablePositionIncrements] -> ShowS
showList :: [EnablePositionIncrements] -> ShowS
Show, Maybe EnablePositionIncrements
Value -> Parser [EnablePositionIncrements]
Value -> Parser EnablePositionIncrements
(Value -> Parser EnablePositionIncrements)
-> (Value -> Parser [EnablePositionIncrements])
-> Maybe EnablePositionIncrements
-> FromJSON EnablePositionIncrements
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser EnablePositionIncrements
parseJSON :: Value -> Parser EnablePositionIncrements
$cparseJSONList :: Value -> Parser [EnablePositionIncrements]
parseJSONList :: Value -> Parser [EnablePositionIncrements]
$comittedField :: Maybe EnablePositionIncrements
omittedField :: Maybe EnablePositionIncrements
FromJSON, [EnablePositionIncrements] -> Value
[EnablePositionIncrements] -> Encoding
EnablePositionIncrements -> Bool
EnablePositionIncrements -> Value
EnablePositionIncrements -> Encoding
(EnablePositionIncrements -> Value)
-> (EnablePositionIncrements -> Encoding)
-> ([EnablePositionIncrements] -> Value)
-> ([EnablePositionIncrements] -> Encoding)
-> (EnablePositionIncrements -> Bool)
-> ToJSON EnablePositionIncrements
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: EnablePositionIncrements -> Value
toJSON :: EnablePositionIncrements -> Value
$ctoEncoding :: EnablePositionIncrements -> Encoding
toEncoding :: EnablePositionIncrements -> Encoding
$ctoJSONList :: [EnablePositionIncrements] -> Value
toJSONList :: [EnablePositionIncrements] -> Value
$ctoEncodingList :: [EnablePositionIncrements] -> Encoding
toEncodingList :: [EnablePositionIncrements] -> Encoding
$comitField :: EnablePositionIncrements -> Bool
omitField :: EnablePositionIncrements -> Bool
ToJSON)

-- | By default, wildcard terms in a query are not analyzed.
--   Setting 'AnalyzeWildcard' to true enables best-effort analysis.
newtype AnalyzeWildcard = AnalyzeWildcard Bool deriving newtype (AnalyzeWildcard -> AnalyzeWildcard -> Bool
(AnalyzeWildcard -> AnalyzeWildcard -> Bool)
-> (AnalyzeWildcard -> AnalyzeWildcard -> Bool)
-> Eq AnalyzeWildcard
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AnalyzeWildcard -> AnalyzeWildcard -> Bool
== :: AnalyzeWildcard -> AnalyzeWildcard -> Bool
$c/= :: AnalyzeWildcard -> AnalyzeWildcard -> Bool
/= :: AnalyzeWildcard -> AnalyzeWildcard -> Bool
Eq, Int -> AnalyzeWildcard -> ShowS
[AnalyzeWildcard] -> ShowS
AnalyzeWildcard -> String
(Int -> AnalyzeWildcard -> ShowS)
-> (AnalyzeWildcard -> String)
-> ([AnalyzeWildcard] -> ShowS)
-> Show AnalyzeWildcard
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AnalyzeWildcard -> ShowS
showsPrec :: Int -> AnalyzeWildcard -> ShowS
$cshow :: AnalyzeWildcard -> String
show :: AnalyzeWildcard -> String
$cshowList :: [AnalyzeWildcard] -> ShowS
showList :: [AnalyzeWildcard] -> ShowS
Show, Maybe AnalyzeWildcard
Value -> Parser [AnalyzeWildcard]
Value -> Parser AnalyzeWildcard
(Value -> Parser AnalyzeWildcard)
-> (Value -> Parser [AnalyzeWildcard])
-> Maybe AnalyzeWildcard
-> FromJSON AnalyzeWildcard
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser AnalyzeWildcard
parseJSON :: Value -> Parser AnalyzeWildcard
$cparseJSONList :: Value -> Parser [AnalyzeWildcard]
parseJSONList :: Value -> Parser [AnalyzeWildcard]
$comittedField :: Maybe AnalyzeWildcard
omittedField :: Maybe AnalyzeWildcard
FromJSON, [AnalyzeWildcard] -> Value
[AnalyzeWildcard] -> Encoding
AnalyzeWildcard -> Bool
AnalyzeWildcard -> Value
AnalyzeWildcard -> Encoding
(AnalyzeWildcard -> Value)
-> (AnalyzeWildcard -> Encoding)
-> ([AnalyzeWildcard] -> Value)
-> ([AnalyzeWildcard] -> Encoding)
-> (AnalyzeWildcard -> Bool)
-> ToJSON AnalyzeWildcard
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: AnalyzeWildcard -> Value
toJSON :: AnalyzeWildcard -> Value
$ctoEncoding :: AnalyzeWildcard -> Encoding
toEncoding :: AnalyzeWildcard -> Encoding
$ctoJSONList :: [AnalyzeWildcard] -> Value
toJSONList :: [AnalyzeWildcard] -> Value
$ctoEncodingList :: [AnalyzeWildcard] -> Encoding
toEncodingList :: [AnalyzeWildcard] -> Encoding
$comitField :: AnalyzeWildcard -> Bool
omitField :: AnalyzeWildcard -> Bool
ToJSON)

-- | 'GeneratePhraseQueries' defaults to false.
newtype GeneratePhraseQueries
  = GeneratePhraseQueries Bool
  deriving newtype (GeneratePhraseQueries -> GeneratePhraseQueries -> Bool
(GeneratePhraseQueries -> GeneratePhraseQueries -> Bool)
-> (GeneratePhraseQueries -> GeneratePhraseQueries -> Bool)
-> Eq GeneratePhraseQueries
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GeneratePhraseQueries -> GeneratePhraseQueries -> Bool
== :: GeneratePhraseQueries -> GeneratePhraseQueries -> Bool
$c/= :: GeneratePhraseQueries -> GeneratePhraseQueries -> Bool
/= :: GeneratePhraseQueries -> GeneratePhraseQueries -> Bool
Eq, Int -> GeneratePhraseQueries -> ShowS
[GeneratePhraseQueries] -> ShowS
GeneratePhraseQueries -> String
(Int -> GeneratePhraseQueries -> ShowS)
-> (GeneratePhraseQueries -> String)
-> ([GeneratePhraseQueries] -> ShowS)
-> Show GeneratePhraseQueries
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GeneratePhraseQueries -> ShowS
showsPrec :: Int -> GeneratePhraseQueries -> ShowS
$cshow :: GeneratePhraseQueries -> String
show :: GeneratePhraseQueries -> String
$cshowList :: [GeneratePhraseQueries] -> ShowS
showList :: [GeneratePhraseQueries] -> ShowS
Show, Maybe GeneratePhraseQueries
Value -> Parser [GeneratePhraseQueries]
Value -> Parser GeneratePhraseQueries
(Value -> Parser GeneratePhraseQueries)
-> (Value -> Parser [GeneratePhraseQueries])
-> Maybe GeneratePhraseQueries
-> FromJSON GeneratePhraseQueries
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser GeneratePhraseQueries
parseJSON :: Value -> Parser GeneratePhraseQueries
$cparseJSONList :: Value -> Parser [GeneratePhraseQueries]
parseJSONList :: Value -> Parser [GeneratePhraseQueries]
$comittedField :: Maybe GeneratePhraseQueries
omittedField :: Maybe GeneratePhraseQueries
FromJSON, [GeneratePhraseQueries] -> Value
[GeneratePhraseQueries] -> Encoding
GeneratePhraseQueries -> Bool
GeneratePhraseQueries -> Value
GeneratePhraseQueries -> Encoding
(GeneratePhraseQueries -> Value)
-> (GeneratePhraseQueries -> Encoding)
-> ([GeneratePhraseQueries] -> Value)
-> ([GeneratePhraseQueries] -> Encoding)
-> (GeneratePhraseQueries -> Bool)
-> ToJSON GeneratePhraseQueries
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: GeneratePhraseQueries -> Value
toJSON :: GeneratePhraseQueries -> Value
$ctoEncoding :: GeneratePhraseQueries -> Encoding
toEncoding :: GeneratePhraseQueries -> Encoding
$ctoJSONList :: [GeneratePhraseQueries] -> Value
toJSONList :: [GeneratePhraseQueries] -> Value
$ctoEncodingList :: [GeneratePhraseQueries] -> Encoding
toEncodingList :: [GeneratePhraseQueries] -> Encoding
$comitField :: GeneratePhraseQueries -> Bool
omitField :: GeneratePhraseQueries -> Bool
ToJSON)

-- | 'Locale' is used for string conversions - defaults to ROOT.
newtype Locale = Locale Text deriving newtype (Locale -> Locale -> Bool
(Locale -> Locale -> Bool)
-> (Locale -> Locale -> Bool) -> Eq Locale
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Locale -> Locale -> Bool
== :: Locale -> Locale -> Bool
$c/= :: Locale -> Locale -> Bool
/= :: Locale -> Locale -> Bool
Eq, Int -> Locale -> ShowS
[Locale] -> ShowS
Locale -> String
(Int -> Locale -> ShowS)
-> (Locale -> String) -> ([Locale] -> ShowS) -> Show Locale
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Locale -> ShowS
showsPrec :: Int -> Locale -> ShowS
$cshow :: Locale -> String
show :: Locale -> String
$cshowList :: [Locale] -> ShowS
showList :: [Locale] -> ShowS
Show, Maybe Locale
Value -> Parser [Locale]
Value -> Parser Locale
(Value -> Parser Locale)
-> (Value -> Parser [Locale]) -> Maybe Locale -> FromJSON Locale
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser Locale
parseJSON :: Value -> Parser Locale
$cparseJSONList :: Value -> Parser [Locale]
parseJSONList :: Value -> Parser [Locale]
$comittedField :: Maybe Locale
omittedField :: Maybe Locale
FromJSON, [Locale] -> Value
[Locale] -> Encoding
Locale -> Bool
Locale -> Value
Locale -> Encoding
(Locale -> Value)
-> (Locale -> Encoding)
-> ([Locale] -> Value)
-> ([Locale] -> Encoding)
-> (Locale -> Bool)
-> ToJSON Locale
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: Locale -> Value
toJSON :: Locale -> Value
$ctoEncoding :: Locale -> Encoding
toEncoding :: Locale -> Encoding
$ctoJSONList :: [Locale] -> Value
toJSONList :: [Locale] -> Value
$ctoEncodingList :: [Locale] -> Encoding
toEncodingList :: [Locale] -> Encoding
$comitField :: Locale -> Bool
omitField :: Locale -> Bool
ToJSON)

newtype MaxWordLength = MaxWordLength Int deriving newtype (MaxWordLength -> MaxWordLength -> Bool
(MaxWordLength -> MaxWordLength -> Bool)
-> (MaxWordLength -> MaxWordLength -> Bool) -> Eq MaxWordLength
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MaxWordLength -> MaxWordLength -> Bool
== :: MaxWordLength -> MaxWordLength -> Bool
$c/= :: MaxWordLength -> MaxWordLength -> Bool
/= :: MaxWordLength -> MaxWordLength -> Bool
Eq, Int -> MaxWordLength -> ShowS
[MaxWordLength] -> ShowS
MaxWordLength -> String
(Int -> MaxWordLength -> ShowS)
-> (MaxWordLength -> String)
-> ([MaxWordLength] -> ShowS)
-> Show MaxWordLength
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MaxWordLength -> ShowS
showsPrec :: Int -> MaxWordLength -> ShowS
$cshow :: MaxWordLength -> String
show :: MaxWordLength -> String
$cshowList :: [MaxWordLength] -> ShowS
showList :: [MaxWordLength] -> ShowS
Show, Maybe MaxWordLength
Value -> Parser [MaxWordLength]
Value -> Parser MaxWordLength
(Value -> Parser MaxWordLength)
-> (Value -> Parser [MaxWordLength])
-> Maybe MaxWordLength
-> FromJSON MaxWordLength
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser MaxWordLength
parseJSON :: Value -> Parser MaxWordLength
$cparseJSONList :: Value -> Parser [MaxWordLength]
parseJSONList :: Value -> Parser [MaxWordLength]
$comittedField :: Maybe MaxWordLength
omittedField :: Maybe MaxWordLength
FromJSON, [MaxWordLength] -> Value
[MaxWordLength] -> Encoding
MaxWordLength -> Bool
MaxWordLength -> Value
MaxWordLength -> Encoding
(MaxWordLength -> Value)
-> (MaxWordLength -> Encoding)
-> ([MaxWordLength] -> Value)
-> ([MaxWordLength] -> Encoding)
-> (MaxWordLength -> Bool)
-> ToJSON MaxWordLength
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: MaxWordLength -> Value
toJSON :: MaxWordLength -> Value
$ctoEncoding :: MaxWordLength -> Encoding
toEncoding :: MaxWordLength -> Encoding
$ctoJSONList :: [MaxWordLength] -> Value
toJSONList :: [MaxWordLength] -> Value
$ctoEncodingList :: [MaxWordLength] -> Encoding
toEncodingList :: [MaxWordLength] -> Encoding
$comitField :: MaxWordLength -> Bool
omitField :: MaxWordLength -> Bool
ToJSON)

newtype MinWordLength = MinWordLength Int deriving newtype (MinWordLength -> MinWordLength -> Bool
(MinWordLength -> MinWordLength -> Bool)
-> (MinWordLength -> MinWordLength -> Bool) -> Eq MinWordLength
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MinWordLength -> MinWordLength -> Bool
== :: MinWordLength -> MinWordLength -> Bool
$c/= :: MinWordLength -> MinWordLength -> Bool
/= :: MinWordLength -> MinWordLength -> Bool
Eq, Int -> MinWordLength -> ShowS
[MinWordLength] -> ShowS
MinWordLength -> String
(Int -> MinWordLength -> ShowS)
-> (MinWordLength -> String)
-> ([MinWordLength] -> ShowS)
-> Show MinWordLength
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MinWordLength -> ShowS
showsPrec :: Int -> MinWordLength -> ShowS
$cshow :: MinWordLength -> String
show :: MinWordLength -> String
$cshowList :: [MinWordLength] -> ShowS
showList :: [MinWordLength] -> ShowS
Show, Maybe MinWordLength
Value -> Parser [MinWordLength]
Value -> Parser MinWordLength
(Value -> Parser MinWordLength)
-> (Value -> Parser [MinWordLength])
-> Maybe MinWordLength
-> FromJSON MinWordLength
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser MinWordLength
parseJSON :: Value -> Parser MinWordLength
$cparseJSONList :: Value -> Parser [MinWordLength]
parseJSONList :: Value -> Parser [MinWordLength]
$comittedField :: Maybe MinWordLength
omittedField :: Maybe MinWordLength
FromJSON, [MinWordLength] -> Value
[MinWordLength] -> Encoding
MinWordLength -> Bool
MinWordLength -> Value
MinWordLength -> Encoding
(MinWordLength -> Value)
-> (MinWordLength -> Encoding)
-> ([MinWordLength] -> Value)
-> ([MinWordLength] -> Encoding)
-> (MinWordLength -> Bool)
-> ToJSON MinWordLength
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: MinWordLength -> Value
toJSON :: MinWordLength -> Value
$ctoEncoding :: MinWordLength -> Encoding
toEncoding :: MinWordLength -> Encoding
$ctoJSONList :: [MinWordLength] -> Value
toJSONList :: [MinWordLength] -> Value
$ctoEncodingList :: [MinWordLength] -> Encoding
toEncodingList :: [MinWordLength] -> Encoding
$comitField :: MinWordLength -> Bool
omitField :: MinWordLength -> Bool
ToJSON)

-- | 'PhraseSlop' sets the default slop for phrases, 0 means exact
--    phrase matches. Default is 0.
newtype PhraseSlop = PhraseSlop Int deriving newtype (PhraseSlop -> PhraseSlop -> Bool
(PhraseSlop -> PhraseSlop -> Bool)
-> (PhraseSlop -> PhraseSlop -> Bool) -> Eq PhraseSlop
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PhraseSlop -> PhraseSlop -> Bool
== :: PhraseSlop -> PhraseSlop -> Bool
$c/= :: PhraseSlop -> PhraseSlop -> Bool
/= :: PhraseSlop -> PhraseSlop -> Bool
Eq, Int -> PhraseSlop -> ShowS
[PhraseSlop] -> ShowS
PhraseSlop -> String
(Int -> PhraseSlop -> ShowS)
-> (PhraseSlop -> String)
-> ([PhraseSlop] -> ShowS)
-> Show PhraseSlop
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PhraseSlop -> ShowS
showsPrec :: Int -> PhraseSlop -> ShowS
$cshow :: PhraseSlop -> String
show :: PhraseSlop -> String
$cshowList :: [PhraseSlop] -> ShowS
showList :: [PhraseSlop] -> ShowS
Show, Maybe PhraseSlop
Value -> Parser [PhraseSlop]
Value -> Parser PhraseSlop
(Value -> Parser PhraseSlop)
-> (Value -> Parser [PhraseSlop])
-> Maybe PhraseSlop
-> FromJSON PhraseSlop
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser PhraseSlop
parseJSON :: Value -> Parser PhraseSlop
$cparseJSONList :: Value -> Parser [PhraseSlop]
parseJSONList :: Value -> Parser [PhraseSlop]
$comittedField :: Maybe PhraseSlop
omittedField :: Maybe PhraseSlop
FromJSON, [PhraseSlop] -> Value
[PhraseSlop] -> Encoding
PhraseSlop -> Bool
PhraseSlop -> Value
PhraseSlop -> Encoding
(PhraseSlop -> Value)
-> (PhraseSlop -> Encoding)
-> ([PhraseSlop] -> Value)
-> ([PhraseSlop] -> Encoding)
-> (PhraseSlop -> Bool)
-> ToJSON PhraseSlop
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: PhraseSlop -> Value
toJSON :: PhraseSlop -> Value
$ctoEncoding :: PhraseSlop -> Encoding
toEncoding :: PhraseSlop -> Encoding
$ctoJSONList :: [PhraseSlop] -> Value
toJSONList :: [PhraseSlop] -> Value
$ctoEncodingList :: [PhraseSlop] -> Encoding
toEncodingList :: [PhraseSlop] -> Encoding
$comitField :: PhraseSlop -> Bool
omitField :: PhraseSlop -> Bool
ToJSON)

newtype MinDocFrequency = MinDocFrequency Int deriving newtype (MinDocFrequency -> MinDocFrequency -> Bool
(MinDocFrequency -> MinDocFrequency -> Bool)
-> (MinDocFrequency -> MinDocFrequency -> Bool)
-> Eq MinDocFrequency
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MinDocFrequency -> MinDocFrequency -> Bool
== :: MinDocFrequency -> MinDocFrequency -> Bool
$c/= :: MinDocFrequency -> MinDocFrequency -> Bool
/= :: MinDocFrequency -> MinDocFrequency -> Bool
Eq, Int -> MinDocFrequency -> ShowS
[MinDocFrequency] -> ShowS
MinDocFrequency -> String
(Int -> MinDocFrequency -> ShowS)
-> (MinDocFrequency -> String)
-> ([MinDocFrequency] -> ShowS)
-> Show MinDocFrequency
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MinDocFrequency -> ShowS
showsPrec :: Int -> MinDocFrequency -> ShowS
$cshow :: MinDocFrequency -> String
show :: MinDocFrequency -> String
$cshowList :: [MinDocFrequency] -> ShowS
showList :: [MinDocFrequency] -> ShowS
Show, Maybe MinDocFrequency
Value -> Parser [MinDocFrequency]
Value -> Parser MinDocFrequency
(Value -> Parser MinDocFrequency)
-> (Value -> Parser [MinDocFrequency])
-> Maybe MinDocFrequency
-> FromJSON MinDocFrequency
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser MinDocFrequency
parseJSON :: Value -> Parser MinDocFrequency
$cparseJSONList :: Value -> Parser [MinDocFrequency]
parseJSONList :: Value -> Parser [MinDocFrequency]
$comittedField :: Maybe MinDocFrequency
omittedField :: Maybe MinDocFrequency
FromJSON, [MinDocFrequency] -> Value
[MinDocFrequency] -> Encoding
MinDocFrequency -> Bool
MinDocFrequency -> Value
MinDocFrequency -> Encoding
(MinDocFrequency -> Value)
-> (MinDocFrequency -> Encoding)
-> ([MinDocFrequency] -> Value)
-> ([MinDocFrequency] -> Encoding)
-> (MinDocFrequency -> Bool)
-> ToJSON MinDocFrequency
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: MinDocFrequency -> Value
toJSON :: MinDocFrequency -> Value
$ctoEncoding :: MinDocFrequency -> Encoding
toEncoding :: MinDocFrequency -> Encoding
$ctoJSONList :: [MinDocFrequency] -> Value
toJSONList :: [MinDocFrequency] -> Value
$ctoEncodingList :: [MinDocFrequency] -> Encoding
toEncodingList :: [MinDocFrequency] -> Encoding
$comitField :: MinDocFrequency -> Bool
omitField :: MinDocFrequency -> Bool
ToJSON)

newtype MaxDocFrequency = MaxDocFrequency Int deriving newtype (MaxDocFrequency -> MaxDocFrequency -> Bool
(MaxDocFrequency -> MaxDocFrequency -> Bool)
-> (MaxDocFrequency -> MaxDocFrequency -> Bool)
-> Eq MaxDocFrequency
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MaxDocFrequency -> MaxDocFrequency -> Bool
== :: MaxDocFrequency -> MaxDocFrequency -> Bool
$c/= :: MaxDocFrequency -> MaxDocFrequency -> Bool
/= :: MaxDocFrequency -> MaxDocFrequency -> Bool
Eq, Int -> MaxDocFrequency -> ShowS
[MaxDocFrequency] -> ShowS
MaxDocFrequency -> String
(Int -> MaxDocFrequency -> ShowS)
-> (MaxDocFrequency -> String)
-> ([MaxDocFrequency] -> ShowS)
-> Show MaxDocFrequency
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MaxDocFrequency -> ShowS
showsPrec :: Int -> MaxDocFrequency -> ShowS
$cshow :: MaxDocFrequency -> String
show :: MaxDocFrequency -> String
$cshowList :: [MaxDocFrequency] -> ShowS
showList :: [MaxDocFrequency] -> ShowS
Show, Maybe MaxDocFrequency
Value -> Parser [MaxDocFrequency]
Value -> Parser MaxDocFrequency
(Value -> Parser MaxDocFrequency)
-> (Value -> Parser [MaxDocFrequency])
-> Maybe MaxDocFrequency
-> FromJSON MaxDocFrequency
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser MaxDocFrequency
parseJSON :: Value -> Parser MaxDocFrequency
$cparseJSONList :: Value -> Parser [MaxDocFrequency]
parseJSONList :: Value -> Parser [MaxDocFrequency]
$comittedField :: Maybe MaxDocFrequency
omittedField :: Maybe MaxDocFrequency
FromJSON, [MaxDocFrequency] -> Value
[MaxDocFrequency] -> Encoding
MaxDocFrequency -> Bool
MaxDocFrequency -> Value
MaxDocFrequency -> Encoding
(MaxDocFrequency -> Value)
-> (MaxDocFrequency -> Encoding)
-> ([MaxDocFrequency] -> Value)
-> ([MaxDocFrequency] -> Encoding)
-> (MaxDocFrequency -> Bool)
-> ToJSON MaxDocFrequency
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: MaxDocFrequency -> Value
toJSON :: MaxDocFrequency -> Value
$ctoEncoding :: MaxDocFrequency -> Encoding
toEncoding :: MaxDocFrequency -> Encoding
$ctoJSONList :: [MaxDocFrequency] -> Value
toJSONList :: [MaxDocFrequency] -> Value
$ctoEncodingList :: [MaxDocFrequency] -> Encoding
toEncodingList :: [MaxDocFrequency] -> Encoding
$comitField :: MaxDocFrequency -> Bool
omitField :: MaxDocFrequency -> Bool
ToJSON)

-- | Indicates whether the relevance score of a matching parent document is aggregated into its child documents.
newtype AggregateParentScore = AggregateParentScore Bool deriving newtype (AggregateParentScore -> AggregateParentScore -> Bool
(AggregateParentScore -> AggregateParentScore -> Bool)
-> (AggregateParentScore -> AggregateParentScore -> Bool)
-> Eq AggregateParentScore
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AggregateParentScore -> AggregateParentScore -> Bool
== :: AggregateParentScore -> AggregateParentScore -> Bool
$c/= :: AggregateParentScore -> AggregateParentScore -> Bool
/= :: AggregateParentScore -> AggregateParentScore -> Bool
Eq, Int -> AggregateParentScore -> ShowS
[AggregateParentScore] -> ShowS
AggregateParentScore -> String
(Int -> AggregateParentScore -> ShowS)
-> (AggregateParentScore -> String)
-> ([AggregateParentScore] -> ShowS)
-> Show AggregateParentScore
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AggregateParentScore -> ShowS
showsPrec :: Int -> AggregateParentScore -> ShowS
$cshow :: AggregateParentScore -> String
show :: AggregateParentScore -> String
$cshowList :: [AggregateParentScore] -> ShowS
showList :: [AggregateParentScore] -> ShowS
Show, Maybe AggregateParentScore
Value -> Parser [AggregateParentScore]
Value -> Parser AggregateParentScore
(Value -> Parser AggregateParentScore)
-> (Value -> Parser [AggregateParentScore])
-> Maybe AggregateParentScore
-> FromJSON AggregateParentScore
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser AggregateParentScore
parseJSON :: Value -> Parser AggregateParentScore
$cparseJSONList :: Value -> Parser [AggregateParentScore]
parseJSONList :: Value -> Parser [AggregateParentScore]
$comittedField :: Maybe AggregateParentScore
omittedField :: Maybe AggregateParentScore
FromJSON, [AggregateParentScore] -> Value
[AggregateParentScore] -> Encoding
AggregateParentScore -> Bool
AggregateParentScore -> Value
AggregateParentScore -> Encoding
(AggregateParentScore -> Value)
-> (AggregateParentScore -> Encoding)
-> ([AggregateParentScore] -> Value)
-> ([AggregateParentScore] -> Encoding)
-> (AggregateParentScore -> Bool)
-> ToJSON AggregateParentScore
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: AggregateParentScore -> Value
toJSON :: AggregateParentScore -> Value
$ctoEncoding :: AggregateParentScore -> Encoding
toEncoding :: AggregateParentScore -> Encoding
$ctoJSONList :: [AggregateParentScore] -> Value
toJSONList :: [AggregateParentScore] -> Value
$ctoEncodingList :: [AggregateParentScore] -> Encoding
toEncodingList :: [AggregateParentScore] -> Encoding
$comitField :: AggregateParentScore -> Bool
omitField :: AggregateParentScore -> Bool
ToJSON)

-- | Indicates whether to ignore an unmapped parent_type and not return any documents instead of an error.
newtype IgnoreUnmapped = IgnoreUnmapped Bool deriving newtype (IgnoreUnmapped -> IgnoreUnmapped -> Bool
(IgnoreUnmapped -> IgnoreUnmapped -> Bool)
-> (IgnoreUnmapped -> IgnoreUnmapped -> Bool) -> Eq IgnoreUnmapped
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IgnoreUnmapped -> IgnoreUnmapped -> Bool
== :: IgnoreUnmapped -> IgnoreUnmapped -> Bool
$c/= :: IgnoreUnmapped -> IgnoreUnmapped -> Bool
/= :: IgnoreUnmapped -> IgnoreUnmapped -> Bool
Eq, Int -> IgnoreUnmapped -> ShowS
[IgnoreUnmapped] -> ShowS
IgnoreUnmapped -> String
(Int -> IgnoreUnmapped -> ShowS)
-> (IgnoreUnmapped -> String)
-> ([IgnoreUnmapped] -> ShowS)
-> Show IgnoreUnmapped
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IgnoreUnmapped -> ShowS
showsPrec :: Int -> IgnoreUnmapped -> ShowS
$cshow :: IgnoreUnmapped -> String
show :: IgnoreUnmapped -> String
$cshowList :: [IgnoreUnmapped] -> ShowS
showList :: [IgnoreUnmapped] -> ShowS
Show, Maybe IgnoreUnmapped
Value -> Parser [IgnoreUnmapped]
Value -> Parser IgnoreUnmapped
(Value -> Parser IgnoreUnmapped)
-> (Value -> Parser [IgnoreUnmapped])
-> Maybe IgnoreUnmapped
-> FromJSON IgnoreUnmapped
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser IgnoreUnmapped
parseJSON :: Value -> Parser IgnoreUnmapped
$cparseJSONList :: Value -> Parser [IgnoreUnmapped]
parseJSONList :: Value -> Parser [IgnoreUnmapped]
$comittedField :: Maybe IgnoreUnmapped
omittedField :: Maybe IgnoreUnmapped
FromJSON, [IgnoreUnmapped] -> Value
[IgnoreUnmapped] -> Encoding
IgnoreUnmapped -> Bool
IgnoreUnmapped -> Value
IgnoreUnmapped -> Encoding
(IgnoreUnmapped -> Value)
-> (IgnoreUnmapped -> Encoding)
-> ([IgnoreUnmapped] -> Value)
-> ([IgnoreUnmapped] -> Encoding)
-> (IgnoreUnmapped -> Bool)
-> ToJSON IgnoreUnmapped
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: IgnoreUnmapped -> Value
toJSON :: IgnoreUnmapped -> Value
$ctoEncoding :: IgnoreUnmapped -> Encoding
toEncoding :: IgnoreUnmapped -> Encoding
$ctoJSONList :: [IgnoreUnmapped] -> Value
toJSONList :: [IgnoreUnmapped] -> Value
$ctoEncodingList :: [IgnoreUnmapped] -> Encoding
toEncodingList :: [IgnoreUnmapped] -> Encoding
$comitField :: IgnoreUnmapped -> Bool
omitField :: IgnoreUnmapped -> Bool
ToJSON)

-- | Maximum number of child documents that match the query allowed for a returned parent document.
--   If the parent document exceeds this limit, it is excluded from the search results.
newtype MinChildren = MinChildren Int deriving newtype (MinChildren -> MinChildren -> Bool
(MinChildren -> MinChildren -> Bool)
-> (MinChildren -> MinChildren -> Bool) -> Eq MinChildren
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MinChildren -> MinChildren -> Bool
== :: MinChildren -> MinChildren -> Bool
$c/= :: MinChildren -> MinChildren -> Bool
/= :: MinChildren -> MinChildren -> Bool
Eq, Int -> MinChildren -> ShowS
[MinChildren] -> ShowS
MinChildren -> String
(Int -> MinChildren -> ShowS)
-> (MinChildren -> String)
-> ([MinChildren] -> ShowS)
-> Show MinChildren
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MinChildren -> ShowS
showsPrec :: Int -> MinChildren -> ShowS
$cshow :: MinChildren -> String
show :: MinChildren -> String
$cshowList :: [MinChildren] -> ShowS
showList :: [MinChildren] -> ShowS
Show, Maybe MinChildren
Value -> Parser [MinChildren]
Value -> Parser MinChildren
(Value -> Parser MinChildren)
-> (Value -> Parser [MinChildren])
-> Maybe MinChildren
-> FromJSON MinChildren
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser MinChildren
parseJSON :: Value -> Parser MinChildren
$cparseJSONList :: Value -> Parser [MinChildren]
parseJSONList :: Value -> Parser [MinChildren]
$comittedField :: Maybe MinChildren
omittedField :: Maybe MinChildren
FromJSON, [MinChildren] -> Value
[MinChildren] -> Encoding
MinChildren -> Bool
MinChildren -> Value
MinChildren -> Encoding
(MinChildren -> Value)
-> (MinChildren -> Encoding)
-> ([MinChildren] -> Value)
-> ([MinChildren] -> Encoding)
-> (MinChildren -> Bool)
-> ToJSON MinChildren
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: MinChildren -> Value
toJSON :: MinChildren -> Value
$ctoEncoding :: MinChildren -> Encoding
toEncoding :: MinChildren -> Encoding
$ctoJSONList :: [MinChildren] -> Value
toJSONList :: [MinChildren] -> Value
$ctoEncodingList :: [MinChildren] -> Encoding
toEncodingList :: [MinChildren] -> Encoding
$comitField :: MinChildren -> Bool
omitField :: MinChildren -> Bool
ToJSON)

-- | Minimum number of child documents that match the query required to match the query for a returned parent document.
--   If the parent document does not meet this limit, it is excluded from the search results.
newtype MaxChildren = MaxChildren Int deriving newtype (MaxChildren -> MaxChildren -> Bool
(MaxChildren -> MaxChildren -> Bool)
-> (MaxChildren -> MaxChildren -> Bool) -> Eq MaxChildren
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MaxChildren -> MaxChildren -> Bool
== :: MaxChildren -> MaxChildren -> Bool
$c/= :: MaxChildren -> MaxChildren -> Bool
/= :: MaxChildren -> MaxChildren -> Bool
Eq, Int -> MaxChildren -> ShowS
[MaxChildren] -> ShowS
MaxChildren -> String
(Int -> MaxChildren -> ShowS)
-> (MaxChildren -> String)
-> ([MaxChildren] -> ShowS)
-> Show MaxChildren
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MaxChildren -> ShowS
showsPrec :: Int -> MaxChildren -> ShowS
$cshow :: MaxChildren -> String
show :: MaxChildren -> String
$cshowList :: [MaxChildren] -> ShowS
showList :: [MaxChildren] -> ShowS
Show, Maybe MaxChildren
Value -> Parser [MaxChildren]
Value -> Parser MaxChildren
(Value -> Parser MaxChildren)
-> (Value -> Parser [MaxChildren])
-> Maybe MaxChildren
-> FromJSON MaxChildren
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser MaxChildren
parseJSON :: Value -> Parser MaxChildren
$cparseJSONList :: Value -> Parser [MaxChildren]
parseJSONList :: Value -> Parser [MaxChildren]
$comittedField :: Maybe MaxChildren
omittedField :: Maybe MaxChildren
FromJSON, [MaxChildren] -> Value
[MaxChildren] -> Encoding
MaxChildren -> Bool
MaxChildren -> Value
MaxChildren -> Encoding
(MaxChildren -> Value)
-> (MaxChildren -> Encoding)
-> ([MaxChildren] -> Value)
-> ([MaxChildren] -> Encoding)
-> (MaxChildren -> Bool)
-> ToJSON MaxChildren
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: MaxChildren -> Value
toJSON :: MaxChildren -> Value
$ctoEncoding :: MaxChildren -> Encoding
toEncoding :: MaxChildren -> Encoding
$ctoJSONList :: [MaxChildren] -> Value
toJSONList :: [MaxChildren] -> Value
$ctoEncodingList :: [MaxChildren] -> Encoding
toEncodingList :: [MaxChildren] -> Encoding
$comitField :: MaxChildren -> Bool
omitField :: MaxChildren -> Bool
ToJSON)

-- | Newtype wrapper to parse ES's concerning tendency to in some APIs return a floating point number of milliseconds since epoch ಠ_ಠ
newtype POSIXMS = POSIXMS {POSIXMS -> UTCTime
posixMS :: UTCTime}

instance FromJSON POSIXMS where
  parseJSON :: Value -> Parser POSIXMS
parseJSON = String -> (Scientific -> Parser POSIXMS) -> Value -> Parser POSIXMS
forall a. String -> (Scientific -> Parser a) -> Value -> Parser a
withScientific String
"POSIXMS" (POSIXMS -> Parser POSIXMS
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (POSIXMS -> Parser POSIXMS)
-> (Scientific -> POSIXMS) -> Scientific -> Parser POSIXMS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scientific -> POSIXMS
forall {p}. RealFrac p => p -> POSIXMS
parse)
    where
      parse :: p -> POSIXMS
parse p
n =
        let n' :: Integer
n' = p -> Integer
forall b. Integral b => p -> b
forall a b. (RealFrac a, Integral b) => a -> b
truncate p
n :: Integer
         in UTCTime -> POSIXMS
POSIXMS (POSIXTime -> UTCTime
posixSecondsToUTCTime (Integer -> POSIXTime
forall a. Num a => Integer -> a
fromInteger (Integer
n' Integer -> Integer -> Integer
forall a. Integral a => a -> a -> a
`div` Integer
1000)))

newtype Boost
  = Boost Double
  deriving newtype (Boost -> Boost -> Bool
(Boost -> Boost -> Bool) -> (Boost -> Boost -> Bool) -> Eq Boost
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Boost -> Boost -> Bool
== :: Boost -> Boost -> Bool
$c/= :: Boost -> Boost -> Bool
/= :: Boost -> Boost -> Bool
Eq, Int -> Boost -> ShowS
[Boost] -> ShowS
Boost -> String
(Int -> Boost -> ShowS)
-> (Boost -> String) -> ([Boost] -> ShowS) -> Show Boost
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Boost -> ShowS
showsPrec :: Int -> Boost -> ShowS
$cshow :: Boost -> String
show :: Boost -> String
$cshowList :: [Boost] -> ShowS
showList :: [Boost] -> ShowS
Show, [Boost] -> Value
[Boost] -> Encoding
Boost -> Bool
Boost -> Value
Boost -> Encoding
(Boost -> Value)
-> (Boost -> Encoding)
-> ([Boost] -> Value)
-> ([Boost] -> Encoding)
-> (Boost -> Bool)
-> ToJSON Boost
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: Boost -> Value
toJSON :: Boost -> Value
$ctoEncoding :: Boost -> Encoding
toEncoding :: Boost -> Encoding
$ctoJSONList :: [Boost] -> Value
toJSONList :: [Boost] -> Value
$ctoEncodingList :: [Boost] -> Encoding
toEncodingList :: [Boost] -> Encoding
$comitField :: Boost -> Bool
omitField :: Boost -> Bool
ToJSON, Maybe Boost
Value -> Parser [Boost]
Value -> Parser Boost
(Value -> Parser Boost)
-> (Value -> Parser [Boost]) -> Maybe Boost -> FromJSON Boost
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser Boost
parseJSON :: Value -> Parser Boost
$cparseJSONList :: Value -> Parser [Boost]
parseJSONList :: Value -> Parser [Boost]
$comittedField :: Maybe Boost
omittedField :: Maybe Boost
FromJSON)

newtype BoostTerms
  = BoostTerms Double
  deriving newtype (BoostTerms -> BoostTerms -> Bool
(BoostTerms -> BoostTerms -> Bool)
-> (BoostTerms -> BoostTerms -> Bool) -> Eq BoostTerms
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BoostTerms -> BoostTerms -> Bool
== :: BoostTerms -> BoostTerms -> Bool
$c/= :: BoostTerms -> BoostTerms -> Bool
/= :: BoostTerms -> BoostTerms -> Bool
Eq, Int -> BoostTerms -> ShowS
[BoostTerms] -> ShowS
BoostTerms -> String
(Int -> BoostTerms -> ShowS)
-> (BoostTerms -> String)
-> ([BoostTerms] -> ShowS)
-> Show BoostTerms
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BoostTerms -> ShowS
showsPrec :: Int -> BoostTerms -> ShowS
$cshow :: BoostTerms -> String
show :: BoostTerms -> String
$cshowList :: [BoostTerms] -> ShowS
showList :: [BoostTerms] -> ShowS
Show, [BoostTerms] -> Value
[BoostTerms] -> Encoding
BoostTerms -> Bool
BoostTerms -> Value
BoostTerms -> Encoding
(BoostTerms -> Value)
-> (BoostTerms -> Encoding)
-> ([BoostTerms] -> Value)
-> ([BoostTerms] -> Encoding)
-> (BoostTerms -> Bool)
-> ToJSON BoostTerms
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: BoostTerms -> Value
toJSON :: BoostTerms -> Value
$ctoEncoding :: BoostTerms -> Encoding
toEncoding :: BoostTerms -> Encoding
$ctoJSONList :: [BoostTerms] -> Value
toJSONList :: [BoostTerms] -> Value
$ctoEncodingList :: [BoostTerms] -> Encoding
toEncodingList :: [BoostTerms] -> Encoding
$comitField :: BoostTerms -> Bool
omitField :: BoostTerms -> Bool
ToJSON, Maybe BoostTerms
Value -> Parser [BoostTerms]
Value -> Parser BoostTerms
(Value -> Parser BoostTerms)
-> (Value -> Parser [BoostTerms])
-> Maybe BoostTerms
-> FromJSON BoostTerms
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser BoostTerms
parseJSON :: Value -> Parser BoostTerms
$cparseJSONList :: Value -> Parser [BoostTerms]
parseJSONList :: Value -> Parser [BoostTerms]
$comittedField :: Maybe BoostTerms
omittedField :: Maybe BoostTerms
FromJSON)

-- | 'ReplicaCount' is part of 'IndexSettings'
newtype ReplicaCount
  = ReplicaCount Int
  deriving newtype (ReplicaCount -> ReplicaCount -> Bool
(ReplicaCount -> ReplicaCount -> Bool)
-> (ReplicaCount -> ReplicaCount -> Bool) -> Eq ReplicaCount
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ReplicaCount -> ReplicaCount -> Bool
== :: ReplicaCount -> ReplicaCount -> Bool
$c/= :: ReplicaCount -> ReplicaCount -> Bool
/= :: ReplicaCount -> ReplicaCount -> Bool
Eq, Int -> ReplicaCount -> ShowS
[ReplicaCount] -> ShowS
ReplicaCount -> String
(Int -> ReplicaCount -> ShowS)
-> (ReplicaCount -> String)
-> ([ReplicaCount] -> ShowS)
-> Show ReplicaCount
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ReplicaCount -> ShowS
showsPrec :: Int -> ReplicaCount -> ShowS
$cshow :: ReplicaCount -> String
show :: ReplicaCount -> String
$cshowList :: [ReplicaCount] -> ShowS
showList :: [ReplicaCount] -> ShowS
Show, [ReplicaCount] -> Value
[ReplicaCount] -> Encoding
ReplicaCount -> Bool
ReplicaCount -> Value
ReplicaCount -> Encoding
(ReplicaCount -> Value)
-> (ReplicaCount -> Encoding)
-> ([ReplicaCount] -> Value)
-> ([ReplicaCount] -> Encoding)
-> (ReplicaCount -> Bool)
-> ToJSON ReplicaCount
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: ReplicaCount -> Value
toJSON :: ReplicaCount -> Value
$ctoEncoding :: ReplicaCount -> Encoding
toEncoding :: ReplicaCount -> Encoding
$ctoJSONList :: [ReplicaCount] -> Value
toJSONList :: [ReplicaCount] -> Value
$ctoEncodingList :: [ReplicaCount] -> Encoding
toEncodingList :: [ReplicaCount] -> Encoding
$comitField :: ReplicaCount -> Bool
omitField :: ReplicaCount -> Bool
ToJSON)

-- | 'ShardCount' is part of 'IndexSettings'
newtype ShardCount
  = ShardCount Int
  deriving newtype (ShardCount -> ShardCount -> Bool
(ShardCount -> ShardCount -> Bool)
-> (ShardCount -> ShardCount -> Bool) -> Eq ShardCount
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShardCount -> ShardCount -> Bool
== :: ShardCount -> ShardCount -> Bool
$c/= :: ShardCount -> ShardCount -> Bool
/= :: ShardCount -> ShardCount -> Bool
Eq, Int -> ShardCount -> ShowS
[ShardCount] -> ShowS
ShardCount -> String
(Int -> ShardCount -> ShowS)
-> (ShardCount -> String)
-> ([ShardCount] -> ShowS)
-> Show ShardCount
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ShardCount -> ShowS
showsPrec :: Int -> ShardCount -> ShowS
$cshow :: ShardCount -> String
show :: ShardCount -> String
$cshowList :: [ShardCount] -> ShowS
showList :: [ShardCount] -> ShowS
Show, [ShardCount] -> Value
[ShardCount] -> Encoding
ShardCount -> Bool
ShardCount -> Value
ShardCount -> Encoding
(ShardCount -> Value)
-> (ShardCount -> Encoding)
-> ([ShardCount] -> Value)
-> ([ShardCount] -> Encoding)
-> (ShardCount -> Bool)
-> ToJSON ShardCount
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: ShardCount -> Value
toJSON :: ShardCount -> Value
$ctoEncoding :: ShardCount -> Encoding
toEncoding :: ShardCount -> Encoding
$ctoJSONList :: [ShardCount] -> Value
toJSONList :: [ShardCount] -> Value
$ctoEncodingList :: [ShardCount] -> Encoding
toEncodingList :: [ShardCount] -> Encoding
$comitField :: ShardCount -> Bool
omitField :: ShardCount -> Bool
ToJSON)

-- This insanity is because ES *sometimes* returns Replica/Shard counts as strings
instance FromJSON ReplicaCount where
  parseJSON :: Value -> Parser ReplicaCount
parseJSON Value
v =
    Value -> Parser ReplicaCount
parseAsInt Value
v
      Parser ReplicaCount -> Parser ReplicaCount -> Parser ReplicaCount
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser ReplicaCount
parseAsString Value
v
    where
      parseAsInt :: Value -> Parser ReplicaCount
parseAsInt = (Int -> ReplicaCount) -> Parser Int -> Parser ReplicaCount
forall a b. (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> ReplicaCount
ReplicaCount (Parser Int -> Parser ReplicaCount)
-> (Value -> Parser Int) -> Value -> Parser ReplicaCount
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Parser Int
forall a. FromJSON a => Value -> Parser a
parseJSON
      parseAsString :: Value -> Parser ReplicaCount
parseAsString = String
-> (Text -> Parser ReplicaCount) -> Value -> Parser ReplicaCount
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"ReplicaCount" ((Int -> ReplicaCount) -> Parser Int -> Parser ReplicaCount
forall a b. (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> ReplicaCount
ReplicaCount (Parser Int -> Parser ReplicaCount)
-> (Text -> Parser Int) -> Text -> Parser ReplicaCount
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Parser Int
forall a. Read a => Text -> Parser a
parseReadText)

instance FromJSON ShardCount where
  parseJSON :: Value -> Parser ShardCount
parseJSON Value
v =
    Value -> Parser ShardCount
parseAsInt Value
v
      Parser ShardCount -> Parser ShardCount -> Parser ShardCount
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Value -> Parser ShardCount
parseAsString Value
v
    where
      parseAsInt :: Value -> Parser ShardCount
parseAsInt = (Int -> ShardCount) -> Parser Int -> Parser ShardCount
forall a b. (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> ShardCount
ShardCount (Parser Int -> Parser ShardCount)
-> (Value -> Parser Int) -> Value -> Parser ShardCount
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value -> Parser Int
forall a. FromJSON a => Value -> Parser a
parseJSON
      parseAsString :: Value -> Parser ShardCount
parseAsString = String -> (Text -> Parser ShardCount) -> Value -> Parser ShardCount
forall a. String -> (Text -> Parser a) -> Value -> Parser a
withText String
"ShardCount" ((Int -> ShardCount) -> Parser Int -> Parser ShardCount
forall a b. (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> ShardCount
ShardCount (Parser Int -> Parser ShardCount)
-> (Text -> Parser Int) -> Text -> Parser ShardCount
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Parser Int
forall a. Read a => Text -> Parser a
parseReadText)

-- | 'IndexName' is used to describe which index to query/create/delete
newtype IndexName
  = IndexName Text
  deriving stock (IndexName -> IndexName -> Bool
(IndexName -> IndexName -> Bool)
-> (IndexName -> IndexName -> Bool) -> Eq IndexName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IndexName -> IndexName -> Bool
== :: IndexName -> IndexName -> Bool
$c/= :: IndexName -> IndexName -> Bool
/= :: IndexName -> IndexName -> Bool
Eq, Eq IndexName
Eq IndexName =>
(IndexName -> IndexName -> Ordering)
-> (IndexName -> IndexName -> Bool)
-> (IndexName -> IndexName -> Bool)
-> (IndexName -> IndexName -> Bool)
-> (IndexName -> IndexName -> Bool)
-> (IndexName -> IndexName -> IndexName)
-> (IndexName -> IndexName -> IndexName)
-> Ord IndexName
IndexName -> IndexName -> Bool
IndexName -> IndexName -> Ordering
IndexName -> IndexName -> IndexName
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 :: IndexName -> IndexName -> Ordering
compare :: IndexName -> IndexName -> Ordering
$c< :: IndexName -> IndexName -> Bool
< :: IndexName -> IndexName -> Bool
$c<= :: IndexName -> IndexName -> Bool
<= :: IndexName -> IndexName -> Bool
$c> :: IndexName -> IndexName -> Bool
> :: IndexName -> IndexName -> Bool
$c>= :: IndexName -> IndexName -> Bool
>= :: IndexName -> IndexName -> Bool
$cmax :: IndexName -> IndexName -> IndexName
max :: IndexName -> IndexName -> IndexName
$cmin :: IndexName -> IndexName -> IndexName
min :: IndexName -> IndexName -> IndexName
Ord, Int -> IndexName -> ShowS
[IndexName] -> ShowS
IndexName -> String
(Int -> IndexName -> ShowS)
-> (IndexName -> String)
-> ([IndexName] -> ShowS)
-> Show IndexName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IndexName -> ShowS
showsPrec :: Int -> IndexName -> ShowS
$cshow :: IndexName -> String
show :: IndexName -> String
$cshowList :: [IndexName] -> ShowS
showList :: [IndexName] -> ShowS
Show, (forall x. IndexName -> Rep IndexName x)
-> (forall x. Rep IndexName x -> IndexName) -> Generic IndexName
forall x. Rep IndexName x -> IndexName
forall x. IndexName -> Rep IndexName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IndexName -> Rep IndexName x
from :: forall x. IndexName -> Rep IndexName x
$cto :: forall x. Rep IndexName x -> IndexName
to :: forall x. Rep IndexName x -> IndexName
Generic)
  deriving newtype (Eq IndexName
Eq IndexName =>
(Int -> IndexName -> Int)
-> (IndexName -> Int) -> Hashable IndexName
Int -> IndexName -> Int
IndexName -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> IndexName -> Int
hashWithSalt :: Int -> IndexName -> Int
$chash :: IndexName -> Int
hash :: IndexName -> Int
Hashable, NonEmpty IndexName -> IndexName
IndexName -> IndexName -> IndexName
(IndexName -> IndexName -> IndexName)
-> (NonEmpty IndexName -> IndexName)
-> (forall b. Integral b => b -> IndexName -> IndexName)
-> Semigroup IndexName
forall b. Integral b => b -> IndexName -> IndexName
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: IndexName -> IndexName -> IndexName
<> :: IndexName -> IndexName -> IndexName
$csconcat :: NonEmpty IndexName -> IndexName
sconcat :: NonEmpty IndexName -> IndexName
$cstimes :: forall b. Integral b => b -> IndexName -> IndexName
stimes :: forall b. Integral b => b -> IndexName -> IndexName
Semigroup, [IndexName] -> Value
[IndexName] -> Encoding
IndexName -> Bool
IndexName -> Value
IndexName -> Encoding
(IndexName -> Value)
-> (IndexName -> Encoding)
-> ([IndexName] -> Value)
-> ([IndexName] -> Encoding)
-> (IndexName -> Bool)
-> ToJSON IndexName
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: IndexName -> Value
toJSON :: IndexName -> Value
$ctoEncoding :: IndexName -> Encoding
toEncoding :: IndexName -> Encoding
$ctoJSONList :: [IndexName] -> Value
toJSONList :: [IndexName] -> Value
$ctoEncodingList :: [IndexName] -> Encoding
toEncodingList :: [IndexName] -> Encoding
$comitField :: IndexName -> Bool
omitField :: IndexName -> Bool
ToJSON, ToJSONKeyFunction [IndexName]
ToJSONKeyFunction IndexName
ToJSONKeyFunction IndexName
-> ToJSONKeyFunction [IndexName] -> ToJSONKey IndexName
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
$ctoJSONKey :: ToJSONKeyFunction IndexName
toJSONKey :: ToJSONKeyFunction IndexName
$ctoJSONKeyList :: ToJSONKeyFunction [IndexName]
toJSONKeyList :: ToJSONKeyFunction [IndexName]
ToJSONKey, FromJSONKeyFunction [IndexName]
FromJSONKeyFunction IndexName
FromJSONKeyFunction IndexName
-> FromJSONKeyFunction [IndexName] -> FromJSONKey IndexName
forall a.
FromJSONKeyFunction a -> FromJSONKeyFunction [a] -> FromJSONKey a
$cfromJSONKey :: FromJSONKeyFunction IndexName
fromJSONKey :: FromJSONKeyFunction IndexName
$cfromJSONKeyList :: FromJSONKeyFunction [IndexName]
fromJSONKeyList :: FromJSONKeyFunction [IndexName]
FromJSONKey)

instance FromJSON IndexName where
  parseJSON :: Value -> Parser IndexName
parseJSON Value
x =
    Value -> Parser Text
forall a. FromJSON a => Value -> Parser a
parseJSON Value
x Parser Text -> (Text -> Parser IndexName) -> Parser IndexName
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Text -> Parser IndexName)
-> (IndexName -> Parser IndexName)
-> Either Text IndexName
-> Parser IndexName
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (String -> Parser IndexName
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser IndexName)
-> (Text -> String) -> Text -> Parser IndexName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
T.unpack) IndexName -> Parser IndexName
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either Text IndexName -> Parser IndexName)
-> (Text -> Either Text IndexName) -> Text -> Parser IndexName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Either Text IndexName
mkIndexNameSystem

unIndexName :: IndexName -> Text
unIndexName :: IndexName -> Text
unIndexName (IndexName Text
x) = Text
x

mkIndexName :: Text -> Either Text IndexName
mkIndexName :: Text -> Either Text IndexName
mkIndexName Text
name = do
  let check :: a -> Bool -> Either a ()
check a
explanation Bool
p = if Bool
p then () -> Either a ()
forall a b. b -> Either a b
Right () else a -> Either a ()
forall a b. a -> Either a b
Left a
explanation
  Text -> Bool -> Either Text ()
forall {a}. a -> Bool -> Either a ()
check Text
"Is empty" (Bool -> Either Text ()) -> Bool -> Either Text ()
forall a b. (a -> b) -> a -> b
$ Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Text -> Bool
T.null Text
name
  Text -> Bool -> Either Text ()
forall {a}. a -> Bool -> Either a ()
check Text
"Is longer than 255 bytes" (Bool -> Either Text ()) -> Bool -> Either Text ()
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
BS.length (Text -> ByteString
T.encodeUtf8 Text
name) Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
256
  Text -> Bool -> Either Text ()
forall {a}. a -> Bool -> Either a ()
check Text
"Contains uppercase letter(s)" (Bool -> Either Text ()) -> Bool -> Either Text ()
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> Text -> Bool
T.all (\Char
x -> Bool -> Bool
not (Char -> Bool
isLetter Char
x) Bool -> Bool -> Bool
|| Char -> Bool
isLower Char
x) Text
name
  Text -> Bool -> Either Text ()
forall {a}. a -> Bool -> Either a ()
check Text
"Includes [\\/*?\"<>| ,#:]" (Bool -> Either Text ()) -> Bool -> Either Text ()
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> Text -> Bool
T.all ((Char -> String -> Bool) -> String -> Char -> Bool
forall a b c. (a -> b -> c) -> b -> a -> c
flip Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
notElem (String
"\\/*?\"<>| ,#:" :: String)) Text
name
  Text -> Bool -> Either Text ()
forall {a}. a -> Bool -> Either a ()
check Text
"Is (.|..)" (Bool -> Either Text ()) -> Bool -> Either Text ()
forall a b. (a -> b) -> a -> b
$ Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
notElem Text
name [Text
".", Text
".."]
  Text -> Bool -> Either Text ()
forall {a}. a -> Bool -> Either a ()
check Text
"Starts with [-_+.]" (Bool -> Either Text ()) -> Bool -> Either Text ()
forall a b. (a -> b) -> a -> b
$ Bool -> ((Char, Text) -> Bool) -> Maybe (Char, Text) -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False ((Char -> String -> Bool) -> String -> Char -> Bool
forall a b c. (a -> b -> c) -> b -> a -> c
flip Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
notElem (String
"-_+." :: String) (Char -> Bool) -> ((Char, Text) -> Char) -> (Char, Text) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char, Text) -> Char
forall a b. (a, b) -> a
fst) (Maybe (Char, Text) -> Bool) -> Maybe (Char, Text) -> Bool
forall a b. (a -> b) -> a -> b
$ Text -> Maybe (Char, Text)
T.uncons Text
name
  IndexName -> Either Text IndexName
forall a. a -> Either Text a
forall (m :: * -> *) a. Monad m => a -> m a
return (IndexName -> Either Text IndexName)
-> IndexName -> Either Text IndexName
forall a b. (a -> b) -> a -> b
$ Text -> IndexName
IndexName Text
name

mkIndexNameSystem :: Text -> Either Text IndexName
mkIndexNameSystem :: Text -> Either Text IndexName
mkIndexNameSystem Text
name = do
  let check :: a -> Bool -> Either a ()
check a
explanation Bool
p = if Bool
p then () -> Either a ()
forall a b. b -> Either a b
Right () else a -> Either a ()
forall a b. a -> Either a b
Left a
explanation
  Text -> Bool -> Either Text ()
forall {a}. a -> Bool -> Either a ()
check Text
"Is empty" (Bool -> Either Text ()) -> Bool -> Either Text ()
forall a b. (a -> b) -> a -> b
$ Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Text -> Bool
T.null Text
name
  Text -> Bool -> Either Text ()
forall {a}. a -> Bool -> Either a ()
check Text
"Is longer than 255 bytes" (Bool -> Either Text ()) -> Bool -> Either Text ()
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
BS.length (Text -> ByteString
T.encodeUtf8 Text
name) Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
256
  Text -> Bool -> Either Text ()
forall {a}. a -> Bool -> Either a ()
check Text
"Contains uppercase letter(s)" (Bool -> Either Text ()) -> Bool -> Either Text ()
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> Text -> Bool
T.all (\Char
x -> Bool -> Bool
not (Char -> Bool
isLetter Char
x) Bool -> Bool -> Bool
|| Char -> Bool
isLower Char
x) Text
name
  Text -> Bool -> Either Text ()
forall {a}. a -> Bool -> Either a ()
check Text
"Includes [\\/*?\"<>| ,#:]" (Bool -> Either Text ()) -> Bool -> Either Text ()
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> Text -> Bool
T.all ((Char -> String -> Bool) -> String -> Char -> Bool
forall a b c. (a -> b -> c) -> b -> a -> c
flip Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
notElem (String
"\\/*?\"<>| ,#:" :: String)) Text
name
  Text -> Bool -> Either Text ()
forall {a}. a -> Bool -> Either a ()
check Text
"Starts with [-_+]" (Bool -> Either Text ()) -> Bool -> Either Text ()
forall a b. (a -> b) -> a -> b
$ Bool -> ((Char, Text) -> Bool) -> Maybe (Char, Text) -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False ((Char -> String -> Bool) -> String -> Char -> Bool
forall a b c. (a -> b -> c) -> b -> a -> c
flip Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
notElem (String
"-_+" :: String) (Char -> Bool) -> ((Char, Text) -> Char) -> (Char, Text) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char, Text) -> Char
forall a b. (a, b) -> a
fst) (Maybe (Char, Text) -> Bool) -> Maybe (Char, Text) -> Bool
forall a b. (a -> b) -> a -> b
$ Text -> Maybe (Char, Text)
T.uncons Text
name
  IndexName -> Either Text IndexName
forall a. a -> Either Text a
forall (m :: * -> *) a. Monad m => a -> m a
return (IndexName -> Either Text IndexName)
-> IndexName -> Either Text IndexName
forall a b. (a -> b) -> a -> b
$ Text -> IndexName
IndexName Text
name

qqIndexName :: QuasiQuoter
qqIndexName :: QuasiQuoter
qqIndexName =
  QuasiQuoter
    { quoteExp :: String -> Q Exp
quoteExp = \String
str -> do
        Loc
loc <- Q Loc
location
        IndexName Text
n <- IO IndexName -> Q IndexName
forall a. IO a -> Q a
runIO (IO IndexName -> Q IndexName) -> IO IndexName -> Q IndexName
forall a b. (a -> b) -> a -> b
$ (Text -> Either Text IndexName) -> Loc -> String -> IO IndexName
forall a. (Text -> Either Text a) -> Loc -> String -> IO a
parseIO Text -> Either Text IndexName
mkIndexName Loc
loc String
str
        Exp -> Q Exp
forall a. a -> Q a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Exp -> Q Exp) -> Exp -> Q Exp
forall a b. (a -> b) -> a -> b
$ Exp -> Exp -> Exp
AppE (Name -> Exp
ConE 'IndexName) (Lit -> Exp
LitE (String -> Lit
StringL (String -> Lit) -> String -> Lit
forall a b. (a -> b) -> a -> b
$ Text -> String
T.unpack Text
n)),
      quotePat :: String -> Q Pat
quotePat = String -> Q Pat
forall a. HasCallStack => a
undefined,
      quoteType :: String -> Q Type
quoteType = String -> Q Type
forall a. HasCallStack => a
undefined,
      quoteDec :: String -> Q [Dec]
quoteDec = String -> Q [Dec]
forall a. HasCallStack => a
undefined
    }
  where
    parseIO :: (Text -> Either Text a) -> Loc -> String -> IO a
    parseIO :: forall a. (Text -> Either Text a) -> Loc -> String -> IO a
parseIO Text -> Either Text a
p Loc
loc String
str =
      case Text -> Either Text a
p (Text -> Either Text a) -> Text -> Either Text a
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack String
str of
        Left Text
err ->
          IOError -> IO a
forall e a. Exception e => e -> IO a
throwIO (IOError -> IO a) -> IOError -> IO a
forall a b. (a -> b) -> a -> b
$
            String -> IOError
userError (String -> IOError) -> String -> IOError
forall a b. (a -> b) -> a -> b
$
              [String] -> String
forall a. Monoid a => [a] -> a
mconcat
                [ String
"'",
                  String
str,
                  String
"'",
                  String
" is not a valid IndexName ",
                  String
"(",
                  Text -> String
T.unpack Text
err,
                  String
")",
                  String
" at ",
                  Loc -> String
loc_filename Loc
loc,
                  String
":",
                  CharPos -> String
forall a. Show a => a -> String
show (Loc -> CharPos
loc_start Loc
loc),
                  String
"-",
                  CharPos -> String
forall a. Show a => a -> String
show (Loc -> CharPos
loc_start Loc
loc)
                ]
        Right a
a ->
          a -> IO a
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return a
a

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

newtype MaybeNA a = MaybeNA {forall a. MaybeNA a -> Maybe a
unMaybeNA :: Maybe a}
  deriving newtype (MaybeNA a -> MaybeNA a -> Bool
(MaybeNA a -> MaybeNA a -> Bool)
-> (MaybeNA a -> MaybeNA a -> Bool) -> Eq (MaybeNA a)
forall a. Eq a => MaybeNA a -> MaybeNA a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => MaybeNA a -> MaybeNA a -> Bool
== :: MaybeNA a -> MaybeNA a -> Bool
$c/= :: forall a. Eq a => MaybeNA a -> MaybeNA a -> Bool
/= :: MaybeNA a -> MaybeNA a -> Bool
Eq, Int -> MaybeNA a -> ShowS
[MaybeNA a] -> ShowS
MaybeNA a -> String
(Int -> MaybeNA a -> ShowS)
-> (MaybeNA a -> String)
-> ([MaybeNA a] -> ShowS)
-> Show (MaybeNA a)
forall a. Show a => Int -> MaybeNA a -> ShowS
forall a. Show a => [MaybeNA a] -> ShowS
forall a. Show a => MaybeNA a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> MaybeNA a -> ShowS
showsPrec :: Int -> MaybeNA a -> ShowS
$cshow :: forall a. Show a => MaybeNA a -> String
show :: MaybeNA a -> String
$cshowList :: forall a. Show a => [MaybeNA a] -> ShowS
showList :: [MaybeNA a] -> ShowS
Show, (forall a b. (a -> b) -> MaybeNA a -> MaybeNA b)
-> (forall a b. a -> MaybeNA b -> MaybeNA a) -> Functor MaybeNA
forall a b. a -> MaybeNA b -> MaybeNA a
forall a b. (a -> b) -> MaybeNA a -> MaybeNA 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) -> MaybeNA a -> MaybeNA b
fmap :: forall a b. (a -> b) -> MaybeNA a -> MaybeNA b
$c<$ :: forall a b. a -> MaybeNA b -> MaybeNA a
<$ :: forall a b. a -> MaybeNA b -> MaybeNA a
Functor, Functor MaybeNA
Functor MaybeNA =>
(forall a. a -> MaybeNA a)
-> (forall a b. MaybeNA (a -> b) -> MaybeNA a -> MaybeNA b)
-> (forall a b c.
    (a -> b -> c) -> MaybeNA a -> MaybeNA b -> MaybeNA c)
-> (forall a b. MaybeNA a -> MaybeNA b -> MaybeNA b)
-> (forall a b. MaybeNA a -> MaybeNA b -> MaybeNA a)
-> Applicative MaybeNA
forall a. a -> MaybeNA a
forall a b. MaybeNA a -> MaybeNA b -> MaybeNA a
forall a b. MaybeNA a -> MaybeNA b -> MaybeNA b
forall a b. MaybeNA (a -> b) -> MaybeNA a -> MaybeNA b
forall a b c. (a -> b -> c) -> MaybeNA a -> MaybeNA b -> MaybeNA c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall a. a -> MaybeNA a
pure :: forall a. a -> MaybeNA a
$c<*> :: forall a b. MaybeNA (a -> b) -> MaybeNA a -> MaybeNA b
<*> :: forall a b. MaybeNA (a -> b) -> MaybeNA a -> MaybeNA b
$cliftA2 :: forall a b c. (a -> b -> c) -> MaybeNA a -> MaybeNA b -> MaybeNA c
liftA2 :: forall a b c. (a -> b -> c) -> MaybeNA a -> MaybeNA b -> MaybeNA c
$c*> :: forall a b. MaybeNA a -> MaybeNA b -> MaybeNA b
*> :: forall a b. MaybeNA a -> MaybeNA b -> MaybeNA b
$c<* :: forall a b. MaybeNA a -> MaybeNA b -> MaybeNA a
<* :: forall a b. MaybeNA a -> MaybeNA b -> MaybeNA a
Applicative, Applicative MaybeNA
Applicative MaybeNA =>
(forall a b. MaybeNA a -> (a -> MaybeNA b) -> MaybeNA b)
-> (forall a b. MaybeNA a -> MaybeNA b -> MaybeNA b)
-> (forall a. a -> MaybeNA a)
-> Monad MaybeNA
forall a. a -> MaybeNA a
forall a b. MaybeNA a -> MaybeNA b -> MaybeNA b
forall a b. MaybeNA a -> (a -> MaybeNA b) -> MaybeNA b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
$c>>= :: forall a b. MaybeNA a -> (a -> MaybeNA b) -> MaybeNA b
>>= :: forall a b. MaybeNA a -> (a -> MaybeNA b) -> MaybeNA b
$c>> :: forall a b. MaybeNA a -> MaybeNA b -> MaybeNA b
>> :: forall a b. MaybeNA a -> MaybeNA b -> MaybeNA b
$creturn :: forall a. a -> MaybeNA a
return :: forall a. a -> MaybeNA a
Monad)

instance (FromJSON a) => FromJSON (MaybeNA a) where
  parseJSON :: Value -> Parser (MaybeNA a)
parseJSON (String Text
"NA") = MaybeNA a -> Parser (MaybeNA a)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MaybeNA a -> Parser (MaybeNA a))
-> MaybeNA a -> Parser (MaybeNA a)
forall a b. (a -> b) -> a -> b
$ Maybe a -> MaybeNA a
forall a. Maybe a -> MaybeNA a
MaybeNA Maybe a
forall a. Maybe a
Nothing
  parseJSON Value
o = Maybe a -> MaybeNA a
forall a. Maybe a -> MaybeNA a
MaybeNA (Maybe a -> MaybeNA a) -> (a -> Maybe a) -> a -> MaybeNA a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Maybe a
forall a. a -> Maybe a
Just (a -> MaybeNA a) -> Parser a -> Parser (MaybeNA a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser a
forall a. FromJSON a => Value -> Parser a
parseJSON Value
o

newtype SnapshotName = SnapshotName {SnapshotName -> Text
snapshotName :: Text}
  deriving newtype (SnapshotName -> SnapshotName -> Bool
(SnapshotName -> SnapshotName -> Bool)
-> (SnapshotName -> SnapshotName -> Bool) -> Eq SnapshotName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SnapshotName -> SnapshotName -> Bool
== :: SnapshotName -> SnapshotName -> Bool
$c/= :: SnapshotName -> SnapshotName -> Bool
/= :: SnapshotName -> SnapshotName -> Bool
Eq, Int -> SnapshotName -> ShowS
[SnapshotName] -> ShowS
SnapshotName -> String
(Int -> SnapshotName -> ShowS)
-> (SnapshotName -> String)
-> ([SnapshotName] -> ShowS)
-> Show SnapshotName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SnapshotName -> ShowS
showsPrec :: Int -> SnapshotName -> ShowS
$cshow :: SnapshotName -> String
show :: SnapshotName -> String
$cshowList :: [SnapshotName] -> ShowS
showList :: [SnapshotName] -> ShowS
Show, [SnapshotName] -> Value
[SnapshotName] -> Encoding
SnapshotName -> Bool
SnapshotName -> Value
SnapshotName -> Encoding
(SnapshotName -> Value)
-> (SnapshotName -> Encoding)
-> ([SnapshotName] -> Value)
-> ([SnapshotName] -> Encoding)
-> (SnapshotName -> Bool)
-> ToJSON SnapshotName
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: SnapshotName -> Value
toJSON :: SnapshotName -> Value
$ctoEncoding :: SnapshotName -> Encoding
toEncoding :: SnapshotName -> Encoding
$ctoJSONList :: [SnapshotName] -> Value
toJSONList :: [SnapshotName] -> Value
$ctoEncodingList :: [SnapshotName] -> Encoding
toEncodingList :: [SnapshotName] -> Encoding
$comitField :: SnapshotName -> Bool
omitField :: SnapshotName -> Bool
ToJSON, Maybe SnapshotName
Value -> Parser [SnapshotName]
Value -> Parser SnapshotName
(Value -> Parser SnapshotName)
-> (Value -> Parser [SnapshotName])
-> Maybe SnapshotName
-> FromJSON SnapshotName
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser SnapshotName
parseJSON :: Value -> Parser SnapshotName
$cparseJSONList :: Value -> Parser [SnapshotName]
parseJSONList :: Value -> Parser [SnapshotName]
$comittedField :: Maybe SnapshotName
omittedField :: Maybe SnapshotName
FromJSON)

-- | Milliseconds
newtype MS = MS NominalDiffTime

-- keeps the unexported constructor warnings at bay
unMS :: MS -> NominalDiffTime
unMS :: MS -> POSIXTime
unMS (MS POSIXTime
t) = POSIXTime
t

instance FromJSON MS where
  parseJSON :: Value -> Parser MS
parseJSON = String -> (Scientific -> Parser MS) -> Value -> Parser MS
forall a. String -> (Scientific -> Parser a) -> Value -> Parser a
withScientific String
"MS" (MS -> Parser MS
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (MS -> Parser MS) -> (Scientific -> MS) -> Scientific -> Parser MS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. POSIXTime -> MS
MS (POSIXTime -> MS) -> (Scientific -> POSIXTime) -> Scientific -> MS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Scientific -> POSIXTime
forall {a} {a}. (RealFrac a, Num a) => a -> a
parse)
    where
      parse :: a -> a
parse a
n = Integer -> a
forall a. Num a => Integer -> a
fromInteger (a -> Integer
forall b. Integral b => a -> b
forall a b. (RealFrac a, Integral b) => a -> b
truncate a
n Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
1000)

newtype TokenFilter
  = TokenFilter Text
  deriving newtype (TokenFilter -> TokenFilter -> Bool
(TokenFilter -> TokenFilter -> Bool)
-> (TokenFilter -> TokenFilter -> Bool) -> Eq TokenFilter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TokenFilter -> TokenFilter -> Bool
== :: TokenFilter -> TokenFilter -> Bool
$c/= :: TokenFilter -> TokenFilter -> Bool
/= :: TokenFilter -> TokenFilter -> Bool
Eq, Int -> TokenFilter -> ShowS
[TokenFilter] -> ShowS
TokenFilter -> String
(Int -> TokenFilter -> ShowS)
-> (TokenFilter -> String)
-> ([TokenFilter] -> ShowS)
-> Show TokenFilter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TokenFilter -> ShowS
showsPrec :: Int -> TokenFilter -> ShowS
$cshow :: TokenFilter -> String
show :: TokenFilter -> String
$cshowList :: [TokenFilter] -> ShowS
showList :: [TokenFilter] -> ShowS
Show, Maybe TokenFilter
Value -> Parser [TokenFilter]
Value -> Parser TokenFilter
(Value -> Parser TokenFilter)
-> (Value -> Parser [TokenFilter])
-> Maybe TokenFilter
-> FromJSON TokenFilter
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser TokenFilter
parseJSON :: Value -> Parser TokenFilter
$cparseJSONList :: Value -> Parser [TokenFilter]
parseJSONList :: Value -> Parser [TokenFilter]
$comittedField :: Maybe TokenFilter
omittedField :: Maybe TokenFilter
FromJSON, [TokenFilter] -> Value
[TokenFilter] -> Encoding
TokenFilter -> Bool
TokenFilter -> Value
TokenFilter -> Encoding
(TokenFilter -> Value)
-> (TokenFilter -> Encoding)
-> ([TokenFilter] -> Value)
-> ([TokenFilter] -> Encoding)
-> (TokenFilter -> Bool)
-> ToJSON TokenFilter
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: TokenFilter -> Value
toJSON :: TokenFilter -> Value
$ctoEncoding :: TokenFilter -> Encoding
toEncoding :: TokenFilter -> Encoding
$ctoJSONList :: [TokenFilter] -> Value
toJSONList :: [TokenFilter] -> Value
$ctoEncodingList :: [TokenFilter] -> Encoding
toEncodingList :: [TokenFilter] -> Encoding
$comitField :: TokenFilter -> Bool
omitField :: TokenFilter -> Bool
ToJSON)

newtype CharFilter
  = CharFilter Text
  deriving newtype (CharFilter -> CharFilter -> Bool
(CharFilter -> CharFilter -> Bool)
-> (CharFilter -> CharFilter -> Bool) -> Eq CharFilter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CharFilter -> CharFilter -> Bool
== :: CharFilter -> CharFilter -> Bool
$c/= :: CharFilter -> CharFilter -> Bool
/= :: CharFilter -> CharFilter -> Bool
Eq, Int -> CharFilter -> ShowS
[CharFilter] -> ShowS
CharFilter -> String
(Int -> CharFilter -> ShowS)
-> (CharFilter -> String)
-> ([CharFilter] -> ShowS)
-> Show CharFilter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CharFilter -> ShowS
showsPrec :: Int -> CharFilter -> ShowS
$cshow :: CharFilter -> String
show :: CharFilter -> String
$cshowList :: [CharFilter] -> ShowS
showList :: [CharFilter] -> ShowS
Show, Maybe CharFilter
Value -> Parser [CharFilter]
Value -> Parser CharFilter
(Value -> Parser CharFilter)
-> (Value -> Parser [CharFilter])
-> Maybe CharFilter
-> FromJSON CharFilter
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser CharFilter
parseJSON :: Value -> Parser CharFilter
$cparseJSONList :: Value -> Parser [CharFilter]
parseJSONList :: Value -> Parser [CharFilter]
$comittedField :: Maybe CharFilter
omittedField :: Maybe CharFilter
FromJSON, [CharFilter] -> Value
[CharFilter] -> Encoding
CharFilter -> Bool
CharFilter -> Value
CharFilter -> Encoding
(CharFilter -> Value)
-> (CharFilter -> Encoding)
-> ([CharFilter] -> Value)
-> ([CharFilter] -> Encoding)
-> (CharFilter -> Bool)
-> ToJSON CharFilter
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: CharFilter -> Value
toJSON :: CharFilter -> Value
$ctoEncoding :: CharFilter -> Encoding
toEncoding :: CharFilter -> Encoding
$ctoJSONList :: [CharFilter] -> Value
toJSONList :: [CharFilter] -> Value
$ctoEncodingList :: [CharFilter] -> Encoding
toEncodingList :: [CharFilter] -> Encoding
$comitField :: CharFilter -> Bool
omitField :: CharFilter -> Bool
ToJSON)