{-# LANGUAGE OverloadedStrings #-}

module Database.Bloodhound.Internal.Versions.Common.Types.Query.Fuzzy
  ( FuzzyQuery (..),
    FuzzyLikeFieldQuery (..),
    FuzzyLikeThisQuery (..),

    -- * Optics
    fuzzyQueryFieldLens,
    fuzzyQueryValueLens,
    fuzzyQueryPrefixLengthLens,
    fuzzyQueryMaxExpansionsLens,
    fuzzyQueryFuzzinessLens,
    fuzzyQueryBoostLens,
    fuzzyLikeFieldQueryFieldLens,
    fuzzyLikeFieldQueryTextLens,
    fuzzyLikeFieldQueryMaxQueryTermsLens,
    fuzzyLikeFieldQueryIgnoreTermFrequencyLens,
    fuzzyLikeFieldQueryFuzzinessLens,
    fuzzyLikeFieldQueryPrefixLengthLens,
    fuzzyLikeFieldQueryBoostLens,
    fuzzyLikeFieldQueryAnalyzerLens,
    fuzzyLikeThisQueryFieldsLens,
    fuzzyLikeThisQueryTextLens,
    fuzzyLikeThisQueryMaxQueryTermsLens,
    fuzzyLikeThisQueryIgnoreTermFrequencyLens,
    fuzzyLikeThisQueryFuzzinessLens,
    fuzzyLikeThisQueryPrefixLengthLens,
    fuzzyLikeThisQueryBoostLens,
    fuzzyLikeThisQueryAnalyzerLens,
  )
where

import Database.Bloodhound.Internal.Utils.Imports
import Database.Bloodhound.Internal.Versions.Common.Types.Newtypes
import Database.Bloodhound.Internal.Versions.Common.Types.Query.Commons
import GHC.Generics

data FuzzyQuery = FuzzyQuery
  { FuzzyQuery -> FieldName
fuzzyQueryField :: FieldName,
    FuzzyQuery -> Text
fuzzyQueryValue :: Text,
    FuzzyQuery -> PrefixLength
fuzzyQueryPrefixLength :: PrefixLength,
    FuzzyQuery -> MaxExpansions
fuzzyQueryMaxExpansions :: MaxExpansions,
    FuzzyQuery -> Fuzziness
fuzzyQueryFuzziness :: Fuzziness,
    FuzzyQuery -> Maybe Boost
fuzzyQueryBoost :: Maybe Boost
  }
  deriving stock (FuzzyQuery -> FuzzyQuery -> Bool
(FuzzyQuery -> FuzzyQuery -> Bool)
-> (FuzzyQuery -> FuzzyQuery -> Bool) -> Eq FuzzyQuery
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FuzzyQuery -> FuzzyQuery -> Bool
== :: FuzzyQuery -> FuzzyQuery -> Bool
$c/= :: FuzzyQuery -> FuzzyQuery -> Bool
/= :: FuzzyQuery -> FuzzyQuery -> Bool
Eq, Int -> FuzzyQuery -> ShowS
[FuzzyQuery] -> ShowS
FuzzyQuery -> String
(Int -> FuzzyQuery -> ShowS)
-> (FuzzyQuery -> String)
-> ([FuzzyQuery] -> ShowS)
-> Show FuzzyQuery
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FuzzyQuery -> ShowS
showsPrec :: Int -> FuzzyQuery -> ShowS
$cshow :: FuzzyQuery -> String
show :: FuzzyQuery -> String
$cshowList :: [FuzzyQuery] -> ShowS
showList :: [FuzzyQuery] -> ShowS
Show, (forall x. FuzzyQuery -> Rep FuzzyQuery x)
-> (forall x. Rep FuzzyQuery x -> FuzzyQuery) -> Generic FuzzyQuery
forall x. Rep FuzzyQuery x -> FuzzyQuery
forall x. FuzzyQuery -> Rep FuzzyQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FuzzyQuery -> Rep FuzzyQuery x
from :: forall x. FuzzyQuery -> Rep FuzzyQuery x
$cto :: forall x. Rep FuzzyQuery x -> FuzzyQuery
to :: forall x. Rep FuzzyQuery x -> FuzzyQuery
Generic)

fuzzyQueryFieldLens :: Lens' FuzzyQuery FieldName
fuzzyQueryFieldLens :: Lens' FuzzyQuery FieldName
fuzzyQueryFieldLens = (FuzzyQuery -> FieldName)
-> (FuzzyQuery -> FieldName -> FuzzyQuery)
-> Lens' FuzzyQuery FieldName
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyQuery -> FieldName
fuzzyQueryField (\FuzzyQuery
x FieldName
y -> FuzzyQuery
x {fuzzyQueryField = y})

fuzzyQueryValueLens :: Lens' FuzzyQuery Text
fuzzyQueryValueLens :: Lens' FuzzyQuery Text
fuzzyQueryValueLens = (FuzzyQuery -> Text)
-> (FuzzyQuery -> Text -> FuzzyQuery) -> Lens' FuzzyQuery Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyQuery -> Text
fuzzyQueryValue (\FuzzyQuery
x Text
y -> FuzzyQuery
x {fuzzyQueryValue = y})

fuzzyQueryPrefixLengthLens :: Lens' FuzzyQuery PrefixLength
fuzzyQueryPrefixLengthLens :: Lens' FuzzyQuery PrefixLength
fuzzyQueryPrefixLengthLens = (FuzzyQuery -> PrefixLength)
-> (FuzzyQuery -> PrefixLength -> FuzzyQuery)
-> Lens' FuzzyQuery PrefixLength
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyQuery -> PrefixLength
fuzzyQueryPrefixLength (\FuzzyQuery
x PrefixLength
y -> FuzzyQuery
x {fuzzyQueryPrefixLength = y})

fuzzyQueryMaxExpansionsLens :: Lens' FuzzyQuery MaxExpansions
fuzzyQueryMaxExpansionsLens :: Lens' FuzzyQuery MaxExpansions
fuzzyQueryMaxExpansionsLens = (FuzzyQuery -> MaxExpansions)
-> (FuzzyQuery -> MaxExpansions -> FuzzyQuery)
-> Lens' FuzzyQuery MaxExpansions
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyQuery -> MaxExpansions
fuzzyQueryMaxExpansions (\FuzzyQuery
x MaxExpansions
y -> FuzzyQuery
x {fuzzyQueryMaxExpansions = y})

fuzzyQueryFuzzinessLens :: Lens' FuzzyQuery Fuzziness
fuzzyQueryFuzzinessLens :: Lens' FuzzyQuery Fuzziness
fuzzyQueryFuzzinessLens = (FuzzyQuery -> Fuzziness)
-> (FuzzyQuery -> Fuzziness -> FuzzyQuery)
-> Lens' FuzzyQuery Fuzziness
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyQuery -> Fuzziness
fuzzyQueryFuzziness (\FuzzyQuery
x Fuzziness
y -> FuzzyQuery
x {fuzzyQueryFuzziness = y})

fuzzyQueryBoostLens :: Lens' FuzzyQuery (Maybe Boost)
fuzzyQueryBoostLens :: Lens' FuzzyQuery (Maybe Boost)
fuzzyQueryBoostLens = (FuzzyQuery -> Maybe Boost)
-> (FuzzyQuery -> Maybe Boost -> FuzzyQuery)
-> Lens' FuzzyQuery (Maybe Boost)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyQuery -> Maybe Boost
fuzzyQueryBoost (\FuzzyQuery
x Maybe Boost
y -> FuzzyQuery
x {fuzzyQueryBoost = y})

instance ToJSON FuzzyQuery where
  toJSON :: FuzzyQuery -> Value
toJSON
    ( FuzzyQuery
        (FieldName Text
fieldName)
        Text
queryText
        PrefixLength
prefixLength
        MaxExpansions
maxEx
        Fuzziness
fuzziness
        Maybe Boost
boost
      ) =
      [Pair] -> Value
object [Text -> Key
fromText Text
fieldName Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Pair]
base]
      where
        base :: [Pair]
base =
          [ Key
"value" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
queryText,
            Key
"fuzziness" Key -> Fuzziness -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Fuzziness
fuzziness,
            Key
"prefix_length" Key -> PrefixLength -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= PrefixLength
prefixLength,
            Key
"boost" Key -> Maybe Boost -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost,
            Key
"max_expansions" Key -> MaxExpansions -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= MaxExpansions
maxEx
          ]

instance FromJSON FuzzyQuery where
  parseJSON :: Value -> Parser FuzzyQuery
parseJSON = String
-> (Object -> Parser FuzzyQuery) -> Value -> Parser FuzzyQuery
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"FuzzyQuery" Object -> Parser FuzzyQuery
parse
    where
      parse :: Object -> Parser FuzzyQuery
parse = (FieldName -> Object -> Parser FuzzyQuery)
-> Object -> Parser FuzzyQuery
forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged ((FieldName -> Object -> Parser FuzzyQuery)
 -> Object -> Parser FuzzyQuery)
-> (FieldName -> Object -> Parser FuzzyQuery)
-> Object
-> Parser FuzzyQuery
forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
        FieldName
-> Text
-> PrefixLength
-> MaxExpansions
-> Fuzziness
-> Maybe Boost
-> FuzzyQuery
FuzzyQuery FieldName
fn
          (Text
 -> PrefixLength
 -> MaxExpansions
 -> Fuzziness
 -> Maybe Boost
 -> FuzzyQuery)
-> Parser Text
-> Parser
     (PrefixLength
      -> MaxExpansions -> Fuzziness -> Maybe Boost -> FuzzyQuery)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
          Parser
  (PrefixLength
   -> MaxExpansions -> Fuzziness -> Maybe Boost -> FuzzyQuery)
-> Parser PrefixLength
-> Parser (MaxExpansions -> Fuzziness -> Maybe Boost -> FuzzyQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser PrefixLength
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"prefix_length"
          Parser (MaxExpansions -> Fuzziness -> Maybe Boost -> FuzzyQuery)
-> Parser MaxExpansions
-> Parser (Fuzziness -> Maybe Boost -> FuzzyQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser MaxExpansions
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"max_expansions"
          Parser (Fuzziness -> Maybe Boost -> FuzzyQuery)
-> Parser Fuzziness -> Parser (Maybe Boost -> FuzzyQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Fuzziness
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"fuzziness"
          Parser (Maybe Boost -> FuzzyQuery)
-> Parser (Maybe Boost) -> Parser FuzzyQuery
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe Boost)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"

data FuzzyLikeFieldQuery = FuzzyLikeFieldQuery
  { FuzzyLikeFieldQuery -> FieldName
fuzzyLikeField :: FieldName,
    -- anaphora is good for the soul.
    FuzzyLikeFieldQuery -> Text
fuzzyLikeFieldText :: Text,
    FuzzyLikeFieldQuery -> MaxQueryTerms
fuzzyLikeFieldMaxQueryTerms :: MaxQueryTerms,
    FuzzyLikeFieldQuery -> IgnoreTermFrequency
fuzzyLikeFieldIgnoreTermFrequency :: IgnoreTermFrequency,
    FuzzyLikeFieldQuery -> Fuzziness
fuzzyLikeFieldFuzziness :: Fuzziness,
    FuzzyLikeFieldQuery -> PrefixLength
fuzzyLikeFieldPrefixLength :: PrefixLength,
    FuzzyLikeFieldQuery -> Boost
fuzzyLikeFieldBoost :: Boost,
    FuzzyLikeFieldQuery -> Maybe Analyzer
fuzzyLikeFieldAnalyzer :: Maybe Analyzer
  }
  deriving stock (FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool
(FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool)
-> (FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool)
-> Eq FuzzyLikeFieldQuery
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool
== :: FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool
$c/= :: FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool
/= :: FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool
Eq, Int -> FuzzyLikeFieldQuery -> ShowS
[FuzzyLikeFieldQuery] -> ShowS
FuzzyLikeFieldQuery -> String
(Int -> FuzzyLikeFieldQuery -> ShowS)
-> (FuzzyLikeFieldQuery -> String)
-> ([FuzzyLikeFieldQuery] -> ShowS)
-> Show FuzzyLikeFieldQuery
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FuzzyLikeFieldQuery -> ShowS
showsPrec :: Int -> FuzzyLikeFieldQuery -> ShowS
$cshow :: FuzzyLikeFieldQuery -> String
show :: FuzzyLikeFieldQuery -> String
$cshowList :: [FuzzyLikeFieldQuery] -> ShowS
showList :: [FuzzyLikeFieldQuery] -> ShowS
Show, (forall x. FuzzyLikeFieldQuery -> Rep FuzzyLikeFieldQuery x)
-> (forall x. Rep FuzzyLikeFieldQuery x -> FuzzyLikeFieldQuery)
-> Generic FuzzyLikeFieldQuery
forall x. Rep FuzzyLikeFieldQuery x -> FuzzyLikeFieldQuery
forall x. FuzzyLikeFieldQuery -> Rep FuzzyLikeFieldQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FuzzyLikeFieldQuery -> Rep FuzzyLikeFieldQuery x
from :: forall x. FuzzyLikeFieldQuery -> Rep FuzzyLikeFieldQuery x
$cto :: forall x. Rep FuzzyLikeFieldQuery x -> FuzzyLikeFieldQuery
to :: forall x. Rep FuzzyLikeFieldQuery x -> FuzzyLikeFieldQuery
Generic)

fuzzyLikeFieldQueryFieldLens :: Lens' FuzzyLikeFieldQuery FieldName
fuzzyLikeFieldQueryFieldLens :: Lens' FuzzyLikeFieldQuery FieldName
fuzzyLikeFieldQueryFieldLens = (FuzzyLikeFieldQuery -> FieldName)
-> (FuzzyLikeFieldQuery -> FieldName -> FuzzyLikeFieldQuery)
-> Lens' FuzzyLikeFieldQuery FieldName
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyLikeFieldQuery -> FieldName
fuzzyLikeField (\FuzzyLikeFieldQuery
x FieldName
y -> FuzzyLikeFieldQuery
x {fuzzyLikeField = y})

fuzzyLikeFieldQueryTextLens :: Lens' FuzzyLikeFieldQuery Text
fuzzyLikeFieldQueryTextLens :: Lens' FuzzyLikeFieldQuery Text
fuzzyLikeFieldQueryTextLens = (FuzzyLikeFieldQuery -> Text)
-> (FuzzyLikeFieldQuery -> Text -> FuzzyLikeFieldQuery)
-> Lens' FuzzyLikeFieldQuery Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyLikeFieldQuery -> Text
fuzzyLikeFieldText (\FuzzyLikeFieldQuery
x Text
y -> FuzzyLikeFieldQuery
x {fuzzyLikeFieldText = y})

fuzzyLikeFieldQueryMaxQueryTermsLens :: Lens' FuzzyLikeFieldQuery MaxQueryTerms
fuzzyLikeFieldQueryMaxQueryTermsLens :: Lens' FuzzyLikeFieldQuery MaxQueryTerms
fuzzyLikeFieldQueryMaxQueryTermsLens = (FuzzyLikeFieldQuery -> MaxQueryTerms)
-> (FuzzyLikeFieldQuery -> MaxQueryTerms -> FuzzyLikeFieldQuery)
-> Lens' FuzzyLikeFieldQuery MaxQueryTerms
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyLikeFieldQuery -> MaxQueryTerms
fuzzyLikeFieldMaxQueryTerms (\FuzzyLikeFieldQuery
x MaxQueryTerms
y -> FuzzyLikeFieldQuery
x {fuzzyLikeFieldMaxQueryTerms = y})

fuzzyLikeFieldQueryIgnoreTermFrequencyLens :: Lens' FuzzyLikeFieldQuery IgnoreTermFrequency
fuzzyLikeFieldQueryIgnoreTermFrequencyLens :: Lens' FuzzyLikeFieldQuery IgnoreTermFrequency
fuzzyLikeFieldQueryIgnoreTermFrequencyLens = (FuzzyLikeFieldQuery -> IgnoreTermFrequency)
-> (FuzzyLikeFieldQuery
    -> IgnoreTermFrequency -> FuzzyLikeFieldQuery)
-> Lens' FuzzyLikeFieldQuery IgnoreTermFrequency
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyLikeFieldQuery -> IgnoreTermFrequency
fuzzyLikeFieldIgnoreTermFrequency (\FuzzyLikeFieldQuery
x IgnoreTermFrequency
y -> FuzzyLikeFieldQuery
x {fuzzyLikeFieldIgnoreTermFrequency = y})

fuzzyLikeFieldQueryFuzzinessLens :: Lens' FuzzyLikeFieldQuery Fuzziness
fuzzyLikeFieldQueryFuzzinessLens :: Lens' FuzzyLikeFieldQuery Fuzziness
fuzzyLikeFieldQueryFuzzinessLens = (FuzzyLikeFieldQuery -> Fuzziness)
-> (FuzzyLikeFieldQuery -> Fuzziness -> FuzzyLikeFieldQuery)
-> Lens' FuzzyLikeFieldQuery Fuzziness
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyLikeFieldQuery -> Fuzziness
fuzzyLikeFieldFuzziness (\FuzzyLikeFieldQuery
x Fuzziness
y -> FuzzyLikeFieldQuery
x {fuzzyLikeFieldFuzziness = y})

fuzzyLikeFieldQueryPrefixLengthLens :: Lens' FuzzyLikeFieldQuery PrefixLength
fuzzyLikeFieldQueryPrefixLengthLens :: Lens' FuzzyLikeFieldQuery PrefixLength
fuzzyLikeFieldQueryPrefixLengthLens = (FuzzyLikeFieldQuery -> PrefixLength)
-> (FuzzyLikeFieldQuery -> PrefixLength -> FuzzyLikeFieldQuery)
-> Lens' FuzzyLikeFieldQuery PrefixLength
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyLikeFieldQuery -> PrefixLength
fuzzyLikeFieldPrefixLength (\FuzzyLikeFieldQuery
x PrefixLength
y -> FuzzyLikeFieldQuery
x {fuzzyLikeFieldPrefixLength = y})

fuzzyLikeFieldQueryBoostLens :: Lens' FuzzyLikeFieldQuery Boost
fuzzyLikeFieldQueryBoostLens :: Lens' FuzzyLikeFieldQuery Boost
fuzzyLikeFieldQueryBoostLens = (FuzzyLikeFieldQuery -> Boost)
-> (FuzzyLikeFieldQuery -> Boost -> FuzzyLikeFieldQuery)
-> Lens' FuzzyLikeFieldQuery Boost
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyLikeFieldQuery -> Boost
fuzzyLikeFieldBoost (\FuzzyLikeFieldQuery
x Boost
y -> FuzzyLikeFieldQuery
x {fuzzyLikeFieldBoost = y})

fuzzyLikeFieldQueryAnalyzerLens :: Lens' FuzzyLikeFieldQuery (Maybe Analyzer)
fuzzyLikeFieldQueryAnalyzerLens :: Lens' FuzzyLikeFieldQuery (Maybe Analyzer)
fuzzyLikeFieldQueryAnalyzerLens = (FuzzyLikeFieldQuery -> Maybe Analyzer)
-> (FuzzyLikeFieldQuery -> Maybe Analyzer -> FuzzyLikeFieldQuery)
-> Lens' FuzzyLikeFieldQuery (Maybe Analyzer)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyLikeFieldQuery -> Maybe Analyzer
fuzzyLikeFieldAnalyzer (\FuzzyLikeFieldQuery
x Maybe Analyzer
y -> FuzzyLikeFieldQuery
x {fuzzyLikeFieldAnalyzer = y})

instance ToJSON FuzzyLikeFieldQuery where
  toJSON :: FuzzyLikeFieldQuery -> Value
toJSON
    ( FuzzyLikeFieldQuery
        (FieldName Text
fieldName)
        Text
fieldText
        MaxQueryTerms
maxTerms
        IgnoreTermFrequency
ignoreFreq
        Fuzziness
fuzziness
        PrefixLength
prefixLength
        Boost
boost
        Maybe Analyzer
analyzer
      ) =
      [Pair] -> Value
object
        [ Text -> Key
fromText Text
fieldName
            Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls
              [ Key
"like_text" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
fieldText,
                Key
"max_query_terms" Key -> MaxQueryTerms -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= MaxQueryTerms
maxTerms,
                Key
"ignore_tf" Key -> IgnoreTermFrequency -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= IgnoreTermFrequency
ignoreFreq,
                Key
"fuzziness" Key -> Fuzziness -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Fuzziness
fuzziness,
                Key
"prefix_length" Key -> PrefixLength -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= PrefixLength
prefixLength,
                Key
"analyzer" Key -> Maybe Analyzer -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
analyzer,
                Key
"boost" Key -> Boost -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Boost
boost
              ]
        ]

instance FromJSON FuzzyLikeFieldQuery where
  parseJSON :: Value -> Parser FuzzyLikeFieldQuery
parseJSON = String
-> (Object -> Parser FuzzyLikeFieldQuery)
-> Value
-> Parser FuzzyLikeFieldQuery
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"FuzzyLikeFieldQuery" Object -> Parser FuzzyLikeFieldQuery
parse
    where
      parse :: Object -> Parser FuzzyLikeFieldQuery
parse = (FieldName -> Object -> Parser FuzzyLikeFieldQuery)
-> Object -> Parser FuzzyLikeFieldQuery
forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged ((FieldName -> Object -> Parser FuzzyLikeFieldQuery)
 -> Object -> Parser FuzzyLikeFieldQuery)
-> (FieldName -> Object -> Parser FuzzyLikeFieldQuery)
-> Object
-> Parser FuzzyLikeFieldQuery
forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
        FieldName
-> Text
-> MaxQueryTerms
-> IgnoreTermFrequency
-> Fuzziness
-> PrefixLength
-> Boost
-> Maybe Analyzer
-> FuzzyLikeFieldQuery
FuzzyLikeFieldQuery FieldName
fn
          (Text
 -> MaxQueryTerms
 -> IgnoreTermFrequency
 -> Fuzziness
 -> PrefixLength
 -> Boost
 -> Maybe Analyzer
 -> FuzzyLikeFieldQuery)
-> Parser Text
-> Parser
     (MaxQueryTerms
      -> IgnoreTermFrequency
      -> Fuzziness
      -> PrefixLength
      -> Boost
      -> Maybe Analyzer
      -> FuzzyLikeFieldQuery)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"like_text"
          Parser
  (MaxQueryTerms
   -> IgnoreTermFrequency
   -> Fuzziness
   -> PrefixLength
   -> Boost
   -> Maybe Analyzer
   -> FuzzyLikeFieldQuery)
-> Parser MaxQueryTerms
-> Parser
     (IgnoreTermFrequency
      -> Fuzziness
      -> PrefixLength
      -> Boost
      -> Maybe Analyzer
      -> FuzzyLikeFieldQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser MaxQueryTerms
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"max_query_terms"
          Parser
  (IgnoreTermFrequency
   -> Fuzziness
   -> PrefixLength
   -> Boost
   -> Maybe Analyzer
   -> FuzzyLikeFieldQuery)
-> Parser IgnoreTermFrequency
-> Parser
     (Fuzziness
      -> PrefixLength -> Boost -> Maybe Analyzer -> FuzzyLikeFieldQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser IgnoreTermFrequency
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"ignore_tf"
          Parser
  (Fuzziness
   -> PrefixLength -> Boost -> Maybe Analyzer -> FuzzyLikeFieldQuery)
-> Parser Fuzziness
-> Parser
     (PrefixLength -> Boost -> Maybe Analyzer -> FuzzyLikeFieldQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Fuzziness
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"fuzziness"
          Parser
  (PrefixLength -> Boost -> Maybe Analyzer -> FuzzyLikeFieldQuery)
-> Parser PrefixLength
-> Parser (Boost -> Maybe Analyzer -> FuzzyLikeFieldQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser PrefixLength
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"prefix_length"
          Parser (Boost -> Maybe Analyzer -> FuzzyLikeFieldQuery)
-> Parser Boost -> Parser (Maybe Analyzer -> FuzzyLikeFieldQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Boost
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"boost"
          Parser (Maybe Analyzer -> FuzzyLikeFieldQuery)
-> Parser (Maybe Analyzer) -> Parser FuzzyLikeFieldQuery
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe Analyzer)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"

data FuzzyLikeThisQuery = FuzzyLikeThisQuery
  { FuzzyLikeThisQuery -> [FieldName]
fuzzyLikeFields :: [FieldName],
    FuzzyLikeThisQuery -> Text
fuzzyLikeText :: Text,
    FuzzyLikeThisQuery -> MaxQueryTerms
fuzzyLikeMaxQueryTerms :: MaxQueryTerms,
    FuzzyLikeThisQuery -> IgnoreTermFrequency
fuzzyLikeIgnoreTermFrequency :: IgnoreTermFrequency,
    FuzzyLikeThisQuery -> Fuzziness
fuzzyLikeFuzziness :: Fuzziness,
    FuzzyLikeThisQuery -> PrefixLength
fuzzyLikePrefixLength :: PrefixLength,
    FuzzyLikeThisQuery -> Boost
fuzzyLikeBoost :: Boost,
    FuzzyLikeThisQuery -> Maybe Analyzer
fuzzyLikeAnalyzer :: Maybe Analyzer
  }
  deriving stock (FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool
(FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool)
-> (FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool)
-> Eq FuzzyLikeThisQuery
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool
== :: FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool
$c/= :: FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool
/= :: FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool
Eq, Int -> FuzzyLikeThisQuery -> ShowS
[FuzzyLikeThisQuery] -> ShowS
FuzzyLikeThisQuery -> String
(Int -> FuzzyLikeThisQuery -> ShowS)
-> (FuzzyLikeThisQuery -> String)
-> ([FuzzyLikeThisQuery] -> ShowS)
-> Show FuzzyLikeThisQuery
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FuzzyLikeThisQuery -> ShowS
showsPrec :: Int -> FuzzyLikeThisQuery -> ShowS
$cshow :: FuzzyLikeThisQuery -> String
show :: FuzzyLikeThisQuery -> String
$cshowList :: [FuzzyLikeThisQuery] -> ShowS
showList :: [FuzzyLikeThisQuery] -> ShowS
Show, (forall x. FuzzyLikeThisQuery -> Rep FuzzyLikeThisQuery x)
-> (forall x. Rep FuzzyLikeThisQuery x -> FuzzyLikeThisQuery)
-> Generic FuzzyLikeThisQuery
forall x. Rep FuzzyLikeThisQuery x -> FuzzyLikeThisQuery
forall x. FuzzyLikeThisQuery -> Rep FuzzyLikeThisQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FuzzyLikeThisQuery -> Rep FuzzyLikeThisQuery x
from :: forall x. FuzzyLikeThisQuery -> Rep FuzzyLikeThisQuery x
$cto :: forall x. Rep FuzzyLikeThisQuery x -> FuzzyLikeThisQuery
to :: forall x. Rep FuzzyLikeThisQuery x -> FuzzyLikeThisQuery
Generic)

fuzzyLikeThisQueryFieldsLens :: Lens' FuzzyLikeThisQuery [FieldName]
fuzzyLikeThisQueryFieldsLens :: Lens' FuzzyLikeThisQuery [FieldName]
fuzzyLikeThisQueryFieldsLens = (FuzzyLikeThisQuery -> [FieldName])
-> (FuzzyLikeThisQuery -> [FieldName] -> FuzzyLikeThisQuery)
-> Lens' FuzzyLikeThisQuery [FieldName]
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyLikeThisQuery -> [FieldName]
fuzzyLikeFields (\FuzzyLikeThisQuery
x [FieldName]
y -> FuzzyLikeThisQuery
x {fuzzyLikeFields = y})

fuzzyLikeThisQueryTextLens :: Lens' FuzzyLikeThisQuery Text
fuzzyLikeThisQueryTextLens :: Lens' FuzzyLikeThisQuery Text
fuzzyLikeThisQueryTextLens = (FuzzyLikeThisQuery -> Text)
-> (FuzzyLikeThisQuery -> Text -> FuzzyLikeThisQuery)
-> Lens' FuzzyLikeThisQuery Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyLikeThisQuery -> Text
fuzzyLikeText (\FuzzyLikeThisQuery
x Text
y -> FuzzyLikeThisQuery
x {fuzzyLikeText = y})

fuzzyLikeThisQueryMaxQueryTermsLens :: Lens' FuzzyLikeThisQuery MaxQueryTerms
fuzzyLikeThisQueryMaxQueryTermsLens :: Lens' FuzzyLikeThisQuery MaxQueryTerms
fuzzyLikeThisQueryMaxQueryTermsLens = (FuzzyLikeThisQuery -> MaxQueryTerms)
-> (FuzzyLikeThisQuery -> MaxQueryTerms -> FuzzyLikeThisQuery)
-> Lens' FuzzyLikeThisQuery MaxQueryTerms
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyLikeThisQuery -> MaxQueryTerms
fuzzyLikeMaxQueryTerms (\FuzzyLikeThisQuery
x MaxQueryTerms
y -> FuzzyLikeThisQuery
x {fuzzyLikeMaxQueryTerms = y})

fuzzyLikeThisQueryIgnoreTermFrequencyLens :: Lens' FuzzyLikeThisQuery IgnoreTermFrequency
fuzzyLikeThisQueryIgnoreTermFrequencyLens :: Lens' FuzzyLikeThisQuery IgnoreTermFrequency
fuzzyLikeThisQueryIgnoreTermFrequencyLens = (FuzzyLikeThisQuery -> IgnoreTermFrequency)
-> (FuzzyLikeThisQuery
    -> IgnoreTermFrequency -> FuzzyLikeThisQuery)
-> Lens' FuzzyLikeThisQuery IgnoreTermFrequency
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyLikeThisQuery -> IgnoreTermFrequency
fuzzyLikeIgnoreTermFrequency (\FuzzyLikeThisQuery
x IgnoreTermFrequency
y -> FuzzyLikeThisQuery
x {fuzzyLikeIgnoreTermFrequency = y})

fuzzyLikeThisQueryFuzzinessLens :: Lens' FuzzyLikeThisQuery Fuzziness
fuzzyLikeThisQueryFuzzinessLens :: Lens' FuzzyLikeThisQuery Fuzziness
fuzzyLikeThisQueryFuzzinessLens = (FuzzyLikeThisQuery -> Fuzziness)
-> (FuzzyLikeThisQuery -> Fuzziness -> FuzzyLikeThisQuery)
-> Lens' FuzzyLikeThisQuery Fuzziness
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyLikeThisQuery -> Fuzziness
fuzzyLikeFuzziness (\FuzzyLikeThisQuery
x Fuzziness
y -> FuzzyLikeThisQuery
x {fuzzyLikeFuzziness = y})

fuzzyLikeThisQueryPrefixLengthLens :: Lens' FuzzyLikeThisQuery PrefixLength
fuzzyLikeThisQueryPrefixLengthLens :: Lens' FuzzyLikeThisQuery PrefixLength
fuzzyLikeThisQueryPrefixLengthLens = (FuzzyLikeThisQuery -> PrefixLength)
-> (FuzzyLikeThisQuery -> PrefixLength -> FuzzyLikeThisQuery)
-> Lens' FuzzyLikeThisQuery PrefixLength
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyLikeThisQuery -> PrefixLength
fuzzyLikePrefixLength (\FuzzyLikeThisQuery
x PrefixLength
y -> FuzzyLikeThisQuery
x {fuzzyLikePrefixLength = y})

fuzzyLikeThisQueryBoostLens :: Lens' FuzzyLikeThisQuery Boost
fuzzyLikeThisQueryBoostLens :: Lens' FuzzyLikeThisQuery Boost
fuzzyLikeThisQueryBoostLens = (FuzzyLikeThisQuery -> Boost)
-> (FuzzyLikeThisQuery -> Boost -> FuzzyLikeThisQuery)
-> Lens' FuzzyLikeThisQuery Boost
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyLikeThisQuery -> Boost
fuzzyLikeBoost (\FuzzyLikeThisQuery
x Boost
y -> FuzzyLikeThisQuery
x {fuzzyLikeBoost = y})

fuzzyLikeThisQueryAnalyzerLens :: Lens' FuzzyLikeThisQuery (Maybe Analyzer)
fuzzyLikeThisQueryAnalyzerLens :: Lens' FuzzyLikeThisQuery (Maybe Analyzer)
fuzzyLikeThisQueryAnalyzerLens = (FuzzyLikeThisQuery -> Maybe Analyzer)
-> (FuzzyLikeThisQuery -> Maybe Analyzer -> FuzzyLikeThisQuery)
-> Lens' FuzzyLikeThisQuery (Maybe Analyzer)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
lens FuzzyLikeThisQuery -> Maybe Analyzer
fuzzyLikeAnalyzer (\FuzzyLikeThisQuery
x Maybe Analyzer
y -> FuzzyLikeThisQuery
x {fuzzyLikeAnalyzer = y})

instance ToJSON FuzzyLikeThisQuery where
  toJSON :: FuzzyLikeThisQuery -> Value
toJSON
    ( FuzzyLikeThisQuery
        [FieldName]
fields
        Text
text
        MaxQueryTerms
maxTerms
        IgnoreTermFrequency
ignoreFreq
        Fuzziness
fuzziness
        PrefixLength
prefixLength
        Boost
boost
        Maybe Analyzer
analyzer
      ) =
      [Pair] -> Value
omitNulls [Pair]
base
      where
        base :: [Pair]
base =
          [ Key
"fields" Key -> [FieldName] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [FieldName]
fields,
            Key
"like_text" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
text,
            Key
"max_query_terms" Key -> MaxQueryTerms -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= MaxQueryTerms
maxTerms,
            Key
"ignore_tf" Key -> IgnoreTermFrequency -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= IgnoreTermFrequency
ignoreFreq,
            Key
"fuzziness" Key -> Fuzziness -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Fuzziness
fuzziness,
            Key
"prefix_length" Key -> PrefixLength -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= PrefixLength
prefixLength,
            Key
"analyzer" Key -> Maybe Analyzer -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
analyzer,
            Key
"boost" Key -> Boost -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Boost
boost
          ]

instance FromJSON FuzzyLikeThisQuery where
  parseJSON :: Value -> Parser FuzzyLikeThisQuery
parseJSON = String
-> (Object -> Parser FuzzyLikeThisQuery)
-> Value
-> Parser FuzzyLikeThisQuery
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"FuzzyLikeThisQuery" Object -> Parser FuzzyLikeThisQuery
parse
    where
      parse :: Object -> Parser FuzzyLikeThisQuery
parse Object
o =
        [FieldName]
-> Text
-> MaxQueryTerms
-> IgnoreTermFrequency
-> Fuzziness
-> PrefixLength
-> Boost
-> Maybe Analyzer
-> FuzzyLikeThisQuery
FuzzyLikeThisQuery
          ([FieldName]
 -> Text
 -> MaxQueryTerms
 -> IgnoreTermFrequency
 -> Fuzziness
 -> PrefixLength
 -> Boost
 -> Maybe Analyzer
 -> FuzzyLikeThisQuery)
-> Parser [FieldName]
-> Parser
     (Text
      -> MaxQueryTerms
      -> IgnoreTermFrequency
      -> Fuzziness
      -> PrefixLength
      -> Boost
      -> Maybe Analyzer
      -> FuzzyLikeThisQuery)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Maybe [FieldName])
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"fields" Parser (Maybe [FieldName]) -> [FieldName] -> Parser [FieldName]
forall a. Parser (Maybe a) -> a -> Parser a
.!= []
          Parser
  (Text
   -> MaxQueryTerms
   -> IgnoreTermFrequency
   -> Fuzziness
   -> PrefixLength
   -> Boost
   -> Maybe Analyzer
   -> FuzzyLikeThisQuery)
-> Parser Text
-> Parser
     (MaxQueryTerms
      -> IgnoreTermFrequency
      -> Fuzziness
      -> PrefixLength
      -> Boost
      -> Maybe Analyzer
      -> FuzzyLikeThisQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"like_text"
          Parser
  (MaxQueryTerms
   -> IgnoreTermFrequency
   -> Fuzziness
   -> PrefixLength
   -> Boost
   -> Maybe Analyzer
   -> FuzzyLikeThisQuery)
-> Parser MaxQueryTerms
-> Parser
     (IgnoreTermFrequency
      -> Fuzziness
      -> PrefixLength
      -> Boost
      -> Maybe Analyzer
      -> FuzzyLikeThisQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser MaxQueryTerms
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"max_query_terms"
          Parser
  (IgnoreTermFrequency
   -> Fuzziness
   -> PrefixLength
   -> Boost
   -> Maybe Analyzer
   -> FuzzyLikeThisQuery)
-> Parser IgnoreTermFrequency
-> Parser
     (Fuzziness
      -> PrefixLength -> Boost -> Maybe Analyzer -> FuzzyLikeThisQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser IgnoreTermFrequency
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"ignore_tf"
          Parser
  (Fuzziness
   -> PrefixLength -> Boost -> Maybe Analyzer -> FuzzyLikeThisQuery)
-> Parser Fuzziness
-> Parser
     (PrefixLength -> Boost -> Maybe Analyzer -> FuzzyLikeThisQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Fuzziness
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"fuzziness"
          Parser
  (PrefixLength -> Boost -> Maybe Analyzer -> FuzzyLikeThisQuery)
-> Parser PrefixLength
-> Parser (Boost -> Maybe Analyzer -> FuzzyLikeThisQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser PrefixLength
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"prefix_length"
          Parser (Boost -> Maybe Analyzer -> FuzzyLikeThisQuery)
-> Parser Boost -> Parser (Maybe Analyzer -> FuzzyLikeThisQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Boost
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"boost"
          Parser (Maybe Analyzer -> FuzzyLikeThisQuery)
-> Parser (Maybe Analyzer) -> Parser FuzzyLikeThisQuery
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe Analyzer)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"