    {-# LANGUAGE DeriveLift #-}
    module Data.Aeson.JSONPath.Types.Filter
      (LogicalOrExpr (..)
      , LogicalAndExpr (..)
      , BasicExpr (..)
      , TestExpr (..)
      , ComparisonExpr (..)
      , ComparisonOp (..)
      , Comparable (..)
      , Literal (..)
      , SingularQueryType (..)
      , SingularQuery (..)
      , SingularQuerySegment (..)
      )
      where

    import Data.Text                   (Text)
    import Data.Scientific             (Scientific)

    import Language.Haskell.TH.Syntax  (Lift)

    import Prelude

    -- |
    newtype LogicalOrExpr a
      = LogicalOr [LogicalAndExpr a]
      deriving (LogicalOrExpr a -> LogicalOrExpr a -> Bool
    (LogicalOrExpr a -> LogicalOrExpr a -> Bool)
    -> (LogicalOrExpr a -> LogicalOrExpr a -> Bool)
    -> Eq (LogicalOrExpr a)
    forall a. Eq a => LogicalOrExpr a -> LogicalOrExpr a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => LogicalOrExpr a -> LogicalOrExpr a -> Bool
    == :: LogicalOrExpr a -> LogicalOrExpr a -> Bool
    $c/= :: forall a. Eq a => LogicalOrExpr a -> LogicalOrExpr a -> Bool
    /= :: LogicalOrExpr a -> LogicalOrExpr a -> Bool
    Eq, Int -> LogicalOrExpr a -> ShowS
    [LogicalOrExpr a] -> ShowS
    LogicalOrExpr a -> String
    (Int -> LogicalOrExpr a -> ShowS)
    -> (LogicalOrExpr a -> String)
    -> ([LogicalOrExpr a] -> ShowS)
    -> Show (LogicalOrExpr a)
    forall a. Show a => Int -> LogicalOrExpr a -> ShowS
    forall a. Show a => [LogicalOrExpr a] -> ShowS
    forall a. Show a => LogicalOrExpr a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> LogicalOrExpr a -> ShowS
    showsPrec :: Int -> LogicalOrExpr a -> ShowS
    $cshow :: forall a. Show a => LogicalOrExpr a -> String
    show :: LogicalOrExpr a -> String
    $cshowList :: forall a. Show a => [LogicalOrExpr a] -> ShowS
    showList :: [LogicalOrExpr a] -> ShowS
    Show, (forall (m :: * -> *). Quote m => LogicalOrExpr a -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        LogicalOrExpr a -> Code m (LogicalOrExpr a))
    -> Lift (LogicalOrExpr a)
    forall a (m :: * -> *).
    (Lift a, Quote m) =>
    LogicalOrExpr a -> m Exp
    forall a (m :: * -> *).
    (Lift a, Quote m) =>
    LogicalOrExpr a -> Code m (LogicalOrExpr a)
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => LogicalOrExpr a -> m Exp
    forall (m :: * -> *).
    Quote m =>
    LogicalOrExpr a -> Code m (LogicalOrExpr a)
    $clift :: forall a (m :: * -> *).
    (Lift a, Quote m) =>
    LogicalOrExpr a -> m Exp
    lift :: forall (m :: * -> *). Quote m => LogicalOrExpr a -> m Exp
    $cliftTyped :: forall a (m :: * -> *).
    (Lift a, Quote m) =>
    LogicalOrExpr a -> Code m (LogicalOrExpr a)
    liftTyped :: forall (m :: * -> *).
    Quote m =>
    LogicalOrExpr a -> Code m (LogicalOrExpr a)
    Lift)

    -- |
    newtype LogicalAndExpr a
      = LogicalAnd [BasicExpr a]
      deriving (LogicalAndExpr a -> LogicalAndExpr a -> Bool
    (LogicalAndExpr a -> LogicalAndExpr a -> Bool)
    -> (LogicalAndExpr a -> LogicalAndExpr a -> Bool)
    -> Eq (LogicalAndExpr a)
    forall a. Eq a => LogicalAndExpr a -> LogicalAndExpr a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => LogicalAndExpr a -> LogicalAndExpr a -> Bool
    == :: LogicalAndExpr a -> LogicalAndExpr a -> Bool
    $c/= :: forall a. Eq a => LogicalAndExpr a -> LogicalAndExpr a -> Bool
    /= :: LogicalAndExpr a -> LogicalAndExpr a -> Bool
    Eq, Int -> LogicalAndExpr a -> ShowS
    [LogicalAndExpr a] -> ShowS
    LogicalAndExpr a -> String
    (Int -> LogicalAndExpr a -> ShowS)
    -> (LogicalAndExpr a -> String)
    -> ([LogicalAndExpr a] -> ShowS)
    -> Show (LogicalAndExpr a)
    forall a. Show a => Int -> LogicalAndExpr a -> ShowS
    forall a. Show a => [LogicalAndExpr a] -> ShowS
    forall a. Show a => LogicalAndExpr a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> LogicalAndExpr a -> ShowS
    showsPrec :: Int -> LogicalAndExpr a -> ShowS
    $cshow :: forall a. Show a => LogicalAndExpr a -> String
    show :: LogicalAndExpr a -> String
    $cshowList :: forall a. Show a => [LogicalAndExpr a] -> ShowS
    showList :: [LogicalAndExpr a] -> ShowS
    Show, (forall (m :: * -> *). Quote m => LogicalAndExpr a -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        LogicalAndExpr a -> Code m (LogicalAndExpr a))
    -> Lift (LogicalAndExpr a)
    forall a (m :: * -> *).
    (Lift a, Quote m) =>
    LogicalAndExpr a -> m Exp
    forall a (m :: * -> *).
    (Lift a, Quote m) =>
    LogicalAndExpr a -> Code m (LogicalAndExpr a)
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => LogicalAndExpr a -> m Exp
    forall (m :: * -> *).
    Quote m =>
    LogicalAndExpr a -> Code m (LogicalAndExpr a)
    $clift :: forall a (m :: * -> *).
    (Lift a, Quote m) =>
    LogicalAndExpr a -> m Exp
    lift :: forall (m :: * -> *). Quote m => LogicalAndExpr a -> m Exp
    $cliftTyped :: forall a (m :: * -> *).
    (Lift a, Quote m) =>
    LogicalAndExpr a -> Code m (LogicalAndExpr a)
    liftTyped :: forall (m :: * -> *).
    Quote m =>
    LogicalAndExpr a -> Code m (LogicalAndExpr a)
    Lift)

    -- |
    data BasicExpr a
      = Paren (LogicalOrExpr a) -- ( expr )
      | NotParen (LogicalOrExpr a) -- not (expr)
      | Test (TestExpr a) -- query
      | NotTest (TestExpr a) -- not query
      | Comparison ComparisonExpr
      deriving (BasicExpr a -> BasicExpr a -> Bool
    (BasicExpr a -> BasicExpr a -> Bool)
    -> (BasicExpr a -> BasicExpr a -> Bool) -> Eq (BasicExpr a)
    forall a. Eq a => BasicExpr a -> BasicExpr a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => BasicExpr a -> BasicExpr a -> Bool
    == :: BasicExpr a -> BasicExpr a -> Bool
    $c/= :: forall a. Eq a => BasicExpr a -> BasicExpr a -> Bool
    /= :: BasicExpr a -> BasicExpr a -> Bool
    Eq, Int -> BasicExpr a -> ShowS
    [BasicExpr a] -> ShowS
    BasicExpr a -> String
    (Int -> BasicExpr a -> ShowS)
    -> (BasicExpr a -> String)
    -> ([BasicExpr a] -> ShowS)
    -> Show (BasicExpr a)
    forall a. Show a => Int -> BasicExpr a -> ShowS
    forall a. Show a => [BasicExpr a] -> ShowS
    forall a. Show a => BasicExpr a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> BasicExpr a -> ShowS
    showsPrec :: Int -> BasicExpr a -> ShowS
    $cshow :: forall a. Show a => BasicExpr a -> String
    show :: BasicExpr a -> String
    $cshowList :: forall a. Show a => [BasicExpr a] -> ShowS
    showList :: [BasicExpr a] -> ShowS
    Show, (forall (m :: * -> *). Quote m => BasicExpr a -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        BasicExpr a -> Code m (BasicExpr a))
    -> Lift (BasicExpr a)
    forall a (m :: * -> *). (Lift a, Quote m) => BasicExpr a -> m Exp
    forall a (m :: * -> *).
    (Lift a, Quote m) =>
    BasicExpr a -> Code m (BasicExpr a)
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => BasicExpr a -> m Exp
    forall (m :: * -> *).
    Quote m =>
    BasicExpr a -> Code m (BasicExpr a)
    $clift :: forall a (m :: * -> *). (Lift a, Quote m) => BasicExpr a -> m Exp
    lift :: forall (m :: * -> *). Quote m => BasicExpr a -> m Exp
    $cliftTyped :: forall a (m :: * -> *).
    (Lift a, Quote m) =>
    BasicExpr a -> Code m (BasicExpr a)
    liftTyped :: forall (m :: * -> *).
    Quote m =>
    BasicExpr a -> Code m (BasicExpr a)
    Lift)

    -- |
    newtype TestExpr a
      = FilterQuery a
      deriving (TestExpr a -> TestExpr a -> Bool
    (TestExpr a -> TestExpr a -> Bool)
    -> (TestExpr a -> TestExpr a -> Bool) -> Eq (TestExpr a)
    forall a. Eq a => TestExpr a -> TestExpr a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => TestExpr a -> TestExpr a -> Bool
    == :: TestExpr a -> TestExpr a -> Bool
    $c/= :: forall a. Eq a => TestExpr a -> TestExpr a -> Bool
    /= :: TestExpr a -> TestExpr a -> Bool
    Eq, Int -> TestExpr a -> ShowS
    [TestExpr a] -> ShowS
    TestExpr a -> String
    (Int -> TestExpr a -> ShowS)
    -> (TestExpr a -> String)
    -> ([TestExpr a] -> ShowS)
    -> Show (TestExpr a)
    forall a. Show a => Int -> TestExpr a -> ShowS
    forall a. Show a => [TestExpr a] -> ShowS
    forall a. Show a => TestExpr a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> TestExpr a -> ShowS
    showsPrec :: Int -> TestExpr a -> ShowS
    $cshow :: forall a. Show a => TestExpr a -> String
    show :: TestExpr a -> String
    $cshowList :: forall a. Show a => [TestExpr a] -> ShowS
    showList :: [TestExpr a] -> ShowS
    Show, (forall (m :: * -> *). Quote m => TestExpr a -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        TestExpr a -> Code m (TestExpr a))
    -> Lift (TestExpr a)
    forall a (m :: * -> *). (Lift a, Quote m) => TestExpr a -> m Exp
    forall a (m :: * -> *).
    (Lift a, Quote m) =>
    TestExpr a -> Code m (TestExpr a)
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => TestExpr a -> m Exp
    forall (m :: * -> *). Quote m => TestExpr a -> Code m (TestExpr a)
    $clift :: forall a (m :: * -> *). (Lift a, Quote m) => TestExpr a -> m Exp
    lift :: forall (m :: * -> *). Quote m => TestExpr a -> m Exp
    $cliftTyped :: forall a (m :: * -> *).
    (Lift a, Quote m) =>
    TestExpr a -> Code m (TestExpr a)
    liftTyped :: forall (m :: * -> *). Quote m => TestExpr a -> Code m (TestExpr a)
    Lift)

    -- |
    data ComparisonExpr
      = Comp Comparable ComparisonOp Comparable
      deriving (ComparisonExpr -> ComparisonExpr -> Bool
    (ComparisonExpr -> ComparisonExpr -> Bool)
    -> (ComparisonExpr -> ComparisonExpr -> Bool) -> Eq ComparisonExpr
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ComparisonExpr -> ComparisonExpr -> Bool
    == :: ComparisonExpr -> ComparisonExpr -> Bool
    $c/= :: ComparisonExpr -> ComparisonExpr -> Bool
    /= :: ComparisonExpr -> ComparisonExpr -> Bool
    Eq, Int -> ComparisonExpr -> ShowS
    [ComparisonExpr] -> ShowS
    ComparisonExpr -> String
    (Int -> ComparisonExpr -> ShowS)
    -> (ComparisonExpr -> String)
    -> ([ComparisonExpr] -> ShowS)
    -> Show ComparisonExpr
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ComparisonExpr -> ShowS
    showsPrec :: Int -> ComparisonExpr -> ShowS
    $cshow :: ComparisonExpr -> String
    show :: ComparisonExpr -> String
    $cshowList :: [ComparisonExpr] -> ShowS
    showList :: [ComparisonExpr] -> ShowS
    Show, (forall (m :: * -> *). Quote m => ComparisonExpr -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        ComparisonExpr -> Code m ComparisonExpr)
    -> Lift ComparisonExpr
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => ComparisonExpr -> m Exp
    forall (m :: * -> *).
    Quote m =>
    ComparisonExpr -> Code m ComparisonExpr
    $clift :: forall (m :: * -> *). Quote m => ComparisonExpr -> m Exp
    lift :: forall (m :: * -> *). Quote m => ComparisonExpr -> m Exp
    $cliftTyped :: forall (m :: * -> *).
    Quote m =>
    ComparisonExpr -> Code m ComparisonExpr
    liftTyped :: forall (m :: * -> *).
    Quote m =>
    ComparisonExpr -> Code m ComparisonExpr
    Lift)

    -- |
    data ComparisonOp
      = Less
      | LessOrEqual
      | Greater
      | GreaterOrEqual
      | Equal
      | NotEqual
      deriving (ComparisonOp -> ComparisonOp -> Bool
    (ComparisonOp -> ComparisonOp -> Bool)
    -> (ComparisonOp -> ComparisonOp -> Bool) -> Eq ComparisonOp
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ComparisonOp -> ComparisonOp -> Bool
    == :: ComparisonOp -> ComparisonOp -> Bool
    $c/= :: ComparisonOp -> ComparisonOp -> Bool
    /= :: ComparisonOp -> ComparisonOp -> Bool
    Eq, Int -> ComparisonOp -> ShowS
    [ComparisonOp] -> ShowS
    ComparisonOp -> String
    (Int -> ComparisonOp -> ShowS)
    -> (ComparisonOp -> String)
    -> ([ComparisonOp] -> ShowS)
    -> Show ComparisonOp
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ComparisonOp -> ShowS
    showsPrec :: Int -> ComparisonOp -> ShowS
    $cshow :: ComparisonOp -> String
    show :: ComparisonOp -> String
    $cshowList :: [ComparisonOp] -> ShowS
    showList :: [ComparisonOp] -> ShowS
    Show, (forall (m :: * -> *). Quote m => ComparisonOp -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        ComparisonOp -> Code m ComparisonOp)
    -> Lift ComparisonOp
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => ComparisonOp -> m Exp
    forall (m :: * -> *).
    Quote m =>
    ComparisonOp -> Code m ComparisonOp
    $clift :: forall (m :: * -> *). Quote m => ComparisonOp -> m Exp
    lift :: forall (m :: * -> *). Quote m => ComparisonOp -> m Exp
    $cliftTyped :: forall (m :: * -> *).
    Quote m =>
    ComparisonOp -> Code m ComparisonOp
    liftTyped :: forall (m :: * -> *).
    Quote m =>
    ComparisonOp -> Code m ComparisonOp
    Lift)

    -- |
    data Comparable
      = CompLit Literal
      | CompSQ SingularQuery
      deriving (Comparable -> Comparable -> Bool
    (Comparable -> Comparable -> Bool)
    -> (Comparable -> Comparable -> Bool) -> Eq Comparable
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Comparable -> Comparable -> Bool
    == :: Comparable -> Comparable -> Bool
    $c/= :: Comparable -> Comparable -> Bool
    /= :: Comparable -> Comparable -> Bool
    Eq, Int -> Comparable -> ShowS
    [Comparable] -> ShowS
    Comparable -> String
    (Int -> Comparable -> ShowS)
    -> (Comparable -> String)
    -> ([Comparable] -> ShowS)
    -> Show Comparable
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Comparable -> ShowS
    showsPrec :: Int -> Comparable -> ShowS
    $cshow :: Comparable -> String
    show :: Comparable -> String
    $cshowList :: [Comparable] -> ShowS
    showList :: [Comparable] -> ShowS
    Show, (forall (m :: * -> *). Quote m => Comparable -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        Comparable -> Code m Comparable)
    -> Lift Comparable
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => Comparable -> m Exp
    forall (m :: * -> *). Quote m => Comparable -> Code m Comparable
    $clift :: forall (m :: * -> *). Quote m => Comparable -> m Exp
    lift :: forall (m :: * -> *). Quote m => Comparable -> m Exp
    $cliftTyped :: forall (m :: * -> *). Quote m => Comparable -> Code m Comparable
    liftTyped :: forall (m :: * -> *). Quote m => Comparable -> Code m Comparable
    Lift)

    -- |
    data Literal
      = LitString Text
      | LitNum Scientific
      | LitBool Bool
      | LitNull
      deriving (Literal -> Literal -> Bool
    (Literal -> Literal -> Bool)
    -> (Literal -> Literal -> Bool) -> Eq Literal
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Literal -> Literal -> Bool
    == :: Literal -> Literal -> Bool
    $c/= :: Literal -> Literal -> Bool
    /= :: Literal -> Literal -> Bool
    Eq, Int -> Literal -> ShowS
    [Literal] -> ShowS
    Literal -> String
    (Int -> Literal -> ShowS)
    -> (Literal -> String) -> ([Literal] -> ShowS) -> Show Literal
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Literal -> ShowS
    showsPrec :: Int -> Literal -> ShowS
    $cshow :: Literal -> String
    show :: Literal -> String
    $cshowList :: [Literal] -> ShowS
    showList :: [Literal] -> ShowS
    Show, (forall (m :: * -> *). Quote m => Literal -> m Exp)
    -> (forall (m :: * -> *). Quote m => Literal -> Code m Literal)
    -> Lift Literal
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => Literal -> m Exp
    forall (m :: * -> *). Quote m => Literal -> Code m Literal
    $clift :: forall (m :: * -> *). Quote m => Literal -> m Exp
    lift :: forall (m :: * -> *). Quote m => Literal -> m Exp
    $cliftTyped :: forall (m :: * -> *). Quote m => Literal -> Code m Literal
    liftTyped :: forall (m :: * -> *). Quote m => Literal -> Code m Literal
    Lift)

    -- |
    data SingularQueryType = RootSQ | CurrentSQ
      deriving (SingularQueryType -> SingularQueryType -> Bool
    (SingularQueryType -> SingularQueryType -> Bool)
    -> (SingularQueryType -> SingularQueryType -> Bool)
    -> Eq SingularQueryType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SingularQueryType -> SingularQueryType -> Bool
    == :: SingularQueryType -> SingularQueryType -> Bool
    $c/= :: SingularQueryType -> SingularQueryType -> Bool
    /= :: SingularQueryType -> SingularQueryType -> Bool
    Eq, Int -> SingularQueryType -> ShowS
    [SingularQueryType] -> ShowS
    SingularQueryType -> String
    (Int -> SingularQueryType -> ShowS)
    -> (SingularQueryType -> String)
    -> ([SingularQueryType] -> ShowS)
    -> Show SingularQueryType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SingularQueryType -> ShowS
    showsPrec :: Int -> SingularQueryType -> ShowS
    $cshow :: SingularQueryType -> String
    show :: SingularQueryType -> String
    $cshowList :: [SingularQueryType] -> ShowS
    showList :: [SingularQueryType] -> ShowS
    Show, (forall (m :: * -> *). Quote m => SingularQueryType -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        SingularQueryType -> Code m SingularQueryType)
    -> Lift SingularQueryType
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => SingularQueryType -> m Exp
    forall (m :: * -> *).
    Quote m =>
    SingularQueryType -> Code m SingularQueryType
    $clift :: forall (m :: * -> *). Quote m => SingularQueryType -> m Exp
    lift :: forall (m :: * -> *). Quote m => SingularQueryType -> m Exp
    $cliftTyped :: forall (m :: * -> *).
    Quote m =>
    SingularQueryType -> Code m SingularQueryType
    liftTyped :: forall (m :: * -> *).
    Quote m =>
    SingularQueryType -> Code m SingularQueryType
    Lift)

    -- |
    data SingularQuery = SingularQuery
      { SingularQuery -> SingularQueryType
    singularQueryType     :: SingularQueryType
      , SingularQuery -> [SingularQuerySegment]
    singularQuerySegments :: [SingularQuerySegment]
      } deriving (SingularQuery -> SingularQuery -> Bool
    (SingularQuery -> SingularQuery -> Bool)
    -> (SingularQuery -> SingularQuery -> Bool) -> Eq SingularQuery
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SingularQuery -> SingularQuery -> Bool
    == :: SingularQuery -> SingularQuery -> Bool
    $c/= :: SingularQuery -> SingularQuery -> Bool
    /= :: SingularQuery -> SingularQuery -> Bool
    Eq, Int -> SingularQuery -> ShowS
    [SingularQuery] -> ShowS
    SingularQuery -> String
    (Int -> SingularQuery -> ShowS)
    -> (SingularQuery -> String)
    -> ([SingularQuery] -> ShowS)
    -> Show SingularQuery
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SingularQuery -> ShowS
    showsPrec :: Int -> SingularQuery -> ShowS
    $cshow :: SingularQuery -> String
    show :: SingularQuery -> String
    $cshowList :: [SingularQuery] -> ShowS
    showList :: [SingularQuery] -> ShowS
    Show, (forall (m :: * -> *). Quote m => SingularQuery -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        SingularQuery -> Code m SingularQuery)
    -> Lift SingularQuery
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => SingularQuery -> m Exp
    forall (m :: * -> *).
    Quote m =>
    SingularQuery -> Code m SingularQuery
    $clift :: forall (m :: * -> *). Quote m => SingularQuery -> m Exp
    lift :: forall (m :: * -> *). Quote m => SingularQuery -> m Exp
    $cliftTyped :: forall (m :: * -> *).
    Quote m =>
    SingularQuery -> Code m SingularQuery
    liftTyped :: forall (m :: * -> *).
    Quote m =>
    SingularQuery -> Code m SingularQuery
    Lift)

    -- |
    data SingularQuerySegment
      = NameSQSeg Text
      | IndexSQSeg Int
      deriving (SingularQuerySegment -> SingularQuerySegment -> Bool
    (SingularQuerySegment -> SingularQuerySegment -> Bool)
    -> (SingularQuerySegment -> SingularQuerySegment -> Bool)
    -> Eq SingularQuerySegment
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SingularQuerySegment -> SingularQuerySegment -> Bool
    == :: SingularQuerySegment -> SingularQuerySegment -> Bool
    $c/= :: SingularQuerySegment -> SingularQuerySegment -> Bool
    /= :: SingularQuerySegment -> SingularQuerySegment -> Bool
    Eq, Int -> SingularQuerySegment -> ShowS
    [SingularQuerySegment] -> ShowS
    SingularQuerySegment -> String
    (Int -> SingularQuerySegment -> ShowS)
    -> (SingularQuerySegment -> String)
    -> ([SingularQuerySegment] -> ShowS)
    -> Show SingularQuerySegment
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SingularQuerySegment -> ShowS
    showsPrec :: Int -> SingularQuerySegment -> ShowS
    $cshow :: SingularQuerySegment -> String
    show :: SingularQuerySegment -> String
    $cshowList :: [SingularQuerySegment] -> ShowS
    showList :: [SingularQuerySegment] -> ShowS
    Show, (forall (m :: * -> *). Quote m => SingularQuerySegment -> m Exp)
    -> (forall (m :: * -> *).
        Quote m =>
        SingularQuerySegment -> Code m SingularQuerySegment)
    -> Lift SingularQuerySegment
    forall t.
    (forall (m :: * -> *). Quote m => t -> m Exp)
    -> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
    forall (m :: * -> *). Quote m => SingularQuerySegment -> m Exp
    forall (m :: * -> *).
    Quote m =>
    SingularQuerySegment -> Code m SingularQuerySegment
    $clift :: forall (m :: * -> *). Quote m => SingularQuerySegment -> m Exp
    lift :: forall (m :: * -> *). Quote m => SingularQuerySegment -> m Exp
    $cliftTyped :: forall (m :: * -> *).
    Quote m =>
    SingularQuerySegment -> Code m SingularQuerySegment
    liftTyped :: forall (m :: * -> *).
    Quote m =>
    SingularQuerySegment -> Code m SingularQuerySegment
    Lift)