module Darcs.Repository.Flags
    (
      Compression (..)
    , RemoteDarcs (..)
    , remoteDarcs
    , Reorder (..)
    , Verbosity (..)
    , UpdatePending (..)
    , UseCache (..)
    , DryRun (..)
    , UMask (..)
    , LookForAdds (..)
    , LookForReplaces (..)
    , DiffAlgorithm (..)
    , LookForMoves (..)
    , RunTest (..)
    , SetScriptsExecutable (..)
    , LeaveTestDir (..)
    , RemoteRepos (..)
    , SetDefault (..)
    , InheritDefault (..)
    , UseIndex (..)
    , ScanKnown (..)
    , CloneKind (..)
    , AllowConflicts (..)
    , ExternalMerge (..)
    , WorkRepo (..)
    , WantGuiPause (..)
    , WithPatchIndex (..)
    , WithWorkingDir (..)
    , ForgetParent (..)
    , PatchFormat (..)
    , IncludeBoring (..)
    , HooksConfig (..)
    , HookConfig (..)
    ) where

import Darcs.Prelude

import Darcs.Util.Diff ( DiffAlgorithm(..) )
import Darcs.Util.Global ( defaultRemoteDarcsCmd )


data Verbosity = Quiet | NormalVerbosity | Verbose
    deriving ( Verbosity -> Verbosity -> Bool
(Verbosity -> Verbosity -> Bool)
-> (Verbosity -> Verbosity -> Bool) -> Eq Verbosity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Verbosity -> Verbosity -> Bool
$c/= :: Verbosity -> Verbosity -> Bool
== :: Verbosity -> Verbosity -> Bool
$c== :: Verbosity -> Verbosity -> Bool
Eq, Int -> Verbosity -> ShowS
[Verbosity] -> ShowS
Verbosity -> String
(Int -> Verbosity -> ShowS)
-> (Verbosity -> String)
-> ([Verbosity] -> ShowS)
-> Show Verbosity
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Verbosity] -> ShowS
$cshowList :: [Verbosity] -> ShowS
show :: Verbosity -> String
$cshow :: Verbosity -> String
showsPrec :: Int -> Verbosity -> ShowS
$cshowsPrec :: Int -> Verbosity -> ShowS
Show )

data Compression = NoCompression
                 | GzipCompression
    deriving ( Compression -> Compression -> Bool
(Compression -> Compression -> Bool)
-> (Compression -> Compression -> Bool) -> Eq Compression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Compression -> Compression -> Bool
$c/= :: Compression -> Compression -> Bool
== :: Compression -> Compression -> Bool
$c== :: Compression -> Compression -> Bool
Eq, Int -> Compression -> ShowS
[Compression] -> ShowS
Compression -> String
(Int -> Compression -> ShowS)
-> (Compression -> String)
-> ([Compression] -> ShowS)
-> Show Compression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Compression] -> ShowS
$cshowList :: [Compression] -> ShowS
show :: Compression -> String
$cshow :: Compression -> String
showsPrec :: Int -> Compression -> ShowS
$cshowsPrec :: Int -> Compression -> ShowS
Show )

data WithPatchIndex = YesPatchIndex | NoPatchIndex
    deriving ( WithPatchIndex -> WithPatchIndex -> Bool
(WithPatchIndex -> WithPatchIndex -> Bool)
-> (WithPatchIndex -> WithPatchIndex -> Bool) -> Eq WithPatchIndex
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WithPatchIndex -> WithPatchIndex -> Bool
$c/= :: WithPatchIndex -> WithPatchIndex -> Bool
== :: WithPatchIndex -> WithPatchIndex -> Bool
$c== :: WithPatchIndex -> WithPatchIndex -> Bool
Eq, Int -> WithPatchIndex -> ShowS
[WithPatchIndex] -> ShowS
WithPatchIndex -> String
(Int -> WithPatchIndex -> ShowS)
-> (WithPatchIndex -> String)
-> ([WithPatchIndex] -> ShowS)
-> Show WithPatchIndex
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WithPatchIndex] -> ShowS
$cshowList :: [WithPatchIndex] -> ShowS
show :: WithPatchIndex -> String
$cshow :: WithPatchIndex -> String
showsPrec :: Int -> WithPatchIndex -> ShowS
$cshowsPrec :: Int -> WithPatchIndex -> ShowS
Show )

data RemoteDarcs = RemoteDarcs String
                 | DefaultRemoteDarcs
    deriving ( RemoteDarcs -> RemoteDarcs -> Bool
(RemoteDarcs -> RemoteDarcs -> Bool)
-> (RemoteDarcs -> RemoteDarcs -> Bool) -> Eq RemoteDarcs
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RemoteDarcs -> RemoteDarcs -> Bool
$c/= :: RemoteDarcs -> RemoteDarcs -> Bool
== :: RemoteDarcs -> RemoteDarcs -> Bool
$c== :: RemoteDarcs -> RemoteDarcs -> Bool
Eq, Int -> RemoteDarcs -> ShowS
[RemoteDarcs] -> ShowS
RemoteDarcs -> String
(Int -> RemoteDarcs -> ShowS)
-> (RemoteDarcs -> String)
-> ([RemoteDarcs] -> ShowS)
-> Show RemoteDarcs
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RemoteDarcs] -> ShowS
$cshowList :: [RemoteDarcs] -> ShowS
show :: RemoteDarcs -> String
$cshow :: RemoteDarcs -> String
showsPrec :: Int -> RemoteDarcs -> ShowS
$cshowsPrec :: Int -> RemoteDarcs -> ShowS
Show )

remoteDarcs :: RemoteDarcs -> String
remoteDarcs :: RemoteDarcs -> String
remoteDarcs RemoteDarcs
DefaultRemoteDarcs = String
defaultRemoteDarcsCmd
remoteDarcs (RemoteDarcs String
x) = String
x

data Reorder = NoReorder | Reorder
    deriving ( Reorder -> Reorder -> Bool
(Reorder -> Reorder -> Bool)
-> (Reorder -> Reorder -> Bool) -> Eq Reorder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Reorder -> Reorder -> Bool
$c/= :: Reorder -> Reorder -> Bool
== :: Reorder -> Reorder -> Bool
$c== :: Reorder -> Reorder -> Bool
Eq )

data UpdatePending = YesUpdatePending | NoUpdatePending
    deriving ( UpdatePending -> UpdatePending -> Bool
(UpdatePending -> UpdatePending -> Bool)
-> (UpdatePending -> UpdatePending -> Bool) -> Eq UpdatePending
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdatePending -> UpdatePending -> Bool
$c/= :: UpdatePending -> UpdatePending -> Bool
== :: UpdatePending -> UpdatePending -> Bool
$c== :: UpdatePending -> UpdatePending -> Bool
Eq, Int -> UpdatePending -> ShowS
[UpdatePending] -> ShowS
UpdatePending -> String
(Int -> UpdatePending -> ShowS)
-> (UpdatePending -> String)
-> ([UpdatePending] -> ShowS)
-> Show UpdatePending
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdatePending] -> ShowS
$cshowList :: [UpdatePending] -> ShowS
show :: UpdatePending -> String
$cshow :: UpdatePending -> String
showsPrec :: Int -> UpdatePending -> ShowS
$cshowsPrec :: Int -> UpdatePending -> ShowS
Show )

data UseCache = YesUseCache | NoUseCache
    deriving ( UseCache -> UseCache -> Bool
(UseCache -> UseCache -> Bool)
-> (UseCache -> UseCache -> Bool) -> Eq UseCache
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UseCache -> UseCache -> Bool
$c/= :: UseCache -> UseCache -> Bool
== :: UseCache -> UseCache -> Bool
$c== :: UseCache -> UseCache -> Bool
Eq, Int -> UseCache -> ShowS
[UseCache] -> ShowS
UseCache -> String
(Int -> UseCache -> ShowS)
-> (UseCache -> String) -> ([UseCache] -> ShowS) -> Show UseCache
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UseCache] -> ShowS
$cshowList :: [UseCache] -> ShowS
show :: UseCache -> String
$cshow :: UseCache -> String
showsPrec :: Int -> UseCache -> ShowS
$cshowsPrec :: Int -> UseCache -> ShowS
Show )

data DryRun = YesDryRun | NoDryRun
    deriving ( DryRun -> DryRun -> Bool
(DryRun -> DryRun -> Bool)
-> (DryRun -> DryRun -> Bool) -> Eq DryRun
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DryRun -> DryRun -> Bool
$c/= :: DryRun -> DryRun -> Bool
== :: DryRun -> DryRun -> Bool
$c== :: DryRun -> DryRun -> Bool
Eq, Int -> DryRun -> ShowS
[DryRun] -> ShowS
DryRun -> String
(Int -> DryRun -> ShowS)
-> (DryRun -> String) -> ([DryRun] -> ShowS) -> Show DryRun
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DryRun] -> ShowS
$cshowList :: [DryRun] -> ShowS
show :: DryRun -> String
$cshow :: DryRun -> String
showsPrec :: Int -> DryRun -> ShowS
$cshowsPrec :: Int -> DryRun -> ShowS
Show )

data UMask = YesUMask String | NoUMask
    deriving ( UMask -> UMask -> Bool
(UMask -> UMask -> Bool) -> (UMask -> UMask -> Bool) -> Eq UMask
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UMask -> UMask -> Bool
$c/= :: UMask -> UMask -> Bool
== :: UMask -> UMask -> Bool
$c== :: UMask -> UMask -> Bool
Eq, Int -> UMask -> ShowS
[UMask] -> ShowS
UMask -> String
(Int -> UMask -> ShowS)
-> (UMask -> String) -> ([UMask] -> ShowS) -> Show UMask
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UMask] -> ShowS
$cshowList :: [UMask] -> ShowS
show :: UMask -> String
$cshow :: UMask -> String
showsPrec :: Int -> UMask -> ShowS
$cshowsPrec :: Int -> UMask -> ShowS
Show )

data LookForAdds = YesLookForAdds | NoLookForAdds
    deriving ( LookForAdds -> LookForAdds -> Bool
(LookForAdds -> LookForAdds -> Bool)
-> (LookForAdds -> LookForAdds -> Bool) -> Eq LookForAdds
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LookForAdds -> LookForAdds -> Bool
$c/= :: LookForAdds -> LookForAdds -> Bool
== :: LookForAdds -> LookForAdds -> Bool
$c== :: LookForAdds -> LookForAdds -> Bool
Eq, Int -> LookForAdds -> ShowS
[LookForAdds] -> ShowS
LookForAdds -> String
(Int -> LookForAdds -> ShowS)
-> (LookForAdds -> String)
-> ([LookForAdds] -> ShowS)
-> Show LookForAdds
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LookForAdds] -> ShowS
$cshowList :: [LookForAdds] -> ShowS
show :: LookForAdds -> String
$cshow :: LookForAdds -> String
showsPrec :: Int -> LookForAdds -> ShowS
$cshowsPrec :: Int -> LookForAdds -> ShowS
Show )

data LookForReplaces = YesLookForReplaces | NoLookForReplaces
    deriving ( LookForReplaces -> LookForReplaces -> Bool
(LookForReplaces -> LookForReplaces -> Bool)
-> (LookForReplaces -> LookForReplaces -> Bool)
-> Eq LookForReplaces
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LookForReplaces -> LookForReplaces -> Bool
$c/= :: LookForReplaces -> LookForReplaces -> Bool
== :: LookForReplaces -> LookForReplaces -> Bool
$c== :: LookForReplaces -> LookForReplaces -> Bool
Eq, Int -> LookForReplaces -> ShowS
[LookForReplaces] -> ShowS
LookForReplaces -> String
(Int -> LookForReplaces -> ShowS)
-> (LookForReplaces -> String)
-> ([LookForReplaces] -> ShowS)
-> Show LookForReplaces
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LookForReplaces] -> ShowS
$cshowList :: [LookForReplaces] -> ShowS
show :: LookForReplaces -> String
$cshow :: LookForReplaces -> String
showsPrec :: Int -> LookForReplaces -> ShowS
$cshowsPrec :: Int -> LookForReplaces -> ShowS
Show )

data LookForMoves = YesLookForMoves | NoLookForMoves
    deriving ( LookForMoves -> LookForMoves -> Bool
(LookForMoves -> LookForMoves -> Bool)
-> (LookForMoves -> LookForMoves -> Bool) -> Eq LookForMoves
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LookForMoves -> LookForMoves -> Bool
$c/= :: LookForMoves -> LookForMoves -> Bool
== :: LookForMoves -> LookForMoves -> Bool
$c== :: LookForMoves -> LookForMoves -> Bool
Eq, Int -> LookForMoves -> ShowS
[LookForMoves] -> ShowS
LookForMoves -> String
(Int -> LookForMoves -> ShowS)
-> (LookForMoves -> String)
-> ([LookForMoves] -> ShowS)
-> Show LookForMoves
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LookForMoves] -> ShowS
$cshowList :: [LookForMoves] -> ShowS
show :: LookForMoves -> String
$cshow :: LookForMoves -> String
showsPrec :: Int -> LookForMoves -> ShowS
$cshowsPrec :: Int -> LookForMoves -> ShowS
Show )

data IncludeBoring = YesIncludeBoring | NoIncludeBoring
    deriving ( IncludeBoring -> IncludeBoring -> Bool
(IncludeBoring -> IncludeBoring -> Bool)
-> (IncludeBoring -> IncludeBoring -> Bool) -> Eq IncludeBoring
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IncludeBoring -> IncludeBoring -> Bool
$c/= :: IncludeBoring -> IncludeBoring -> Bool
== :: IncludeBoring -> IncludeBoring -> Bool
$c== :: IncludeBoring -> IncludeBoring -> Bool
Eq, Int -> IncludeBoring -> ShowS
[IncludeBoring] -> ShowS
IncludeBoring -> String
(Int -> IncludeBoring -> ShowS)
-> (IncludeBoring -> String)
-> ([IncludeBoring] -> ShowS)
-> Show IncludeBoring
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IncludeBoring] -> ShowS
$cshowList :: [IncludeBoring] -> ShowS
show :: IncludeBoring -> String
$cshow :: IncludeBoring -> String
showsPrec :: Int -> IncludeBoring -> ShowS
$cshowsPrec :: Int -> IncludeBoring -> ShowS
Show )

data RunTest = YesRunTest | NoRunTest
    deriving ( RunTest -> RunTest -> Bool
(RunTest -> RunTest -> Bool)
-> (RunTest -> RunTest -> Bool) -> Eq RunTest
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RunTest -> RunTest -> Bool
$c/= :: RunTest -> RunTest -> Bool
== :: RunTest -> RunTest -> Bool
$c== :: RunTest -> RunTest -> Bool
Eq, Int -> RunTest -> ShowS
[RunTest] -> ShowS
RunTest -> String
(Int -> RunTest -> ShowS)
-> (RunTest -> String) -> ([RunTest] -> ShowS) -> Show RunTest
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RunTest] -> ShowS
$cshowList :: [RunTest] -> ShowS
show :: RunTest -> String
$cshow :: RunTest -> String
showsPrec :: Int -> RunTest -> ShowS
$cshowsPrec :: Int -> RunTest -> ShowS
Show )

data SetScriptsExecutable = YesSetScriptsExecutable | NoSetScriptsExecutable
    deriving ( SetScriptsExecutable -> SetScriptsExecutable -> Bool
(SetScriptsExecutable -> SetScriptsExecutable -> Bool)
-> (SetScriptsExecutable -> SetScriptsExecutable -> Bool)
-> Eq SetScriptsExecutable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SetScriptsExecutable -> SetScriptsExecutable -> Bool
$c/= :: SetScriptsExecutable -> SetScriptsExecutable -> Bool
== :: SetScriptsExecutable -> SetScriptsExecutable -> Bool
$c== :: SetScriptsExecutable -> SetScriptsExecutable -> Bool
Eq, Int -> SetScriptsExecutable -> ShowS
[SetScriptsExecutable] -> ShowS
SetScriptsExecutable -> String
(Int -> SetScriptsExecutable -> ShowS)
-> (SetScriptsExecutable -> String)
-> ([SetScriptsExecutable] -> ShowS)
-> Show SetScriptsExecutable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SetScriptsExecutable] -> ShowS
$cshowList :: [SetScriptsExecutable] -> ShowS
show :: SetScriptsExecutable -> String
$cshow :: SetScriptsExecutable -> String
showsPrec :: Int -> SetScriptsExecutable -> ShowS
$cshowsPrec :: Int -> SetScriptsExecutable -> ShowS
Show )

data LeaveTestDir = YesLeaveTestDir | NoLeaveTestDir
    deriving ( LeaveTestDir -> LeaveTestDir -> Bool
(LeaveTestDir -> LeaveTestDir -> Bool)
-> (LeaveTestDir -> LeaveTestDir -> Bool) -> Eq LeaveTestDir
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LeaveTestDir -> LeaveTestDir -> Bool
$c/= :: LeaveTestDir -> LeaveTestDir -> Bool
== :: LeaveTestDir -> LeaveTestDir -> Bool
$c== :: LeaveTestDir -> LeaveTestDir -> Bool
Eq, Int -> LeaveTestDir -> ShowS
[LeaveTestDir] -> ShowS
LeaveTestDir -> String
(Int -> LeaveTestDir -> ShowS)
-> (LeaveTestDir -> String)
-> ([LeaveTestDir] -> ShowS)
-> Show LeaveTestDir
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LeaveTestDir] -> ShowS
$cshowList :: [LeaveTestDir] -> ShowS
show :: LeaveTestDir -> String
$cshow :: LeaveTestDir -> String
showsPrec :: Int -> LeaveTestDir -> ShowS
$cshowsPrec :: Int -> LeaveTestDir -> ShowS
Show )

data RemoteRepos = RemoteRepos [String]
    deriving ( RemoteRepos -> RemoteRepos -> Bool
(RemoteRepos -> RemoteRepos -> Bool)
-> (RemoteRepos -> RemoteRepos -> Bool) -> Eq RemoteRepos
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RemoteRepos -> RemoteRepos -> Bool
$c/= :: RemoteRepos -> RemoteRepos -> Bool
== :: RemoteRepos -> RemoteRepos -> Bool
$c== :: RemoteRepos -> RemoteRepos -> Bool
Eq, Int -> RemoteRepos -> ShowS
[RemoteRepos] -> ShowS
RemoteRepos -> String
(Int -> RemoteRepos -> ShowS)
-> (RemoteRepos -> String)
-> ([RemoteRepos] -> ShowS)
-> Show RemoteRepos
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RemoteRepos] -> ShowS
$cshowList :: [RemoteRepos] -> ShowS
show :: RemoteRepos -> String
$cshow :: RemoteRepos -> String
showsPrec :: Int -> RemoteRepos -> ShowS
$cshowsPrec :: Int -> RemoteRepos -> ShowS
Show )

data SetDefault = YesSetDefault Bool | NoSetDefault Bool
    deriving ( SetDefault -> SetDefault -> Bool
(SetDefault -> SetDefault -> Bool)
-> (SetDefault -> SetDefault -> Bool) -> Eq SetDefault
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SetDefault -> SetDefault -> Bool
$c/= :: SetDefault -> SetDefault -> Bool
== :: SetDefault -> SetDefault -> Bool
$c== :: SetDefault -> SetDefault -> Bool
Eq, Int -> SetDefault -> ShowS
[SetDefault] -> ShowS
SetDefault -> String
(Int -> SetDefault -> ShowS)
-> (SetDefault -> String)
-> ([SetDefault] -> ShowS)
-> Show SetDefault
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SetDefault] -> ShowS
$cshowList :: [SetDefault] -> ShowS
show :: SetDefault -> String
$cshow :: SetDefault -> String
showsPrec :: Int -> SetDefault -> ShowS
$cshowsPrec :: Int -> SetDefault -> ShowS
Show )

data InheritDefault = YesInheritDefault | NoInheritDefault
    deriving ( InheritDefault -> InheritDefault -> Bool
(InheritDefault -> InheritDefault -> Bool)
-> (InheritDefault -> InheritDefault -> Bool) -> Eq InheritDefault
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InheritDefault -> InheritDefault -> Bool
$c/= :: InheritDefault -> InheritDefault -> Bool
== :: InheritDefault -> InheritDefault -> Bool
$c== :: InheritDefault -> InheritDefault -> Bool
Eq, Int -> InheritDefault -> ShowS
[InheritDefault] -> ShowS
InheritDefault -> String
(Int -> InheritDefault -> ShowS)
-> (InheritDefault -> String)
-> ([InheritDefault] -> ShowS)
-> Show InheritDefault
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InheritDefault] -> ShowS
$cshowList :: [InheritDefault] -> ShowS
show :: InheritDefault -> String
$cshow :: InheritDefault -> String
showsPrec :: Int -> InheritDefault -> ShowS
$cshowsPrec :: Int -> InheritDefault -> ShowS
Show )

data UseIndex = UseIndex | IgnoreIndex deriving ( UseIndex -> UseIndex -> Bool
(UseIndex -> UseIndex -> Bool)
-> (UseIndex -> UseIndex -> Bool) -> Eq UseIndex
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UseIndex -> UseIndex -> Bool
$c/= :: UseIndex -> UseIndex -> Bool
== :: UseIndex -> UseIndex -> Bool
$c== :: UseIndex -> UseIndex -> Bool
Eq, Int -> UseIndex -> ShowS
[UseIndex] -> ShowS
UseIndex -> String
(Int -> UseIndex -> ShowS)
-> (UseIndex -> String) -> ([UseIndex] -> ShowS) -> Show UseIndex
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UseIndex] -> ShowS
$cshowList :: [UseIndex] -> ShowS
show :: UseIndex -> String
$cshow :: UseIndex -> String
showsPrec :: Int -> UseIndex -> ShowS
$cshowsPrec :: Int -> UseIndex -> ShowS
Show )

data ScanKnown = ScanKnown -- ^Just files already known to darcs
               | ScanAll -- ^All files, i.e. look for new ones
               | ScanBoring -- ^All files, even boring ones
    deriving ( ScanKnown -> ScanKnown -> Bool
(ScanKnown -> ScanKnown -> Bool)
-> (ScanKnown -> ScanKnown -> Bool) -> Eq ScanKnown
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScanKnown -> ScanKnown -> Bool
$c/= :: ScanKnown -> ScanKnown -> Bool
== :: ScanKnown -> ScanKnown -> Bool
$c== :: ScanKnown -> ScanKnown -> Bool
Eq, Int -> ScanKnown -> ShowS
[ScanKnown] -> ShowS
ScanKnown -> String
(Int -> ScanKnown -> ShowS)
-> (ScanKnown -> String)
-> ([ScanKnown] -> ShowS)
-> Show ScanKnown
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ScanKnown] -> ShowS
$cshowList :: [ScanKnown] -> ShowS
show :: ScanKnown -> String
$cshow :: ScanKnown -> String
showsPrec :: Int -> ScanKnown -> ShowS
$cshowsPrec :: Int -> ScanKnown -> ShowS
Show )

-- Various kinds of getting repositories
data CloneKind = LazyClone       -- ^Just copy pristine and inventories
               | NormalClone     -- ^First do a lazy clone then copy everything
               | CompleteClone   -- ^Same as Normal but omit telling user they can interrumpt
    deriving ( CloneKind -> CloneKind -> Bool
(CloneKind -> CloneKind -> Bool)
-> (CloneKind -> CloneKind -> Bool) -> Eq CloneKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CloneKind -> CloneKind -> Bool
$c/= :: CloneKind -> CloneKind -> Bool
== :: CloneKind -> CloneKind -> Bool
$c== :: CloneKind -> CloneKind -> Bool
Eq, Int -> CloneKind -> ShowS
[CloneKind] -> ShowS
CloneKind -> String
(Int -> CloneKind -> ShowS)
-> (CloneKind -> String)
-> ([CloneKind] -> ShowS)
-> Show CloneKind
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CloneKind] -> ShowS
$cshowList :: [CloneKind] -> ShowS
show :: CloneKind -> String
$cshow :: CloneKind -> String
showsPrec :: Int -> CloneKind -> ShowS
$cshowsPrec :: Int -> CloneKind -> ShowS
Show )

data AllowConflicts = NoAllowConflicts | YesAllowConflicts | YesAllowConflictsAndMark
    deriving ( AllowConflicts -> AllowConflicts -> Bool
(AllowConflicts -> AllowConflicts -> Bool)
-> (AllowConflicts -> AllowConflicts -> Bool) -> Eq AllowConflicts
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AllowConflicts -> AllowConflicts -> Bool
$c/= :: AllowConflicts -> AllowConflicts -> Bool
== :: AllowConflicts -> AllowConflicts -> Bool
$c== :: AllowConflicts -> AllowConflicts -> Bool
Eq, Int -> AllowConflicts -> ShowS
[AllowConflicts] -> ShowS
AllowConflicts -> String
(Int -> AllowConflicts -> ShowS)
-> (AllowConflicts -> String)
-> ([AllowConflicts] -> ShowS)
-> Show AllowConflicts
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AllowConflicts] -> ShowS
$cshowList :: [AllowConflicts] -> ShowS
show :: AllowConflicts -> String
$cshow :: AllowConflicts -> String
showsPrec :: Int -> AllowConflicts -> ShowS
$cshowsPrec :: Int -> AllowConflicts -> ShowS
Show )

data ExternalMerge = YesExternalMerge String | NoExternalMerge
    deriving ( ExternalMerge -> ExternalMerge -> Bool
(ExternalMerge -> ExternalMerge -> Bool)
-> (ExternalMerge -> ExternalMerge -> Bool) -> Eq ExternalMerge
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExternalMerge -> ExternalMerge -> Bool
$c/= :: ExternalMerge -> ExternalMerge -> Bool
== :: ExternalMerge -> ExternalMerge -> Bool
$c== :: ExternalMerge -> ExternalMerge -> Bool
Eq, Int -> ExternalMerge -> ShowS
[ExternalMerge] -> ShowS
ExternalMerge -> String
(Int -> ExternalMerge -> ShowS)
-> (ExternalMerge -> String)
-> ([ExternalMerge] -> ShowS)
-> Show ExternalMerge
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExternalMerge] -> ShowS
$cshowList :: [ExternalMerge] -> ShowS
show :: ExternalMerge -> String
$cshow :: ExternalMerge -> String
showsPrec :: Int -> ExternalMerge -> ShowS
$cshowsPrec :: Int -> ExternalMerge -> ShowS
Show )

data WorkRepo = WorkRepoDir String | WorkRepoPossibleURL String | WorkRepoCurrentDir
    deriving ( WorkRepo -> WorkRepo -> Bool
(WorkRepo -> WorkRepo -> Bool)
-> (WorkRepo -> WorkRepo -> Bool) -> Eq WorkRepo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WorkRepo -> WorkRepo -> Bool
$c/= :: WorkRepo -> WorkRepo -> Bool
== :: WorkRepo -> WorkRepo -> Bool
$c== :: WorkRepo -> WorkRepo -> Bool
Eq, Int -> WorkRepo -> ShowS
[WorkRepo] -> ShowS
WorkRepo -> String
(Int -> WorkRepo -> ShowS)
-> (WorkRepo -> String) -> ([WorkRepo] -> ShowS) -> Show WorkRepo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WorkRepo] -> ShowS
$cshowList :: [WorkRepo] -> ShowS
show :: WorkRepo -> String
$cshow :: WorkRepo -> String
showsPrec :: Int -> WorkRepo -> ShowS
$cshowsPrec :: Int -> WorkRepo -> ShowS
Show )

data WantGuiPause = YesWantGuiPause | NoWantGuiPause
    deriving ( WantGuiPause -> WantGuiPause -> Bool
(WantGuiPause -> WantGuiPause -> Bool)
-> (WantGuiPause -> WantGuiPause -> Bool) -> Eq WantGuiPause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WantGuiPause -> WantGuiPause -> Bool
$c/= :: WantGuiPause -> WantGuiPause -> Bool
== :: WantGuiPause -> WantGuiPause -> Bool
$c== :: WantGuiPause -> WantGuiPause -> Bool
Eq, Int -> WantGuiPause -> ShowS
[WantGuiPause] -> ShowS
WantGuiPause -> String
(Int -> WantGuiPause -> ShowS)
-> (WantGuiPause -> String)
-> ([WantGuiPause] -> ShowS)
-> Show WantGuiPause
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WantGuiPause] -> ShowS
$cshowList :: [WantGuiPause] -> ShowS
show :: WantGuiPause -> String
$cshow :: WantGuiPause -> String
showsPrec :: Int -> WantGuiPause -> ShowS
$cshowsPrec :: Int -> WantGuiPause -> ShowS
Show )

data WithWorkingDir = WithWorkingDir | NoWorkingDir
    deriving ( WithWorkingDir -> WithWorkingDir -> Bool
(WithWorkingDir -> WithWorkingDir -> Bool)
-> (WithWorkingDir -> WithWorkingDir -> Bool) -> Eq WithWorkingDir
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WithWorkingDir -> WithWorkingDir -> Bool
$c/= :: WithWorkingDir -> WithWorkingDir -> Bool
== :: WithWorkingDir -> WithWorkingDir -> Bool
$c== :: WithWorkingDir -> WithWorkingDir -> Bool
Eq, Int -> WithWorkingDir -> ShowS
[WithWorkingDir] -> ShowS
WithWorkingDir -> String
(Int -> WithWorkingDir -> ShowS)
-> (WithWorkingDir -> String)
-> ([WithWorkingDir] -> ShowS)
-> Show WithWorkingDir
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WithWorkingDir] -> ShowS
$cshowList :: [WithWorkingDir] -> ShowS
show :: WithWorkingDir -> String
$cshow :: WithWorkingDir -> String
showsPrec :: Int -> WithWorkingDir -> ShowS
$cshowsPrec :: Int -> WithWorkingDir -> ShowS
Show )

data ForgetParent = YesForgetParent | NoForgetParent
    deriving ( ForgetParent -> ForgetParent -> Bool
(ForgetParent -> ForgetParent -> Bool)
-> (ForgetParent -> ForgetParent -> Bool) -> Eq ForgetParent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ForgetParent -> ForgetParent -> Bool
$c/= :: ForgetParent -> ForgetParent -> Bool
== :: ForgetParent -> ForgetParent -> Bool
$c== :: ForgetParent -> ForgetParent -> Bool
Eq, Int -> ForgetParent -> ShowS
[ForgetParent] -> ShowS
ForgetParent -> String
(Int -> ForgetParent -> ShowS)
-> (ForgetParent -> String)
-> ([ForgetParent] -> ShowS)
-> Show ForgetParent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ForgetParent] -> ShowS
$cshowList :: [ForgetParent] -> ShowS
show :: ForgetParent -> String
$cshow :: ForgetParent -> String
showsPrec :: Int -> ForgetParent -> ShowS
$cshowsPrec :: Int -> ForgetParent -> ShowS
Show )

data PatchFormat = PatchFormat1 | PatchFormat2 | PatchFormat3
    deriving ( PatchFormat -> PatchFormat -> Bool
(PatchFormat -> PatchFormat -> Bool)
-> (PatchFormat -> PatchFormat -> Bool) -> Eq PatchFormat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PatchFormat -> PatchFormat -> Bool
$c/= :: PatchFormat -> PatchFormat -> Bool
== :: PatchFormat -> PatchFormat -> Bool
$c== :: PatchFormat -> PatchFormat -> Bool
Eq, Int -> PatchFormat -> ShowS
[PatchFormat] -> ShowS
PatchFormat -> String
(Int -> PatchFormat -> ShowS)
-> (PatchFormat -> String)
-> ([PatchFormat] -> ShowS)
-> Show PatchFormat
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PatchFormat] -> ShowS
$cshowList :: [PatchFormat] -> ShowS
show :: PatchFormat -> String
$cshow :: PatchFormat -> String
showsPrec :: Int -> PatchFormat -> ShowS
$cshowsPrec :: Int -> PatchFormat -> ShowS
Show )

data HooksConfig = HooksConfig
  { HooksConfig -> HookConfig
pre :: HookConfig
  , HooksConfig -> HookConfig
post :: HookConfig
  }

data HookConfig = HookConfig
  { HookConfig -> Maybe String
cmd :: Maybe String
  , HookConfig -> Bool
prompt :: Bool
  }