module IHP.IDE.ToolServer.Types where

import IHP.Prelude
import qualified IHP.IDE.Types as DevServer

data ToolServerApplication = ToolServerApplication { ToolServerApplication -> Context
devServerContext :: DevServer.Context }

data SchemaController
    = PushToDbAction
    | DumpDbAction
    | UpdateDbAction
    | ShowCodeAction
    | SaveCodeAction
    | ShowGeneratedCodeAction { SchemaController -> Text
statementName :: Text }
    deriving (SchemaController -> SchemaController -> Bool
(SchemaController -> SchemaController -> Bool)
-> (SchemaController -> SchemaController -> Bool)
-> Eq SchemaController
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SchemaController -> SchemaController -> Bool
== :: SchemaController -> SchemaController -> Bool
$c/= :: SchemaController -> SchemaController -> Bool
/= :: SchemaController -> SchemaController -> Bool
Eq, Int -> SchemaController -> ShowS
[SchemaController] -> ShowS
SchemaController -> String
(Int -> SchemaController -> ShowS)
-> (SchemaController -> String)
-> ([SchemaController] -> ShowS)
-> Show SchemaController
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SchemaController -> ShowS
showsPrec :: Int -> SchemaController -> ShowS
$cshow :: SchemaController -> String
show :: SchemaController -> String
$cshowList :: [SchemaController] -> ShowS
showList :: [SchemaController] -> ShowS
Show, Typeable SchemaController
Typeable SchemaController
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> SchemaController -> c SchemaController)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SchemaController)
-> (SchemaController -> Constr)
-> (SchemaController -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SchemaController))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SchemaController))
-> ((forall b. Data b => b -> b)
    -> SchemaController -> SchemaController)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SchemaController -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SchemaController -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SchemaController -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SchemaController -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SchemaController -> m SchemaController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SchemaController -> m SchemaController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SchemaController -> m SchemaController)
-> Data SchemaController
SchemaController -> Constr
SchemaController -> DataType
(forall b. Data b => b -> b)
-> SchemaController -> SchemaController
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> SchemaController -> u
forall u. (forall d. Data d => d -> u) -> SchemaController -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaController -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaController -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SchemaController -> m SchemaController
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SchemaController -> m SchemaController
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaController
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaController -> c SchemaController
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemaController)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemaController)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaController -> c SchemaController
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SchemaController -> c SchemaController
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaController
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SchemaController
$ctoConstr :: SchemaController -> Constr
toConstr :: SchemaController -> Constr
$cdataTypeOf :: SchemaController -> DataType
dataTypeOf :: SchemaController -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemaController)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SchemaController)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemaController)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SchemaController)
$cgmapT :: (forall b. Data b => b -> b)
-> SchemaController -> SchemaController
gmapT :: (forall b. Data b => b -> b)
-> SchemaController -> SchemaController
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaController -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaController -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaController -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SchemaController -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SchemaController -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SchemaController -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SchemaController -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SchemaController -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SchemaController -> m SchemaController
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SchemaController -> m SchemaController
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SchemaController -> m SchemaController
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SchemaController -> m SchemaController
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SchemaController -> m SchemaController
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SchemaController -> m SchemaController
Data)

data TablesController
    = TablesAction
    | ShowTableAction { TablesController -> Text
tableName :: Text }
    | NewTableAction
    | CreateTableAction
    | EditTableAction { tableName :: Text, TablesController -> Int
tableId :: Int }
    | UpdateTableAction
    | DeleteTableAction { tableId :: Int, tableName :: Text }
    deriving (TablesController -> TablesController -> Bool
(TablesController -> TablesController -> Bool)
-> (TablesController -> TablesController -> Bool)
-> Eq TablesController
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TablesController -> TablesController -> Bool
== :: TablesController -> TablesController -> Bool
$c/= :: TablesController -> TablesController -> Bool
/= :: TablesController -> TablesController -> Bool
Eq, Int -> TablesController -> ShowS
[TablesController] -> ShowS
TablesController -> String
(Int -> TablesController -> ShowS)
-> (TablesController -> String)
-> ([TablesController] -> ShowS)
-> Show TablesController
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TablesController -> ShowS
showsPrec :: Int -> TablesController -> ShowS
$cshow :: TablesController -> String
show :: TablesController -> String
$cshowList :: [TablesController] -> ShowS
showList :: [TablesController] -> ShowS
Show, Typeable TablesController
Typeable TablesController
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TablesController -> c TablesController)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TablesController)
-> (TablesController -> Constr)
-> (TablesController -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TablesController))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TablesController))
-> ((forall b. Data b => b -> b)
    -> TablesController -> TablesController)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TablesController -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TablesController -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> TablesController -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TablesController -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TablesController -> m TablesController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TablesController -> m TablesController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TablesController -> m TablesController)
-> Data TablesController
TablesController -> Constr
TablesController -> DataType
(forall b. Data b => b -> b)
-> TablesController -> TablesController
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> TablesController -> u
forall u. (forall d. Data d => d -> u) -> TablesController -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TablesController -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TablesController -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TablesController -> m TablesController
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TablesController -> m TablesController
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TablesController
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TablesController -> c TablesController
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TablesController)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TablesController)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TablesController -> c TablesController
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TablesController -> c TablesController
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TablesController
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TablesController
$ctoConstr :: TablesController -> Constr
toConstr :: TablesController -> Constr
$cdataTypeOf :: TablesController -> DataType
dataTypeOf :: TablesController -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TablesController)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TablesController)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TablesController)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TablesController)
$cgmapT :: (forall b. Data b => b -> b)
-> TablesController -> TablesController
gmapT :: (forall b. Data b => b -> b)
-> TablesController -> TablesController
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TablesController -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TablesController -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TablesController -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TablesController -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TablesController -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TablesController -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> TablesController -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> TablesController -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TablesController -> m TablesController
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TablesController -> m TablesController
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TablesController -> m TablesController
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TablesController -> m TablesController
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TablesController -> m TablesController
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TablesController -> m TablesController
Data)

data ColumnsController
    = NewColumnAction { ColumnsController -> Text
tableName :: Text }
    | CreateColumnAction
    | EditColumnAction { tableName :: Text, ColumnsController -> Int
columnId :: Int }
    | UpdateColumnAction
    | DeleteColumnAction { tableName :: Text, columnId :: Int, ColumnsController -> Text
columnName :: Text }
    | ToggleColumnUniqueAction { tableName :: Text, columnId :: Int }
    | NewForeignKeyAction { tableName :: Text, columnName :: Text }
    | CreateForeignKeyAction
    | EditForeignKeyAction { tableName :: Text, columnName :: Text, ColumnsController -> Text
constraintName :: Text, ColumnsController -> Text
referenceTable :: Text }
    | UpdateForeignKeyAction
    | DeleteForeignKeyAction { constraintName :: Text, tableName :: Text }
    deriving (ColumnsController -> ColumnsController -> Bool
(ColumnsController -> ColumnsController -> Bool)
-> (ColumnsController -> ColumnsController -> Bool)
-> Eq ColumnsController
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ColumnsController -> ColumnsController -> Bool
== :: ColumnsController -> ColumnsController -> Bool
$c/= :: ColumnsController -> ColumnsController -> Bool
/= :: ColumnsController -> ColumnsController -> Bool
Eq, Int -> ColumnsController -> ShowS
[ColumnsController] -> ShowS
ColumnsController -> String
(Int -> ColumnsController -> ShowS)
-> (ColumnsController -> String)
-> ([ColumnsController] -> ShowS)
-> Show ColumnsController
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ColumnsController -> ShowS
showsPrec :: Int -> ColumnsController -> ShowS
$cshow :: ColumnsController -> String
show :: ColumnsController -> String
$cshowList :: [ColumnsController] -> ShowS
showList :: [ColumnsController] -> ShowS
Show, Typeable ColumnsController
Typeable ColumnsController
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> ColumnsController
    -> c ColumnsController)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ColumnsController)
-> (ColumnsController -> Constr)
-> (ColumnsController -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ColumnsController))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ColumnsController))
-> ((forall b. Data b => b -> b)
    -> ColumnsController -> ColumnsController)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ColumnsController -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ColumnsController -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ColumnsController -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ColumnsController -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ColumnsController -> m ColumnsController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ColumnsController -> m ColumnsController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ColumnsController -> m ColumnsController)
-> Data ColumnsController
ColumnsController -> Constr
ColumnsController -> DataType
(forall b. Data b => b -> b)
-> ColumnsController -> ColumnsController
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> ColumnsController -> u
forall u. (forall d. Data d => d -> u) -> ColumnsController -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColumnsController -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ColumnsController -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ColumnsController -> m ColumnsController
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ColumnsController -> m ColumnsController
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColumnsController
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColumnsController -> c ColumnsController
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ColumnsController)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ColumnsController)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColumnsController -> c ColumnsController
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ColumnsController -> c ColumnsController
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColumnsController
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ColumnsController
$ctoConstr :: ColumnsController -> Constr
toConstr :: ColumnsController -> Constr
$cdataTypeOf :: ColumnsController -> DataType
dataTypeOf :: ColumnsController -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ColumnsController)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ColumnsController)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ColumnsController)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ColumnsController)
$cgmapT :: (forall b. Data b => b -> b)
-> ColumnsController -> ColumnsController
gmapT :: (forall b. Data b => b -> b)
-> ColumnsController -> ColumnsController
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColumnsController -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ColumnsController -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ColumnsController -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ColumnsController -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ColumnsController -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ColumnsController -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ColumnsController -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ColumnsController -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ColumnsController -> m ColumnsController
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ColumnsController -> m ColumnsController
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ColumnsController -> m ColumnsController
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ColumnsController -> m ColumnsController
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ColumnsController -> m ColumnsController
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ColumnsController -> m ColumnsController
Data)

data PoliciesController
    = NewPolicyAction { PoliciesController -> Text
tableName :: Text }
    | CreatePolicyAction
    | EditPolicyAction { tableName :: Text, PoliciesController -> Text
policyName :: Text }
    | UpdatePolicyAction
    | DeletePolicyAction { tableName :: Text, policyName :: Text }
    deriving (PoliciesController -> PoliciesController -> Bool
(PoliciesController -> PoliciesController -> Bool)
-> (PoliciesController -> PoliciesController -> Bool)
-> Eq PoliciesController
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PoliciesController -> PoliciesController -> Bool
== :: PoliciesController -> PoliciesController -> Bool
$c/= :: PoliciesController -> PoliciesController -> Bool
/= :: PoliciesController -> PoliciesController -> Bool
Eq, Int -> PoliciesController -> ShowS
[PoliciesController] -> ShowS
PoliciesController -> String
(Int -> PoliciesController -> ShowS)
-> (PoliciesController -> String)
-> ([PoliciesController] -> ShowS)
-> Show PoliciesController
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PoliciesController -> ShowS
showsPrec :: Int -> PoliciesController -> ShowS
$cshow :: PoliciesController -> String
show :: PoliciesController -> String
$cshowList :: [PoliciesController] -> ShowS
showList :: [PoliciesController] -> ShowS
Show, Typeable PoliciesController
Typeable PoliciesController
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> PoliciesController
    -> c PoliciesController)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PoliciesController)
-> (PoliciesController -> Constr)
-> (PoliciesController -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PoliciesController))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c PoliciesController))
-> ((forall b. Data b => b -> b)
    -> PoliciesController -> PoliciesController)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PoliciesController -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PoliciesController -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> PoliciesController -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PoliciesController -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> PoliciesController -> m PoliciesController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PoliciesController -> m PoliciesController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PoliciesController -> m PoliciesController)
-> Data PoliciesController
PoliciesController -> Constr
PoliciesController -> DataType
(forall b. Data b => b -> b)
-> PoliciesController -> PoliciesController
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> PoliciesController -> u
forall u. (forall d. Data d => d -> u) -> PoliciesController -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PoliciesController -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PoliciesController -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PoliciesController -> m PoliciesController
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PoliciesController -> m PoliciesController
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PoliciesController
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PoliciesController
-> c PoliciesController
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PoliciesController)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PoliciesController)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PoliciesController
-> c PoliciesController
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PoliciesController
-> c PoliciesController
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PoliciesController
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PoliciesController
$ctoConstr :: PoliciesController -> Constr
toConstr :: PoliciesController -> Constr
$cdataTypeOf :: PoliciesController -> DataType
dataTypeOf :: PoliciesController -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PoliciesController)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PoliciesController)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PoliciesController)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PoliciesController)
$cgmapT :: (forall b. Data b => b -> b)
-> PoliciesController -> PoliciesController
gmapT :: (forall b. Data b => b -> b)
-> PoliciesController -> PoliciesController
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PoliciesController -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PoliciesController -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PoliciesController -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PoliciesController -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PoliciesController -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PoliciesController -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PoliciesController -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PoliciesController -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PoliciesController -> m PoliciesController
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PoliciesController -> m PoliciesController
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PoliciesController -> m PoliciesController
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PoliciesController -> m PoliciesController
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PoliciesController -> m PoliciesController
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PoliciesController -> m PoliciesController
Data)

data EnumsController
    = ShowEnumAction { EnumsController -> Text
enumName :: Text }
    | NewEnumAction
    | CreateEnumAction
    | EditEnumAction { enumName :: Text, EnumsController -> Int
enumId :: Int }
    | UpdateEnumAction
    | DeleteEnumAction { EnumsController -> Int
tableId :: Int }
    deriving (EnumsController -> EnumsController -> Bool
(EnumsController -> EnumsController -> Bool)
-> (EnumsController -> EnumsController -> Bool)
-> Eq EnumsController
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EnumsController -> EnumsController -> Bool
== :: EnumsController -> EnumsController -> Bool
$c/= :: EnumsController -> EnumsController -> Bool
/= :: EnumsController -> EnumsController -> Bool
Eq, Int -> EnumsController -> ShowS
[EnumsController] -> ShowS
EnumsController -> String
(Int -> EnumsController -> ShowS)
-> (EnumsController -> String)
-> ([EnumsController] -> ShowS)
-> Show EnumsController
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EnumsController -> ShowS
showsPrec :: Int -> EnumsController -> ShowS
$cshow :: EnumsController -> String
show :: EnumsController -> String
$cshowList :: [EnumsController] -> ShowS
showList :: [EnumsController] -> ShowS
Show, Typeable EnumsController
Typeable EnumsController
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EnumsController -> c EnumsController)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EnumsController)
-> (EnumsController -> Constr)
-> (EnumsController -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EnumsController))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c EnumsController))
-> ((forall b. Data b => b -> b)
    -> EnumsController -> EnumsController)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EnumsController -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EnumsController -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> EnumsController -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> EnumsController -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> EnumsController -> m EnumsController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EnumsController -> m EnumsController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EnumsController -> m EnumsController)
-> Data EnumsController
EnumsController -> Constr
EnumsController -> DataType
(forall b. Data b => b -> b) -> EnumsController -> EnumsController
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> EnumsController -> u
forall u. (forall d. Data d => d -> u) -> EnumsController -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumsController -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumsController -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EnumsController -> m EnumsController
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnumsController -> m EnumsController
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumsController
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumsController -> c EnumsController
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumsController)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EnumsController)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumsController -> c EnumsController
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumsController -> c EnumsController
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumsController
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumsController
$ctoConstr :: EnumsController -> Constr
toConstr :: EnumsController -> Constr
$cdataTypeOf :: EnumsController -> DataType
dataTypeOf :: EnumsController -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumsController)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumsController)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EnumsController)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EnumsController)
$cgmapT :: (forall b. Data b => b -> b) -> EnumsController -> EnumsController
gmapT :: (forall b. Data b => b -> b) -> EnumsController -> EnumsController
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumsController -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumsController -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumsController -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumsController -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> EnumsController -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> EnumsController -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> EnumsController -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> EnumsController -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EnumsController -> m EnumsController
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EnumsController -> m EnumsController
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnumsController -> m EnumsController
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnumsController -> m EnumsController
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnumsController -> m EnumsController
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnumsController -> m EnumsController
Data)

data EnumValuesController
    = NewEnumValueAction { EnumValuesController -> Text
enumName :: Text }
    | CreateEnumValueAction
    | EditEnumValueAction { enumName :: Text, EnumValuesController -> Int
valueId :: Int }
    | UpdateEnumValueAction
    | DeleteEnumValueAction { enumName :: Text, valueId :: Int }
    deriving (EnumValuesController -> EnumValuesController -> Bool
(EnumValuesController -> EnumValuesController -> Bool)
-> (EnumValuesController -> EnumValuesController -> Bool)
-> Eq EnumValuesController
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EnumValuesController -> EnumValuesController -> Bool
== :: EnumValuesController -> EnumValuesController -> Bool
$c/= :: EnumValuesController -> EnumValuesController -> Bool
/= :: EnumValuesController -> EnumValuesController -> Bool
Eq, Int -> EnumValuesController -> ShowS
[EnumValuesController] -> ShowS
EnumValuesController -> String
(Int -> EnumValuesController -> ShowS)
-> (EnumValuesController -> String)
-> ([EnumValuesController] -> ShowS)
-> Show EnumValuesController
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EnumValuesController -> ShowS
showsPrec :: Int -> EnumValuesController -> ShowS
$cshow :: EnumValuesController -> String
show :: EnumValuesController -> String
$cshowList :: [EnumValuesController] -> ShowS
showList :: [EnumValuesController] -> ShowS
Show, Typeable EnumValuesController
Typeable EnumValuesController
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> EnumValuesController
    -> c EnumValuesController)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EnumValuesController)
-> (EnumValuesController -> Constr)
-> (EnumValuesController -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EnumValuesController))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c EnumValuesController))
-> ((forall b. Data b => b -> b)
    -> EnumValuesController -> EnumValuesController)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EnumValuesController -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EnumValuesController -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> EnumValuesController -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> EnumValuesController -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> EnumValuesController -> m EnumValuesController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EnumValuesController -> m EnumValuesController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EnumValuesController -> m EnumValuesController)
-> Data EnumValuesController
EnumValuesController -> Constr
EnumValuesController -> DataType
(forall b. Data b => b -> b)
-> EnumValuesController -> EnumValuesController
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> EnumValuesController -> u
forall u.
(forall d. Data d => d -> u) -> EnumValuesController -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumValuesController -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumValuesController -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EnumValuesController -> m EnumValuesController
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnumValuesController -> m EnumValuesController
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumValuesController
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> EnumValuesController
-> c EnumValuesController
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumValuesController)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EnumValuesController)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> EnumValuesController
-> c EnumValuesController
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> EnumValuesController
-> c EnumValuesController
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumValuesController
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumValuesController
$ctoConstr :: EnumValuesController -> Constr
toConstr :: EnumValuesController -> Constr
$cdataTypeOf :: EnumValuesController -> DataType
dataTypeOf :: EnumValuesController -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumValuesController)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumValuesController)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EnumValuesController)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EnumValuesController)
$cgmapT :: (forall b. Data b => b -> b)
-> EnumValuesController -> EnumValuesController
gmapT :: (forall b. Data b => b -> b)
-> EnumValuesController -> EnumValuesController
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumValuesController -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumValuesController -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumValuesController -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumValuesController -> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> EnumValuesController -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> EnumValuesController -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> EnumValuesController -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> EnumValuesController -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EnumValuesController -> m EnumValuesController
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EnumValuesController -> m EnumValuesController
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnumValuesController -> m EnumValuesController
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnumValuesController -> m EnumValuesController
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnumValuesController -> m EnumValuesController
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnumValuesController -> m EnumValuesController
Data)

data DataController
    = ShowDatabaseAction
    | ShowTableRowsAction { DataController -> Text
tableName :: Text }
    | DeleteTableRowsAction { tableName :: Text }
    | NewQueryAction
    | QueryAction
    | DeleteEntryAction { DataController -> Text
primaryKey :: Text, tableName :: Text }
    | CreateRowAction
    | NewRowAction { tableName :: Text }
    | EditRowAction { tableName :: Text, DataController -> Text
targetPrimaryKey :: Text }
    | UpdateRowAction
    | EditRowValueAction { tableName :: Text, DataController -> Text
targetName :: Text, DataController -> Text
id :: Text }
    | ToggleBooleanFieldAction { tableName :: Text, targetName :: Text, targetPrimaryKey :: Text }
    | UpdateValueAction
    | ShowForeignKeyHoverCardAction { tableName :: Text, id :: Text, DataController -> Text
columnName :: Text }
    | AutocompleteForeignKeyColumnAction { tableName :: !Text, columnName :: !Text, DataController -> Maybe Text
term :: !(Maybe Text) }
    deriving (DataController -> DataController -> Bool
(DataController -> DataController -> Bool)
-> (DataController -> DataController -> Bool) -> Eq DataController
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DataController -> DataController -> Bool
== :: DataController -> DataController -> Bool
$c/= :: DataController -> DataController -> Bool
/= :: DataController -> DataController -> Bool
Eq, Int -> DataController -> ShowS
[DataController] -> ShowS
DataController -> String
(Int -> DataController -> ShowS)
-> (DataController -> String)
-> ([DataController] -> ShowS)
-> Show DataController
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DataController -> ShowS
showsPrec :: Int -> DataController -> ShowS
$cshow :: DataController -> String
show :: DataController -> String
$cshowList :: [DataController] -> ShowS
showList :: [DataController] -> ShowS
Show, Typeable DataController
Typeable DataController
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DataController -> c DataController)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DataController)
-> (DataController -> Constr)
-> (DataController -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DataController))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DataController))
-> ((forall b. Data b => b -> b)
    -> DataController -> DataController)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataController -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataController -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DataController -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DataController -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DataController -> m DataController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DataController -> m DataController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DataController -> m DataController)
-> Data DataController
DataController -> Constr
DataController -> DataType
(forall b. Data b => b -> b) -> DataController -> DataController
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DataController -> u
forall u. (forall d. Data d => d -> u) -> DataController -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataController -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataController -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DataController -> m DataController
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DataController -> m DataController
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataController
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataController -> c DataController
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataController)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DataController)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataController -> c DataController
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataController -> c DataController
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataController
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataController
$ctoConstr :: DataController -> Constr
toConstr :: DataController -> Constr
$cdataTypeOf :: DataController -> DataType
dataTypeOf :: DataController -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataController)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataController)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DataController)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DataController)
$cgmapT :: (forall b. Data b => b -> b) -> DataController -> DataController
gmapT :: (forall b. Data b => b -> b) -> DataController -> DataController
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataController -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataController -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataController -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataController -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DataController -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DataController -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DataController -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DataController -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DataController -> m DataController
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DataController -> m DataController
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DataController -> m DataController
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DataController -> m DataController
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DataController -> m DataController
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DataController -> m DataController
Data)

data LogsController
    = AppLogsAction
    | PostgresLogsAction
    | OpenEditorAction
    deriving (LogsController -> LogsController -> Bool
(LogsController -> LogsController -> Bool)
-> (LogsController -> LogsController -> Bool) -> Eq LogsController
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LogsController -> LogsController -> Bool
== :: LogsController -> LogsController -> Bool
$c/= :: LogsController -> LogsController -> Bool
/= :: LogsController -> LogsController -> Bool
Eq, Int -> LogsController -> ShowS
[LogsController] -> ShowS
LogsController -> String
(Int -> LogsController -> ShowS)
-> (LogsController -> String)
-> ([LogsController] -> ShowS)
-> Show LogsController
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LogsController -> ShowS
showsPrec :: Int -> LogsController -> ShowS
$cshow :: LogsController -> String
show :: LogsController -> String
$cshowList :: [LogsController] -> ShowS
showList :: [LogsController] -> ShowS
Show, Typeable LogsController
Typeable LogsController
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> LogsController -> c LogsController)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c LogsController)
-> (LogsController -> Constr)
-> (LogsController -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c LogsController))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c LogsController))
-> ((forall b. Data b => b -> b)
    -> LogsController -> LogsController)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> LogsController -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> LogsController -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> LogsController -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> LogsController -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> LogsController -> m LogsController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> LogsController -> m LogsController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> LogsController -> m LogsController)
-> Data LogsController
LogsController -> Constr
LogsController -> DataType
(forall b. Data b => b -> b) -> LogsController -> LogsController
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> LogsController -> u
forall u. (forall d. Data d => d -> u) -> LogsController -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LogsController -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LogsController -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> LogsController -> m LogsController
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LogsController -> m LogsController
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LogsController
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LogsController -> c LogsController
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LogsController)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LogsController)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LogsController -> c LogsController
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LogsController -> c LogsController
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LogsController
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LogsController
$ctoConstr :: LogsController -> Constr
toConstr :: LogsController -> Constr
$cdataTypeOf :: LogsController -> DataType
dataTypeOf :: LogsController -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LogsController)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LogsController)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LogsController)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LogsController)
$cgmapT :: (forall b. Data b => b -> b) -> LogsController -> LogsController
gmapT :: (forall b. Data b => b -> b) -> LogsController -> LogsController
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LogsController -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LogsController -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LogsController -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LogsController -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> LogsController -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> LogsController -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> LogsController -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> LogsController -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> LogsController -> m LogsController
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> LogsController -> m LogsController
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LogsController -> m LogsController
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LogsController -> m LogsController
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LogsController -> m LogsController
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LogsController -> m LogsController
Data)

data CodeGenController
    = GeneratorsAction
    | NewControllerAction
    | NewScriptAction
    | NewViewAction
    | NewMailAction
    | NewActionAction
    | NewApplicationAction
    | NewJobAction
    | CreateControllerAction
    | CreateScriptAction
    | CreateViewAction
    | CreateMailAction
    | CreateActionAction
    | CreateApplicationAction
    | CreateJobAction
    | OpenControllerAction
    deriving (CodeGenController -> CodeGenController -> Bool
(CodeGenController -> CodeGenController -> Bool)
-> (CodeGenController -> CodeGenController -> Bool)
-> Eq CodeGenController
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CodeGenController -> CodeGenController -> Bool
== :: CodeGenController -> CodeGenController -> Bool
$c/= :: CodeGenController -> CodeGenController -> Bool
/= :: CodeGenController -> CodeGenController -> Bool
Eq, Int -> CodeGenController -> ShowS
[CodeGenController] -> ShowS
CodeGenController -> String
(Int -> CodeGenController -> ShowS)
-> (CodeGenController -> String)
-> ([CodeGenController] -> ShowS)
-> Show CodeGenController
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CodeGenController -> ShowS
showsPrec :: Int -> CodeGenController -> ShowS
$cshow :: CodeGenController -> String
show :: CodeGenController -> String
$cshowList :: [CodeGenController] -> ShowS
showList :: [CodeGenController] -> ShowS
Show, Typeable CodeGenController
Typeable CodeGenController
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> CodeGenController
    -> c CodeGenController)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CodeGenController)
-> (CodeGenController -> Constr)
-> (CodeGenController -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CodeGenController))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CodeGenController))
-> ((forall b. Data b => b -> b)
    -> CodeGenController -> CodeGenController)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CodeGenController -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CodeGenController -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> CodeGenController -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CodeGenController -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CodeGenController -> m CodeGenController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CodeGenController -> m CodeGenController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CodeGenController -> m CodeGenController)
-> Data CodeGenController
CodeGenController -> Constr
CodeGenController -> DataType
(forall b. Data b => b -> b)
-> CodeGenController -> CodeGenController
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> CodeGenController -> u
forall u. (forall d. Data d => d -> u) -> CodeGenController -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CodeGenController -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CodeGenController -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CodeGenController -> m CodeGenController
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CodeGenController -> m CodeGenController
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CodeGenController
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CodeGenController -> c CodeGenController
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CodeGenController)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CodeGenController)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CodeGenController -> c CodeGenController
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CodeGenController -> c CodeGenController
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CodeGenController
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CodeGenController
$ctoConstr :: CodeGenController -> Constr
toConstr :: CodeGenController -> Constr
$cdataTypeOf :: CodeGenController -> DataType
dataTypeOf :: CodeGenController -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CodeGenController)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CodeGenController)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CodeGenController)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CodeGenController)
$cgmapT :: (forall b. Data b => b -> b)
-> CodeGenController -> CodeGenController
gmapT :: (forall b. Data b => b -> b)
-> CodeGenController -> CodeGenController
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CodeGenController -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CodeGenController -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CodeGenController -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CodeGenController -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CodeGenController -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CodeGenController -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CodeGenController -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CodeGenController -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CodeGenController -> m CodeGenController
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CodeGenController -> m CodeGenController
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CodeGenController -> m CodeGenController
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CodeGenController -> m CodeGenController
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CodeGenController -> m CodeGenController
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CodeGenController -> m CodeGenController
Data)

data MigrationsController
    = MigrationsAction
    | NewMigrationAction
    | CreateMigrationAction
    | EditMigrationAction { MigrationsController -> Int
migrationId :: !Int }
    | UpdateMigrationAction { migrationId :: !Int }
    | DeleteMigrationAction { migrationId :: !Int }
    | RunMigrationAction { migrationId :: !Int }
    deriving (MigrationsController -> MigrationsController -> Bool
(MigrationsController -> MigrationsController -> Bool)
-> (MigrationsController -> MigrationsController -> Bool)
-> Eq MigrationsController
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MigrationsController -> MigrationsController -> Bool
== :: MigrationsController -> MigrationsController -> Bool
$c/= :: MigrationsController -> MigrationsController -> Bool
/= :: MigrationsController -> MigrationsController -> Bool
Eq, Int -> MigrationsController -> ShowS
[MigrationsController] -> ShowS
MigrationsController -> String
(Int -> MigrationsController -> ShowS)
-> (MigrationsController -> String)
-> ([MigrationsController] -> ShowS)
-> Show MigrationsController
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MigrationsController -> ShowS
showsPrec :: Int -> MigrationsController -> ShowS
$cshow :: MigrationsController -> String
show :: MigrationsController -> String
$cshowList :: [MigrationsController] -> ShowS
showList :: [MigrationsController] -> ShowS
Show, Typeable MigrationsController
Typeable MigrationsController
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> MigrationsController
    -> c MigrationsController)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MigrationsController)
-> (MigrationsController -> Constr)
-> (MigrationsController -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MigrationsController))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c MigrationsController))
-> ((forall b. Data b => b -> b)
    -> MigrationsController -> MigrationsController)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MigrationsController -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MigrationsController -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> MigrationsController -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> MigrationsController -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> MigrationsController -> m MigrationsController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MigrationsController -> m MigrationsController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MigrationsController -> m MigrationsController)
-> Data MigrationsController
MigrationsController -> Constr
MigrationsController -> DataType
(forall b. Data b => b -> b)
-> MigrationsController -> MigrationsController
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> MigrationsController -> u
forall u.
(forall d. Data d => d -> u) -> MigrationsController -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MigrationsController -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MigrationsController -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MigrationsController -> m MigrationsController
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MigrationsController -> m MigrationsController
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MigrationsController
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> MigrationsController
-> c MigrationsController
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MigrationsController)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MigrationsController)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> MigrationsController
-> c MigrationsController
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> MigrationsController
-> c MigrationsController
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MigrationsController
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MigrationsController
$ctoConstr :: MigrationsController -> Constr
toConstr :: MigrationsController -> Constr
$cdataTypeOf :: MigrationsController -> DataType
dataTypeOf :: MigrationsController -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MigrationsController)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MigrationsController)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MigrationsController)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MigrationsController)
$cgmapT :: (forall b. Data b => b -> b)
-> MigrationsController -> MigrationsController
gmapT :: (forall b. Data b => b -> b)
-> MigrationsController -> MigrationsController
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MigrationsController -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MigrationsController -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MigrationsController -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MigrationsController -> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> MigrationsController -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> MigrationsController -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MigrationsController -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MigrationsController -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MigrationsController -> m MigrationsController
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MigrationsController -> m MigrationsController
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MigrationsController -> m MigrationsController
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MigrationsController -> m MigrationsController
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MigrationsController -> m MigrationsController
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MigrationsController -> m MigrationsController
Data)

data IndexesController
    = EditIndexAction { IndexesController -> Text
tableName :: !Text, IndexesController -> Text
indexName :: !Text }
    | UpdateIndexAction { tableName :: !Text, indexName :: !Text }
    | DeleteIndexAction { tableName :: !Text, indexName :: !Text }
    | CreateIndexAction { tableName :: !Text, IndexesController -> Text
columnName :: !Text }
    deriving (IndexesController -> IndexesController -> Bool
(IndexesController -> IndexesController -> Bool)
-> (IndexesController -> IndexesController -> Bool)
-> Eq IndexesController
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IndexesController -> IndexesController -> Bool
== :: IndexesController -> IndexesController -> Bool
$c/= :: IndexesController -> IndexesController -> Bool
/= :: IndexesController -> IndexesController -> Bool
Eq, Int -> IndexesController -> ShowS
[IndexesController] -> ShowS
IndexesController -> String
(Int -> IndexesController -> ShowS)
-> (IndexesController -> String)
-> ([IndexesController] -> ShowS)
-> Show IndexesController
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IndexesController -> ShowS
showsPrec :: Int -> IndexesController -> ShowS
$cshow :: IndexesController -> String
show :: IndexesController -> String
$cshowList :: [IndexesController] -> ShowS
showList :: [IndexesController] -> ShowS
Show, Typeable IndexesController
Typeable IndexesController
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> IndexesController
    -> c IndexesController)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c IndexesController)
-> (IndexesController -> Constr)
-> (IndexesController -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c IndexesController))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c IndexesController))
-> ((forall b. Data b => b -> b)
    -> IndexesController -> IndexesController)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IndexesController -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IndexesController -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> IndexesController -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> IndexesController -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> IndexesController -> m IndexesController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> IndexesController -> m IndexesController)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> IndexesController -> m IndexesController)
-> Data IndexesController
IndexesController -> Constr
IndexesController -> DataType
(forall b. Data b => b -> b)
-> IndexesController -> IndexesController
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> IndexesController -> u
forall u. (forall d. Data d => d -> u) -> IndexesController -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IndexesController -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IndexesController -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> IndexesController -> m IndexesController
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IndexesController -> m IndexesController
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IndexesController
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IndexesController -> c IndexesController
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IndexesController)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IndexesController)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IndexesController -> c IndexesController
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IndexesController -> c IndexesController
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IndexesController
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IndexesController
$ctoConstr :: IndexesController -> Constr
toConstr :: IndexesController -> Constr
$cdataTypeOf :: IndexesController -> DataType
dataTypeOf :: IndexesController -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IndexesController)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IndexesController)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IndexesController)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IndexesController)
$cgmapT :: (forall b. Data b => b -> b)
-> IndexesController -> IndexesController
gmapT :: (forall b. Data b => b -> b)
-> IndexesController -> IndexesController
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IndexesController -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IndexesController -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IndexesController -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IndexesController -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> IndexesController -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> IndexesController -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> IndexesController -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> IndexesController -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> IndexesController -> m IndexesController
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> IndexesController -> m IndexesController
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IndexesController -> m IndexesController
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IndexesController -> m IndexesController
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IndexesController -> m IndexesController
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IndexesController -> m IndexesController
Data)

data DynamicField = DynamicField
    { DynamicField -> Maybe ByteString
fieldValue :: Maybe ByteString
    , DynamicField -> ByteString
fieldName :: ByteString
    } deriving (Int -> DynamicField -> ShowS
[DynamicField] -> ShowS
DynamicField -> String
(Int -> DynamicField -> ShowS)
-> (DynamicField -> String)
-> ([DynamicField] -> ShowS)
-> Show DynamicField
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DynamicField -> ShowS
showsPrec :: Int -> DynamicField -> ShowS
$cshow :: DynamicField -> String
show :: DynamicField -> String
$cshowList :: [DynamicField] -> ShowS
showList :: [DynamicField] -> ShowS
Show)

data ColumnDefinition = ColumnDefinition
    { ColumnDefinition -> Text
columnName :: Text
    , ColumnDefinition -> Text
columnType :: Text
    , ColumnDefinition -> Maybe Text
columnDefault :: Maybe Text
    , ColumnDefinition -> Bool
isNullable :: Bool
    } deriving (Int -> ColumnDefinition -> ShowS
[ColumnDefinition] -> ShowS
ColumnDefinition -> String
(Int -> ColumnDefinition -> ShowS)
-> (ColumnDefinition -> String)
-> ([ColumnDefinition] -> ShowS)
-> Show ColumnDefinition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ColumnDefinition -> ShowS
showsPrec :: Int -> ColumnDefinition -> ShowS
$cshow :: ColumnDefinition -> String
show :: ColumnDefinition -> String
$cshowList :: [ColumnDefinition] -> ShowS
showList :: [ColumnDefinition] -> ShowS
Show)


-- | Keeps track of all all available apps in the projects. Used to display
-- the apps inside the sidebar navigation
--
-- Usually this list is like: @["Web"]@ or @["Web", "Admin"]@
newtype AvailableApps = AvailableApps [Text]

-- | Wrapper to pass the app url to the layout.
-- Usually "http://localhost:8000"
newtype AppUrl = AppUrl Text

-- | List of all controllers. Used inside e.g. the Schema Designer to decide whether to display
-- the 'Generate Controller' option
newtype WebControllers = WebControllers [Text]

newtype DatabaseNeedsMigration = DatabaseNeedsMigration Bool

data SqlConsoleResult
    = SelectQueryResult ![[DynamicField]]
    | InsertOrUpdateResult !Int64