-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Monad transformer for the persistent API
--   
--   A monad transformer and mtl-style type class for using the persistent
--   API directly in your monad transformer stack.
@package persistent-mtl
@version 0.5.1


-- | Defines the <a>MonadRerunnableIO</a> type class that is functionally
--   equivalent to <a>MonadIO</a>, but use of it requires the user to
--   explicitly acknowledge that the given IO operation can be rerun.
module Control.Monad.IO.Rerunnable

-- | A copy of <a>MonadIO</a> to explicitly allow only IO operations that
--   are rerunnable, e.g. in the context of a SQL transaction.
class (Monad m) => MonadRerunnableIO m

-- | Lift the given IO operation to <tt>m</tt>.
--   
--   The given IO operation may be rerun, so use of this function requires
--   manually verifying that the given IO operation is rerunnable.
rerunnableIO :: MonadRerunnableIO m => IO a -> m a
instance Control.Monad.IO.Rerunnable.MonadRerunnableIO GHC.Types.IO
instance Control.Monad.IO.Rerunnable.MonadRerunnableIO m => Control.Monad.IO.Rerunnable.MonadRerunnableIO (Control.Monad.Trans.Reader.ReaderT r m)
instance Control.Monad.IO.Rerunnable.MonadRerunnableIO m => Control.Monad.IO.Rerunnable.MonadRerunnableIO (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.IO.Rerunnable.MonadRerunnableIO m => Control.Monad.IO.Rerunnable.MonadRerunnableIO (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.IO.Rerunnable.MonadRerunnableIO m => Control.Monad.IO.Rerunnable.MonadRerunnableIO (Control.Monad.Trans.Maybe.MaybeT m)
instance (GHC.Base.Monoid w, Control.Monad.IO.Rerunnable.MonadRerunnableIO m) => Control.Monad.IO.Rerunnable.MonadRerunnableIO (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (GHC.Base.Monoid w, Control.Monad.IO.Rerunnable.MonadRerunnableIO m) => Control.Monad.IO.Rerunnable.MonadRerunnableIO (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance Control.Monad.IO.Rerunnable.MonadRerunnableIO m => Control.Monad.IO.Rerunnable.MonadRerunnableIO (Control.Monad.Trans.State.Lazy.StateT s m)
instance Control.Monad.IO.Rerunnable.MonadRerunnableIO m => Control.Monad.IO.Rerunnable.MonadRerunnableIO (Control.Monad.Trans.State.Strict.StateT s m)
instance (GHC.Base.Monoid w, Control.Monad.IO.Rerunnable.MonadRerunnableIO m) => Control.Monad.IO.Rerunnable.MonadRerunnableIO (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (GHC.Base.Monoid w, Control.Monad.IO.Rerunnable.MonadRerunnableIO m) => Control.Monad.IO.Rerunnable.MonadRerunnableIO (Control.Monad.Trans.Writer.Strict.WriterT w m)
instance Control.Monad.IO.Rerunnable.MonadRerunnableIO m => Control.Monad.IO.Rerunnable.MonadRerunnableIO (Control.Monad.Trans.Resource.Internal.ResourceT m)


-- | Defines the <a>MonadRerunnableTrans</a> type class that is
--   functionally equivalent to <a>MonadTrans</a>, but use of it requires
--   the user to explicitly acknowledge that lifting the given action can
--   be rerun.
module Control.Monad.Trans.Rerunnable

-- | A copy of <a>MonadTrans</a> to explicitly allow only lifting actions
--   that are rerunnable, e.g. in the context of a SQL transaction.
class MonadRerunnableTrans t

-- | Lift the given action.
--   
--   The given action may be rerun, so use of this function requires
--   manually verifying that the given action is rerunnable.
rerunnableLift :: (MonadRerunnableTrans t, Monad m) => m a -> t m a
instance Control.Monad.Trans.Rerunnable.MonadRerunnableTrans (Control.Monad.Trans.Reader.ReaderT r)
instance Control.Monad.Trans.Rerunnable.MonadRerunnableTrans (Control.Monad.Trans.Except.ExceptT e)
instance Control.Monad.Trans.Rerunnable.MonadRerunnableTrans Control.Monad.Trans.Identity.IdentityT
instance Control.Monad.Trans.Rerunnable.MonadRerunnableTrans Control.Monad.Trans.Maybe.MaybeT
instance GHC.Base.Monoid w => Control.Monad.Trans.Rerunnable.MonadRerunnableTrans (Control.Monad.Trans.RWS.Lazy.RWST r w s)
instance GHC.Base.Monoid w => Control.Monad.Trans.Rerunnable.MonadRerunnableTrans (Control.Monad.Trans.RWS.Strict.RWST r w s)
instance Control.Monad.Trans.Rerunnable.MonadRerunnableTrans (Control.Monad.Trans.State.Lazy.StateT s)
instance Control.Monad.Trans.Rerunnable.MonadRerunnableTrans (Control.Monad.Trans.State.Strict.StateT s)
instance GHC.Base.Monoid w => Control.Monad.Trans.Rerunnable.MonadRerunnableTrans (Control.Monad.Trans.Writer.Lazy.WriterT w)
instance GHC.Base.Monoid w => Control.Monad.Trans.Rerunnable.MonadRerunnableTrans (Control.Monad.Trans.Writer.Strict.WriterT w)
instance Control.Monad.Trans.Rerunnable.MonadRerunnableTrans Control.Monad.Trans.Resource.Internal.ResourceT

module Database.Persist.Monad.Internal.PersistentShim

-- | A type class which is used to witness that a type is safe to insert
--   into the database without providing a primary key.
--   
--   The <tt>TemplateHaskell</tt> function <tt>mkPersist</tt> will generate
--   instances of this class for any entity that it works on. If the entity
--   has a default primary key, then it provides a regular instance. If the
--   entity has a <tt>Primary</tt> natural key, then this works fine. But
--   if the entity has an <tt>Id</tt> column with no <tt>default=</tt>,
--   then this does a <a>TypeError</a> and forces the user to use
--   <tt>insertKey</tt>.
class SafeToInsert a


-- | Defines the <a>SqlQueryRep</a> data type that contains a constructor
--   corresponding to a <tt>persistent</tt> function.
--   
--   This file is autogenerated, to keep it in sync with
--   <tt>Database.Persist.Monad.Shim</tt>.
module Database.Persist.Monad.SqlQueryRep

-- | The data type containing a constructor for each persistent function
--   we'd like to lift into <a>MonadSqlQuery</a>.
--   
--   The <tt>record</tt> type parameter contains the <a>PersistEntity</a>
--   types used in a given function.
--   
--   We're using a free-monads-like technique here to allow us to
--   introspect persistent functions in <a>MonadSqlQuery</a>, e.g. to mock
--   out persistent calls in tests.
data SqlQueryRep record a

-- | Constructor corresponding to <a>get</a>
[Get] :: PersistRecordBackend record SqlBackend => Key record -> SqlQueryRep record (Maybe record)

-- | Constructor corresponding to <a>getMany</a>
[GetMany] :: PersistRecordBackend record SqlBackend => [Key record] -> SqlQueryRep record (Map (Key record) record)

-- | Constructor corresponding to <a>getJust</a>
[GetJust] :: PersistRecordBackend record SqlBackend => Key record -> SqlQueryRep record record

-- | Constructor corresponding to <a>getJustEntity</a>
[GetJustEntity] :: PersistRecordBackend record SqlBackend => Key record -> SqlQueryRep record (Entity record)

-- | Constructor corresponding to <a>getEntity</a>
[GetEntity] :: PersistRecordBackend record SqlBackend => Key record -> SqlQueryRep record (Maybe (Entity record))

-- | Constructor corresponding to <a>belongsTo</a>
[BelongsTo] :: (PersistEntity record1, PersistRecordBackend record2 SqlBackend) => (record1 -> Maybe (Key record2)) -> record1 -> SqlQueryRep (record1, record2) (Maybe record2)

-- | Constructor corresponding to <a>belongsToJust</a>
[BelongsToJust] :: (PersistEntity record1, PersistRecordBackend record2 SqlBackend) => (record1 -> Key record2) -> record1 -> SqlQueryRep (record1, record2) record2

-- | Constructor corresponding to <a>insert</a>
[Insert] :: (PersistRecordBackend record SqlBackend, SafeToInsert record) => record -> SqlQueryRep record (Key record)

-- | Constructor corresponding to <a>insert_</a>
[Insert_] :: (PersistRecordBackend record SqlBackend, SafeToInsert record) => record -> SqlQueryRep record ()

-- | Constructor corresponding to <a>insertMany</a>
[InsertMany] :: (PersistRecordBackend record SqlBackend, SafeToInsert record) => [record] -> SqlQueryRep record [Key record]

-- | Constructor corresponding to <a>insertMany_</a>
[InsertMany_] :: (PersistRecordBackend record SqlBackend, SafeToInsert record) => [record] -> SqlQueryRep record ()

-- | Constructor corresponding to <a>insertEntityMany</a>
[InsertEntityMany] :: PersistRecordBackend record SqlBackend => [Entity record] -> SqlQueryRep record ()

-- | Constructor corresponding to <a>insertKey</a>
[InsertKey] :: PersistRecordBackend record SqlBackend => Key record -> record -> SqlQueryRep record ()

-- | Constructor corresponding to <a>repsert</a>
[Repsert] :: PersistRecordBackend record SqlBackend => Key record -> record -> SqlQueryRep record ()

-- | Constructor corresponding to <a>repsertMany</a>
[RepsertMany] :: PersistRecordBackend record SqlBackend => [(Key record, record)] -> SqlQueryRep record ()

-- | Constructor corresponding to <a>replace</a>
[Replace] :: PersistRecordBackend record SqlBackend => Key record -> record -> SqlQueryRep record ()

-- | Constructor corresponding to <a>delete</a>
[Delete] :: PersistRecordBackend record SqlBackend => Key record -> SqlQueryRep record ()

-- | Constructor corresponding to <a>update</a>
[Update] :: PersistRecordBackend record SqlBackend => Key record -> [Update record] -> SqlQueryRep record ()

-- | Constructor corresponding to <a>updateGet</a>
[UpdateGet] :: PersistRecordBackend record SqlBackend => Key record -> [Update record] -> SqlQueryRep record record

-- | Constructor corresponding to <a>insertEntity</a>
[InsertEntity] :: (PersistRecordBackend record SqlBackend, SafeToInsert record) => record -> SqlQueryRep record (Entity record)

-- | Constructor corresponding to <a>insertRecord</a>
[InsertRecord] :: (PersistRecordBackend record SqlBackend, SafeToInsert record) => record -> SqlQueryRep record record

-- | Constructor corresponding to <a>getBy</a>
[GetBy] :: PersistRecordBackend record SqlBackend => Unique record -> SqlQueryRep record (Maybe (Entity record))

-- | Constructor corresponding to <a>getByValue</a>
[GetByValue] :: (PersistRecordBackend record SqlBackend, AtLeastOneUniqueKey record) => record -> SqlQueryRep record (Maybe (Entity record))

-- | Constructor corresponding to <a>checkUnique</a>
[CheckUnique] :: PersistRecordBackend record SqlBackend => record -> SqlQueryRep record (Maybe (Unique record))

-- | Constructor corresponding to <a>checkUniqueUpdateable</a>
[CheckUniqueUpdateable] :: PersistRecordBackend record SqlBackend => Entity record -> SqlQueryRep record (Maybe (Unique record))

-- | Constructor corresponding to <a>deleteBy</a>
[DeleteBy] :: PersistRecordBackend record SqlBackend => Unique record -> SqlQueryRep record ()

-- | Constructor corresponding to <a>insertUnique</a>
[InsertUnique] :: (PersistRecordBackend record SqlBackend, SafeToInsert record) => record -> SqlQueryRep record (Maybe (Key record))

-- | Constructor corresponding to <a>upsert</a>
[Upsert] :: (PersistRecordBackend record SqlBackend, OnlyOneUniqueKey record, SafeToInsert record) => record -> [Update record] -> SqlQueryRep record (Entity record)

-- | Constructor corresponding to <a>upsertBy</a>
[UpsertBy] :: (PersistRecordBackend record SqlBackend, SafeToInsert record) => Unique record -> record -> [Update record] -> SqlQueryRep record (Entity record)

-- | Constructor corresponding to <a>putMany</a>
[PutMany] :: (PersistRecordBackend record SqlBackend, SafeToInsert record) => [record] -> SqlQueryRep record ()

-- | Constructor corresponding to <a>insertBy</a>
[InsertBy] :: (PersistRecordBackend record SqlBackend, AtLeastOneUniqueKey record, SafeToInsert record) => record -> SqlQueryRep record (Either (Entity record) (Key record))

-- | Constructor corresponding to <a>insertUniqueEntity</a>
[InsertUniqueEntity] :: (PersistRecordBackend record SqlBackend, SafeToInsert record) => record -> SqlQueryRep record (Maybe (Entity record))

-- | Constructor corresponding to <a>replaceUnique</a>
[ReplaceUnique] :: (PersistRecordBackend record SqlBackend, Eq (Unique record), Eq record) => Key record -> record -> SqlQueryRep record (Maybe (Unique record))

-- | Constructor corresponding to <a>onlyUnique</a>
[OnlyUnique] :: (PersistRecordBackend record SqlBackend, OnlyOneUniqueKey record) => record -> SqlQueryRep record (Unique record)

-- | Constructor corresponding to <a>selectSourceRes</a>
[SelectSourceRes] :: (MonadIO m2, PersistRecordBackend record SqlBackend) => [Filter record] -> [SelectOpt record] -> SqlQueryRep record (Acquire (ConduitM () (Entity record) m2 ()))

-- | Constructor corresponding to <a>selectFirst</a>
[SelectFirst] :: PersistRecordBackend record SqlBackend => [Filter record] -> [SelectOpt record] -> SqlQueryRep record (Maybe (Entity record))

-- | Constructor corresponding to <a>selectKeysRes</a>
[SelectKeysRes] :: (MonadIO m2, PersistRecordBackend record SqlBackend) => [Filter record] -> [SelectOpt record] -> SqlQueryRep record (Acquire (ConduitM () (Key record) m2 ()))

-- | Constructor corresponding to <a>count</a>
[Count] :: PersistRecordBackend record SqlBackend => [Filter record] -> SqlQueryRep record Int

-- | Constructor corresponding to <a>exists</a>
[Exists] :: PersistRecordBackend record SqlBackend => [Filter record] -> SqlQueryRep record Bool

-- | Constructor corresponding to <a>selectList</a>
[SelectList] :: PersistRecordBackend record SqlBackend => [Filter record] -> [SelectOpt record] -> SqlQueryRep record [Entity record]

-- | Constructor corresponding to <a>selectKeysList</a>
[SelectKeysList] :: PersistRecordBackend record SqlBackend => [Filter record] -> [SelectOpt record] -> SqlQueryRep record [Key record]

-- | Constructor corresponding to <a>updateWhere</a>
[UpdateWhere] :: PersistRecordBackend record SqlBackend => [Filter record] -> [Update record] -> SqlQueryRep record ()

-- | Constructor corresponding to <a>deleteWhere</a>
[DeleteWhere] :: PersistRecordBackend record SqlBackend => [Filter record] -> SqlQueryRep record ()

-- | Constructor corresponding to <a>deleteWhereCount</a>
[DeleteWhereCount] :: PersistRecordBackend record SqlBackend => [Filter record] -> SqlQueryRep record Int64

-- | Constructor corresponding to <a>updateWhereCount</a>
[UpdateWhereCount] :: PersistRecordBackend record SqlBackend => [Filter record] -> [Update record] -> SqlQueryRep record Int64

-- | Constructor corresponding to <a>parseMigration</a>
[ParseMigration] :: HasCallStack => Migration -> SqlQueryRep Void (Either [Text] CautiousMigration)

-- | Constructor corresponding to <a>parseMigration'</a>
[ParseMigration'] :: HasCallStack => Migration -> SqlQueryRep Void CautiousMigration

-- | Constructor corresponding to <a>printMigration</a>
[PrintMigration] :: HasCallStack => Migration -> SqlQueryRep Void ()

-- | Constructor corresponding to <a>showMigration</a>
[ShowMigration] :: HasCallStack => Migration -> SqlQueryRep Void [Text]

-- | Constructor corresponding to <a>getMigration</a>
[GetMigration] :: HasCallStack => Migration -> SqlQueryRep Void [Sql]

-- | Constructor corresponding to <a>runMigration</a>
[RunMigration] :: () => Migration -> SqlQueryRep Void ()

-- | Constructor corresponding to <a>runMigrationQuiet</a>
[RunMigrationQuiet] :: () => Migration -> SqlQueryRep Void [Text]

-- | Constructor corresponding to <a>runMigrationSilent</a>
[RunMigrationSilent] :: () => Migration -> SqlQueryRep Void [Text]

-- | Constructor corresponding to <a>runMigrationUnsafe</a>
[RunMigrationUnsafe] :: () => Migration -> SqlQueryRep Void ()

-- | Constructor corresponding to <a>runMigrationUnsafeQuiet</a>
[RunMigrationUnsafeQuiet] :: HasCallStack => Migration -> SqlQueryRep Void [Text]

-- | Constructor corresponding to <a>getFieldName</a>
[GetFieldName] :: PersistRecordBackend record SqlBackend => EntityField record typ -> SqlQueryRep record Text

-- | Constructor corresponding to <a>getTableName</a>
[GetTableName] :: PersistRecordBackend record SqlBackend => record -> SqlQueryRep record Text

-- | Constructor corresponding to <a>withRawQuery</a>
[WithRawQuery] :: () => Text -> [PersistValue] -> ConduitM [PersistValue] Void IO a -> SqlQueryRep Void a

-- | Constructor corresponding to <a>rawQueryRes</a>
[RawQueryRes] :: MonadIO m2 => Text -> [PersistValue] -> SqlQueryRep Void (Acquire (ConduitM () [PersistValue] m2 ()))

-- | Constructor corresponding to <a>rawExecute</a>
[RawExecute] :: () => Text -> [PersistValue] -> SqlQueryRep Void ()

-- | Constructor corresponding to <a>rawExecuteCount</a>
[RawExecuteCount] :: () => Text -> [PersistValue] -> SqlQueryRep Void Int64

-- | Constructor corresponding to <a>rawSql</a>
[RawSql] :: RawSql a => Text -> [PersistValue] -> SqlQueryRep Void [a]

-- | Constructor corresponding to <a>transactionSave</a>
[TransactionSave] :: () => SqlQueryRep Void ()

-- | Constructor corresponding to <a>transactionSaveWithIsolation</a>
[TransactionSaveWithIsolation] :: () => IsolationLevel -> SqlQueryRep Void ()

-- | Constructor corresponding to <a>transactionUndo</a>
[TransactionUndo] :: () => SqlQueryRep Void ()

-- | Constructor corresponding to <a>transactionUndoWithIsolation</a>
[TransactionUndoWithIsolation] :: () => IsolationLevel -> SqlQueryRep Void ()

-- | Constructor for lifting an arbitrary SqlPersistT action into
--   SqlQueryRep.
[UnsafeLiftSql] :: Text -> (forall m. MonadIO m => SqlPersistT m a) -> SqlQueryRep Void a

-- | A helper to execute the actual <tt>persistent</tt> function
--   corresponding to each <a>SqlQueryRep</a> data constructor.
runSqlQueryRep :: MonadUnliftIO m => SqlQueryRep record a -> SqlPersistT m a
instance Data.Typeable.Internal.Typeable record => GHC.Show.Show (Database.Persist.Monad.SqlQueryRep.SqlQueryRep record a)


-- | Defines the <a>MonadSqlQuery</a> type class that a monad can make an
--   instance of in order to interpret how to run a <a>SqlQueryRep</a> sent
--   by a lifted function from <tt>Database.Persist.Monad.Shim</tt>.
module Database.Persist.Monad.Class

-- | The type-class for monads that can run persistent database queries.
class (Monad m, MonadSqlQuery (TransactionM m)) => MonadSqlQuery m where {
    type TransactionM m :: Type -> Type;
}

-- | Interpret the given SQL query operation.
runQueryRep :: (MonadSqlQuery m, Typeable record) => SqlQueryRep record a -> m a

-- | Run all queries in the given action using the same database
--   connection.
withTransaction :: MonadSqlQuery m => TransactionM m a -> m a
instance Database.Persist.Monad.Class.MonadSqlQuery m => Database.Persist.Monad.Class.MonadSqlQuery (Control.Monad.Trans.Reader.ReaderT r m)
instance Database.Persist.Monad.Class.MonadSqlQuery m => Database.Persist.Monad.Class.MonadSqlQuery (Control.Monad.Trans.Except.ExceptT e m)
instance Database.Persist.Monad.Class.MonadSqlQuery m => Database.Persist.Monad.Class.MonadSqlQuery (Control.Monad.Trans.Identity.IdentityT m)
instance Database.Persist.Monad.Class.MonadSqlQuery m => Database.Persist.Monad.Class.MonadSqlQuery (Control.Monad.Trans.Maybe.MaybeT m)
instance (GHC.Base.Monoid w, Database.Persist.Monad.Class.MonadSqlQuery m) => Database.Persist.Monad.Class.MonadSqlQuery (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
instance (GHC.Base.Monoid w, Database.Persist.Monad.Class.MonadSqlQuery m) => Database.Persist.Monad.Class.MonadSqlQuery (Control.Monad.Trans.RWS.Strict.RWST r w s m)
instance Database.Persist.Monad.Class.MonadSqlQuery m => Database.Persist.Monad.Class.MonadSqlQuery (Control.Monad.Trans.State.Lazy.StateT s m)
instance Database.Persist.Monad.Class.MonadSqlQuery m => Database.Persist.Monad.Class.MonadSqlQuery (Control.Monad.Trans.State.Strict.StateT s m)
instance (GHC.Base.Monoid w, Database.Persist.Monad.Class.MonadSqlQuery m) => Database.Persist.Monad.Class.MonadSqlQuery (Control.Monad.Trans.Writer.Lazy.WriterT w m)
instance (GHC.Base.Monoid w, Database.Persist.Monad.Class.MonadSqlQuery m) => Database.Persist.Monad.Class.MonadSqlQuery (Control.Monad.Trans.Writer.Strict.WriterT w m)


-- | Defines all the <tt>persistent</tt> functions lifted into
--   <a>MonadSqlQuery</a>.
--   
--   This file is autogenerated, to keep it in sync with
--   <tt>Database.Persist.Monad.SqlQueryRep</tt>.
module Database.Persist.Monad.Shim

-- | The lifted version of <a>get</a>
get :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> m (Maybe record)

-- | The lifted version of <a>getMany</a>
getMany :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Key record] -> m (Map (Key record) record)

-- | The lifted version of <a>getJust</a>
getJust :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> m record

-- | The lifted version of <a>getJustEntity</a>
getJustEntity :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> m (Entity record)

-- | The lifted version of <a>getEntity</a>
getEntity :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> m (Maybe (Entity record))

-- | The lifted version of <a>belongsTo</a>
belongsTo :: (PersistEntity record1, PersistRecordBackend record2 SqlBackend, Typeable record1, Typeable record2, MonadSqlQuery m) => (record1 -> Maybe (Key record2)) -> record1 -> m (Maybe record2)

-- | The lifted version of <a>belongsToJust</a>
belongsToJust :: (PersistEntity record1, PersistRecordBackend record2 SqlBackend, Typeable record1, Typeable record2, MonadSqlQuery m) => (record1 -> Key record2) -> record1 -> m record2

-- | The lifted version of <a>insert</a>
insert :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m (Key record)

-- | The lifted version of <a>insert_</a>
insert_ :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m ()

-- | The lifted version of <a>insertMany</a>
insertMany :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => [record] -> m [Key record]

-- | The lifted version of <a>insertMany_</a>
insertMany_ :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => [record] -> m ()

-- | The lifted version of <a>insertEntityMany</a>
insertEntityMany :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Entity record] -> m ()

-- | The lifted version of <a>insertKey</a>
insertKey :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> record -> m ()

-- | The lifted version of <a>repsert</a>
repsert :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> record -> m ()

-- | The lifted version of <a>repsertMany</a>
repsertMany :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [(Key record, record)] -> m ()

-- | The lifted version of <a>replace</a>
replace :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> record -> m ()

-- | The lifted version of <a>delete</a>
delete :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> m ()

-- | The lifted version of <a>update</a>
update :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> [Update record] -> m ()

-- | The lifted version of <a>updateGet</a>
updateGet :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> [Update record] -> m record

-- | The lifted version of <a>insertEntity</a>
insertEntity :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m (Entity record)

-- | The lifted version of <a>insertRecord</a>
insertRecord :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m record

-- | The lifted version of <a>getBy</a>
getBy :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Unique record -> m (Maybe (Entity record))

-- | The lifted version of <a>getByValue</a>
getByValue :: (PersistRecordBackend record SqlBackend, AtLeastOneUniqueKey record, Typeable record, MonadSqlQuery m) => record -> m (Maybe (Entity record))

-- | The lifted version of <a>checkUnique</a>
checkUnique :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => record -> m (Maybe (Unique record))

-- | The lifted version of <a>checkUniqueUpdateable</a>
checkUniqueUpdateable :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Entity record -> m (Maybe (Unique record))

-- | The lifted version of <a>deleteBy</a>
deleteBy :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Unique record -> m ()

-- | The lifted version of <a>insertUnique</a>
insertUnique :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m (Maybe (Key record))

-- | The lifted version of <a>upsert</a>
upsert :: (PersistRecordBackend record SqlBackend, OnlyOneUniqueKey record, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> [Update record] -> m (Entity record)

-- | The lifted version of <a>upsertBy</a>
upsertBy :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => Unique record -> record -> [Update record] -> m (Entity record)

-- | The lifted version of <a>putMany</a>
putMany :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => [record] -> m ()

-- | The lifted version of <a>insertBy</a>
insertBy :: (PersistRecordBackend record SqlBackend, AtLeastOneUniqueKey record, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m (Either (Entity record) (Key record))

-- | The lifted version of <a>insertUniqueEntity</a>
insertUniqueEntity :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m (Maybe (Entity record))

-- | The lifted version of <a>replaceUnique</a>
replaceUnique :: (PersistRecordBackend record SqlBackend, Eq (Unique record), Eq record, Typeable record, MonadSqlQuery m) => Key record -> record -> m (Maybe (Unique record))

-- | The lifted version of <a>onlyUnique</a>
onlyUnique :: (PersistRecordBackend record SqlBackend, OnlyOneUniqueKey record, Typeable record, MonadSqlQuery m) => record -> m (Unique record)

-- | The lifted version of <a>selectSourceRes</a>
selectSourceRes :: (MonadIO m2, PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> m (Acquire (ConduitM () (Entity record) m2 ()))

-- | The lifted version of <a>selectFirst</a>
selectFirst :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> m (Maybe (Entity record))

-- | The lifted version of <a>selectKeysRes</a>
selectKeysRes :: (MonadIO m2, PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> m (Acquire (ConduitM () (Key record) m2 ()))

-- | The lifted version of <a>count</a>
count :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> m Int

-- | The lifted version of <a>exists</a>
exists :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> m Bool

-- | The lifted version of <a>selectSource</a>
selectSource :: (PersistRecordBackend record SqlBackend, MonadResource m, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> ConduitM () (Entity record) m ()

-- | The lifted version of <a>selectKeys</a>
selectKeys :: (PersistRecordBackend record SqlBackend, MonadResource m, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> ConduitM () (Key record) m ()

-- | The lifted version of <a>selectList</a>
selectList :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> m [Entity record]

-- | The lifted version of <a>selectKeysList</a>
selectKeysList :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> m [Key record]

-- | The lifted version of <a>updateWhere</a>
updateWhere :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [Update record] -> m ()

-- | The lifted version of <a>deleteWhere</a>
deleteWhere :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> m ()

-- | The lifted version of <a>deleteWhereCount</a>
deleteWhereCount :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> m Int64

-- | The lifted version of <a>updateWhereCount</a>
updateWhereCount :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [Update record] -> m Int64

-- | The lifted version of <a>parseMigration</a>
parseMigration :: (HasCallStack, MonadSqlQuery m) => Migration -> m (Either [Text] CautiousMigration)

-- | The lifted version of <a>parseMigration'</a>
parseMigration' :: (HasCallStack, MonadSqlQuery m) => Migration -> m CautiousMigration

-- | The lifted version of <a>printMigration</a>
printMigration :: (HasCallStack, MonadSqlQuery m) => Migration -> m ()

-- | The lifted version of <a>showMigration</a>
showMigration :: (HasCallStack, MonadSqlQuery m) => Migration -> m [Text]

-- | The lifted version of <a>getMigration</a>
getMigration :: (HasCallStack, MonadSqlQuery m) => Migration -> m [Sql]

-- | The lifted version of <a>runMigration</a>
runMigration :: MonadSqlQuery m => Migration -> m ()

-- | The lifted version of <a>runMigrationQuiet</a>
runMigrationQuiet :: MonadSqlQuery m => Migration -> m [Text]

-- | The lifted version of <a>runMigrationSilent</a>
runMigrationSilent :: MonadSqlQuery m => Migration -> m [Text]

-- | The lifted version of <a>runMigrationUnsafe</a>
runMigrationUnsafe :: MonadSqlQuery m => Migration -> m ()

-- | The lifted version of <a>runMigrationUnsafeQuiet</a>
runMigrationUnsafeQuiet :: (HasCallStack, MonadSqlQuery m) => Migration -> m [Text]

-- | The lifted version of <a>getFieldName</a>
getFieldName :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => EntityField record typ -> m Text

-- | The lifted version of <a>getTableName</a>
getTableName :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => record -> m Text

-- | The lifted version of <a>withRawQuery</a>
withRawQuery :: MonadSqlQuery m => Text -> [PersistValue] -> ConduitM [PersistValue] Void IO a -> m a

-- | The lifted version of <a>rawQueryRes</a>
rawQueryRes :: (MonadIO m2, MonadSqlQuery m) => Text -> [PersistValue] -> m (Acquire (ConduitM () [PersistValue] m2 ()))

-- | The lifted version of <a>rawQuery</a>
rawQuery :: (MonadResource m, MonadSqlQuery m) => Text -> [PersistValue] -> ConduitM () [PersistValue] m ()

-- | The lifted version of <a>rawExecute</a>
rawExecute :: MonadSqlQuery m => Text -> [PersistValue] -> m ()

-- | The lifted version of <a>rawExecuteCount</a>
rawExecuteCount :: MonadSqlQuery m => Text -> [PersistValue] -> m Int64

-- | The lifted version of <a>rawSql</a>
rawSql :: (RawSql a, MonadSqlQuery m) => Text -> [PersistValue] -> m [a]

-- | The lifted version of <a>transactionSave</a>
transactionSave :: MonadSqlQuery m => m ()

-- | The lifted version of <a>transactionSaveWithIsolation</a>
transactionSaveWithIsolation :: MonadSqlQuery m => IsolationLevel -> m ()

-- | The lifted version of <a>transactionUndo</a>
transactionUndo :: MonadSqlQuery m => m ()

-- | The lifted version of <a>transactionUndoWithIsolation</a>
transactionUndoWithIsolation :: MonadSqlQuery m => IsolationLevel -> m ()

-- | Lift an arbitrary <a>SqlPersistT</a> action into <a>MonadSqlQuery</a>.
--   
--   This is unsafe because the action may be rerun. This function should
--   primarily be used to interop with other libraries built on top of
--   persistent.
--   
--   Example usage:
--   
--   <pre>
--   -- | Run an esqueleto select.
--   select :: (MonadSqlQuery m, E.SqlSelect a r) =&gt; E.SqlQuery a -&gt; m [r]
--   select q = unsafeLiftSql "esqueleto-select" (E.select q)
--   </pre>
unsafeLiftSql :: MonadSqlQuery m => Text -> (forall m2. MonadIO m2 => SqlPersistT m2 a) -> m a

-- | A helper for functions that return a conduit.
fromAcquire :: MonadResource m => m (Acquire (ConduitM i o m a)) -> ConduitM i o m a

module Database.Persist.Monad.Internal.SqlTransaction

-- | The monad that tracks transaction state.
--   
--   Conceptually equivalent to <a>SqlPersistT</a>, but restricts IO
--   operations, for two reasons:
--   
--   <ol>
--   <li>Forking a thread that uses the same <a>SqlBackend</a> as the
--   current thread causes Bad Things to happen.</li>
--   <li>Transactions may need to be retried, in which case IO operations
--   in a transaction are required to be rerunnable.</li>
--   </ol>
--   
--   You shouldn't need to explicitly use this type; your functions should
--   only declare the <a>MonadSqlQuery</a> constraint.
newtype SqlTransaction m a
UnsafeSqlTransaction :: ReaderT SqlTransactionEnv m a -> SqlTransaction m a
[unSqlTransaction] :: SqlTransaction m a -> ReaderT SqlTransactionEnv m a
data SqlTransactionEnv
SqlTransactionEnv :: SqlBackend -> (SomeException -> Bool) -> SqlTransactionEnv
[sqlBackend] :: SqlTransactionEnv -> SqlBackend
[ignoreCatch] :: SqlTransactionEnv -> SomeException -> Bool
runSqlTransaction :: MonadUnliftIO m => SqlTransactionEnv -> SqlTransaction m a -> m a

-- | Like normal <tt>catch</tt>, except ignores errors specified by
--   <a>ignoreCatch</a>.
catchSqlTransaction :: (MonadUnliftIO m, Exception e) => SqlTransaction m a -> (e -> SqlTransaction m a) -> SqlTransaction m a
instance Control.Monad.Trans.Rerunnable.MonadRerunnableTrans Database.Persist.Monad.Internal.SqlTransaction.SqlTransaction
instance Control.Monad.IO.Rerunnable.MonadRerunnableIO m => Control.Monad.IO.Rerunnable.MonadRerunnableIO (Database.Persist.Monad.Internal.SqlTransaction.SqlTransaction m)
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Database.Persist.Monad.Internal.SqlTransaction.SqlTransaction m)
instance GHC.Base.Monad m => GHC.Base.Monad (Database.Persist.Monad.Internal.SqlTransaction.SqlTransaction m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Database.Persist.Monad.Internal.SqlTransaction.SqlTransaction m)
instance GHC.Base.Functor m => GHC.Base.Functor (Database.Persist.Monad.Internal.SqlTransaction.SqlTransaction m)
instance ((TypeError ...), GHC.Base.Monad m) => Control.Monad.IO.Class.MonadIO (Database.Persist.Monad.Internal.SqlTransaction.SqlTransaction m)
instance (Database.Persist.Monad.Class.MonadSqlQuery m, Control.Monad.IO.Unlift.MonadUnliftIO m) => Database.Persist.Monad.Class.MonadSqlQuery (Database.Persist.Monad.Internal.SqlTransaction.SqlTransaction m)


-- | Defines the <a>SqlQueryT</a> monad transformer, which has a
--   <a>MonadSqlQuery</a> instance to execute <tt>persistent</tt> database
--   operations. Also provides easy transaction management with
--   <a>withTransaction</a>, which supports retrying with exponential
--   backoff and restricts IO actions to only allow IO actions explicitly
--   marked as rerunnable.
--   
--   Usage:
--   
--   <pre>
--   myFunction :: (MonadSqlQuery m, MonadIO m) =&gt; m ()
--   myFunction = do
--     insert_ $ Person { name = "Alice", age = Just 25 }
--     insert_ $ Person { name = "Bob", age = Nothing }
--   
--     -- some other business logic
--   
--     personList &lt;- selectList [] []
--     liftIO $ print (personList :: [Person])
--   
--     -- everything in here will run in a transaction
--     withTransaction $ do
--       selectFirst [PersonAge &gt;. 30] [] &gt;&gt;= \case
--         Nothing -&gt; insert_ $ Person { name = "Claire", age = Just 50 }
--         Just (Entity key person) -&gt; replace key person{ age = Just (age person - 10) }
--   
--       -- liftIO doesn't work in here, since transactions can be retried.
--       -- Use rerunnableIO to run IO actions, after verifying that the IO action
--       -- can be rerun if the transaction needs to be retried.
--       rerunnableIO $ putStrLn "Transaction is finished!"
--   
--     -- some more business logic
--   
--     return ()
--   </pre>
module Database.Persist.Monad

-- | The type-class for monads that can run persistent database queries.
class (Monad m, MonadSqlQuery (TransactionM m)) => MonadSqlQuery m

-- | Run all queries in the given action using the same database
--   connection.
withTransaction :: MonadSqlQuery m => TransactionM m a -> m a

-- | The monad transformer that implements <a>MonadSqlQuery</a>.
newtype SqlQueryT m a
SqlQueryT :: ReaderT SqlQueryEnv m a -> SqlQueryT m a
[unSqlQueryT] :: SqlQueryT m a -> ReaderT SqlQueryEnv m a
mapSqlQueryT :: (m a -> n b) -> SqlQueryT m a -> SqlQueryT n b

-- | Run the <a>SqlQueryT</a> monad transformer with the given backend.
runSqlQueryT :: Pool SqlBackend -> SqlQueryT m a -> m a

-- | Run the <a>SqlQueryT</a> monad transformer with the explicitly
--   provided environment.
runSqlQueryTWith :: SqlQueryEnv -> SqlQueryT m a -> m a

-- | Environment to configure running <a>SqlQueryT</a>.
--   
--   For simple usage, you can just use <a>runSqlQueryT</a>, but for more
--   advanced usage, including the ability to retry transactions, use
--   <a>mkSqlQueryEnv</a> with <a>runSqlQueryTWith</a>.
data SqlQueryEnv
SqlQueryEnv :: Pool SqlBackend -> (SomeException -> Bool) -> Int -> (SomeException -> IO ()) -> SqlQueryEnv

-- | The pool for your persistent backend. Get this from
--   <tt>withSqlitePool</tt> or the equivalent for your backend.
[backendPool] :: SqlQueryEnv -> Pool SqlBackend

-- | Retry a transaction when an exception matches this predicate. Will
--   retry with an exponential backoff.
--   
--   Defaults to always returning False (i.e. never retry)
[retryIf] :: SqlQueryEnv -> SomeException -> Bool

-- | The number of times to retry, if <a>retryIf</a> is satisfied.
--   
--   Defaults to 10.
[retryLimit] :: SqlQueryEnv -> Int

-- | A callback to run if <a>retryIf</a> returns True. Useful for logging.
[retryCallback] :: SqlQueryEnv -> SomeException -> IO ()

-- | Build a SqlQueryEnv from the default.
--   
--   Usage:
--   
--   <pre>
--   let env = mkSqlQueryEnv pool $ \env -&gt; env { retryIf = 10 }
--   in runSqlQueryTWith env m
--   
--   </pre>
mkSqlQueryEnv :: Pool SqlBackend -> (SqlQueryEnv -> SqlQueryEnv) -> SqlQueryEnv
getSqlBackendPool :: Monad m => SqlQueryT m (Pool SqlBackend)

-- | The monad that tracks transaction state.
--   
--   Conceptually equivalent to <a>SqlPersistT</a>, but restricts IO
--   operations, for two reasons:
--   
--   <ol>
--   <li>Forking a thread that uses the same <a>SqlBackend</a> as the
--   current thread causes Bad Things to happen.</li>
--   <li>Transactions may need to be retried, in which case IO operations
--   in a transaction are required to be rerunnable.</li>
--   </ol>
--   
--   You shouldn't need to explicitly use this type; your functions should
--   only declare the <a>MonadSqlQuery</a> constraint.
data SqlTransaction m a

-- | Errors that can occur when running a SQL transaction.
data TransactionError

-- | The retry limit was reached when retrying a transaction.
RetryLimitExceeded :: TransactionError

-- | Like normal <tt>catch</tt>, except ignores errors specified by
--   <a>ignoreCatch</a>.
catchSqlTransaction :: (MonadUnliftIO m, Exception e) => SqlTransaction m a -> (e -> SqlTransaction m a) -> SqlTransaction m a
instance Control.Monad.Logger.MonadLogger m => Control.Monad.Logger.MonadLogger (Database.Persist.Monad.SqlQueryT m)
instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (Database.Persist.Monad.SqlQueryT m)
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Database.Persist.Monad.SqlQueryT m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Database.Persist.Monad.SqlQueryT m)
instance Control.Monad.IO.Rerunnable.MonadRerunnableIO m => Control.Monad.IO.Rerunnable.MonadRerunnableIO (Database.Persist.Monad.SqlQueryT m)
instance Control.Monad.Trans.Resource.Internal.MonadResource m => Control.Monad.Trans.Resource.Internal.MonadResource (Database.Persist.Monad.SqlQueryT m)
instance Control.Monad.Trans.Class.MonadTrans Database.Persist.Monad.SqlQueryT
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Database.Persist.Monad.SqlQueryT m)
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Database.Persist.Monad.SqlQueryT m)
instance GHC.Base.Monad m => GHC.Base.Monad (Database.Persist.Monad.SqlQueryT m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Database.Persist.Monad.SqlQueryT m)
instance GHC.Base.Functor m => GHC.Base.Functor (Database.Persist.Monad.SqlQueryT m)
instance GHC.Classes.Eq Database.Persist.Monad.TransactionError
instance GHC.Show.Show Database.Persist.Monad.TransactionError
instance Control.Monad.IO.Unlift.MonadUnliftIO m => Database.Persist.Monad.Class.MonadSqlQuery (Database.Persist.Monad.SqlQueryT m)
instance GHC.Exception.Type.Exception Database.Persist.Monad.TransactionError
instance Control.Monad.IO.Unlift.MonadUnliftIO m => Control.Monad.IO.Unlift.MonadUnliftIO (Database.Persist.Monad.SqlQueryT m)
instance Control.Monad.Reader.Class.MonadReader r m => Control.Monad.Reader.Class.MonadReader r (Database.Persist.Monad.SqlQueryT m)


-- | Defines <a>MockSqlQueryT</a>, which one can use in tests in order to
--   mock out <tt>persistent</tt> database queries called in production
--   code.
module Database.Persist.Monad.TestUtils

-- | A monad transformer for testing functions that use
--   <a>MonadSqlQuery</a>.
data MockSqlQueryT m a

-- | Runs a <a>MockSqlQueryT</a> monad transformer using the given mocks.
--   
--   When a database query is executed, the first mock that returns a
--   <a>Just</a> is returned. If no mocks match the query, an error is
--   thrown. See <a>SqlQueryRep</a> for the constructors available to match
--   against. Most of the time, you'll want to use <a>withRecord</a> to
--   only match queries against a specific <tt>record</tt> type (e.g. only
--   match <a>selectList</a> calls for the <tt>Person</tt> entity).
--   
--   Usage:
--   
--   <pre>
--   myFunction :: MonadSqlQuery m =&gt; m [String]
--   myFunction = map personName <a>$</a> selectList [PersonAge &gt;. 25] []
--   
--   let persons = [Person ...]
--   result &lt;- runMockSqlQueryT myFunction
--     [ withRecord @Person $ \case
--         SelectList _ _ -&gt; Just persons
--         _ -&gt; Nothing
--     , withRecord @Post $ \case
--         Insert Post{ name = "post1" } -&gt; Just $ toSqlKey 1
--         _ -&gt; Nothing
--     , mockQuery $ \case
--         RawExecuteCount "DELETE FROM person WHERE name = 'Alice'" [] -&gt; Just 1
--         _ -&gt; Nothing
--     ]
--   
--   </pre>
runMockSqlQueryT :: MockSqlQueryT m a -> [MockQuery] -> m a

-- | A helper for defining a mocked database query against a specific
--   <tt>record</tt> type. Designed to be used with TypeApplications.
--   
--   Most <a>SqlQueryRep</a> constructors are in the context of a specific
--   <tt>record</tt> type, like <tt>Person</tt>. This helper only matches
--   mocked database queries that are querying the record you specify.
--   
--   Some constructors reference multiple <tt>record</tt> types, like
--   <a>BelongsTo</a>. Look at the type to see the record you need to match
--   against. For example,
--   
--   <pre>
--   withRecord @(Person, Post) $ \case
--     BelongsTo _ _ -&gt; ...
--   
--   </pre>
--   
--   would match the function call
--   
--   <pre>
--   belongsTo :: (Person -&gt; Maybe (Key Post)) -&gt; Person -&gt; SqlQueryRep (Person, Post) (Maybe Post)
--   
--   </pre>
withRecord :: forall record. Typeable record => (forall a. SqlQueryRep record a -> Maybe a) -> MockQuery

-- | A helper for defining a mocked database query.
--   
--   This does not do any matching on the <tt>record</tt> type, so it is
--   mostly useful for queries that don't use the <tt>record</tt> type,
--   like <a>rawExecute</a>.
mockQuery :: (forall record a. Typeable record => SqlQueryRep record a -> Maybe a) -> MockQuery

-- | A mocked query to use in <a>runMockSqlQueryT</a>.
--   
--   Use <a>withRecord</a> or another helper to create a <a>MockQuery</a>.
data MockQuery

-- | A helper for mocking a <a>selectSource</a> or <a>selectSourceRes</a>
--   call.
--   
--   Usage:
--   
--   <pre>
--   mockSelectSource $ \filters opts -&gt;
--     if null filters &amp;&amp; null opts
--       then
--         let person1 = [Entity (toSqlKey 1) $ Person "Alice"]
--             person2 = [Entity (toSqlKey 2) $ Person "Bob"]
--         in Just [person1, person2]
--       else Nothing
--   
--   </pre>
mockSelectSource :: forall record. Typeable record => ([Filter record] -> [SelectOpt record] -> Maybe [Entity record]) -> MockQuery

-- | A helper for mocking a <a>selectKeys</a> or <a>selectKeysRes</a> call.
--   
--   Usage:
--   
--   <pre>
--   mockSelectKeys $ \filters opts -&gt;
--     if null filters &amp;&amp; null opts
--       then Just $ map toSqlKey [1, 2]
--       else Nothing
--   
--   </pre>
mockSelectKeys :: forall record. Typeable record => ([Filter record] -> [SelectOpt record] -> Maybe [Key record]) -> MockQuery

-- | A helper for mocking a <a>withRawQuery</a> call.
--   
--   Usage:
--   
--   <pre>
--   mockWithRawQuery $ \sql vals -&gt;
--     if sql == "SELECT id, name FROM person"
--       then
--         let row1 = [toPersistValue 1, toPersistValue "Alice"]
--             row2 = [toPersistValue 2, toPersistValue "Bob"]
--         in Just [row1, row2]
--       else Nothing
--   
--   </pre>
mockWithRawQuery :: (Text -> [PersistValue] -> Maybe [[PersistValue]]) -> MockQuery

-- | A helper for mocking a <a>rawQuery</a> or <a>rawQueryRes</a> call.
--   
--   Usage:
--   
--   <pre>
--   mockRawQuery $ \sql vals -&gt;
--     if sql == "SELECT id, name FROM person"
--       then
--         let row1 = [toPersistValue 1, toPersistValue "Alice"]
--             row2 = [toPersistValue 2, toPersistValue "Bob"]
--         in Just [row1, row2]
--       else Nothing
--   
--   </pre>
mockRawQuery :: (Text -> [PersistValue] -> Maybe [[PersistValue]]) -> MockQuery

-- | A helper for mocking a <a>rawSql</a> call.
--   
--   Usage:
--   
--   <pre>
--   mockRawSql $ \sql vals -&gt;
--     if sql == "SELECT id, name FROM person"
--       then
--         let row1 = [toPersistValue 1, toPersistValue "Alice"]
--             row2 = [toPersistValue 2, toPersistValue "Bob"]
--         in Just [row1, row2]
--       else Nothing
--   
--   </pre>
mockRawSql :: (Text -> [PersistValue] -> Maybe [[PersistValue]]) -> MockQuery

-- | The data type containing a constructor for each persistent function
--   we'd like to lift into <a>MonadSqlQuery</a>.
--   
--   The <tt>record</tt> type parameter contains the <a>PersistEntity</a>
--   types used in a given function.
--   
--   We're using a free-monads-like technique here to allow us to
--   introspect persistent functions in <a>MonadSqlQuery</a>, e.g. to mock
--   out persistent calls in tests.
data SqlQueryRep record a

-- | Constructor corresponding to <a>get</a>
[Get] :: PersistRecordBackend record SqlBackend => Key record -> SqlQueryRep record (Maybe record)

-- | Constructor corresponding to <a>getMany</a>
[GetMany] :: PersistRecordBackend record SqlBackend => [Key record] -> SqlQueryRep record (Map (Key record) record)

-- | Constructor corresponding to <a>getJust</a>
[GetJust] :: PersistRecordBackend record SqlBackend => Key record -> SqlQueryRep record record

-- | Constructor corresponding to <a>getJustEntity</a>
[GetJustEntity] :: PersistRecordBackend record SqlBackend => Key record -> SqlQueryRep record (Entity record)

-- | Constructor corresponding to <a>getEntity</a>
[GetEntity] :: PersistRecordBackend record SqlBackend => Key record -> SqlQueryRep record (Maybe (Entity record))

-- | Constructor corresponding to <a>belongsTo</a>
[BelongsTo] :: (PersistEntity record1, PersistRecordBackend record2 SqlBackend) => (record1 -> Maybe (Key record2)) -> record1 -> SqlQueryRep (record1, record2) (Maybe record2)

-- | Constructor corresponding to <a>belongsToJust</a>
[BelongsToJust] :: (PersistEntity record1, PersistRecordBackend record2 SqlBackend) => (record1 -> Key record2) -> record1 -> SqlQueryRep (record1, record2) record2

-- | Constructor corresponding to <a>insert</a>
[Insert] :: (PersistRecordBackend record SqlBackend, SafeToInsert record) => record -> SqlQueryRep record (Key record)

-- | Constructor corresponding to <a>insert_</a>
[Insert_] :: (PersistRecordBackend record SqlBackend, SafeToInsert record) => record -> SqlQueryRep record ()

-- | Constructor corresponding to <a>insertMany</a>
[InsertMany] :: (PersistRecordBackend record SqlBackend, SafeToInsert record) => [record] -> SqlQueryRep record [Key record]

-- | Constructor corresponding to <a>insertMany_</a>
[InsertMany_] :: (PersistRecordBackend record SqlBackend, SafeToInsert record) => [record] -> SqlQueryRep record ()

-- | Constructor corresponding to <a>insertEntityMany</a>
[InsertEntityMany] :: PersistRecordBackend record SqlBackend => [Entity record] -> SqlQueryRep record ()

-- | Constructor corresponding to <a>insertKey</a>
[InsertKey] :: PersistRecordBackend record SqlBackend => Key record -> record -> SqlQueryRep record ()

-- | Constructor corresponding to <a>repsert</a>
[Repsert] :: PersistRecordBackend record SqlBackend => Key record -> record -> SqlQueryRep record ()

-- | Constructor corresponding to <a>repsertMany</a>
[RepsertMany] :: PersistRecordBackend record SqlBackend => [(Key record, record)] -> SqlQueryRep record ()

-- | Constructor corresponding to <a>replace</a>
[Replace] :: PersistRecordBackend record SqlBackend => Key record -> record -> SqlQueryRep record ()

-- | Constructor corresponding to <a>delete</a>
[Delete] :: PersistRecordBackend record SqlBackend => Key record -> SqlQueryRep record ()

-- | Constructor corresponding to <a>update</a>
[Update] :: PersistRecordBackend record SqlBackend => Key record -> [Update record] -> SqlQueryRep record ()

-- | Constructor corresponding to <a>updateGet</a>
[UpdateGet] :: PersistRecordBackend record SqlBackend => Key record -> [Update record] -> SqlQueryRep record record

-- | Constructor corresponding to <a>insertEntity</a>
[InsertEntity] :: (PersistRecordBackend record SqlBackend, SafeToInsert record) => record -> SqlQueryRep record (Entity record)

-- | Constructor corresponding to <a>insertRecord</a>
[InsertRecord] :: (PersistRecordBackend record SqlBackend, SafeToInsert record) => record -> SqlQueryRep record record

-- | Constructor corresponding to <a>getBy</a>
[GetBy] :: PersistRecordBackend record SqlBackend => Unique record -> SqlQueryRep record (Maybe (Entity record))

-- | Constructor corresponding to <a>getByValue</a>
[GetByValue] :: (PersistRecordBackend record SqlBackend, AtLeastOneUniqueKey record) => record -> SqlQueryRep record (Maybe (Entity record))

-- | Constructor corresponding to <a>checkUnique</a>
[CheckUnique] :: PersistRecordBackend record SqlBackend => record -> SqlQueryRep record (Maybe (Unique record))

-- | Constructor corresponding to <a>checkUniqueUpdateable</a>
[CheckUniqueUpdateable] :: PersistRecordBackend record SqlBackend => Entity record -> SqlQueryRep record (Maybe (Unique record))

-- | Constructor corresponding to <a>deleteBy</a>
[DeleteBy] :: PersistRecordBackend record SqlBackend => Unique record -> SqlQueryRep record ()

-- | Constructor corresponding to <a>insertUnique</a>
[InsertUnique] :: (PersistRecordBackend record SqlBackend, SafeToInsert record) => record -> SqlQueryRep record (Maybe (Key record))

-- | Constructor corresponding to <a>upsert</a>
[Upsert] :: (PersistRecordBackend record SqlBackend, OnlyOneUniqueKey record, SafeToInsert record) => record -> [Update record] -> SqlQueryRep record (Entity record)

-- | Constructor corresponding to <a>upsertBy</a>
[UpsertBy] :: (PersistRecordBackend record SqlBackend, SafeToInsert record) => Unique record -> record -> [Update record] -> SqlQueryRep record (Entity record)

-- | Constructor corresponding to <a>putMany</a>
[PutMany] :: (PersistRecordBackend record SqlBackend, SafeToInsert record) => [record] -> SqlQueryRep record ()

-- | Constructor corresponding to <a>insertBy</a>
[InsertBy] :: (PersistRecordBackend record SqlBackend, AtLeastOneUniqueKey record, SafeToInsert record) => record -> SqlQueryRep record (Either (Entity record) (Key record))

-- | Constructor corresponding to <a>insertUniqueEntity</a>
[InsertUniqueEntity] :: (PersistRecordBackend record SqlBackend, SafeToInsert record) => record -> SqlQueryRep record (Maybe (Entity record))

-- | Constructor corresponding to <a>replaceUnique</a>
[ReplaceUnique] :: (PersistRecordBackend record SqlBackend, Eq (Unique record), Eq record) => Key record -> record -> SqlQueryRep record (Maybe (Unique record))

-- | Constructor corresponding to <a>onlyUnique</a>
[OnlyUnique] :: (PersistRecordBackend record SqlBackend, OnlyOneUniqueKey record) => record -> SqlQueryRep record (Unique record)

-- | Constructor corresponding to <a>selectSourceRes</a>
[SelectSourceRes] :: (MonadIO m2, PersistRecordBackend record SqlBackend) => [Filter record] -> [SelectOpt record] -> SqlQueryRep record (Acquire (ConduitM () (Entity record) m2 ()))

-- | Constructor corresponding to <a>selectFirst</a>
[SelectFirst] :: PersistRecordBackend record SqlBackend => [Filter record] -> [SelectOpt record] -> SqlQueryRep record (Maybe (Entity record))

-- | Constructor corresponding to <a>selectKeysRes</a>
[SelectKeysRes] :: (MonadIO m2, PersistRecordBackend record SqlBackend) => [Filter record] -> [SelectOpt record] -> SqlQueryRep record (Acquire (ConduitM () (Key record) m2 ()))

-- | Constructor corresponding to <a>count</a>
[Count] :: PersistRecordBackend record SqlBackend => [Filter record] -> SqlQueryRep record Int

-- | Constructor corresponding to <a>exists</a>
[Exists] :: PersistRecordBackend record SqlBackend => [Filter record] -> SqlQueryRep record Bool

-- | Constructor corresponding to <a>selectList</a>
[SelectList] :: PersistRecordBackend record SqlBackend => [Filter record] -> [SelectOpt record] -> SqlQueryRep record [Entity record]

-- | Constructor corresponding to <a>selectKeysList</a>
[SelectKeysList] :: PersistRecordBackend record SqlBackend => [Filter record] -> [SelectOpt record] -> SqlQueryRep record [Key record]

-- | Constructor corresponding to <a>updateWhere</a>
[UpdateWhere] :: PersistRecordBackend record SqlBackend => [Filter record] -> [Update record] -> SqlQueryRep record ()

-- | Constructor corresponding to <a>deleteWhere</a>
[DeleteWhere] :: PersistRecordBackend record SqlBackend => [Filter record] -> SqlQueryRep record ()

-- | Constructor corresponding to <a>deleteWhereCount</a>
[DeleteWhereCount] :: PersistRecordBackend record SqlBackend => [Filter record] -> SqlQueryRep record Int64

-- | Constructor corresponding to <a>updateWhereCount</a>
[UpdateWhereCount] :: PersistRecordBackend record SqlBackend => [Filter record] -> [Update record] -> SqlQueryRep record Int64

-- | Constructor corresponding to <a>parseMigration</a>
[ParseMigration] :: HasCallStack => Migration -> SqlQueryRep Void (Either [Text] CautiousMigration)

-- | Constructor corresponding to <a>parseMigration'</a>
[ParseMigration'] :: HasCallStack => Migration -> SqlQueryRep Void CautiousMigration

-- | Constructor corresponding to <a>printMigration</a>
[PrintMigration] :: HasCallStack => Migration -> SqlQueryRep Void ()

-- | Constructor corresponding to <a>showMigration</a>
[ShowMigration] :: HasCallStack => Migration -> SqlQueryRep Void [Text]

-- | Constructor corresponding to <a>getMigration</a>
[GetMigration] :: HasCallStack => Migration -> SqlQueryRep Void [Sql]

-- | Constructor corresponding to <a>runMigration</a>
[RunMigration] :: () => Migration -> SqlQueryRep Void ()

-- | Constructor corresponding to <a>runMigrationQuiet</a>
[RunMigrationQuiet] :: () => Migration -> SqlQueryRep Void [Text]

-- | Constructor corresponding to <a>runMigrationSilent</a>
[RunMigrationSilent] :: () => Migration -> SqlQueryRep Void [Text]

-- | Constructor corresponding to <a>runMigrationUnsafe</a>
[RunMigrationUnsafe] :: () => Migration -> SqlQueryRep Void ()

-- | Constructor corresponding to <a>runMigrationUnsafeQuiet</a>
[RunMigrationUnsafeQuiet] :: HasCallStack => Migration -> SqlQueryRep Void [Text]

-- | Constructor corresponding to <a>getFieldName</a>
[GetFieldName] :: PersistRecordBackend record SqlBackend => EntityField record typ -> SqlQueryRep record Text

-- | Constructor corresponding to <a>getTableName</a>
[GetTableName] :: PersistRecordBackend record SqlBackend => record -> SqlQueryRep record Text

-- | Constructor corresponding to <a>withRawQuery</a>
[WithRawQuery] :: () => Text -> [PersistValue] -> ConduitM [PersistValue] Void IO a -> SqlQueryRep Void a

-- | Constructor corresponding to <a>rawQueryRes</a>
[RawQueryRes] :: MonadIO m2 => Text -> [PersistValue] -> SqlQueryRep Void (Acquire (ConduitM () [PersistValue] m2 ()))

-- | Constructor corresponding to <a>rawExecute</a>
[RawExecute] :: () => Text -> [PersistValue] -> SqlQueryRep Void ()

-- | Constructor corresponding to <a>rawExecuteCount</a>
[RawExecuteCount] :: () => Text -> [PersistValue] -> SqlQueryRep Void Int64

-- | Constructor corresponding to <a>rawSql</a>
[RawSql] :: RawSql a => Text -> [PersistValue] -> SqlQueryRep Void [a]

-- | Constructor corresponding to <a>transactionSave</a>
[TransactionSave] :: () => SqlQueryRep Void ()

-- | Constructor corresponding to <a>transactionSaveWithIsolation</a>
[TransactionSaveWithIsolation] :: () => IsolationLevel -> SqlQueryRep Void ()

-- | Constructor corresponding to <a>transactionUndo</a>
[TransactionUndo] :: () => SqlQueryRep Void ()

-- | Constructor corresponding to <a>transactionUndoWithIsolation</a>
[TransactionUndoWithIsolation] :: () => IsolationLevel -> SqlQueryRep Void ()

-- | Constructor for lifting an arbitrary SqlPersistT action into
--   SqlQueryRep.
[UnsafeLiftSql] :: Text -> (forall m. MonadIO m => SqlPersistT m a) -> SqlQueryRep Void a
instance Control.Monad.Trans.Resource.Internal.MonadResource m => Control.Monad.Trans.Resource.Internal.MonadResource (Database.Persist.Monad.TestUtils.MockSqlQueryT m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Database.Persist.Monad.TestUtils.MockSqlQueryT m)
instance GHC.Base.Monad m => GHC.Base.Monad (Database.Persist.Monad.TestUtils.MockSqlQueryT m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Database.Persist.Monad.TestUtils.MockSqlQueryT m)
instance GHC.Base.Functor m => GHC.Base.Functor (Database.Persist.Monad.TestUtils.MockSqlQueryT m)
instance Control.Monad.IO.Class.MonadIO m => Database.Persist.Monad.Class.MonadSqlQuery (Database.Persist.Monad.TestUtils.MockSqlQueryT m)


-- | Defines all the <tt>persistent</tt> functions lifted into
--   <tt>MonadSqlQuery</tt>, and re-exports a version of the
--   <tt>Database.Persist.Sql</tt> module replacing each function with the
--   lifted version.
--   
--   This file is autogenerated, to keep it in sync with
--   <tt>Database.Persist.Monad.Shim</tt>.
module Database.Persist.Sql.Shim

-- | Run an action against the database during a migration. Can be useful
--   for eg creating Postgres extensions:
--   
--   <pre>
--   runSqlCommand $ <a>rawExecute</a> "CREATE EXTENSION IF NOT EXISTS "uuid-ossp";" []
--   </pre>
runSqlCommand :: SqlPersistT IO () -> Migration

-- | Add a <a>CautiousMigration</a> (aka a <tt>[(<a>Bool</a>,
--   <a>Text</a>)]</tt>) to the migration plan.
addMigrations :: CautiousMigration -> Migration

-- | Add a migration to the migration plan.
addMigration :: Bool -> Sql -> Migration

-- | Report multiple errors in a <a>Migration</a>.
reportErrors :: [Text] -> Migration

-- | Report a single error in a <a>Migration</a>.
reportError :: Text -> Migration

-- | Given a list of old entity definitions and a new <a>EntityDef</a> in
--   <tt>val</tt>, this creates a <a>Migration</a> to update the old list
--   of definitions with the new one.
migrate :: [EntityDef] -> EntityDef -> Migration
type Sql = Text

-- | A list of SQL operations, marked with a safety flag. If the
--   <a>Bool</a> is <a>True</a>, then the operation is *unsafe* - it might
--   be destructive, or otherwise not idempotent. If the <a>Bool</a> is
--   <a>False</a>, then the operation is *safe*, and can be run repeatedly
--   without issues.
type CautiousMigration = [(Bool, Sql)]

-- | A <a>Migration</a> is a four level monad stack consisting of:
--   
--   <ul>
--   <li><tt><a>WriterT</a> [<a>Text</a>]</tt> representing a log of errors
--   in the migrations.</li>
--   <li><tt><a>WriterT</a> <a>CautiousMigration</a></tt> representing a
--   list of migrations to run, along with whether or not they are
--   safe.</li>
--   <li><tt><a>ReaderT</a> <a>SqlBackend</a></tt>, aka the
--   <a>SqlPersistT</a> transformer for database interop.</li>
--   <li><tt><a>IO</a></tt> for arbitrary IO.</li>
--   </ul>
type Migration = WriterT [Text] WriterT CautiousMigration ReaderT SqlBackend IO ()

-- | An exception indicating that Persistent refused to run some unsafe
--   migrations. Contains a list of pairs where the Bool tracks whether the
--   migration was unsafe (True means unsafe), and the Sql is the sql
--   statement for the migration.
newtype PersistUnsafeMigrationException
PersistUnsafeMigrationException :: [(Bool, Sql)] -> PersistUnsafeMigrationException

-- | Generates sql for limit and offset for postgres, sqlite and mysql.
decorateSQLWithLimitOffset :: Text -> (Int, Int) -> Text -> Text

-- | Render a <tt>[<a>SelectOpt</a> record]</tt> made up *only* of
--   <a>Asc</a> and <a>Desc</a> constructors into a <a>Text</a> value
--   suitable for inclusion into a SQL query.
orderClause :: PersistEntity val => Maybe FilterTablePrefix -> SqlBackend -> [SelectOpt val] -> Text

-- | Render a <tt>[<a>Filter</a> record]</tt> into a <a>Text</a> value
--   suitable for inclusion into a SQL query, as well as the
--   <tt>[<a>PersistValue</a>]</tt> to properly fill in the <tt>?</tt>
--   place holders.
filterClauseWithVals :: PersistEntity val => Maybe FilterTablePrefix -> SqlBackend -> [Filter val] -> (Text, [PersistValue])

-- | Render a <tt>[<a>Filter</a> record]</tt> into a <a>Text</a> value
--   suitable for inclusion into a SQL query.
filterClause :: PersistEntity val => Maybe FilterTablePrefix -> SqlBackend -> [Filter val] -> Text

-- | Used when determining how to prefix a column name in a <tt>WHERE</tt>
--   clause.
data FilterTablePrefix

-- | Prefix the column with the table name. This is useful if the column
--   name might be ambiguous.
PrefixTableName :: FilterTablePrefix

-- | Prefix the column name with the <tt>EXCLUDED</tt> keyword. This is
--   used with the Postgresql backend when doing <tt>ON CONFLICT DO
--   UPDATE</tt> clauses - see the documentation on <tt>upsertWhere</tt>
--   and <tt>upsertManyWhere</tt>.
PrefixExcluded :: FilterTablePrefix

-- | useful for a backend to implement fieldName by adding escaping
fieldDBName :: PersistEntity record => EntityField record typ -> FieldNameDB

-- | useful for a backend to implement tableName by adding escaping
tableDBName :: PersistEntity record => record -> EntityNameDB
fromSqlKey :: ToBackendKey SqlBackend record => Key record -> Int64
toSqlKey :: ToBackendKey SqlBackend record => Int64 -> Key record
close' :: BackendCompatible SqlBackend backend => backend -> IO ()

-- | Create a connection and run sql queries within it. This function
--   automatically closes the connection on it's completion.
--   
--   <h3><b>Example usage</b></h3>
--   
--   <pre>
--   {-# LANGUAGE GADTs #-}
--   {-# LANGUAGE ScopedTypeVariables #-}
--   {-# LANGUAGE OverloadedStrings #-}
--   {-# LANGUAGE MultiParamTypeClasses #-}
--   {-# LANGUAGE TypeFamilies#-}
--   {-# LANGUAGE TemplateHaskell#-}
--   {-# LANGUAGE QuasiQuotes#-}
--   {-# LANGUAGE GeneralizedNewtypeDeriving #-}
--   
--   import Control.Monad.IO.Class  (liftIO)
--   import Control.Monad.Logger
--   import Conduit
--   import Database.Persist
--   import Database.Sqlite
--   import Database.Persist.Sqlite
--   import Database.Persist.TH
--   
--   share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase|
--   Person
--     name String
--     age Int Maybe
--     deriving Show
--   |]
--   
--   openConnection :: LogFunc -&gt; IO SqlBackend
--   openConnection logfn = do
--    conn &lt;- open "/home/sibi/test.db"
--    wrapConnection conn logfn
--   
--   main :: IO ()
--   main = do
--     runNoLoggingT $ runResourceT $ withSqlConn openConnection (\backend -&gt;
--                                         flip runSqlConn backend $ do
--                                           runMigration migrateAll
--                                           insert_ $ Person "John doe" $ Just 35
--                                           insert_ $ Person "Divya" $ Just 36
--                                           (pers :: [Entity Person]) &lt;- selectList [] []
--                                           liftIO $ print pers
--                                           return ()
--                                        )
--   </pre>
--   
--   On executing it, you get this output:
--   
--   <pre>
--   Migrating: CREATE TABLE "person"("id" INTEGER PRIMARY KEY,"name" VARCHAR NOT NULL,"age" INTEGER NULL)
--   [Entity {entityKey = PersonKey {unPersonKey = SqlBackendKey {unSqlBackendKey = 1}}, entityVal = Person {personName = "John doe", personAge = Just 35}},Entity {entityKey = PersonKey {unPersonKey = SqlBackendKey {unSqlBackendKey = 2}}, entityVal = Person {personName = "Hema", personAge = Just 36}}]
--   </pre>
withSqlConn :: forall backend m a. (MonadUnliftIO m, MonadLoggerIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> (backend -> m a) -> m a

-- | Creates a pool of connections to a SQL database.
createSqlPoolWithConfig :: (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> ConnectionPoolConfig -> m (Pool backend)
createSqlPool :: forall backend m. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> Int -> m (Pool backend)

-- | Creates a pool of connections to a SQL database which can be used by
--   the <tt>Pool backend -&gt; m a</tt> function. After the function
--   completes, the connections are destroyed.
withSqlPoolWithConfig :: forall backend m a. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> ConnectionPoolConfig -> (Pool backend -> m a) -> m a
withSqlPool :: forall backend m a. (MonadLoggerIO m, MonadUnliftIO m, BackendCompatible SqlBackend backend) => (LogFunc -> IO backend) -> Int -> (Pool backend -> m a) -> m a
liftSqlPersistMPool :: forall backend m a. (MonadIO m, BackendCompatible SqlBackend backend) => ReaderT backend (NoLoggingT (ResourceT IO)) a -> Pool backend -> m a
runSqlPersistMPool :: BackendCompatible SqlBackend backend => ReaderT backend (NoLoggingT (ResourceT IO)) a -> Pool backend -> IO a
runSqlPersistM :: BackendCompatible SqlBackend backend => ReaderT backend (NoLoggingT (ResourceT IO)) a -> backend -> IO a

-- | Like <a>runSqlConn</a>, but supports specifying an isolation level.
runSqlConnWithIsolation :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> backend -> IsolationLevel -> m a
runSqlConn :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> backend -> m a

-- | Like <a>acquireSqlConn</a>, but lets you specify an explicit isolation
--   level.
acquireSqlConnWithIsolation :: (MonadReader backend m, BackendCompatible SqlBackend backend) => IsolationLevel -> m (Acquire backend)

-- | Starts a new transaction on the connection. When the acquired
--   connection is released the transaction is committed and the connection
--   returned to the pool.
--   
--   Upon an exception the transaction is rolled back and the connection
--   destroyed.
--   
--   This is equivalent to <a>runSqlConn</a> but does not incur the
--   <a>MonadUnliftIO</a> constraint, meaning it can be used within, for
--   example, a <tt>Conduit</tt> pipeline.
acquireSqlConn :: (MonadReader backend m, BackendCompatible SqlBackend backend) => m (Acquire backend)

-- | This function is how <a>runSqlPoolWithHooks</a> is defined.
--   
--   It's currently the most general function for using a SQL pool.
runSqlPoolWithExtensibleHooks :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> Maybe IsolationLevel -> SqlPoolHooks m backend -> m a

-- | This function is how <a>runSqlPool</a> and
--   <a>runSqlPoolNoTransaction</a> are defined. In addition to the action
--   to be performed and the <a>Pool</a> of conections to use, we give you
--   the opportunity to provide three actions - initialize, afterwards, and
--   onException.
runSqlPoolWithHooks :: forall backend m a before after onException. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> Maybe IsolationLevel -> (backend -> m before) -> (backend -> m after) -> (backend -> SomeException -> m onException) -> m a

-- | Like <a>runSqlPool</a>, but does not surround the action in a
--   transaction. This action might leave your database in a weird state.
runSqlPoolNoTransaction :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> Maybe IsolationLevel -> m a

-- | Like <a>runSqlPool</a>, but supports specifying an isolation level.
runSqlPoolWithIsolation :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> IsolationLevel -> m a

-- | Get a connection from the pool, run the given action, and then return
--   the connection to the pool.
--   
--   This function performs the given action in a transaction. If an
--   exception occurs during the action, then the transaction is rolled
--   back.
--   
--   Note: This function previously timed out after 2 seconds, but this
--   behavior was buggy and caused more problems than it solved. Since
--   version 2.1.2, it performs no timeout checks.
runSqlPool :: forall backend m a. (MonadUnliftIO m, BackendCompatible SqlBackend backend) => ReaderT backend m a -> Pool backend -> m a
getStmtConn :: SqlBackend -> Text -> IO Statement

-- | A helper function to tell GHC what the <a>EntityWithPrefix</a> prefix
--   should be. This allows you to use a type application to specify the
--   prefix, instead of specifying the etype on the result.
--   
--   As an example, here's code that uses this:
--   
--   <pre>
--   myQuery :: <a>SqlPersistM</a> [<a>Entity</a> Person]
--   myQuery = fmap (unPrefix @"p") <a>$</a> rawSql query []
--     where
--       query = "SELECT ?? FROM person AS p"
--   </pre>
unPrefix :: forall (prefix :: Symbol) record. EntityWithPrefix prefix record -> Entity record

-- | Class for data types that may be retrived from a <tt>rawSql</tt>
--   query.
class RawSql a

-- | Number of columns that this data type needs and the list of
--   substitutions for <tt>SELECT</tt> placeholders <tt>??</tt>.
rawSqlCols :: RawSql a => (Text -> Text) -> a -> (Int, [Text])

-- | A string telling the user why the column count is what it is.
rawSqlColCountReason :: RawSql a => a -> String

-- | Transform a row of the result into the data type.
rawSqlProcessRow :: RawSql a => [PersistValue] -> Either Text a

-- | This newtype wrapper is useful when selecting an entity out of the
--   database and you want to provide a prefix to the table being selected.
--   
--   Consider this raw SQL query:
--   
--   <pre>
--   SELECT ??
--   FROM my_long_table_name AS mltn
--   INNER JOIN other_table AS ot
--      ON mltn.some_col = ot.other_col
--   WHERE ...
--   </pre>
--   
--   We don't want to refer to <tt>my_long_table_name</tt> every time, so
--   we create an alias. If we want to select it, we have to tell the raw
--   SQL quasi-quoter that we expect the entity to be prefixed with some
--   other name.
--   
--   We can give the above query a type with this, like:
--   
--   <pre>
--   getStuff :: <a>SqlPersistM</a> [<a>EntityWithPrefix</a> "mltn" MyLongTableName]
--   getStuff = rawSql queryText []
--   </pre>
--   
--   The <a>EntityWithPrefix</a> bit is a boilerplate newtype wrapper, so
--   you can remove it with <a>unPrefix</a>, like this:
--   
--   <pre>
--   getStuff :: <a>SqlPersistM</a> [<a>Entity</a> MyLongTableName]
--   getStuff = <a>unPrefix</a> @"mltn" <a>&lt;$&gt;</a> <tt>rawSql</tt> queryText []
--   </pre>
--   
--   The <tt> symbol is a "type application" and requires the
--   </tt>TypeApplications@ language extension.
newtype EntityWithPrefix (prefix :: Symbol) record
EntityWithPrefix :: Entity record -> EntityWithPrefix (prefix :: Symbol) record
[unEntityWithPrefix] :: EntityWithPrefix (prefix :: Symbol) record -> Entity record

-- | Tells Persistent what database column type should be used to store a
--   Haskell type.
--   
--   <h4><b>Examples</b></h4>
--   
--   <h5>Simple Boolean Alternative</h5>
--   
--   <pre>
--   data Switch = On | Off
--     deriving (Show, Eq)
--   
--   instance <a>PersistField</a> Switch where
--     <a>toPersistValue</a> s = case s of
--       On -&gt; <a>PersistBool</a> True
--       Off -&gt; <a>PersistBool</a> False
--     <a>fromPersistValue</a> (<a>PersistBool</a> b) = if b then <a>Right</a> On else <a>Right</a> Off
--     <a>fromPersistValue</a> x = Left $ "File.hs: When trying to deserialize a Switch: expected PersistBool, received: " &lt;&gt; T.pack (show x)
--   
--   instance <a>PersistFieldSql</a> Switch where
--     <a>sqlType</a> _ = <a>SqlBool</a>
--   </pre>
--   
--   <h5>Non-Standard Database Types</h5>
--   
--   If your database supports non-standard types, such as Postgres'
--   <tt>uuid</tt>, you can use <a>SqlOther</a> to use them:
--   
--   <pre>
--   import qualified Data.UUID as UUID
--   instance <a>PersistField</a> UUID where
--     <a>toPersistValue</a> = <tt>PersistLiteralEncoded</tt> . toASCIIBytes
--     <a>fromPersistValue</a> (<tt>PersistLiteralEncoded</tt> uuid) =
--       case fromASCIIBytes uuid of
--         <a>Nothing</a> -&gt; <a>Left</a> $ "Model/CustomTypes.hs: Failed to deserialize a UUID; received: " &lt;&gt; T.pack (show uuid)
--         <a>Just</a> uuid' -&gt; <a>Right</a> uuid'
--     <a>fromPersistValue</a> x = Left $ "File.hs: When trying to deserialize a UUID: expected PersistLiteralEncoded, received: "-- &gt;  &lt;&gt; T.pack (show x)
--   
--   instance <a>PersistFieldSql</a> UUID where
--     <a>sqlType</a> _ = <a>SqlOther</a> "uuid"
--   </pre>
--   
--   <h5>User Created Database Types</h5>
--   
--   Similarly, some databases support creating custom types, e.g.
--   Postgres' <a>DOMAIN</a> and <a>ENUM</a> features. You can use
--   <a>SqlOther</a> to specify a custom type:
--   
--   <pre>
--   CREATE DOMAIN ssn AS text
--         CHECK ( value ~ '^[0-9]{9}$');
--   </pre>
--   
--   <pre>
--   instance <tt>PersistFieldSQL</tt> SSN where
--     <a>sqlType</a> _ = <a>SqlOther</a> "ssn"
--   </pre>
--   
--   <pre>
--   CREATE TYPE rainbow_color AS ENUM ('red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet');
--   </pre>
--   
--   <pre>
--   instance <tt>PersistFieldSQL</tt> RainbowColor where
--     <a>sqlType</a> _ = <a>SqlOther</a> "rainbow_color"
--   </pre>
class PersistField a => PersistFieldSql a
sqlType :: PersistFieldSql a => Proxy a -> SqlType

-- | FIXME What's this exactly?
limitOffsetOrder :: PersistEntity val => [SelectOpt val] -> (Int, Int, [SelectOpt val])

-- | A more general way to convert instances of <a>ToJSON</a> type class to
--   strict text <a>Text</a>.
toJsonText :: ToJSON j => j -> Text

-- | Convert map (list of tuples) into textual representation of JSON
--   object. This is a type-constrained synonym for <a>toJsonText</a>.
mapToJSON :: [(Text, PersistValue)] -> Text

-- | Convert list of <a>PersistValue</a>s into textual representation of
--   JSON object. This is a type-constrained synonym for <a>toJsonText</a>.
listToJSON :: [PersistValue] -> Text

-- | The OR of two lists of filters. For example:
--   
--   <pre>
--   selectList
--       ([ PersonAge &gt;. 25
--        , PersonAge &lt;. 30 ] ||.
--        [ PersonIncome &gt;. 15000
--        , PersonIncome &lt;. 25000 ])
--       []
--   </pre>
--   
--   will filter records where a person's age is between 25 and 30
--   <i>or</i> a person's income is between (15000 and 25000).
--   
--   If you are looking for an <tt>(&amp;&amp;.)</tt> operator to do <tt>(A
--   AND B AND (C OR D))</tt> you can use the <tt>(++)</tt> operator
--   instead as there is no <tt>(&amp;&amp;.)</tt>. For example:
--   
--   <pre>
--   selectList
--       ([ PersonAge &gt;. 25
--        , PersonAge &lt;. 30 ] ++
--       ([PersonCategory ==. 1] ||.
--        [PersonCategory ==. 5]))
--       []
--   </pre>
--   
--   will filter records where a person's age is between 25 and 30
--   <i>and</i> (person's category is either 1 or 5).
(||.) :: [Filter v] -> [Filter v] -> [Filter v]
infixl 3 ||.

-- | Check if value is not in given list.
--   
--   <h3>Examples</h3>
--   
--   <pre>
--   selectSimon :: MonadIO m =&gt; ReaderT SqlBackend m [Entity User]
--   selectSimon = selectList [UserAge /&lt;-. [40]] []
--   </pre>
--   
--   The above query when applied on <a>dataset-1</a>, will produce this:
--   
--   <pre>
--   +-----+-----+-----+
--   |id   |name |age  |
--   +-----+-----+-----+
--   |2    |Simon|41   |
--   +-----+-----+-----+
--   </pre>
(/<-.) :: forall v typ. PersistField typ => EntityField v typ -> [typ] -> Filter v
infix 4 /<-.

-- | Check if value is in given list.
--   
--   <h3>Examples</h3>
--   
--   <pre>
--   selectUsers :: MonadIO m =&gt; ReaderT SqlBackend m [Entity User]
--   selectUsers = selectList [UserAge &lt;-. [40, 41]] []
--   </pre>
--   
--   The above query when applied on <a>dataset-1</a>, will produce this:
--   
--   <pre>
--   +-----+-----+-----+
--   |id   |name |age  |
--   +-----+-----+-----+
--   |1    |SPJ  |40   |
--   +-----+-----+-----+
--   |2    |Simon|41   |
--   +-----+-----+-----+
--   </pre>
--   
--   <pre>
--   selectSPJ :: MonadIO m =&gt; ReaderT SqlBackend m [Entity User]
--   selectSPJ = selectList [UserAge &lt;-. [40]] []
--   </pre>
--   
--   The above query when applied on <a>dataset-1</a>, will produce this:
--   
--   <pre>
--   +-----+-----+-----+
--   |id   |name |age  |
--   +-----+-----+-----+
--   |1    |SPJ  |40   |
--   +-----+-----+-----+
--   </pre>
(<-.) :: forall v typ. PersistField typ => EntityField v typ -> [typ] -> Filter v
infix 4 <-.

-- | Greater-than or equal check.
--   
--   <h3>Examples</h3>
--   
--   <pre>
--   selectGreaterEqualAge :: MonadIO m =&gt; ReaderT SqlBackend m [Entity User]
--   selectGreaterEqualAge = selectList [UserAge &gt;=. 41 ] []
--   </pre>
--   
--   The above query when applied on <a>dataset-1</a>, will produce this:
--   
--   <pre>
--   +-----+-----+-----+
--   |id   |name |age  |
--   +-----+-----+-----+
--   |2    |Simon|41   |
--   +-----+-----+-----+
--   </pre>
(>=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v
infix 4 >=.

-- | Greater-than check.
--   
--   <h3>Examples</h3>
--   
--   <pre>
--   selectGreaterAge :: MonadIO m =&gt; ReaderT SqlBackend m [Entity User]
--   selectGreaterAge = selectList [UserAge &gt;. 40 ] []
--   </pre>
--   
--   The above query when applied on <a>dataset-1</a>, will produce this:
--   
--   <pre>
--   +-----+-----+-----+
--   |id   |name |age  |
--   +-----+-----+-----+
--   |2    |Simon|41   |
--   +-----+-----+-----+
--   </pre>
(>.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v
infix 4 >.

-- | Less-than or equal check.
--   
--   <h3>Examples</h3>
--   
--   <pre>
--   selectLessEqualAge :: MonadIO m =&gt; ReaderT SqlBackend m [Entity User]
--   selectLessEqualAge = selectList [UserAge &lt;=. 40 ] []
--   </pre>
--   
--   The above query when applied on <a>dataset-1</a>, will produce this:
--   
--   <pre>
--   +-----+-----+-----+
--   |id   |name |age  |
--   +-----+-----+-----+
--   |1    |SPJ  |40   |
--   +-----+-----+-----+
--   </pre>
(<=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v
infix 4 <=.

-- | Less-than check.
--   
--   <h3>Examples</h3>
--   
--   <pre>
--   selectLessAge :: MonadIO m =&gt; ReaderT SqlBackend m [Entity User]
--   selectLessAge = selectList [UserAge &lt;. 41 ] []
--   </pre>
--   
--   The above query when applied on <a>dataset-1</a>, will produce this:
--   
--   <pre>
--   +-----+-----+-----+
--   |id   |name |age  |
--   +-----+-----+-----+
--   |1    |SPJ  |40   |
--   +-----+-----+-----+
--   </pre>
(<.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v
infix 4 <.

-- | Non-equality check.
--   
--   <h3>Examples</h3>
--   
--   <pre>
--   selectSimon :: MonadIO m =&gt; ReaderT SqlBackend m [Entity User]
--   selectSimon = selectList [UserName !=. "SPJ" ] []
--   </pre>
--   
--   The above query when applied on <a>dataset-1</a>, will produce this:
--   
--   <pre>
--   +-----+-----+-----+
--   |id   |name |age  |
--   +-----+-----+-----+
--   |2    |Simon|41   |
--   +-----+-----+-----+
--   </pre>
(!=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v
infix 4 !=.

-- | Check for equality.
--   
--   <h3>Examples</h3>
--   
--   <pre>
--   selectSPJ :: MonadIO m =&gt; ReaderT SqlBackend m [Entity User]
--   selectSPJ = selectList [UserName ==. "SPJ" ] []
--   </pre>
--   
--   The above query when applied on <a>dataset-1</a>, will produce this:
--   
--   <pre>
--   +-----+-----+-----+
--   |id   |name |age  |
--   +-----+-----+-----+
--   |1    |SPJ  |40   |
--   +-----+-----+-----+
--   </pre>
(==.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Filter v
infix 4 ==.

-- | Assign a field by division (<tt>/=</tt>).
--   
--   <h3>Examples</h3>
--   
--   <pre>
--   divideAge :: MonadIO m =&gt; ReaderT SqlBackend m ()
--   divideAge = updateWhere [UserName ==. "SPJ" ] [UserAge /=. 2]
--   </pre>
--   
--   The above query when applied on <a>dataset-1</a>, will produce this:
--   
--   <pre>
--   +-----+-----+---------+
--   |id   |name |age      |
--   +-----+-----+---------+
--   |1    |SPJ  |40 -&gt; 20 |
--   +-----+-----+---------+
--   |2    |Simon|41       |
--   +-----+-----+---------+
--   </pre>
(/=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Update v
infixr 3 /=.

-- | Assign a field by multiplication (<tt>*=</tt>).
--   
--   <h3>Examples</h3>
--   
--   <pre>
--   multiplyAge :: MonadIO m =&gt; ReaderT SqlBackend m ()
--   multiplyAge = updateWhere [UserName ==. "SPJ" ] [UserAge *=. 2]
--   </pre>
--   
--   The above query when applied on <a>dataset-1</a>, will produce this:
--   
--   <pre>
--   +-----+-----+--------+
--   |id   |name |age     |
--   +-----+-----+--------+
--   |1    |SPJ  |40 -&gt; 80|
--   +-----+-----+--------+
--   |2    |Simon|41      |
--   +-----+-----+--------+
--   </pre>
(*=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Update v
infixr 3 *=.

-- | Assign a field by subtraction (<tt>-=</tt>).
--   
--   <h3>Examples</h3>
--   
--   <pre>
--   subtractAge :: MonadIO m =&gt; ReaderT SqlBackend m ()
--   subtractAge = updateWhere [UserName ==. "SPJ" ] [UserAge -=. 1]
--   </pre>
--   
--   The above query when applied on <a>dataset-1</a>, will produce this:
--   
--   <pre>
--   +-----+-----+---------+
--   |id   |name |age      |
--   +-----+-----+---------+
--   |1    |SPJ  |40 -&gt; 39 |
--   +-----+-----+---------+
--   |2    |Simon|41       |
--   +-----+-----+---------+
--   </pre>
(-=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Update v
infixr 3 -=.

-- | Assign a field by addition (<tt>+=</tt>).
--   
--   <h3>Examples</h3>
--   
--   <pre>
--   addAge :: MonadIO m =&gt; ReaderT SqlBackend m ()
--   addAge = updateWhere [UserName ==. "SPJ" ] [UserAge +=. 1]
--   </pre>
--   
--   The above query when applied on <a>dataset-1</a>, will produce this:
--   
--   <pre>
--   +-----+-----+---------+
--   |id   |name |age      |
--   +-----+-----+---------+
--   |1    |SPJ  |40 -&gt; 41 |
--   +-----+-----+---------+
--   |2    |Simon|41       |
--   +-----+-----+---------+
--   </pre>
(+=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Update v
infixr 3 +=.

-- | Assign a field a value.
--   
--   <h3>Examples</h3>
--   
--   <pre>
--   updateAge :: MonadIO m =&gt; ReaderT SqlBackend m ()
--   updateAge = updateWhere [UserName ==. "SPJ" ] [UserAge =. 45]
--   </pre>
--   
--   Similar to <a>updateWhere</a> which is shown in the above example you
--   can use other functions present in the module
--   <a>Database.Persist.Class</a>. Note that the first parameter of
--   <a>updateWhere</a> is [<a>Filter</a> val] and second parameter is
--   [<a>Update</a> val]. By comparing this with the type of <a>==.</a> and
--   <a>=.</a>, you can see that they match up in the above usage.
--   
--   The above query when applied on <a>dataset-1</a>, will produce this:
--   
--   <pre>
--   +-----+-----+--------+
--   |id   |name |age     |
--   +-----+-----+--------+
--   |1    |SPJ  |40 -&gt; 45|
--   +-----+-----+--------+
--   |2    |Simon|41      |
--   +-----+-----+--------+
--   </pre>
(=.) :: forall v typ. PersistField typ => EntityField v typ -> typ -> Update v
infixr 3 =.

-- | Create the list of columns for the given entity.
mkColumns :: [EntityDef] -> EntityDef -> BackendSpecificOverrides -> ([Column], [UniqueDef], [ForeignDef])
defaultAttribute :: [FieldAttr] -> Maybe Text

-- | Creates an empty <a>BackendSpecificOverrides</a> (i.e. use the default
--   behavior; no overrides)
emptyBackendSpecificOverrides :: BackendSpecificOverrides

-- | Set the backend's foreign key generation function to this value.
setBackendSpecificForeignKeyName :: (EntityNameDB -> FieldNameDB -> ConstraintNameDB) -> BackendSpecificOverrides -> BackendSpecificOverrides

-- | If the override is defined, then this returns a function that accepts
--   an entity name and field name and provides the <a>ConstraintNameDB</a>
--   for the foreign key constraint.
--   
--   An abstract accessor for the <a>BackendSpecificOverrides</a>
getBackendSpecificForeignKeyName :: BackendSpecificOverrides -> Maybe (EntityNameDB -> FieldNameDB -> ConstraintNameDB)

-- | Record of functions to override the default behavior in
--   <a>mkColumns</a>. It is recommended you initialize this with
--   <a>emptyBackendSpecificOverrides</a> and override the default values,
--   so that as new fields are added, your code still compiles.
--   
--   For added safety, use the <tt>getBackendSpecific*</tt> and
--   <tt>setBackendSpecific*</tt> functions, as a breaking change to the
--   record field labels won't be reflected in a major version bump of the
--   library.
data BackendSpecificOverrides

-- | Initializes a ConnectionPoolConfig with default values. See the
--   documentation of <a>ConnectionPoolConfig</a> for each field's default
--   value.
defaultConnectionPoolConfig :: ConnectionPoolConfig
data Column
Column :: !FieldNameDB -> !Bool -> !SqlType -> !Maybe Text -> !Maybe Text -> !Maybe ConstraintNameDB -> !Maybe Integer -> !Maybe ColumnReference -> Column
[cName] :: Column -> !FieldNameDB
[cNull] :: Column -> !Bool
[cSqlType] :: Column -> !SqlType
[cDefault] :: Column -> !Maybe Text
[cGenerated] :: Column -> !Maybe Text
[cDefaultConstraintName] :: Column -> !Maybe ConstraintNameDB
[cMaxLen] :: Column -> !Maybe Integer
[cReference] :: Column -> !Maybe ColumnReference

-- | This value specifies how a field references another table.
data ColumnReference
ColumnReference :: !EntityNameDB -> !ConstraintNameDB -> !FieldCascade -> ColumnReference

-- | The table name that the
[crTableName] :: ColumnReference -> !EntityNameDB

-- | The name of the foreign key constraint.
[crConstraintName] :: ColumnReference -> !ConstraintNameDB

-- | Whether or not updates/deletions to the referenced table cascade to
--   this table.
[crFieldCascade] :: ColumnReference -> !FieldCascade
data PersistentSqlException
StatementAlreadyFinalized :: Text -> PersistentSqlException
Couldn'tGetSQLConnection :: PersistentSqlException
type SqlPersistT = ReaderT SqlBackend
type SqlPersistM = SqlPersistT NoLoggingT ResourceT IO
type ConnectionPool = Pool SqlBackend

-- | Values to configure a pool of database connections. See
--   <a>Data.Pool</a> for details.
data ConnectionPoolConfig
ConnectionPoolConfig :: Int -> NominalDiffTime -> Int -> ConnectionPoolConfig

-- | How many stripes to divide the pool into. See <a>Data.Pool</a> for
--   details. Default: 1.
[connectionPoolConfigStripes] :: ConnectionPoolConfig -> Int

-- | How long connections can remain idle before being disposed of, in
--   seconds. Default: 600
[connectionPoolConfigIdleTimeout] :: ConnectionPoolConfig -> NominalDiffTime

-- | How many connections should be held in the connection pool. Default:
--   10
[connectionPoolConfigSize] :: ConnectionPoolConfig -> Int

-- | A single column (see <tt>rawSql</tt>). Any <tt>PersistField</tt> may
--   be used here, including <a>PersistValue</a> (which does not do any
--   processing).
newtype Single a
Single :: a -> Single a
[unSingle] :: Single a -> a

-- | Useful for running a read query against a backend with unknown
--   capabilities.
readToUnknown :: forall (m :: Type -> Type) a. Monad m => ReaderT SqlReadBackend m a -> ReaderT SqlBackend m a

-- | Useful for running a read query against a backend with read and write
--   capabilities.
readToWrite :: forall (m :: Type -> Type) a. Monad m => ReaderT SqlReadBackend m a -> ReaderT SqlWriteBackend m a

-- | Useful for running a write query against an untagged backend with
--   unknown capabilities.
writeToUnknown :: forall (m :: Type -> Type) a. Monad m => ReaderT SqlWriteBackend m a -> ReaderT SqlBackend m a

-- | An SQL backend which can only handle read queries
--   
--   The constructor was exposed in 2.10.0.
newtype SqlReadBackend
SqlReadBackend :: SqlBackend -> SqlReadBackend
[$sel:unSqlReadBackend:SqlReadBackend] :: SqlReadBackend -> SqlBackend

-- | An SQL backend which can handle read or write queries
--   
--   The constructor was exposed in 2.10.0
newtype SqlWriteBackend
SqlWriteBackend :: SqlBackend -> SqlWriteBackend
[$sel:unSqlWriteBackend:SqlWriteBackend] :: SqlWriteBackend -> SqlBackend

-- | A constraint synonym which witnesses that a backend is SQL and can run
--   read queries.
type SqlBackendCanRead backend = (BackendCompatible SqlBackend backend, PersistQueryRead backend, PersistStoreRead backend, PersistUniqueRead backend)

-- | A constraint synonym which witnesses that a backend is SQL and can run
--   read and write queries.
type SqlBackendCanWrite backend = (SqlBackendCanRead backend, PersistQueryWrite backend, PersistStoreWrite backend, PersistUniqueWrite backend)

-- | Like <tt>SqlPersistT</tt> but compatible with any SQL backend which
--   can handle read queries.
type SqlReadT (m :: Type -> Type) a = forall backend. SqlBackendCanRead backend => ReaderT backend m a

-- | Like <tt>SqlPersistT</tt> but compatible with any SQL backend which
--   can handle read and write queries.
type SqlWriteT (m :: Type -> Type) a = forall backend. SqlBackendCanWrite backend => ReaderT backend m a

-- | A backend which is a wrapper around <tt>SqlBackend</tt>.
type IsSqlBackend backend = (IsPersistBackend backend, BaseBackend backend ~ SqlBackend)

-- | A backwards-compatible alias for those that don't care about
--   distinguishing between read and write queries. It signifies the
--   assumption that, by default, a backend can write as well as read.
type PersistUnique a = PersistUniqueWrite a

-- | A backwards-compatible alias for those that don't care about
--   distinguishing between read and write queries. It signifies the
--   assumption that, by default, a backend can write as well as read.
type PersistQuery a = PersistQueryWrite a

-- | A backwards-compatible alias for those that don't care about
--   distinguishing between read and write queries. It signifies the
--   assumption that, by default, a backend can write as well as read.
type PersistStore a = PersistStoreWrite a

-- | Backends supporting conditional read operations.
class (PersistCore backend, PersistStoreRead backend) => PersistQueryRead backend

-- | Backends supporting conditional write operations
class (PersistQueryRead backend, PersistStoreWrite backend) => PersistQueryWrite backend

-- | Given a proxy for a <a>PersistEntity</a> record, this returns the sole
--   <a>UniqueDef</a> for that entity.
onlyOneUniqueDef :: (OnlyOneUniqueKey record, Monad proxy) => proxy record -> UniqueDef

-- | Queries against <a>Unique</a> keys (other than the id <a>Key</a>).
--   
--   Please read the general Persistent documentation to learn how to
--   create <a>Unique</a> keys.
--   
--   Using this with an Entity without a Unique key leads to undefined
--   behavior. A few of these functions require a <i>single</i>
--   <a>Unique</a>, so using an Entity with multiple <a>Unique</a>s is also
--   undefined. In these cases persistent's goal is to throw an exception
--   as soon as possible, but persistent is still transitioning to that.
--   
--   SQL backends automatically create uniqueness constraints, but for
--   MongoDB you must manually place a unique index on a field to have a
--   uniqueness constraint.
class PersistStoreRead backend => PersistUniqueRead backend

-- | Returns True if a record with this unique key exists, otherwise False.
--   
--   <h3><b>Example usage</b></h3>
--   
--   With <a>schema-1</a> and <a>dataset-1</a>:
--   
--   <pre>
--   existsBySpjName :: MonadIO m  =&gt; ReaderT SqlBackend m Bool
--   existsBySpjName = existsBy $ UniqueUserName "SPJ"
--   </pre>
--   
--   <pre>
--   spjEntExists &lt;- existsBySpjName
--   </pre>
--   
--   The above query when applied on <a>dataset-1</a>, will return the
--   value True.
existsBy :: forall record (m :: Type -> Type). (PersistUniqueRead backend, MonadIO m, PersistRecordBackend record backend) => Unique record -> ReaderT backend m Bool

-- | Some functions in this module (<a>insertUnique</a>, <a>insertBy</a>,
--   and <a>replaceUnique</a>) first query the unique indexes to check for
--   conflicts. You could instead optimistically attempt to perform the
--   operation (e.g. <a>replace</a> instead of <a>replaceUnique</a>).
--   However,
--   
--   <ul>
--   <li>there is some fragility to trying to catch the correct exception
--   and determing the column of failure;</li>
--   <li>an exception will automatically abort the current SQL
--   transaction.</li>
--   </ul>
class (PersistUniqueRead backend, PersistStoreWrite backend) => PersistUniqueWrite backend

-- | Same as <a>insertUnique</a> but doesn't return a <tt>Key</tt>.
--   
--   <h3><b>Example usage</b></h3>
--   
--   With <a>schema-1</a> and <a>dataset-1</a>, we try to insert the
--   following two records:
--   
--   <pre>
--   linusId &lt;- insertUnique_ $ User "Linus" 48
--   spjId   &lt;- insertUnique_ $ User "SPJ" 90
--   </pre>
--   
--   <pre>
--   +-----+------+-----+
--   |id   |name  |age  |
--   +-----+------+-----+
--   |1    |SPJ   |40   |
--   +-----+------+-----+
--   |2    |Simon |41   |
--   +-----+------+-----+
--   |3    |Linus |48   |
--   +-----+------+-----+
--   </pre>
--   
--   Linus's record was inserted to <a>dataset-1</a>, while SPJ wasn't
--   because SPJ already exists in <a>dataset-1</a>.
insertUnique_ :: forall record (m :: Type -> Type). (PersistUniqueWrite backend, MonadIO m, PersistRecordBackend record backend, SafeToInsert record) => record -> ReaderT backend m (Maybe ())

-- | This class is used to ensure that <a>upsert</a> is only called on
--   records that have a single <a>Unique</a> key. The quasiquoter
--   automatically generates working instances for appropriate records, and
--   generates <tt>TypeError</tt> instances for records that have 0 or
--   multiple unique keys.
class PersistEntity record => OnlyOneUniqueKey record
onlyUniqueP :: OnlyOneUniqueKey record => record -> Unique record

-- | This is an error message. It is used when writing instances of
--   <a>OnlyOneUniqueKey</a> for an entity that has no unique keys.
type NoUniqueKeysError ty = 'Text "The entity " :<>: 'ShowType ty :<>: 'Text " does not have any unique keys." :$$: 'Text "The function you are trying to call requires a unique key " :<>: 'Text "to be defined on the entity."

-- | This is an error message. It is used when an entity has multiple
--   unique keys, and the function expects a single unique key.
type MultipleUniqueKeysError ty = 'Text "The entity " :<>: 'ShowType ty :<>: 'Text " has multiple unique keys." :$$: 'Text "The function you are trying to call requires only a single " :<>: 'Text "unique key." :$$: 'Text "There is probably a variant of the function with 'By' " :<>: 'Text "appended that will allow you to select a unique key " :<>: 'Text "for the operation."

-- | This class is used to ensure that functions requring at least one
--   unique key are not called with records that have 0 unique keys. The
--   quasiquoter automatically writes working instances for appropriate
--   entities, and generates <tt>TypeError</tt> instances for records that
--   have 0 unique keys.
class PersistEntity record => AtLeastOneUniqueKey record
requireUniquesP :: AtLeastOneUniqueKey record => record -> NonEmpty (Unique record)

-- | A <a>SqlBackend</a> represents a handle or connection to a database.
--   It contains functions and values that allow databases to have more
--   optimized implementations, as well as references that benefit
--   performance and sharing.
--   
--   Instead of using the <a>SqlBackend</a> constructor directly, use the
--   <a>mkSqlBackend</a> function.
--   
--   A <a>SqlBackend</a> is *not* thread-safe. You should not assume that a
--   <a>SqlBackend</a> can be shared among threads and run concurrent
--   queries. This *will* result in problems. Instead, you should create a
--   <tt><tt>Pool</tt> <a>SqlBackend</a></tt>, known as a
--   <tt>ConnectionPool</tt>, and pass that around in multi-threaded
--   applications.
--   
--   To run actions in the <tt>persistent</tt> library, you should use the
--   <tt>runSqlConn</tt> function. If you're using a multithreaded
--   application, use the <tt>runSqlPool</tt> function.
data SqlBackend
liftPersist :: (MonadIO m, MonadReader backend m) => ReaderT backend IO b -> m b

-- | Run a query against a compatible backend, by projecting the backend
--   
--   This is a helper for using queries which run against a specific
--   backend type that your backend is compatible with.
withCompatibleBackend :: forall sup sub (m :: Type -> Type) a. BackendCompatible sup sub => ReaderT sup m a -> ReaderT sub m a

-- | Run a query against a larger backend by plucking out <tt>BaseBackend
--   backend</tt>
--   
--   This is a helper for reusing existing queries when expanding the
--   backend type.
withBaseBackend :: forall backend (m :: Type -> Type) a. HasPersistBackend backend => ReaderT (BaseBackend backend) m a -> ReaderT backend m a
type family BaseBackend backend

-- | Class which allows the plucking of a <tt>BaseBackend backend</tt> from
--   some larger type. For example, <tt> instance HasPersistBackend
--   (SqlReadBackend, Int) where type BaseBackend (SqlReadBackend, Int) =
--   SqlBackend persistBackend = unSqlReadBackend . fst </tt>
class HasPersistBackend backend where {
    type family BaseBackend backend;
}
persistBackend :: HasPersistBackend backend => backend -> BaseBackend backend

-- | Class which witnesses that <tt>backend</tt> is essentially the same as
--   <tt>BaseBackend backend</tt>. That is, they're isomorphic and
--   <tt>backend</tt> is just some wrapper over <tt>BaseBackend
--   backend</tt>.
class HasPersistBackend backend => IsPersistBackend backend

-- | This class witnesses that two backend are compatible, and that you can
--   convert from the <tt>sub</tt> backend into the <tt>sup</tt> backend.
--   This is similar to the <a>HasPersistBackend</a> and
--   <a>IsPersistBackend</a> classes, but where you don't want to fix the
--   type associated with the <a>PersistEntityBackend</a> of a record.
--   
--   Generally speaking, where you might have:
--   
--   <pre>
--   foo ::
--     ( <a>PersistEntity</a> record
--     , <a>PersistEntityBackend</a> record ~ <a>BaseBackend</a> backend
--     , <tt>IsSqlBackend</tt> backend
--     )
--   </pre>
--   
--   this can be replaced with:
--   
--   <pre>
--   foo ::
--     ( <a>PersistEntity</a> record,
--     , <a>PersistEntityBackend</a> record ~ backend
--     , <a>BackendCompatible</a> <tt>SqlBackend</tt> backend
--     )
--   </pre>
--   
--   This works for <tt>SqlReadBackend</tt> because of the <tt>instance
--   <a>BackendCompatible</a> <tt>SqlBackend</tt>
--   <tt>SqlReadBackend</tt></tt>, without needing to go through the
--   <a>BaseBackend</a> type family.
--   
--   Likewise, functions that are currently hardcoded to use
--   <tt>SqlBackend</tt> can be generalized:
--   
--   <pre>
--   -- before:
--   asdf :: <a>ReaderT</a> <tt>SqlBackend</tt> m ()
--   asdf = pure ()
--   
--   -- after:
--   asdf' :: <a>BackendCompatible</a> SqlBackend backend =&gt; ReaderT backend m ()
--   asdf' = <a>withCompatibleBackend</a> asdf
--   </pre>
class BackendCompatible sup sub
projectBackend :: BackendCompatible sup sub => sub -> sup

-- | A convenient alias for common type signatures
type PersistRecordBackend record backend = (PersistEntity record, PersistEntityBackend record ~ BaseBackend backend)

-- | <a>ToBackendKey</a> converts a <a>PersistEntity</a> <a>Key</a> into a
--   <a>BackendKey</a> This can be used by each backend to convert between
--   a <a>Key</a> and a plain Haskell type. For Sql, that is done with
--   <tt>toSqlKey</tt> and <tt>fromSqlKey</tt>.
--   
--   By default, a <a>PersistEntity</a> uses the default <a>BackendKey</a>
--   for its Key and is an instance of ToBackendKey
--   
--   A <a>Key</a> that instead uses a custom type will not be an instance
--   of <a>ToBackendKey</a>.
class (PersistEntity record, PersistEntityBackend record ~ backend, PersistCore backend) => ToBackendKey backend record
toBackendKey :: ToBackendKey backend record => Key record -> BackendKey backend
fromBackendKey :: ToBackendKey backend record => BackendKey backend -> Key record
data family BackendKey backend
class PersistCore backend where {
    data family BackendKey backend;
}
class (Show BackendKey backend, Read BackendKey backend, Eq BackendKey backend, Ord BackendKey backend, PersistCore backend, PersistField BackendKey backend, ToJSON BackendKey backend, FromJSON BackendKey backend) => PersistStoreRead backend
class (Show BackendKey backend, Read BackendKey backend, Eq BackendKey backend, Ord BackendKey backend, PersistStoreRead backend, PersistField BackendKey backend, ToJSON BackendKey backend, FromJSON BackendKey backend) => PersistStoreWrite backend

-- | Convenience function for getting a free <a>PersistField</a> instance
--   from a type with JSON instances. The JSON parser used will accept JSON
--   values other that object and arrays. So, if your instance serializes
--   the data to a JSON string, this will still work.
--   
--   Example usage in combination with <a>toPersistValueJSON</a>:
--   
--   <pre>
--   instance PersistField MyData where
--     fromPersistValue = fromPersistValueJSON
--     toPersistValue = toPersistValueJSON
--   </pre>
fromPersistValueJSON :: FromJSON a => PersistValue -> Either Text a

-- | Convenience function for getting a free <a>PersistField</a> instance
--   from a type with JSON instances.
--   
--   Example usage in combination with <a>fromPersistValueJSON</a>:
--   
--   <pre>
--   instance PersistField MyData where
--     fromPersistValue = fromPersistValueJSON
--     toPersistValue = toPersistValueJSON
--   </pre>
toPersistValueJSON :: ToJSON a => a -> PersistValue

-- | Predefined <tt>parseJSON</tt>. The input JSON looks like <tt>{"id": 1,
--   "name": ...}</tt>.
--   
--   The typical usage is:
--   
--   <pre>
--   instance FromJSON (Entity User) where
--       parseJSON = entityIdFromJSON
--   </pre>
entityIdFromJSON :: (PersistEntity record, FromJSON record) => Value -> Parser (Entity record)

-- | Predefined <tt>toJSON</tt>. The resulting JSON looks like <tt>{"id":
--   1, "name": ...}</tt>.
--   
--   The typical usage is:
--   
--   <pre>
--   instance ToJSON (Entity User) where
--       toJSON = entityIdToJSON
--   </pre>
entityIdToJSON :: (PersistEntity record, ToJSON record) => Entity record -> Value

-- | Predefined <tt>parseJSON</tt>. The input JSON looks like <tt>{"key":
--   1, "value": {"name": ...}}</tt>.
--   
--   The typical usage is:
--   
--   <pre>
--   instance FromJSON (Entity User) where
--       parseJSON = keyValueEntityFromJSON
--   </pre>
keyValueEntityFromJSON :: (PersistEntity record, FromJSON record) => Value -> Parser (Entity record)

-- | Predefined <tt>toJSON</tt>. The resulting JSON looks like <tt>{"key":
--   1, "value": {"name": ...}}</tt>.
--   
--   The typical usage is:
--   
--   <pre>
--   instance ToJSON (Entity User) where
--       toJSON = keyValueEntityToJSON
--   </pre>
keyValueEntityToJSON :: (PersistEntity record, ToJSON record) => Entity record -> Value

-- | Get list of values corresponding to given entity.
entityValues :: PersistEntity record => Entity record -> [PersistValue]

-- | Construct an <tt><a>Entity</a> record</tt> by providing a value for
--   each of the record's fields.
--   
--   These constructions are equivalent:
--   
--   <pre>
--   entityMattConstructor, entityMattTabulate :: Entity User
--   entityMattConstructor =
--       Entity
--           { entityKey = toSqlKey 123
--           , entityVal =
--               User
--                   { userName = <a>Matt</a>
--                   , userAge = 33
--                   }
--           }
--   
--   entityMattTabulate =
--       tabulateEntity $ \case
--           UserId -&gt;
--               toSqlKey 123
--           UserName -&gt;
--               <a>Matt</a>
--           UserAge -&gt;
--               33
--   </pre>
--   
--   This is a specialization of <a>tabulateEntityA</a>, which allows you
--   to construct an <a>Entity</a> by providing an <a>Applicative</a>
--   action for each field instead of a regular function.
tabulateEntity :: PersistEntity record => (forall a. () => EntityField record a -> a) -> Entity record

-- | Unique keys besides the <a>Key</a>.
data family Unique record

-- | An <a>EntityField</a> is parameterised by the Haskell record it
--   belongs to and the additional type of that field.
--   
--   As of <tt>persistent-2.11.0.0</tt>, it's possible to use the
--   <tt>OverloadedLabels</tt> language extension to refer to
--   <a>EntityField</a> values polymorphically. See the documentation on
--   <a>SymbolToField</a> for more information.
data family EntityField record :: Type -> Type

-- | By default, a backend will automatically generate the key Instead you
--   can specify a Primary key made up of unique values.
data family Key record

-- | Persistent allows multiple different backends (databases).
type family PersistEntityBackend record

-- | Persistent serialized Haskell records to the database. A Database
--   <a>Entity</a> (A row in SQL, a document in MongoDB, etc) corresponds
--   to a <a>Key</a> plus a Haskell record.
--   
--   For every Haskell record type stored in the database there is a
--   corresponding <a>PersistEntity</a> instance. An instance of
--   PersistEntity contains meta-data for the record. PersistEntity also
--   helps abstract over different record types. That way the same query
--   interface can return a <a>PersistEntity</a>, with each query returning
--   different types of Haskell records.
--   
--   Some advanced type system capabilities are used to make this process
--   type-safe. Persistent users usually don't need to understand the class
--   associated data and functions.
class (PersistField Key record, ToJSON Key record, FromJSON Key record, Show Key record, Read Key record, Eq Key record, Ord Key record) => PersistEntity record where {
    
    -- | Persistent allows multiple different backends (databases).
    type family PersistEntityBackend record;
    
    -- | By default, a backend will automatically generate the key Instead you
    --   can specify a Primary key made up of unique values.
    data family Key record;
    
    -- | An <a>EntityField</a> is parameterised by the Haskell record it
    --   belongs to and the additional type of that field.
    --   
    --   As of <tt>persistent-2.11.0.0</tt>, it's possible to use the
    --   <tt>OverloadedLabels</tt> language extension to refer to
    --   <a>EntityField</a> values polymorphically. See the documentation on
    --   <a>SymbolToField</a> for more information.
    data family EntityField record :: Type -> Type;
    
    -- | Unique keys besides the <a>Key</a>.
    data family Unique record;
}

-- | A lower-level key operation.
keyToValues :: PersistEntity record => Key record -> [PersistValue]

-- | A lower-level key operation.
keyFromValues :: PersistEntity record => [PersistValue] -> Either Text (Key record)

-- | A meta-operation to retrieve the <a>Key</a> <a>EntityField</a>.
persistIdField :: PersistEntity record => EntityField record (Key record)

-- | Retrieve the <a>EntityDef</a> meta-data for the record.
entityDef :: PersistEntity record => proxy record -> EntityDef

-- | Return meta-data for a given <a>EntityField</a>.
persistFieldDef :: PersistEntity record => EntityField record typ -> FieldDef

-- | A meta-operation to get the database fields of a record.
toPersistFields :: PersistEntity record => record -> [PersistValue]

-- | A lower-level operation to convert from database values to a Haskell
--   record.
fromPersistValues :: PersistEntity record => [PersistValue] -> Either Text record

-- | This function allows you to build an <tt><a>Entity</a> a</tt> by
--   specifying an action that returns a value for the field in the
--   callback function. Let's look at an example.
--   
--   <pre>
--   parseFromEnvironmentVariables :: IO (Entity User)
--   parseFromEnvironmentVariables =
--       tabulateEntityA $ \userField -&gt;
--           case userField of
--               UserName -&gt;
--                   getEnv <a>USER_NAME</a>
--               UserAge -&gt; do
--                   ageVar &lt;- getEnv <a>USER_AGE</a>
--                   case readMaybe ageVar of
--                       Just age -&gt;
--                           pure age
--                       Nothing -&gt;
--                           error $ "Failed to parse Age from: " &lt;&gt; ageVar
--               UserAddressId -&gt; do
--                   addressVar &lt;- getEnv <a>USER_ADDRESS_ID</a>
--                   pure $ AddressKey addressVar
--   </pre>
tabulateEntityA :: (PersistEntity record, Applicative f) => (forall a. () => EntityField record a -> f a) -> f (Entity record)

-- | A meta operation to retrieve all the <a>Unique</a> keys.
persistUniqueKeys :: PersistEntity record => record -> [Unique record]

-- | A lower level operation.
persistUniqueToFieldNames :: PersistEntity record => Unique record -> NonEmpty (FieldNameHS, FieldNameDB)

-- | A lower level operation.
persistUniqueToValues :: PersistEntity record => Unique record -> [PersistValue]

-- | Use a <a>PersistField</a> as a lens.
fieldLens :: PersistEntity record => EntityField record field -> forall (f :: Type -> Type). Functor f => (field -> f field) -> Entity record -> f (Entity record)

-- | Extract a <tt><a>Key</a> record</tt> from a <tt>record</tt> value.
--   Currently, this is only defined for entities using the
--   <tt>Primary</tt> syntax for natural/composite keys. In a future
--   version of <tt>persistent</tt> which incorporates the ID directly into
--   the entity, this will always be Just.
keyFromRecordM :: PersistEntity record => Maybe (record -> Key record)
type family BackendSpecificUpdate backend record

-- | Updating a database entity.
--   
--   Persistent users use combinators to create these.
data Update record
Update :: EntityField record typ -> typ -> PersistUpdate -> Update record
[updateField] :: Update record -> EntityField record typ
[updateValue] :: Update record -> typ
[updateUpdate] :: Update record -> PersistUpdate
BackendUpdate :: BackendSpecificUpdate (PersistEntityBackend record) record -> Update record

-- | Query options.
--   
--   Persistent users use these directly.
data SelectOpt record
Asc :: EntityField record typ -> SelectOpt record
Desc :: EntityField record typ -> SelectOpt record
OffsetBy :: Int -> SelectOpt record
LimitTo :: Int -> SelectOpt record
type family BackendSpecificFilter backend record

-- | Filters which are available for <tt>select</tt>, <tt>updateWhere</tt>
--   and <tt>deleteWhere</tt>. Each filter constructor specifies the field
--   being filtered on, the type of comparison applied (equals, not equals,
--   etc) and the argument for the comparison.
--   
--   Persistent users use combinators to create these.
--   
--   Note that it's important to be careful about the <a>PersistFilter</a>
--   that you are using, if you use this directly. For example, using the
--   <a>In</a> <a>PersistFilter</a> requires that you have an array- or
--   list-shaped <a>EntityField</a>. It is possible to construct values
--   using this that will create malformed runtime values.
data Filter record
Filter :: EntityField record typ -> FilterValue typ -> PersistFilter -> Filter record
[filterField] :: Filter record -> EntityField record typ
[filterValue] :: Filter record -> FilterValue typ
[filterFilter] :: Filter record -> PersistFilter

-- | convenient for internal use, not needed for the API
FilterAnd :: [Filter record] -> Filter record
FilterOr :: [Filter record] -> Filter record
BackendFilter :: BackendSpecificFilter (PersistEntityBackend record) record -> Filter record

-- | Value to filter with. Highly dependant on the type of filter used.
data FilterValue typ
[FilterValue] :: forall typ. typ -> FilterValue typ
[FilterValues] :: forall typ. [typ] -> FilterValue typ
[UnsafeValue] :: forall a typ. PersistField a => a -> FilterValue typ

-- | Datatype that represents an entity, with both its <a>Key</a> and its
--   Haskell record representation.
--   
--   When using a SQL-based backend (such as SQLite or PostgreSQL), an
--   <a>Entity</a> may take any number of columns depending on how many
--   fields it has. In order to reconstruct your entity on the Haskell
--   side, <tt>persistent</tt> needs all of your entity columns and in the
--   right order. Note that you don't need to worry about this when using
--   <tt>persistent</tt>'s API since everything is handled correctly behind
--   the scenes.
--   
--   However, if you want to issue a raw SQL command that returns an
--   <a>Entity</a>, then you have to be careful with the column order.
--   While you could use <tt>SELECT Entity.* WHERE ...</tt> and that would
--   work most of the time, there are times when the order of the columns
--   on your database is different from the order that <tt>persistent</tt>
--   expects (for example, if you add a new field in the middle of you
--   entity definition and then use the migration code --
--   <tt>persistent</tt> will expect the column to be in the middle, but
--   your DBMS will put it as the last column). So, instead of using a
--   query like the one above, you may use <a>rawSql</a> (from the
--   <a>Database.Persist.Sql</a> module) with its /entity selection
--   placeholder/ (a double question mark <tt>??</tt>). Using
--   <tt>rawSql</tt> the query above must be written as <tt>SELECT ?? WHERE
--   ..</tt>. Then <tt>rawSql</tt> will replace <tt>??</tt> with the list
--   of all columns that we need from your entity in the right order. If
--   your query returns two entities (i.e. <tt>(Entity backend a, Entity
--   backend b)</tt>), then you must you use <tt>SELECT ??, ?? WHERE
--   ...</tt>, and so on.
data Entity record
Entity :: Key record -> record -> Entity record
[entityKey] :: Entity record -> Key record
[entityVal] :: Entity record -> record

-- | This type class is used with the <tt>OverloadedLabels</tt> extension
--   to provide a more convenient means of using the <a>EntityField</a>
--   type. <a>EntityField</a> definitions are prefixed with the type name
--   to avoid ambiguity, but this ambiguity can result in verbose code.
--   
--   If you have a table <tt>User</tt> with a <tt>name Text</tt> field,
--   then the corresponding <a>EntityField</a> is <tt>UserName</tt>. With
--   this, we can write <tt>#name :: <a>EntityField</a> User Text</tt>.
--   
--   What's more fun is that the type is more general: it's actually <tt>
--   #name :: (<a>SymbolToField</a> "name" rec typ) =&gt; EntityField rec
--   typ </tt>
--   
--   Which means it is *polymorphic* over the actual record. This allows
--   you to write code that can be generic over the tables, provided they
--   have the right fields.
class SymbolToField (sym :: Symbol) rec typ | sym rec -> typ
symbolToField :: SymbolToField sym rec typ => EntityField rec typ

-- | A type class which is used to witness that a type is safe to insert
--   into the database without providing a primary key.
--   
--   The <tt>TemplateHaskell</tt> function <tt>mkPersist</tt> will generate
--   instances of this class for any entity that it works on. If the entity
--   has a default primary key, then it provides a regular instance. If the
--   entity has a <tt>Primary</tt> natural key, then this works fine. But
--   if the entity has an <tt>Id</tt> column with no <tt>default=</tt>,
--   then this does a <a>TypeError</a> and forces the user to use
--   <tt>insertKey</tt>.
class SafeToInsert a

-- | FIXME Add documentation to that.
getPersistMap :: PersistValue -> Either Text [(Text, PersistValue)]

-- | This class teaches Persistent how to take a custom type and marshal it
--   to and from a <a>PersistValue</a>, allowing it to be stored in a
--   database.
--   
--   <h4><b>Examples</b></h4>
--   
--   <h5>Simple Newtype</h5>
--   
--   You can use <tt>newtype</tt> to add more type safety/readability to a
--   basis type like <a>ByteString</a>. In these cases, just derive
--   <a>PersistField</a> and <tt>PersistFieldSql</tt>:
--   
--   <pre>
--   {-# LANGUAGE GeneralizedNewtypeDeriving #-}
--   
--   newtype HashedPassword = HashedPassword <a>ByteString</a>
--     deriving (Eq, Show, <a>PersistField</a>, PersistFieldSql)
--   </pre>
--   
--   <h5>Smart Constructor Newtype</h5>
--   
--   In this example, we create a <a>PersistField</a> instance for a
--   newtype following the "Smart Constructor" pattern.
--   
--   <pre>
--   {-# LANGUAGE GeneralizedNewtypeDeriving #-}
--   import qualified <a>Data.Text</a> as T
--   import qualified <a>Data.Char</a> as C
--   
--   -- | An American Social Security Number
--   newtype SSN = SSN <a>ErrorMessage</a>
--    deriving (Eq, Show, PersistFieldSql)
--   
--   mkSSN :: <a>ErrorMessage</a> -&gt; <a>Either</a> <a>ErrorMessage</a> SSN
--   mkSSN t = if (T.length t == 9) &amp;&amp; (T.all C.isDigit t)
--    then <a>Right</a> $ SSN t
--    else <a>Left</a> $ "Invalid SSN: " &lt;&gt; t
--   
--   instance <a>PersistField</a> SSN where
--     <a>toPersistValue</a> (SSN t) = <a>PersistText</a> t
--     <a>fromPersistValue</a> (<a>PersistText</a> t) = mkSSN t
--     -- Handle cases where the database does not give us PersistText
--     <a>fromPersistValue</a> x = <a>Left</a> $ "File.hs: When trying to deserialize an SSN: expected PersistText, received: " &lt;&gt; T.pack (show x)
--   </pre>
--   
--   Tips:
--   
--   <ul>
--   <li>This file contain dozens of <a>PersistField</a> instances you can
--   look at for examples.</li>
--   <li>Typically custom <a>PersistField</a> instances will only accept a
--   single <a>PersistValue</a> constructor in
--   <a>fromPersistValue</a>.</li>
--   <li>Internal <a>PersistField</a> instances accept a wide variety of
--   <a>PersistValue</a>s to accomodate e.g. storing booleans as integers,
--   booleans or strings.</li>
--   <li>If you're making a custom instance and using a SQL database,
--   you'll also need <tt>PersistFieldSql</tt> to specify the type of the
--   database column.</li>
--   </ul>
class PersistField a
toPersistValue :: PersistField a => a -> PersistValue
fromPersistValue :: PersistField a => PersistValue -> Either Text a

-- | Prior to <tt>persistent-2.11.0</tt>, we provided an instance of
--   <a>PersistField</a> for the <a>Natural</a> type. This was in error,
--   because <a>Natural</a> represents an infinite value, and databases
--   don't have reasonable types for this.
--   
--   The instance for <a>Natural</a> used the <a>Int64</a> underlying type,
--   which will cause underflow and overflow errors. This type has the
--   exact same code in the instances, and will work seamlessly.
--   
--   A more appropriate type for this is the <a>Word</a> series of types
--   from <a>Data.Word</a>. These have a bounded size, are guaranteed to be
--   non-negative, and are quite efficient for the database to store.
newtype OverflowNatural
OverflowNatural :: Natural -> OverflowNatural
[unOverflowNatural] :: OverflowNatural -> Natural

-- | Perform a mapping function over all of the entity fields, as
--   determined by <a>getEntityFieldsDatabase</a>.
overEntityFields :: ([FieldDef] -> [FieldDef]) -> EntityDef -> EntityDef

getEntityKeyFields :: EntityDef -> NonEmpty FieldDef

setEntityIdDef :: EntityIdDef -> EntityDef -> EntityDef

-- | Set an <a>entityId</a> to be the given <a>FieldDef</a>.
setEntityId :: FieldDef -> EntityDef -> EntityDef

getEntityIdField :: EntityDef -> Maybe FieldDef

getEntityId :: EntityDef -> EntityIdDef

isEntitySum :: EntityDef -> Bool

-- | This returns all of the <a>FieldDef</a> defined for the
--   <a>EntityDef</a>, including those fields that are marked as
--   <tt>MigrationOnly</tt> (and therefore only present in the database) or
--   <tt>SafeToRemove</tt> (and a migration will drop the column if it
--   exists in the database).
--   
--   For all the fields that are present on the Haskell-type, see
--   <a>getEntityFields</a>.
getEntityFieldsDatabase :: EntityDef -> [FieldDef]

-- | Retrieve the list of <a>FieldDef</a> that makes up the fields of the
--   entity.
--   
--   This does not return the fields for an <tt>Id</tt> column or an
--   implicit <tt>id</tt>. It will return the key columns if you used the
--   <tt>Primary</tt> syntax for defining the primary key.
--   
--   This does not return fields that are marked <tt>SafeToRemove</tt> or
--   <tt>MigrationOnly</tt> - so it only returns fields that are
--   represented in the Haskell type. If you need those fields, use
--   <a>getEntityFieldsDatabase</a>.
getEntityFields :: EntityDef -> [FieldDef]

getEntityForeignDefs :: EntityDef -> [ForeignDef]
getEntityComments :: EntityDef -> Maybe Text

setEntityDBName :: EntityNameDB -> EntityDef -> EntityDef
getEntityExtra :: EntityDef -> Map Text [[Text]]

-- | Return the database name for the given entity.
getEntityDBName :: EntityDef -> EntityNameDB

-- | Retrieve the Haskell name of the given entity.
getEntityHaskellName :: EntityDef -> EntityNameHS

-- | Retrieve the list of <a>UniqueDef</a> from an <a>EntityDef</a>. As of
--   version 2.14, this will also include the primary key on the entity, if
--   one is defined. If you do not want the primary key, see
--   <a>getEntityUniquesNoPrimaryKey</a>.
getEntityUniques :: EntityDef -> [UniqueDef]

-- | Retrieve the list of <a>UniqueDef</a> from an <a>EntityDef</a>. This
--   does not include a <tt>Primary</tt> key, if one is defined. A future
--   version of <tt>persistent</tt> will include a <tt>Primary</tt> key
--   among the <tt>Unique</tt> constructors for the <tt>Entity</tt>.
getEntityUniquesNoPrimaryKey :: EntityDef -> [UniqueDef]

-- | Check if the field is `Maybe a`
isFieldMaybe :: FieldDef -> Bool

-- | Check if the field definition is nullable
isFieldNullable :: FieldDef -> IsNullable

-- | Add an attribute to the list of field attributes.
addFieldAttr :: FieldAttr -> FieldDef -> FieldDef

-- | Modify the list of field attributes.
overFieldAttrs :: ([FieldAttr] -> [FieldAttr]) -> FieldDef -> FieldDef

-- | Replace the <a>FieldDef</a> <a>FieldAttr</a> with the new list.
setFieldAttrs :: [FieldAttr] -> FieldDef -> FieldDef
type LogFunc = Loc -> LogSource -> LogLevel -> LogStr -> IO ()
data InsertSqlResult
ISRSingle :: Text -> InsertSqlResult
ISRInsertGet :: Text -> Text -> InsertSqlResult
ISRManyKeys :: Text -> [PersistValue] -> InsertSqlResult

-- | A <a>Statement</a> is a representation of a database query that has
--   been prepared and stored on the server side.
data Statement
Statement :: IO () -> IO () -> ([PersistValue] -> IO Int64) -> (forall (m :: Type -> Type). MonadIO m => [PersistValue] -> Acquire (ConduitM () [PersistValue] m ())) -> Statement
[stmtFinalize] :: Statement -> IO ()
[stmtReset] :: Statement -> IO ()
[stmtExecute] :: Statement -> [PersistValue] -> IO Int64
[stmtQuery] :: Statement -> forall (m :: Type -> Type). MonadIO m => [PersistValue] -> Acquire (ConduitM () [PersistValue] m ())

-- | Render a <a>CascadeAction</a> to <a>Text</a> such that it can be used
--   in a SQL command.
renderCascadeAction :: CascadeAction -> Text

-- | Renders a <a>FieldCascade</a> value such that it can be used in SQL
--   migrations.
renderFieldCascade :: FieldCascade -> Text

-- | A <a>FieldCascade</a> that does nothing.
noCascade :: FieldCascade

-- | Returns <a>True</a> if the <a>FieldDef</a> does not have a
--   <tt>MigrationOnly</tt> or <tt>SafeToRemove</tt> flag from the
--   QuasiQuoter.
isHaskellField :: FieldDef -> Bool
isFieldNotGenerated :: FieldDef -> Bool

-- | Parse raw field attributes into structured form. Any unrecognized
--   attributes will be preserved, identically as they are encountered, as
--   <a>FieldAttrOther</a> values.
parseFieldAttrs :: [Text] -> [FieldAttr]

-- | Returns a <a>NonEmpty</a> list of <a>FieldDef</a> that correspond with
--   the key columns for an <a>EntityDef</a>.
keyAndEntityFields :: EntityDef -> NonEmpty FieldDef
entityPrimary :: EntityDef -> Maybe CompositeDef

-- | Return the <tt>[<a>FieldDef</a>]</tt> for the entity keys.
entitiesPrimary :: EntityDef -> NonEmpty FieldDef
fieldAttrsContainsNullable :: [FieldAttr] -> IsNullable

-- | A <a>Checkmark</a> should be used as a field type whenever a
--   uniqueness constraint should guarantee that a certain kind of record
--   may appear at most once, but other kinds of records may appear any
--   number of times.
--   
--   <i>NOTE:</i> You need to mark any <tt>Checkmark</tt> fields as
--   <tt>nullable</tt> (see the following example).
--   
--   For example, suppose there's a <tt>Location</tt> entity that
--   represents where a user has lived:
--   
--   <pre>
--   Location
--       user    UserId
--       name    Text
--       current Checkmark nullable
--   
--       UniqueLocation user current
--   </pre>
--   
--   The <tt>UniqueLocation</tt> constraint allows any number of
--   <a>Inactive</a> <tt>Location</tt>s to be <tt>current</tt>. However,
--   there may be at most one <tt>current</tt> <tt>Location</tt> per user
--   (i.e., either zero or one per user).
--   
--   This data type works because of the way that SQL treats
--   <tt>NULL</tt>able fields within uniqueness constraints. The SQL
--   standard says that <tt>NULL</tt> values should be considered
--   different, so we represent <a>Inactive</a> as SQL <tt>NULL</tt>, thus
--   allowing any number of <a>Inactive</a> records. On the other hand, we
--   represent <a>Active</a> as <tt>TRUE</tt>, so the uniqueness constraint
--   will disallow more than one <a>Active</a> record.
--   
--   <i>Note:</i> There may be DBMSs that do not respect the SQL standard's
--   treatment of <tt>NULL</tt> values on uniqueness constraints, please
--   check if this data type works before relying on it.
--   
--   The SQL <tt>BOOLEAN</tt> type is used because it's the smallest data
--   type available. Note that we never use <tt>FALSE</tt>, just
--   <tt>TRUE</tt> and <tt>NULL</tt>. Provides the same behavior <tt>Maybe
--   ()</tt> would if <tt>()</tt> was a valid <tt>PersistField</tt>.
data Checkmark

-- | When used on a uniqueness constraint, there may be at most one
--   <a>Active</a> record.
Active :: Checkmark

-- | When used on a uniqueness constraint, there may be any number of
--   <a>Inactive</a> records.
Inactive :: Checkmark
data IsNullable
Nullable :: !WhyNullable -> IsNullable
NotNullable :: IsNullable

-- | The reason why a field is <tt>nullable</tt> is very important. A field
--   that is nullable because of a <tt>Maybe</tt> tag will have its type
--   changed from <tt>A</tt> to <tt>Maybe A</tt>. OTOH, a field that is
--   nullable because of a <tt>nullable</tt> tag will remain with the same
--   type.
data WhyNullable
ByMaybeAttr :: WhyNullable
ByNullableAttr :: WhyNullable

-- | An <a>EntityDef</a> represents the information that
--   <tt>persistent</tt> knows about an Entity. It uses this information to
--   generate the Haskell datatype, the SQL migrations, and other relevant
--   conversions.
data EntityDef

-- | The definition for the entity's primary key ID.
data EntityIdDef

-- | The entity has a single key column, and it is a surrogate key - that
--   is, you can't go from <tt>rec -&gt; Key rec</tt>.
EntityIdField :: !FieldDef -> EntityIdDef

-- | The entity has a natural key. This means you can write <tt>rec -&gt;
--   Key rec</tt> because all the key fields are present on the datatype.
--   
--   A natural key can have one or more columns.
EntityIdNaturalKey :: !CompositeDef -> EntityIdDef
type ExtraLine = [Text]
type Attr = Text

-- | Attributes that may be attached to fields that can affect migrations
--   and serialization in backend-specific ways.
--   
--   While we endeavor to, we can't forsee all use cases for all backends,
--   and so <a>FieldAttr</a> is extensible through its constructor
--   <a>FieldAttrOther</a>.
data FieldAttr

-- | The <a>Maybe</a> keyword goes after the type. This indicates that the
--   column is nullable, and the generated Haskell code will have a
--   <tt><a>Maybe</a></tt> type for it.
--   
--   Example:
--   
--   <pre>
--   User
--       name Text Maybe
--   </pre>
FieldAttrMaybe :: FieldAttr

-- | This indicates that the column is nullable, but should not have a
--   <a>Maybe</a> type. For this to work out, you need to ensure that the
--   <tt>PersistField</tt> instance for the type in question can support a
--   <a>PersistNull</a> value.
--   
--   <pre>
--   data What = NoWhat | Hello Text
--   
--   instance PersistField What where
--       fromPersistValue PersistNull =
--           pure NoWhat
--       fromPersistValue pv =
--           Hello <a>$</a> fromPersistValue pv
--   
--   instance PersistFieldSql What where
--       sqlType _ = SqlString
--   
--   User
--       what What nullable
--   </pre>
FieldAttrNullable :: FieldAttr

-- | This tag means that the column will not be present on the Haskell
--   code, but will not be removed from the database. Useful to deprecate
--   fields in phases.
--   
--   You should set the column to be nullable in the database. Otherwise,
--   inserts won't have values.
--   
--   <pre>
--   User
--       oldName Text MigrationOnly
--       newName Text
--   </pre>
FieldAttrMigrationOnly :: FieldAttr

-- | A <tt>SafeToRemove</tt> attribute is not present on the Haskell
--   datatype, and the backend migrations should attempt to drop the column
--   without triggering any unsafe migration warnings.
--   
--   Useful after you've used <tt>MigrationOnly</tt> to remove a column
--   from the database in phases.
--   
--   <pre>
--   User
--       oldName Text SafeToRemove
--       newName Text
--   </pre>
FieldAttrSafeToRemove :: FieldAttr

-- | This attribute indicates that we should not create a foreign key
--   reference from a column. By default, <tt>persistent</tt> will try and
--   create a foreign key reference for a column if it can determine that
--   the type of the column is a <tt><tt>Key</tt> entity</tt> or an
--   <tt>EntityId</tt> and the <tt>Entity</tt>'s name was present in
--   <tt>mkPersist</tt>.
--   
--   This is useful if you want to use the explicit foreign key syntax.
--   
--   <pre>
--   Post
--       title    Text
--   
--   Comment
--       postId   PostId      noreference
--       Foreign Post fk_comment_post postId
--   </pre>
FieldAttrNoreference :: FieldAttr

-- | This is set to specify precisely the database table the column refers
--   to.
--   
--   <pre>
--   Post
--       title    Text
--   
--   Comment
--       postId   PostId references="post"
--   </pre>
--   
--   You should not need this - <tt>persistent</tt> should be capable of
--   correctly determining the target table's name. If you do need this,
--   please file an issue describing why.
FieldAttrReference :: Text -> FieldAttr

-- | Specify a name for the constraint on the foreign key reference for
--   this table.
--   
--   <pre>
--   Post
--       title    Text
--   
--   Comment
--       postId   PostId constraint="my_cool_constraint_name"
--   </pre>
FieldAttrConstraint :: Text -> FieldAttr

-- | Specify the default value for a column.
--   
--   <pre>
--   User
--       createdAt    UTCTime     default="NOW()"
--   </pre>
--   
--   Note that a <tt>default=</tt> attribute does not mean you can omit the
--   value while inserting.
FieldAttrDefault :: Text -> FieldAttr

-- | Specify a custom SQL type for the column. Generally, you should define
--   a custom datatype with a custom <tt>PersistFieldSql</tt> instance
--   instead of using this.
--   
--   <pre>
--   User
--       uuid     Text    sqltype=<a>UUID</a>
--   </pre>
FieldAttrSqltype :: Text -> FieldAttr

-- | Set a maximum length for a column. Useful for VARCHAR and indexes.
--   
--   <pre>
--   User
--       name     Text    maxlen=200
--   
--       UniqueName name
--   </pre>
FieldAttrMaxlen :: Integer -> FieldAttr

-- | Specify the database name of the column.
--   
--   <pre>
--   User
--       blarghle     Int     sql="b_l_a_r_g_h_l_e"
--   </pre>
--   
--   Useful for performing phased migrations, where one column is renamed
--   to another column over time.
FieldAttrSql :: Text -> FieldAttr

-- | A grab bag of random attributes that were unrecognized by the parser.
FieldAttrOther :: Text -> FieldAttr

-- | A <a>FieldType</a> describes a field parsed from the QuasiQuoter and
--   is used to determine the Haskell type in the generated code.
--   
--   <tt>name Text</tt> parses into <tt>FTTypeCon Nothing <a>Text</a></tt>
--   
--   <tt>name T.Text</tt> parses into <tt>FTTypeCon (Just <a>T</a>
--   <a>Text</a>)</tt>
--   
--   <tt>name (Jsonb User)</tt> parses into:
--   
--   <pre>
--   FTApp (FTTypeCon Nothing <a>Jsonb</a>) (FTTypeCon Nothing <a>User</a>)
--   </pre>
data FieldType

-- | Optional module and name.
FTTypeCon :: Maybe Text -> Text -> FieldType
FTLit :: FieldTypeLit -> FieldType
FTTypePromoted :: Text -> FieldType
FTApp :: FieldType -> FieldType -> FieldType
FTList :: FieldType -> FieldType

-- | There are 3 kinds of references 1) composite (to fields that exist in
--   the record) 2) single field 3) embedded
data ReferenceDef
NoReference :: ReferenceDef

-- | A ForeignRef has a late binding to the EntityDef it references via
--   name and has the Haskell type of the foreign key in the form of
--   FieldType
ForeignRef :: !EntityNameHS -> ReferenceDef
EmbedRef :: EntityNameHS -> ReferenceDef

-- | A SelfReference stops an immediate cycle which causes non-termination
--   at compile-time (issue #311).
SelfReference :: ReferenceDef

-- | An EmbedEntityDef is the same as an EntityDef But it is only used for
--   fieldReference so it only has data needed for embedding
data EmbedEntityDef
EmbedEntityDef :: EntityNameHS -> [EmbedFieldDef] -> EmbedEntityDef
[embeddedHaskell] :: EmbedEntityDef -> EntityNameHS
[embeddedFields] :: EmbedEntityDef -> [EmbedFieldDef]

-- | An EmbedFieldDef is the same as a FieldDef But it is only used for
--   embeddedFields so it only has data needed for embedding
data EmbedFieldDef
EmbedFieldDef :: FieldNameDB -> Maybe (Either SelfEmbed EntityNameHS) -> EmbedFieldDef
[emFieldDB] :: EmbedFieldDef -> FieldNameDB
[emFieldEmbed] :: EmbedFieldDef -> Maybe (Either SelfEmbed EntityNameHS)

-- | Type for storing the Uniqueness constraint in the Schema. Assume you
--   have the following schema with a uniqueness constraint:
--   
--   <pre>
--   Person
--     name String
--     age Int
--     UniqueAge age
--   </pre>
--   
--   This will be represented as:
--   
--   <pre>
--   UniqueDef
--       { uniqueHaskell = ConstraintNameHS (packPTH <a>UniqueAge</a>)
--       , uniqueDBName = ConstraintNameDB (packPTH "unique_age")
--       , uniqueFields = [(FieldNameHS (packPTH "age"), FieldNameDB (packPTH "age"))]
--       , uniqueAttrs = []
--       }
--   </pre>
data UniqueDef
UniqueDef :: !ConstraintNameHS -> !ConstraintNameDB -> !NonEmpty (FieldNameHS, FieldNameDB) -> ![Attr] -> UniqueDef
[uniqueHaskell] :: UniqueDef -> !ConstraintNameHS
[uniqueDBName] :: UniqueDef -> !ConstraintNameDB
[uniqueFields] :: UniqueDef -> !NonEmpty (FieldNameHS, FieldNameDB)
[uniqueAttrs] :: UniqueDef -> ![Attr]
data CompositeDef
CompositeDef :: !NonEmpty FieldDef -> ![Attr] -> CompositeDef
[compositeFields] :: CompositeDef -> !NonEmpty FieldDef
[compositeAttrs] :: CompositeDef -> ![Attr]

-- | Used instead of FieldDef to generate a smaller amount of code
type ForeignFieldDef = (FieldNameHS, FieldNameDB)
data ForeignDef
ForeignDef :: !EntityNameHS -> !EntityNameDB -> !ConstraintNameHS -> !ConstraintNameDB -> !FieldCascade -> ![(ForeignFieldDef, ForeignFieldDef)] -> ![Attr] -> Bool -> Bool -> ForeignDef
[foreignRefTableHaskell] :: ForeignDef -> !EntityNameHS
[foreignRefTableDBName] :: ForeignDef -> !EntityNameDB
[foreignConstraintNameHaskell] :: ForeignDef -> !ConstraintNameHS
[foreignConstraintNameDBName] :: ForeignDef -> !ConstraintNameDB

-- | Determine how the field will cascade on updates and deletions.
[foreignFieldCascade] :: ForeignDef -> !FieldCascade
[foreignFields] :: ForeignDef -> ![(ForeignFieldDef, ForeignFieldDef)]
[foreignAttrs] :: ForeignDef -> ![Attr]
[foreignNullable] :: ForeignDef -> Bool

-- | Determines if the reference is towards a Primary Key or not.
[foreignToPrimary] :: ForeignDef -> Bool

-- | This datatype describes how a foreign reference field cascades deletes
--   or updates.
--   
--   This type is used in both parsing the model definitions and performing
--   migrations. A <a>Nothing</a> in either of the field values means that
--   the user has not specified a <a>CascadeAction</a>. An unspecified
--   <a>CascadeAction</a> is defaulted to <a>Restrict</a> when doing
--   migrations.
data FieldCascade
FieldCascade :: !Maybe CascadeAction -> !Maybe CascadeAction -> FieldCascade
[fcOnUpdate] :: FieldCascade -> !Maybe CascadeAction
[fcOnDelete] :: FieldCascade -> !Maybe CascadeAction

-- | An action that might happen on a deletion or update on a foreign key
--   change.
data CascadeAction
Cascade :: CascadeAction
Restrict :: CascadeAction
SetNull :: CascadeAction
SetDefault :: CascadeAction
data PersistException

-- | Generic Exception
PersistError :: Text -> PersistException
PersistMarshalError :: Text -> PersistException
PersistInvalidField :: Text -> PersistException
PersistForeignConstraintUnmet :: Text -> PersistException
PersistMongoDBError :: Text -> PersistException
PersistMongoDBUnsupported :: Text -> PersistException

-- | A SQL data type. Naming attempts to reflect the underlying Haskell
--   datatypes, eg SqlString instead of SqlVarchar. Different SQL databases
--   may have different translations for these types.
data SqlType
SqlString :: SqlType
SqlInt32 :: SqlType
SqlInt64 :: SqlType
SqlReal :: SqlType
SqlNumeric :: Word32 -> Word32 -> SqlType
SqlBool :: SqlType
SqlDay :: SqlType
SqlTime :: SqlType

-- | Always uses UTC timezone
SqlDayTime :: SqlType
SqlBlob :: SqlType

-- | a backend-specific name
SqlOther :: Text -> SqlType
data PersistFilter
Eq :: PersistFilter
Ne :: PersistFilter
Gt :: PersistFilter
Lt :: PersistFilter
Ge :: PersistFilter
Le :: PersistFilter
In :: PersistFilter
NotIn :: PersistFilter
BackendSpecificFilter :: Text -> PersistFilter
data UpdateException
KeyNotFound :: String -> UpdateException
UpsertError :: String -> UpdateException
data PersistUpdate
Assign :: PersistUpdate
Add :: PersistUpdate
Subtract :: PersistUpdate
Multiply :: PersistUpdate
Divide :: PersistUpdate
BackendSpecificUpdate :: Text -> PersistUpdate

-- | A <a>FieldDef</a> represents the inormation that <tt>persistent</tt>
--   knows about a field of a datatype. This includes information used to
--   parse the field out of the database and what the field corresponds to.
data FieldDef
FieldDef :: !FieldNameHS -> !FieldNameDB -> !FieldType -> !SqlType -> ![FieldAttr] -> !Bool -> !ReferenceDef -> !FieldCascade -> !Maybe Text -> !Maybe Text -> !Bool -> FieldDef

-- | The name of the field. Note that this does not corresponds to the
--   record labels generated for the particular entity - record labels are
--   generated with the type name prefixed to the field, so a
--   <a>FieldDef</a> that contains a <tt><a>FieldNameHS</a> "name"</tt> for
--   a type <tt>User</tt> will have a record field <tt>userName</tt>.
[fieldHaskell] :: FieldDef -> !FieldNameHS

-- | The name of the field in the database. For SQL databases, this
--   corresponds to the column name.
[fieldDB] :: FieldDef -> !FieldNameDB

-- | The type of the field in Haskell.
[fieldType] :: FieldDef -> !FieldType

-- | The type of the field in a SQL database.
[fieldSqlType] :: FieldDef -> !SqlType

-- | User annotations for a field. These are provided with the <tt>!</tt>
--   operator.
[fieldAttrs] :: FieldDef -> ![FieldAttr]

-- | If this is <a>True</a>, then the Haskell datatype will have a strict
--   record field. The default value for this is <a>True</a>.
[fieldStrict] :: FieldDef -> !Bool
[fieldReference] :: FieldDef -> !ReferenceDef

-- | Defines how operations on the field cascade on to the referenced
--   tables. This doesn't have any meaning if the <a>fieldReference</a> is
--   set to <a>NoReference</a> or <a>SelfReference</a>. The cascade option
--   here should be the same as the one obtained in the
--   <a>fieldReference</a>.
[fieldCascade] :: FieldDef -> !FieldCascade

-- | Optional comments for a <tt>Field</tt>.
[fieldComments] :: FieldDef -> !Maybe Text

-- | Whether or not the field is a <tt>GENERATED</tt> column, and
--   additionally the expression to use for generation.
[fieldGenerated] :: FieldDef -> !Maybe Text

-- | <a>True</a> if the field is an implicit ID column. <a>False</a>
--   otherwise.
[fieldIsImplicitIdColumn] :: FieldDef -> !Bool

-- | Please refer to the documentation for the database in question for a
--   full overview of the semantics of the varying isloation levels
data IsolationLevel
ReadUncommitted :: IsolationLevel
ReadCommitted :: IsolationLevel
RepeatableRead :: IsolationLevel
Serializable :: IsolationLevel
fromPersistValueText :: PersistValue -> Either Text Text

-- | A raw value which can be stored in any backend and can be marshalled
--   to and from a <tt>PersistField</tt>.
data PersistValue
PersistText :: Text -> PersistValue
PersistByteString :: ByteString -> PersistValue
PersistInt64 :: Int64 -> PersistValue
PersistDouble :: Double -> PersistValue
PersistRational :: Rational -> PersistValue
PersistBool :: Bool -> PersistValue
PersistDay :: Day -> PersistValue
PersistTimeOfDay :: TimeOfDay -> PersistValue
PersistUTCTime :: UTCTime -> PersistValue
PersistNull :: PersistValue
PersistList :: [PersistValue] -> PersistValue
PersistMap :: [(Text, PersistValue)] -> PersistValue

-- | Intended especially for MongoDB backend
PersistObjectId :: ByteString -> PersistValue

-- | Intended especially for PostgreSQL backend for text arrays
PersistArray :: [PersistValue] -> PersistValue

-- | This constructor is used to specify some raw literal value for the
--   backend. The <a>LiteralType</a> value specifies how the value should
--   be escaped. This can be used to make special, custom types avaialable
--   in the back end.
PersistLiteral_ :: LiteralType -> ByteString -> PersistValue

-- | This pattern synonym used to be a data constructor for the
--   <a>PersistValue</a> type. It was changed to be a pattern so that
--   JSON-encoded database values could be parsed into their corresponding
--   values. You should not use this, and instead prefer to pattern match
--   on <a>PersistLiteral_</a> directly.
--   
--   If you use this, it will overlap a patern match on the
--   'PersistLiteral_, <a>PersistLiteral</a>, and
--   <a>PersistLiteralEscaped</a> patterns. If you need to disambiguate
--   between these constructors, pattern match on <a>PersistLiteral_</a>
--   directly.
pattern PersistDbSpecific :: ByteString -> PersistValue

-- | This pattern synonym used to be a data constructor on
--   <a>PersistValue</a>, but was changed into a catch-all pattern synonym
--   to allow backwards compatiblity with database types. See the
--   documentation on <a>PersistDbSpecific</a> for more details.
pattern PersistLiteralEscaped :: ByteString -> PersistValue

-- | This pattern synonym used to be a data constructor on
--   <a>PersistValue</a>, but was changed into a catch-all pattern synonym
--   to allow backwards compatiblity with database types. See the
--   documentation on <a>PersistDbSpecific</a> for more details.
pattern PersistLiteral :: ByteString -> PersistValue

-- | A type that determines how a backend should handle the literal.
data LiteralType

-- | The accompanying value will be escaped before inserting into the
--   database. This is the correct default choice to use.
Escaped :: LiteralType

-- | The accompanying value will not be escaped when inserting into the
--   database. This is potentially dangerous - use this with care.
Unescaped :: LiteralType

-- | The <a>DbSpecific</a> constructor corresponds to the legacy
--   <a>PersistDbSpecific</a> constructor. We need to keep this around
--   because old databases may have serialized JSON representations that
--   reference this. We don't want to break the ability of a database to
--   load rows.
DbSpecific :: LiteralType

-- | Convenience operations for working with '-NameDB' types.
class DatabaseName a
escapeWith :: DatabaseName a => (Text -> str) -> a -> str

-- | A <a>FieldNameDB</a> represents the datastore-side name that
--   <tt>persistent</tt> will use for a field.
newtype FieldNameDB
FieldNameDB :: Text -> FieldNameDB
[unFieldNameDB] :: FieldNameDB -> Text

-- | A <a>FieldNameHS</a> represents the Haskell-side name that
--   <tt>persistent</tt> will use for a field.
newtype FieldNameHS
FieldNameHS :: Text -> FieldNameHS
[unFieldNameHS] :: FieldNameHS -> Text

-- | An <a>EntityNameHS</a> represents the Haskell-side name that
--   <tt>persistent</tt> will use for an entity.
newtype EntityNameHS
EntityNameHS :: Text -> EntityNameHS
[unEntityNameHS] :: EntityNameHS -> Text

-- | An <a>EntityNameDB</a> represents the datastore-side name that
--   <tt>persistent</tt> will use for an entity.
newtype EntityNameDB
EntityNameDB :: Text -> EntityNameDB
[unEntityNameDB] :: EntityNameDB -> Text

-- | A <a>ConstraintNameDB</a> represents the datastore-side name that
--   <tt>persistent</tt> will use for a constraint.
newtype ConstraintNameDB
ConstraintNameDB :: Text -> ConstraintNameDB
[unConstraintNameDB] :: ConstraintNameDB -> Text

-- | An <a>ConstraintNameHS</a> represents the Haskell-side name that
--   <tt>persistent</tt> will use for a constraint.
newtype ConstraintNameHS
ConstraintNameHS :: Text -> ConstraintNameHS
[unConstraintNameHS] :: ConstraintNameHS -> Text
type family PersistConfigPool c
type family PersistConfigBackend c :: Type -> Type -> Type -> Type

-- | Represents a value containing all the configuration options for a
--   specific backend. This abstraction makes it easier to write code that
--   can easily swap backends.
class PersistConfig c where {
    type family PersistConfigBackend c :: Type -> Type -> Type -> Type;
    type family PersistConfigPool c;
}

-- | Load the config settings from a <a>Value</a>, most likely taken from a
--   YAML config file.
loadConfig :: PersistConfig c => Value -> Parser c

-- | Modify the config settings based on environment variables.
applyEnv :: PersistConfig c => c -> IO c

-- | Create a new connection pool based on the given config settings.
createPoolConfig :: PersistConfig c => c -> IO (PersistConfigPool c)

-- | Run a database action by taking a connection from the pool.
runPool :: (PersistConfig c, MonadUnliftIO m) => c -> PersistConfigBackend c m a -> PersistConfigPool c -> m a

-- | The lifted version of <a>get</a>
get :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> m (Maybe record)

-- | The lifted version of <a>getMany</a>
getMany :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Key record] -> m (Map (Key record) record)

-- | The lifted version of <a>getJust</a>
getJust :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> m record

-- | The lifted version of <a>getJustEntity</a>
getJustEntity :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> m (Entity record)

-- | The lifted version of <a>getEntity</a>
getEntity :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> m (Maybe (Entity record))

-- | The lifted version of <a>belongsTo</a>
belongsTo :: (PersistEntity record1, PersistRecordBackend record2 SqlBackend, Typeable record1, Typeable record2, MonadSqlQuery m) => (record1 -> Maybe (Key record2)) -> record1 -> m (Maybe record2)

-- | The lifted version of <a>belongsToJust</a>
belongsToJust :: (PersistEntity record1, PersistRecordBackend record2 SqlBackend, Typeable record1, Typeable record2, MonadSqlQuery m) => (record1 -> Key record2) -> record1 -> m record2

-- | The lifted version of <a>insert</a>
insert :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m (Key record)

-- | The lifted version of <a>insert_</a>
insert_ :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m ()

-- | The lifted version of <a>insertMany</a>
insertMany :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => [record] -> m [Key record]

-- | The lifted version of <a>insertMany_</a>
insertMany_ :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => [record] -> m ()

-- | The lifted version of <a>insertEntityMany</a>
insertEntityMany :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Entity record] -> m ()

-- | The lifted version of <a>insertKey</a>
insertKey :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> record -> m ()

-- | The lifted version of <a>repsert</a>
repsert :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> record -> m ()

-- | The lifted version of <a>repsertMany</a>
repsertMany :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [(Key record, record)] -> m ()

-- | The lifted version of <a>replace</a>
replace :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> record -> m ()

-- | The lifted version of <a>delete</a>
delete :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> m ()

-- | The lifted version of <a>update</a>
update :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> [Update record] -> m ()

-- | The lifted version of <a>updateGet</a>
updateGet :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Key record -> [Update record] -> m record

-- | The lifted version of <a>insertEntity</a>
insertEntity :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m (Entity record)

-- | The lifted version of <a>insertRecord</a>
insertRecord :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m record

-- | The lifted version of <a>getBy</a>
getBy :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Unique record -> m (Maybe (Entity record))

-- | The lifted version of <a>getByValue</a>
getByValue :: (PersistRecordBackend record SqlBackend, AtLeastOneUniqueKey record, Typeable record, MonadSqlQuery m) => record -> m (Maybe (Entity record))

-- | The lifted version of <a>checkUnique</a>
checkUnique :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => record -> m (Maybe (Unique record))

-- | The lifted version of <a>checkUniqueUpdateable</a>
checkUniqueUpdateable :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Entity record -> m (Maybe (Unique record))

-- | The lifted version of <a>deleteBy</a>
deleteBy :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => Unique record -> m ()

-- | The lifted version of <a>insertUnique</a>
insertUnique :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m (Maybe (Key record))

-- | The lifted version of <a>upsert</a>
upsert :: (PersistRecordBackend record SqlBackend, OnlyOneUniqueKey record, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> [Update record] -> m (Entity record)

-- | The lifted version of <a>upsertBy</a>
upsertBy :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => Unique record -> record -> [Update record] -> m (Entity record)

-- | The lifted version of <a>putMany</a>
putMany :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => [record] -> m ()

-- | The lifted version of <a>insertBy</a>
insertBy :: (PersistRecordBackend record SqlBackend, AtLeastOneUniqueKey record, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m (Either (Entity record) (Key record))

-- | The lifted version of <a>insertUniqueEntity</a>
insertUniqueEntity :: (PersistRecordBackend record SqlBackend, SafeToInsert record, Typeable record, MonadSqlQuery m) => record -> m (Maybe (Entity record))

-- | The lifted version of <a>replaceUnique</a>
replaceUnique :: (PersistRecordBackend record SqlBackend, Eq (Unique record), Eq record, Typeable record, MonadSqlQuery m) => Key record -> record -> m (Maybe (Unique record))

-- | The lifted version of <a>onlyUnique</a>
onlyUnique :: (PersistRecordBackend record SqlBackend, OnlyOneUniqueKey record, Typeable record, MonadSqlQuery m) => record -> m (Unique record)

-- | The lifted version of <a>selectSourceRes</a>
selectSourceRes :: (MonadIO m2, PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> m (Acquire (ConduitM () (Entity record) m2 ()))

-- | The lifted version of <a>selectFirst</a>
selectFirst :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> m (Maybe (Entity record))

-- | The lifted version of <a>selectKeysRes</a>
selectKeysRes :: (MonadIO m2, PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> m (Acquire (ConduitM () (Key record) m2 ()))

-- | The lifted version of <a>count</a>
count :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> m Int

-- | The lifted version of <a>exists</a>
exists :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> m Bool

-- | The lifted version of <a>selectSource</a>
selectSource :: (PersistRecordBackend record SqlBackend, MonadResource m, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> ConduitM () (Entity record) m ()

-- | The lifted version of <a>selectKeys</a>
selectKeys :: (PersistRecordBackend record SqlBackend, MonadResource m, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> ConduitM () (Key record) m ()

-- | The lifted version of <a>selectList</a>
selectList :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> m [Entity record]

-- | The lifted version of <a>selectKeysList</a>
selectKeysList :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [SelectOpt record] -> m [Key record]

-- | The lifted version of <a>updateWhere</a>
updateWhere :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [Update record] -> m ()

-- | The lifted version of <a>deleteWhere</a>
deleteWhere :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> m ()

-- | The lifted version of <a>deleteWhereCount</a>
deleteWhereCount :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> m Int64

-- | The lifted version of <a>updateWhereCount</a>
updateWhereCount :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => [Filter record] -> [Update record] -> m Int64

-- | The lifted version of <a>parseMigration</a>
parseMigration :: (HasCallStack, MonadSqlQuery m) => Migration -> m (Either [Text] CautiousMigration)

-- | The lifted version of <a>parseMigration'</a>
parseMigration' :: (HasCallStack, MonadSqlQuery m) => Migration -> m CautiousMigration

-- | The lifted version of <a>printMigration</a>
printMigration :: (HasCallStack, MonadSqlQuery m) => Migration -> m ()

-- | The lifted version of <a>showMigration</a>
showMigration :: (HasCallStack, MonadSqlQuery m) => Migration -> m [Text]

-- | The lifted version of <a>getMigration</a>
getMigration :: (HasCallStack, MonadSqlQuery m) => Migration -> m [Sql]

-- | The lifted version of <a>runMigration</a>
runMigration :: MonadSqlQuery m => Migration -> m ()

-- | The lifted version of <a>runMigrationQuiet</a>
runMigrationQuiet :: MonadSqlQuery m => Migration -> m [Text]

-- | The lifted version of <a>runMigrationSilent</a>
runMigrationSilent :: MonadSqlQuery m => Migration -> m [Text]

-- | The lifted version of <a>runMigrationUnsafe</a>
runMigrationUnsafe :: MonadSqlQuery m => Migration -> m ()

-- | The lifted version of <a>runMigrationUnsafeQuiet</a>
runMigrationUnsafeQuiet :: (HasCallStack, MonadSqlQuery m) => Migration -> m [Text]

-- | The lifted version of <a>getFieldName</a>
getFieldName :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => EntityField record typ -> m Text

-- | The lifted version of <a>getTableName</a>
getTableName :: (PersistRecordBackend record SqlBackend, Typeable record, MonadSqlQuery m) => record -> m Text

-- | The lifted version of <a>withRawQuery</a>
withRawQuery :: MonadSqlQuery m => Text -> [PersistValue] -> ConduitM [PersistValue] Void IO a -> m a

-- | The lifted version of <a>rawQueryRes</a>
rawQueryRes :: (MonadIO m2, MonadSqlQuery m) => Text -> [PersistValue] -> m (Acquire (ConduitM () [PersistValue] m2 ()))

-- | The lifted version of <a>rawQuery</a>
rawQuery :: (MonadResource m, MonadSqlQuery m) => Text -> [PersistValue] -> ConduitM () [PersistValue] m ()

-- | The lifted version of <a>rawExecute</a>
rawExecute :: MonadSqlQuery m => Text -> [PersistValue] -> m ()

-- | The lifted version of <a>rawExecuteCount</a>
rawExecuteCount :: MonadSqlQuery m => Text -> [PersistValue] -> m Int64

-- | The lifted version of <a>rawSql</a>
rawSql :: (RawSql a, MonadSqlQuery m) => Text -> [PersistValue] -> m [a]

-- | The lifted version of <a>transactionSave</a>
transactionSave :: MonadSqlQuery m => m ()

-- | The lifted version of <a>transactionSaveWithIsolation</a>
transactionSaveWithIsolation :: MonadSqlQuery m => IsolationLevel -> m ()

-- | The lifted version of <a>transactionUndo</a>
transactionUndo :: MonadSqlQuery m => m ()

-- | The lifted version of <a>transactionUndoWithIsolation</a>
transactionUndoWithIsolation :: MonadSqlQuery m => IsolationLevel -> m ()

-- | Lift an arbitrary <a>SqlPersistT</a> action into <a>MonadSqlQuery</a>.
--   
--   This is unsafe because the action may be rerun. This function should
--   primarily be used to interop with other libraries built on top of
--   persistent.
--   
--   Example usage:
--   
--   <pre>
--   -- | Run an esqueleto select.
--   select :: (MonadSqlQuery m, E.SqlSelect a r) =&gt; E.SqlQuery a -&gt; m [r]
--   select q = unsafeLiftSql "esqueleto-select" (E.select q)
--   </pre>
unsafeLiftSql :: MonadSqlQuery m => Text -> (forall m2. MonadIO m2 => SqlPersistT m2 a) -> m a