{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeFamilies #-}

-- |
-- Module      : GitLab.SystemHooks.Types
-- Description : Haskell records corresponding to JSON data from GitLab system hook events
-- Copyright   : (c) Rob Stewart, Heriot-Watt University, 2020
-- License     : BSD3
-- Maintainer  : robstewart57@gmail.com
-- Stability   : stable
module GitLab.SystemHooks.Types
  ( Rule (..),
    SystemHook (..),
    ProjectCreate (..),
    ProjectDestroy (..),
    ProjectRename (..),
    ProjectTransfer (..),
    ProjectUpdate (..),
    ProjectChanges (..),
    UserAddToTeam (..),
    UserUpdateForTeam (..),
    UserRemoveFromTeam (..),
    UserCreate (..),
    UserRemove (..),
    UserFailedLogin (..),
    UserRename (..),
    KeyCreate (..),
    KeyRemove (..),
    GroupCreate (..),
    GroupRemove (..),
    GroupRename (..),
    NewGroupMember (..),
    GroupMemberRemove (..),
    GroupMemberUpdate (..),
    Push (..),
    TagPush (..),
    ProjectEvent (..),
    RepositoryEvent (..),
    RepositoryUpdate (..),
    CommitEvent (..),
    CommitAuthorEvent (..),
    Visibility (..),
    MergeRequestEvent (..),
    Label (..),
    MergeRequestChanges (..),
    MergeRequestChange (..),
    MergeRequestObjectAttributes (..),
    MergeParams (..),
    UserEvent (..),
    BuildEvent (..),
    BuildCommit (..),
    BuildProject (..),
    PipelineEvent (..),
    PipelineObjectAttributes (..),
    PipelineBuild (..),
    IssueEvent (..),
    IssueEventObjectAttributes (..),
    IssueEventChanges (..),
    IssueChangesAuthorId (..),
    IssueChangesCreatedAt (..),
    IssueChangesDescription (..),
    IssueChangesId (..),
    IssueChangesIid (..),
    IssueChangesProjectId (..),
    IssueChangesTitle (..),
    IssueChangesClosedAt (..),
    IssueChangesStateId (..),
    IssueChangesUpdatedAt (..),
    Runner (..),
    ArtifactsFile (..),
    NoteEvent (..),
    NoteObjectAttributes (..),
    WikiPageEvent (..),
    Wiki (..),
    WikiPageObjectAttributes (..),
    WorkItemEvent (..),
    WorkItemObjectAttributes (..),
    parseEvent,
  )
where

import Data.Aeson
import Data.Text (Text)
import qualified Data.Text.Encoding as T
import Data.Typeable
import GHC.Generics
import GitLab.Types

-- | Pattern matching rules on GitLab hook events.
data Rule where
  Match :: (Typeable a, SystemHook a) => String -> (a -> GitLab ()) -> Rule
  MatchIf :: (Typeable a, SystemHook a) => String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule

-- | A typeclass for GitLab hook events.
class (FromJSON a) => SystemHook a where
  match :: String -> (a -> GitLab ()) -> Rule
  matchIf :: String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule

-- | Parse JSON data into GitLab events.
parseEvent :: (FromJSON a) => Text -> Maybe a
parseEvent :: forall a. FromJSON a => Text -> Maybe a
parseEvent Text
eventText =
  case ByteString -> Either String a
forall a. FromJSON a => ByteString -> Either String a
eitherDecodeStrict (Text -> ByteString
T.encodeUtf8 Text
eventText) of
    Left String
_error -> Maybe a
forall a. Maybe a
Nothing
    Right a
event -> a -> Maybe a
forall a. a -> Maybe a
Just a
event

instance SystemHook ProjectCreate where
  match :: String -> (ProjectCreate -> GitLab ()) -> Rule
match = String -> (ProjectCreate -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (ProjectCreate -> GitLab Bool)
-> (ProjectCreate -> GitLab ())
-> Rule
matchIf = String
-> (ProjectCreate -> GitLab Bool)
-> (ProjectCreate -> GitLab ())
-> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | GitLab project creation.
data ProjectCreate = ProjectCreate
  { ProjectCreate -> Text
projectCreate_created_at :: Text,
    ProjectCreate -> Text
projectCreate_updated_at :: Text,
    ProjectCreate -> Text
projectCreate_action :: Text,
    ProjectCreate -> Text
projectCreate_name :: Text,
    ProjectCreate -> Text
projectCreate_owner_email :: Text,
    ProjectCreate -> Text
projectCreate_owner_name :: Text,
    ProjectCreate -> Text
projectCreate_path :: Text,
    ProjectCreate -> Text
projectCreate_path_with_namespace :: Text,
    ProjectCreate -> Int
projectCreate_project_id :: Int,
    ProjectCreate -> Visibility
projectCreate_project_visibility :: Visibility
  }
  deriving (Typeable, Int -> ProjectCreate -> ShowS
[ProjectCreate] -> ShowS
ProjectCreate -> String
(Int -> ProjectCreate -> ShowS)
-> (ProjectCreate -> String)
-> ([ProjectCreate] -> ShowS)
-> Show ProjectCreate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProjectCreate -> ShowS
showsPrec :: Int -> ProjectCreate -> ShowS
$cshow :: ProjectCreate -> String
show :: ProjectCreate -> String
$cshowList :: [ProjectCreate] -> ShowS
showList :: [ProjectCreate] -> ShowS
Show, ProjectCreate -> ProjectCreate -> Bool
(ProjectCreate -> ProjectCreate -> Bool)
-> (ProjectCreate -> ProjectCreate -> Bool) -> Eq ProjectCreate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProjectCreate -> ProjectCreate -> Bool
== :: ProjectCreate -> ProjectCreate -> Bool
$c/= :: ProjectCreate -> ProjectCreate -> Bool
/= :: ProjectCreate -> ProjectCreate -> Bool
Eq)

instance SystemHook ProjectDestroy where
  match :: String -> (ProjectDestroy -> GitLab ()) -> Rule
match = String -> (ProjectDestroy -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (ProjectDestroy -> GitLab Bool)
-> (ProjectDestroy -> GitLab ())
-> Rule
matchIf = String
-> (ProjectDestroy -> GitLab Bool)
-> (ProjectDestroy -> GitLab ())
-> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | Removal of a GitLab removal.
data ProjectDestroy = ProjectDestroy
  { ProjectDestroy -> Text
projectDestroy_created_at :: Text,
    ProjectDestroy -> Text
projectDestroy_updated_at :: Text,
    ProjectDestroy -> Text
projectDestroy_action :: Text,
    ProjectDestroy -> Text
projectDestroy_name :: Text,
    ProjectDestroy -> Text
projectDestroy_owner_email :: Text,
    ProjectDestroy -> Text
projectDestroy_owner_name :: Text,
    ProjectDestroy -> Text
projectDestroy_path :: Text,
    ProjectDestroy -> Text
projectDestroy_path_with_namespace :: Text,
    ProjectDestroy -> Int
projectDestroy_project_id :: Int,
    ProjectDestroy -> Visibility
projectDestroy_project_visibility :: Visibility
  }
  deriving (Typeable, Int -> ProjectDestroy -> ShowS
[ProjectDestroy] -> ShowS
ProjectDestroy -> String
(Int -> ProjectDestroy -> ShowS)
-> (ProjectDestroy -> String)
-> ([ProjectDestroy] -> ShowS)
-> Show ProjectDestroy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProjectDestroy -> ShowS
showsPrec :: Int -> ProjectDestroy -> ShowS
$cshow :: ProjectDestroy -> String
show :: ProjectDestroy -> String
$cshowList :: [ProjectDestroy] -> ShowS
showList :: [ProjectDestroy] -> ShowS
Show, ProjectDestroy -> ProjectDestroy -> Bool
(ProjectDestroy -> ProjectDestroy -> Bool)
-> (ProjectDestroy -> ProjectDestroy -> Bool) -> Eq ProjectDestroy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProjectDestroy -> ProjectDestroy -> Bool
== :: ProjectDestroy -> ProjectDestroy -> Bool
$c/= :: ProjectDestroy -> ProjectDestroy -> Bool
/= :: ProjectDestroy -> ProjectDestroy -> Bool
Eq)

instance SystemHook ProjectRename where
  match :: String -> (ProjectRename -> GitLab ()) -> Rule
match = String -> (ProjectRename -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (ProjectRename -> GitLab Bool)
-> (ProjectRename -> GitLab ())
-> Rule
matchIf = String
-> (ProjectRename -> GitLab Bool)
-> (ProjectRename -> GitLab ())
-> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | Renaming of a GitLab project.
data ProjectRename = ProjectRename
  { ProjectRename -> Text
projectRename_created_at :: Text,
    ProjectRename -> Text
projectRename_updated_at :: Text,
    ProjectRename -> Text
projectRename_event_name :: Text,
    ProjectRename -> Text
projectRename_name :: Text,
    ProjectRename -> Text
projectRename_path :: Text,
    ProjectRename -> Text
projectRename_path_with_namespace :: Text,
    ProjectRename -> Int
projectRename_project_id :: Int,
    ProjectRename -> Text
projectRename_owner_name :: Text,
    ProjectRename -> Text
projectRename_owner_email :: Text,
    ProjectRename -> Visibility
projectRename_project_visibility :: Visibility,
    ProjectRename -> Text
projectRename_old_path_with_namespace :: Text
  }
  deriving (Typeable, Int -> ProjectRename -> ShowS
[ProjectRename] -> ShowS
ProjectRename -> String
(Int -> ProjectRename -> ShowS)
-> (ProjectRename -> String)
-> ([ProjectRename] -> ShowS)
-> Show ProjectRename
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProjectRename -> ShowS
showsPrec :: Int -> ProjectRename -> ShowS
$cshow :: ProjectRename -> String
show :: ProjectRename -> String
$cshowList :: [ProjectRename] -> ShowS
showList :: [ProjectRename] -> ShowS
Show, ProjectRename -> ProjectRename -> Bool
(ProjectRename -> ProjectRename -> Bool)
-> (ProjectRename -> ProjectRename -> Bool) -> Eq ProjectRename
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProjectRename -> ProjectRename -> Bool
== :: ProjectRename -> ProjectRename -> Bool
$c/= :: ProjectRename -> ProjectRename -> Bool
/= :: ProjectRename -> ProjectRename -> Bool
Eq)

instance SystemHook ProjectTransfer where
  match :: String -> (ProjectTransfer -> GitLab ()) -> Rule
match = String -> (ProjectTransfer -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (ProjectTransfer -> GitLab Bool)
-> (ProjectTransfer -> GitLab ())
-> Rule
matchIf = String
-> (ProjectTransfer -> GitLab Bool)
-> (ProjectTransfer -> GitLab ())
-> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | A project has been transferred.
data ProjectTransfer = ProjectTransfer
  { ProjectTransfer -> Text
projectTransfer_created_at :: Text,
    ProjectTransfer -> Text
projectTransfer_updated_at :: Text,
    ProjectTransfer -> Text
projectTransfer_event_name :: Text,
    ProjectTransfer -> Text
projectTransfer_name :: Text,
    ProjectTransfer -> Text
projectTransfer_path :: Text,
    ProjectTransfer -> Text
projectTransfer_path_with_namespace :: Text,
    ProjectTransfer -> Int
projectTransfer_project_id :: Int,
    ProjectTransfer -> Text
projectTransfer_owner_name :: Text,
    ProjectTransfer -> Text
projectTransfer_owner_email :: Text,
    ProjectTransfer -> Visibility
projectTransfer_project_visibility :: Visibility,
    ProjectTransfer -> Text
projectTransfer_old_path_with_namespace :: Text
  }
  deriving (Typeable, Int -> ProjectTransfer -> ShowS
[ProjectTransfer] -> ShowS
ProjectTransfer -> String
(Int -> ProjectTransfer -> ShowS)
-> (ProjectTransfer -> String)
-> ([ProjectTransfer] -> ShowS)
-> Show ProjectTransfer
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProjectTransfer -> ShowS
showsPrec :: Int -> ProjectTransfer -> ShowS
$cshow :: ProjectTransfer -> String
show :: ProjectTransfer -> String
$cshowList :: [ProjectTransfer] -> ShowS
showList :: [ProjectTransfer] -> ShowS
Show, ProjectTransfer -> ProjectTransfer -> Bool
(ProjectTransfer -> ProjectTransfer -> Bool)
-> (ProjectTransfer -> ProjectTransfer -> Bool)
-> Eq ProjectTransfer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProjectTransfer -> ProjectTransfer -> Bool
== :: ProjectTransfer -> ProjectTransfer -> Bool
$c/= :: ProjectTransfer -> ProjectTransfer -> Bool
/= :: ProjectTransfer -> ProjectTransfer -> Bool
Eq)

instance SystemHook ProjectUpdate where
  match :: String -> (ProjectUpdate -> GitLab ()) -> Rule
match = String -> (ProjectUpdate -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (ProjectUpdate -> GitLab Bool)
-> (ProjectUpdate -> GitLab ())
-> Rule
matchIf = String
-> (ProjectUpdate -> GitLab Bool)
-> (ProjectUpdate -> GitLab ())
-> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | A project has been updated.
data ProjectUpdate = ProjectUpdate
  { ProjectUpdate -> Text
projectUpdate_created_at :: Text,
    ProjectUpdate -> Text
projectUpdate_updated_at :: Text,
    ProjectUpdate -> Text
projectUpdate_event_name :: Text,
    ProjectUpdate -> Text
projectUpdate_name :: Text,
    ProjectUpdate -> Text
projectUpdate_owner_email :: Text,
    ProjectUpdate -> Text
projectUpdate_owner_name :: Text,
    ProjectUpdate -> Text
projectUpdate_path :: Text,
    ProjectUpdate -> Text
projectUpdate_path_with_namespace :: Text,
    ProjectUpdate -> Int
projectUpdate_project_id :: Int,
    ProjectUpdate -> Visibility
projectUpdate_project_visibility :: Visibility
  }
  deriving (Typeable, Int -> ProjectUpdate -> ShowS
[ProjectUpdate] -> ShowS
ProjectUpdate -> String
(Int -> ProjectUpdate -> ShowS)
-> (ProjectUpdate -> String)
-> ([ProjectUpdate] -> ShowS)
-> Show ProjectUpdate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProjectUpdate -> ShowS
showsPrec :: Int -> ProjectUpdate -> ShowS
$cshow :: ProjectUpdate -> String
show :: ProjectUpdate -> String
$cshowList :: [ProjectUpdate] -> ShowS
showList :: [ProjectUpdate] -> ShowS
Show, ProjectUpdate -> ProjectUpdate -> Bool
(ProjectUpdate -> ProjectUpdate -> Bool)
-> (ProjectUpdate -> ProjectUpdate -> Bool) -> Eq ProjectUpdate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProjectUpdate -> ProjectUpdate -> Bool
== :: ProjectUpdate -> ProjectUpdate -> Bool
$c/= :: ProjectUpdate -> ProjectUpdate -> Bool
/= :: ProjectUpdate -> ProjectUpdate -> Bool
Eq)

instance SystemHook UserAddToTeam where
  match :: String -> (UserAddToTeam -> GitLab ()) -> Rule
match = String -> (UserAddToTeam -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (UserAddToTeam -> GitLab Bool)
-> (UserAddToTeam -> GitLab ())
-> Rule
matchIf = String
-> (UserAddToTeam -> GitLab Bool)
-> (UserAddToTeam -> GitLab ())
-> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | A user has been added to a team.
data UserAddToTeam = UserAddToTeam
  { UserAddToTeam -> Text
userAddTeam_created_at :: Text, -- todo improve: date
    UserAddToTeam -> Text
userAddTeam_updated_at :: Text, -- todo improve: date
    UserAddToTeam -> Text
userAddTeam_event_name :: Text,
    UserAddToTeam -> Text
userAddTeam_access_level :: Text, -- todo improve: Maintainer/...
    UserAddToTeam -> Int
userAddTeam_project_id :: Int,
    UserAddToTeam -> Text
userAddTeam_project_name :: Text,
    UserAddToTeam -> Text
userAddTeam_project_path :: Text,
    UserAddToTeam -> Text
userAddTeam_project_path_with_namespace :: Text,
    UserAddToTeam -> Text
userAddTeam_user_email :: Text,
    UserAddToTeam -> Text
userAddTeam_user_name :: Text,
    UserAddToTeam -> Text
userAddTeam_user_username :: Text,
    UserAddToTeam -> Int
userAddTeam_user_id :: Int,
    UserAddToTeam -> Visibility
userAddTeam_project_visibility :: Visibility
  }
  deriving (Typeable, Int -> UserAddToTeam -> ShowS
[UserAddToTeam] -> ShowS
UserAddToTeam -> String
(Int -> UserAddToTeam -> ShowS)
-> (UserAddToTeam -> String)
-> ([UserAddToTeam] -> ShowS)
-> Show UserAddToTeam
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UserAddToTeam -> ShowS
showsPrec :: Int -> UserAddToTeam -> ShowS
$cshow :: UserAddToTeam -> String
show :: UserAddToTeam -> String
$cshowList :: [UserAddToTeam] -> ShowS
showList :: [UserAddToTeam] -> ShowS
Show, UserAddToTeam -> UserAddToTeam -> Bool
(UserAddToTeam -> UserAddToTeam -> Bool)
-> (UserAddToTeam -> UserAddToTeam -> Bool) -> Eq UserAddToTeam
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UserAddToTeam -> UserAddToTeam -> Bool
== :: UserAddToTeam -> UserAddToTeam -> Bool
$c/= :: UserAddToTeam -> UserAddToTeam -> Bool
/= :: UserAddToTeam -> UserAddToTeam -> Bool
Eq)

instance SystemHook UserUpdateForTeam where
  match :: String -> (UserUpdateForTeam -> GitLab ()) -> Rule
match = String -> (UserUpdateForTeam -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (UserUpdateForTeam -> GitLab Bool)
-> (UserUpdateForTeam -> GitLab ())
-> Rule
matchIf = String
-> (UserUpdateForTeam -> GitLab Bool)
-> (UserUpdateForTeam -> GitLab ())
-> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | A user in a team has been updated.
data UserUpdateForTeam = UserUpdateForTeam
  { UserUpdateForTeam -> Text
userUpdateTeam_created_at :: Text, -- todo improve: date
    UserUpdateForTeam -> Text
userUpdateTeam_updated_at :: Text, -- todo improve: date
    UserUpdateForTeam -> Text
userUpdateTeam_event_name :: Text,
    UserUpdateForTeam -> Text
userUpdateTeam_access_level :: Text, -- todo improve: Maintainer/...
    UserUpdateForTeam -> Int
userUpdateTeam_project_id :: Int,
    UserUpdateForTeam -> Text
userUpdateTeam_project_name :: Text,
    UserUpdateForTeam -> Text
userUpdateTeam_project_path :: Text,
    UserUpdateForTeam -> Text
userUpdateTeam_project_path_with_namespace :: Text,
    UserUpdateForTeam -> Text
userUpdateTeam_user_email :: Text,
    UserUpdateForTeam -> Text
userUpdateTeam_user_name :: Text,
    UserUpdateForTeam -> Text
userUpdateTeam_user_username :: Text,
    UserUpdateForTeam -> Int
userUpdateTeam_user_id :: Int,
    UserUpdateForTeam -> Visibility
userUpdateTeam_project_visibility :: Visibility
  }
  deriving (Typeable, Int -> UserUpdateForTeam -> ShowS
[UserUpdateForTeam] -> ShowS
UserUpdateForTeam -> String
(Int -> UserUpdateForTeam -> ShowS)
-> (UserUpdateForTeam -> String)
-> ([UserUpdateForTeam] -> ShowS)
-> Show UserUpdateForTeam
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UserUpdateForTeam -> ShowS
showsPrec :: Int -> UserUpdateForTeam -> ShowS
$cshow :: UserUpdateForTeam -> String
show :: UserUpdateForTeam -> String
$cshowList :: [UserUpdateForTeam] -> ShowS
showList :: [UserUpdateForTeam] -> ShowS
Show, UserUpdateForTeam -> UserUpdateForTeam -> Bool
(UserUpdateForTeam -> UserUpdateForTeam -> Bool)
-> (UserUpdateForTeam -> UserUpdateForTeam -> Bool)
-> Eq UserUpdateForTeam
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UserUpdateForTeam -> UserUpdateForTeam -> Bool
== :: UserUpdateForTeam -> UserUpdateForTeam -> Bool
$c/= :: UserUpdateForTeam -> UserUpdateForTeam -> Bool
/= :: UserUpdateForTeam -> UserUpdateForTeam -> Bool
Eq)

instance SystemHook UserRemoveFromTeam where
  match :: String -> (UserRemoveFromTeam -> GitLab ()) -> Rule
match = String -> (UserRemoveFromTeam -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (UserRemoveFromTeam -> GitLab Bool)
-> (UserRemoveFromTeam -> GitLab ())
-> Rule
matchIf = String
-> (UserRemoveFromTeam -> GitLab Bool)
-> (UserRemoveFromTeam -> GitLab ())
-> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | A user has been removed from a team.
data UserRemoveFromTeam = UserRemoveFromTeam
  { UserRemoveFromTeam -> Text
userRemoveTeam_created_at :: Text, -- todo improve: date
    UserRemoveFromTeam -> Text
userRemoveTeam_updated_at :: Text, -- todo improve: date
    UserRemoveFromTeam -> Text
userRemoveTeam_event_name :: Text,
    UserRemoveFromTeam -> Text
userRemoveTeam_access_level :: Text, -- todo improve: Maintainer/...
    UserRemoveFromTeam -> Int
userRemoveTeam_project_id :: Int,
    UserRemoveFromTeam -> Text
userRemoveTeam_project_name :: Text,
    UserRemoveFromTeam -> Text
userRemoveTeam_project_path :: Text,
    UserRemoveFromTeam -> Text
userRemoveTeam_project_path_with_namespace :: Text,
    UserRemoveFromTeam -> Text
userRemoveTeam_user_email :: Text,
    UserRemoveFromTeam -> Text
userRemoveTeam_user_name :: Text,
    UserRemoveFromTeam -> Text
userRemoveTeam_user_username :: Text,
    UserRemoveFromTeam -> Int
userRemoveTeam_user_id :: Int,
    UserRemoveFromTeam -> Visibility
userRemoveTeam_project_visibility :: Visibility
  }
  deriving (Typeable, Int -> UserRemoveFromTeam -> ShowS
[UserRemoveFromTeam] -> ShowS
UserRemoveFromTeam -> String
(Int -> UserRemoveFromTeam -> ShowS)
-> (UserRemoveFromTeam -> String)
-> ([UserRemoveFromTeam] -> ShowS)
-> Show UserRemoveFromTeam
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UserRemoveFromTeam -> ShowS
showsPrec :: Int -> UserRemoveFromTeam -> ShowS
$cshow :: UserRemoveFromTeam -> String
show :: UserRemoveFromTeam -> String
$cshowList :: [UserRemoveFromTeam] -> ShowS
showList :: [UserRemoveFromTeam] -> ShowS
Show, UserRemoveFromTeam -> UserRemoveFromTeam -> Bool
(UserRemoveFromTeam -> UserRemoveFromTeam -> Bool)
-> (UserRemoveFromTeam -> UserRemoveFromTeam -> Bool)
-> Eq UserRemoveFromTeam
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UserRemoveFromTeam -> UserRemoveFromTeam -> Bool
== :: UserRemoveFromTeam -> UserRemoveFromTeam -> Bool
$c/= :: UserRemoveFromTeam -> UserRemoveFromTeam -> Bool
/= :: UserRemoveFromTeam -> UserRemoveFromTeam -> Bool
Eq)

instance SystemHook UserCreate where
  match :: String -> (UserCreate -> GitLab ()) -> Rule
match = String -> (UserCreate -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (UserCreate -> GitLab Bool) -> (UserCreate -> GitLab ()) -> Rule
matchIf = String
-> (UserCreate -> GitLab Bool) -> (UserCreate -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | A user has been created.
data UserCreate = UserCreate
  { UserCreate -> Text
userCreate_created_at :: Text, -- todo improve: date
    UserCreate -> Text
userCreate_updated_at :: Text, -- todo improve: date
    UserCreate -> Text
userCreate_email :: Text,
    UserCreate -> Text
userCreate_event_name :: Text,
    UserCreate -> Text
userCreate_name :: Text,
    UserCreate -> Text
userCreate_username :: Text,
    UserCreate -> Int
userCreate_user_id :: Int
  }
  deriving (Typeable, Int -> UserCreate -> ShowS
[UserCreate] -> ShowS
UserCreate -> String
(Int -> UserCreate -> ShowS)
-> (UserCreate -> String)
-> ([UserCreate] -> ShowS)
-> Show UserCreate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UserCreate -> ShowS
showsPrec :: Int -> UserCreate -> ShowS
$cshow :: UserCreate -> String
show :: UserCreate -> String
$cshowList :: [UserCreate] -> ShowS
showList :: [UserCreate] -> ShowS
Show, UserCreate -> UserCreate -> Bool
(UserCreate -> UserCreate -> Bool)
-> (UserCreate -> UserCreate -> Bool) -> Eq UserCreate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UserCreate -> UserCreate -> Bool
== :: UserCreate -> UserCreate -> Bool
$c/= :: UserCreate -> UserCreate -> Bool
/= :: UserCreate -> UserCreate -> Bool
Eq)

instance SystemHook UserRemove where
  match :: String -> (UserRemove -> GitLab ()) -> Rule
match = String -> (UserRemove -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (UserRemove -> GitLab Bool) -> (UserRemove -> GitLab ()) -> Rule
matchIf = String
-> (UserRemove -> GitLab Bool) -> (UserRemove -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | A user has been removed.
data UserRemove = UserRemove
  { UserRemove -> Text
userRemove_created_at :: Text, -- todo improve: date
    UserRemove -> Text
userRemove_updated_at :: Text, -- todo improve: date
    UserRemove -> Text
userRemove_email :: Text,
    UserRemove -> Text
userRemove_event_name :: Text,
    UserRemove -> Text
userRemove_name :: Text,
    UserRemove -> Text
userRemove_username :: Text,
    UserRemove -> Int
userRemove_user_id :: Int
  }
  deriving (Typeable, Int -> UserRemove -> ShowS
[UserRemove] -> ShowS
UserRemove -> String
(Int -> UserRemove -> ShowS)
-> (UserRemove -> String)
-> ([UserRemove] -> ShowS)
-> Show UserRemove
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UserRemove -> ShowS
showsPrec :: Int -> UserRemove -> ShowS
$cshow :: UserRemove -> String
show :: UserRemove -> String
$cshowList :: [UserRemove] -> ShowS
showList :: [UserRemove] -> ShowS
Show, UserRemove -> UserRemove -> Bool
(UserRemove -> UserRemove -> Bool)
-> (UserRemove -> UserRemove -> Bool) -> Eq UserRemove
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UserRemove -> UserRemove -> Bool
== :: UserRemove -> UserRemove -> Bool
$c/= :: UserRemove -> UserRemove -> Bool
/= :: UserRemove -> UserRemove -> Bool
Eq)

instance SystemHook UserFailedLogin where
  match :: String -> (UserFailedLogin -> GitLab ()) -> Rule
match = String -> (UserFailedLogin -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (UserFailedLogin -> GitLab Bool)
-> (UserFailedLogin -> GitLab ())
-> Rule
matchIf = String
-> (UserFailedLogin -> GitLab Bool)
-> (UserFailedLogin -> GitLab ())
-> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | A user has failed to log in.
data UserFailedLogin = UserFailedLogin
  { UserFailedLogin -> Text
userFailedLogin_event_name :: Text,
    UserFailedLogin -> Text
userFailedLogin_created_at :: Text, -- todo improve: date
    UserFailedLogin -> Text
userFailedLogin_updated_at :: Text, -- todo improve: date
    UserFailedLogin -> Text
userFailedLogin_name :: Text,
    UserFailedLogin -> Text
userFailedLogin_email :: Text,
    UserFailedLogin -> Int
userFailedLogin_user_id :: Int,
    UserFailedLogin -> Text
userFailedLogin_username :: Text,
    -- create Haskell sum type for this
    UserFailedLogin -> Text
userFailedLogin_state :: Text
  }
  deriving (Typeable, Int -> UserFailedLogin -> ShowS
[UserFailedLogin] -> ShowS
UserFailedLogin -> String
(Int -> UserFailedLogin -> ShowS)
-> (UserFailedLogin -> String)
-> ([UserFailedLogin] -> ShowS)
-> Show UserFailedLogin
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UserFailedLogin -> ShowS
showsPrec :: Int -> UserFailedLogin -> ShowS
$cshow :: UserFailedLogin -> String
show :: UserFailedLogin -> String
$cshowList :: [UserFailedLogin] -> ShowS
showList :: [UserFailedLogin] -> ShowS
Show, UserFailedLogin -> UserFailedLogin -> Bool
(UserFailedLogin -> UserFailedLogin -> Bool)
-> (UserFailedLogin -> UserFailedLogin -> Bool)
-> Eq UserFailedLogin
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UserFailedLogin -> UserFailedLogin -> Bool
== :: UserFailedLogin -> UserFailedLogin -> Bool
$c/= :: UserFailedLogin -> UserFailedLogin -> Bool
/= :: UserFailedLogin -> UserFailedLogin -> Bool
Eq)

instance SystemHook UserRename where
  match :: String -> (UserRename -> GitLab ()) -> Rule
match = String -> (UserRename -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (UserRename -> GitLab Bool) -> (UserRename -> GitLab ()) -> Rule
matchIf = String
-> (UserRename -> GitLab Bool) -> (UserRename -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | A user has been renamed.
data UserRename = UserRename
  { UserRename -> Text
userRename_event_name :: Text,
    UserRename -> Text
userRename_created_at :: Text, -- todo improve: date
    UserRename -> Text
userRename_updated_at :: Text, -- todo improve: date
    UserRename -> Text
userRename_name :: Text,
    UserRename -> Text
userRename_email :: Text,
    UserRename -> Int
userRename_user_id :: Int,
    UserRename -> Text
userRename_username :: Text,
    UserRename -> Text
userRename_old_username :: Text
  }
  deriving (Typeable, Int -> UserRename -> ShowS
[UserRename] -> ShowS
UserRename -> String
(Int -> UserRename -> ShowS)
-> (UserRename -> String)
-> ([UserRename] -> ShowS)
-> Show UserRename
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UserRename -> ShowS
showsPrec :: Int -> UserRename -> ShowS
$cshow :: UserRename -> String
show :: UserRename -> String
$cshowList :: [UserRename] -> ShowS
showList :: [UserRename] -> ShowS
Show, UserRename -> UserRename -> Bool
(UserRename -> UserRename -> Bool)
-> (UserRename -> UserRename -> Bool) -> Eq UserRename
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UserRename -> UserRename -> Bool
== :: UserRename -> UserRename -> Bool
$c/= :: UserRename -> UserRename -> Bool
/= :: UserRename -> UserRename -> Bool
Eq)

instance SystemHook KeyCreate where
  match :: String -> (KeyCreate -> GitLab ()) -> Rule
match = String -> (KeyCreate -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (KeyCreate -> GitLab Bool) -> (KeyCreate -> GitLab ()) -> Rule
matchIf = String
-> (KeyCreate -> GitLab Bool) -> (KeyCreate -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | A key has been created.
data KeyCreate = KeyCreate
  { KeyCreate -> Text
keyCreate_event_name :: Text,
    KeyCreate -> Text
keyCreate_created_at :: Text, -- todo improve: date
    KeyCreate -> Text
keyCreate_updated_at :: Text, -- todo improve: date
    KeyCreate -> Text
keyCreate_username :: Text,
    KeyCreate -> Text
keyCreate_key :: Text,
    KeyCreate -> Int
keyCreate_id :: Int
  }
  deriving (Typeable, Int -> KeyCreate -> ShowS
[KeyCreate] -> ShowS
KeyCreate -> String
(Int -> KeyCreate -> ShowS)
-> (KeyCreate -> String)
-> ([KeyCreate] -> ShowS)
-> Show KeyCreate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyCreate -> ShowS
showsPrec :: Int -> KeyCreate -> ShowS
$cshow :: KeyCreate -> String
show :: KeyCreate -> String
$cshowList :: [KeyCreate] -> ShowS
showList :: [KeyCreate] -> ShowS
Show, KeyCreate -> KeyCreate -> Bool
(KeyCreate -> KeyCreate -> Bool)
-> (KeyCreate -> KeyCreate -> Bool) -> Eq KeyCreate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeyCreate -> KeyCreate -> Bool
== :: KeyCreate -> KeyCreate -> Bool
$c/= :: KeyCreate -> KeyCreate -> Bool
/= :: KeyCreate -> KeyCreate -> Bool
Eq)

instance SystemHook KeyRemove where
  match :: String -> (KeyRemove -> GitLab ()) -> Rule
match = String -> (KeyRemove -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (KeyRemove -> GitLab Bool) -> (KeyRemove -> GitLab ()) -> Rule
matchIf = String
-> (KeyRemove -> GitLab Bool) -> (KeyRemove -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | A key has been removed.
data KeyRemove = KeyRemove
  { KeyRemove -> Text
keyRemove_event_name :: Text,
    KeyRemove -> Text
keyRemove_created_at :: Text, -- todo improve: date
    KeyRemove -> Text
keyRemove_updated_at :: Text, -- todo improve: date
    KeyRemove -> Text
keyRemove_username :: Text,
    KeyRemove -> Text
keyRemove_key :: Text,
    KeyRemove -> Int
keyRemove_id :: Int
  }
  deriving (Typeable, Int -> KeyRemove -> ShowS
[KeyRemove] -> ShowS
KeyRemove -> String
(Int -> KeyRemove -> ShowS)
-> (KeyRemove -> String)
-> ([KeyRemove] -> ShowS)
-> Show KeyRemove
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyRemove -> ShowS
showsPrec :: Int -> KeyRemove -> ShowS
$cshow :: KeyRemove -> String
show :: KeyRemove -> String
$cshowList :: [KeyRemove] -> ShowS
showList :: [KeyRemove] -> ShowS
Show, KeyRemove -> KeyRemove -> Bool
(KeyRemove -> KeyRemove -> Bool)
-> (KeyRemove -> KeyRemove -> Bool) -> Eq KeyRemove
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeyRemove -> KeyRemove -> Bool
== :: KeyRemove -> KeyRemove -> Bool
$c/= :: KeyRemove -> KeyRemove -> Bool
/= :: KeyRemove -> KeyRemove -> Bool
Eq)

instance SystemHook GroupCreate where
  match :: String -> (GroupCreate -> GitLab ()) -> Rule
match = String -> (GroupCreate -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (GroupCreate -> GitLab Bool)
-> (GroupCreate -> GitLab ())
-> Rule
matchIf = String
-> (GroupCreate -> GitLab Bool)
-> (GroupCreate -> GitLab ())
-> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | A group has been created.
data GroupCreate = GroupCreate
  { GroupCreate -> Text
groupCreate_created_at :: Text, -- todo improve: date
    GroupCreate -> Text
groupCreate_updated_at :: Text, -- todo improve: date
    GroupCreate -> Text
groupCreate_event_name :: Text,
    GroupCreate -> Text
groupCreate_name :: Text,
    GroupCreate -> Maybe Text
groupCreate_owner_email :: Maybe Text,
    GroupCreate -> Maybe Text
groupCreate_owner_name :: Maybe Text,
    GroupCreate -> Text
groupCreate_path :: Text,
    GroupCreate -> Int
groupCreate_group_id :: Int
  }
  deriving (Typeable, Int -> GroupCreate -> ShowS
[GroupCreate] -> ShowS
GroupCreate -> String
(Int -> GroupCreate -> ShowS)
-> (GroupCreate -> String)
-> ([GroupCreate] -> ShowS)
-> Show GroupCreate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GroupCreate -> ShowS
showsPrec :: Int -> GroupCreate -> ShowS
$cshow :: GroupCreate -> String
show :: GroupCreate -> String
$cshowList :: [GroupCreate] -> ShowS
showList :: [GroupCreate] -> ShowS
Show, GroupCreate -> GroupCreate -> Bool
(GroupCreate -> GroupCreate -> Bool)
-> (GroupCreate -> GroupCreate -> Bool) -> Eq GroupCreate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GroupCreate -> GroupCreate -> Bool
== :: GroupCreate -> GroupCreate -> Bool
$c/= :: GroupCreate -> GroupCreate -> Bool
/= :: GroupCreate -> GroupCreate -> Bool
Eq)

instance SystemHook GroupRemove where
  match :: String -> (GroupRemove -> GitLab ()) -> Rule
match = String -> (GroupRemove -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (GroupRemove -> GitLab Bool)
-> (GroupRemove -> GitLab ())
-> Rule
matchIf = String
-> (GroupRemove -> GitLab Bool)
-> (GroupRemove -> GitLab ())
-> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | A group has been removed.
data GroupRemove = GroupRemove
  { GroupRemove -> Text
groupRemove_created_at :: Text, -- todo improve: date
    GroupRemove -> Text
groupRemove_updated_at :: Text, -- todo improve: date
    GroupRemove -> Text
groupRemove_event_name :: Text,
    GroupRemove -> Text
groupRemove_name :: Text,
    GroupRemove -> Maybe Text
groupRemove_owner_email :: Maybe Text,
    GroupRemove -> Maybe Text
groupRemove_owner_name :: Maybe Text,
    GroupRemove -> Text
groupRemove_path :: Text,
    GroupRemove -> Int
groupRemove_group_id :: Int
  }
  deriving (Typeable, Int -> GroupRemove -> ShowS
[GroupRemove] -> ShowS
GroupRemove -> String
(Int -> GroupRemove -> ShowS)
-> (GroupRemove -> String)
-> ([GroupRemove] -> ShowS)
-> Show GroupRemove
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GroupRemove -> ShowS
showsPrec :: Int -> GroupRemove -> ShowS
$cshow :: GroupRemove -> String
show :: GroupRemove -> String
$cshowList :: [GroupRemove] -> ShowS
showList :: [GroupRemove] -> ShowS
Show, GroupRemove -> GroupRemove -> Bool
(GroupRemove -> GroupRemove -> Bool)
-> (GroupRemove -> GroupRemove -> Bool) -> Eq GroupRemove
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GroupRemove -> GroupRemove -> Bool
== :: GroupRemove -> GroupRemove -> Bool
$c/= :: GroupRemove -> GroupRemove -> Bool
/= :: GroupRemove -> GroupRemove -> Bool
Eq)

instance SystemHook GroupRename where
  match :: String -> (GroupRename -> GitLab ()) -> Rule
match = String -> (GroupRename -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (GroupRename -> GitLab Bool)
-> (GroupRename -> GitLab ())
-> Rule
matchIf = String
-> (GroupRename -> GitLab Bool)
-> (GroupRename -> GitLab ())
-> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | A group has been renamed.
data GroupRename = GroupRename
  { GroupRename -> Text
groupRename_event_name :: Text,
    GroupRename -> Text
groupRename_created_at :: Text, -- todo improve: date
    GroupRename -> Text
groupRename_updated_at :: Text, -- todo improve: date
    GroupRename -> Text
groupRename_name :: Text,
    GroupRename -> Text
groupRename_path :: Text,
    GroupRename -> Text
groupRename_full_path :: Text,
    GroupRename -> Int
groupRename_group_id :: Int,
    GroupRename -> Maybe Text
groupRename_owner_name :: Maybe Text,
    GroupRename -> Maybe Text
groupRename_owner_email :: Maybe Text,
    GroupRename -> Text
groupRename_old_path :: Text,
    GroupRename -> Text
groupRename_old_full_path :: Text
  }
  deriving (Typeable, Int -> GroupRename -> ShowS
[GroupRename] -> ShowS
GroupRename -> String
(Int -> GroupRename -> ShowS)
-> (GroupRename -> String)
-> ([GroupRename] -> ShowS)
-> Show GroupRename
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GroupRename -> ShowS
showsPrec :: Int -> GroupRename -> ShowS
$cshow :: GroupRename -> String
show :: GroupRename -> String
$cshowList :: [GroupRename] -> ShowS
showList :: [GroupRename] -> ShowS
Show, GroupRename -> GroupRename -> Bool
(GroupRename -> GroupRename -> Bool)
-> (GroupRename -> GroupRename -> Bool) -> Eq GroupRename
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GroupRename -> GroupRename -> Bool
== :: GroupRename -> GroupRename -> Bool
$c/= :: GroupRename -> GroupRename -> Bool
/= :: GroupRename -> GroupRename -> Bool
Eq)

instance SystemHook NewGroupMember where
  match :: String -> (NewGroupMember -> GitLab ()) -> Rule
match = String -> (NewGroupMember -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (NewGroupMember -> GitLab Bool)
-> (NewGroupMember -> GitLab ())
-> Rule
matchIf = String
-> (NewGroupMember -> GitLab Bool)
-> (NewGroupMember -> GitLab ())
-> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | A user has been added to a group.
data NewGroupMember = NewGroupMember
  { NewGroupMember -> Text
newGroupMember_created_at :: Text, -- todo improve: date
    NewGroupMember -> Text
newGroupMember_updated_at :: Text, -- todo improve: date
    NewGroupMember -> Text
newGroupMember_event_name :: Text,
    NewGroupMember -> Text
newGroupMember_group_access :: Text, -- todo Haskell type for this
    NewGroupMember -> Int
newGroupMember_group_id :: Int,
    NewGroupMember -> Text
newGroupMember_group_name :: Text,
    NewGroupMember -> Text
newGroupMember_group_path :: Text,
    NewGroupMember -> Text
newGroupMember_user_email :: Text,
    NewGroupMember -> Text
newGroupMember_user_name :: Text,
    NewGroupMember -> Text
newGroupMember_user_username :: Text,
    NewGroupMember -> Int
newGroupMember_user_id :: Int
  }
  deriving (Typeable, Int -> NewGroupMember -> ShowS
[NewGroupMember] -> ShowS
NewGroupMember -> String
(Int -> NewGroupMember -> ShowS)
-> (NewGroupMember -> String)
-> ([NewGroupMember] -> ShowS)
-> Show NewGroupMember
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NewGroupMember -> ShowS
showsPrec :: Int -> NewGroupMember -> ShowS
$cshow :: NewGroupMember -> String
show :: NewGroupMember -> String
$cshowList :: [NewGroupMember] -> ShowS
showList :: [NewGroupMember] -> ShowS
Show, NewGroupMember -> NewGroupMember -> Bool
(NewGroupMember -> NewGroupMember -> Bool)
-> (NewGroupMember -> NewGroupMember -> Bool) -> Eq NewGroupMember
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NewGroupMember -> NewGroupMember -> Bool
== :: NewGroupMember -> NewGroupMember -> Bool
$c/= :: NewGroupMember -> NewGroupMember -> Bool
/= :: NewGroupMember -> NewGroupMember -> Bool
Eq)

instance SystemHook GroupMemberRemove where
  match :: String -> (GroupMemberRemove -> GitLab ()) -> Rule
match = String -> (GroupMemberRemove -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (GroupMemberRemove -> GitLab Bool)
-> (GroupMemberRemove -> GitLab ())
-> Rule
matchIf = String
-> (GroupMemberRemove -> GitLab Bool)
-> (GroupMemberRemove -> GitLab ())
-> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | A user has been removed from a group.
data GroupMemberRemove = GroupMemberRemove
  { GroupMemberRemove -> Text
groupMemberRemove_created_at :: Text, -- todo improve: date
    GroupMemberRemove -> Text
groupMemberRemove_updated_at :: Text, -- todo improve: date
    GroupMemberRemove -> Text
groupMemberRemove_event_name :: Text,
    GroupMemberRemove -> Text
groupMemberRemove_group_access :: Text, -- todo Haskell type for this
    GroupMemberRemove -> Int
groupMemberRemove_group_id :: Int,
    GroupMemberRemove -> Text
groupMemberRemove_group_name :: Text,
    GroupMemberRemove -> Text
groupMemberRemove_group_path :: Text,
    GroupMemberRemove -> Text
groupMemberRemove_user_email :: Text,
    GroupMemberRemove -> Text
groupMemberRemove_user_name :: Text,
    GroupMemberRemove -> Text
groupMemberRemove_user_username :: Text,
    GroupMemberRemove -> Int
groupMemberRemove_user_id :: Int
  }
  deriving (Typeable, Int -> GroupMemberRemove -> ShowS
[GroupMemberRemove] -> ShowS
GroupMemberRemove -> String
(Int -> GroupMemberRemove -> ShowS)
-> (GroupMemberRemove -> String)
-> ([GroupMemberRemove] -> ShowS)
-> Show GroupMemberRemove
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GroupMemberRemove -> ShowS
showsPrec :: Int -> GroupMemberRemove -> ShowS
$cshow :: GroupMemberRemove -> String
show :: GroupMemberRemove -> String
$cshowList :: [GroupMemberRemove] -> ShowS
showList :: [GroupMemberRemove] -> ShowS
Show, GroupMemberRemove -> GroupMemberRemove -> Bool
(GroupMemberRemove -> GroupMemberRemove -> Bool)
-> (GroupMemberRemove -> GroupMemberRemove -> Bool)
-> Eq GroupMemberRemove
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GroupMemberRemove -> GroupMemberRemove -> Bool
== :: GroupMemberRemove -> GroupMemberRemove -> Bool
$c/= :: GroupMemberRemove -> GroupMemberRemove -> Bool
/= :: GroupMemberRemove -> GroupMemberRemove -> Bool
Eq)

instance SystemHook GroupMemberUpdate where
  match :: String -> (GroupMemberUpdate -> GitLab ()) -> Rule
match = String -> (GroupMemberUpdate -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (GroupMemberUpdate -> GitLab Bool)
-> (GroupMemberUpdate -> GitLab ())
-> Rule
matchIf = String
-> (GroupMemberUpdate -> GitLab Bool)
-> (GroupMemberUpdate -> GitLab ())
-> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | A group member has been updated.
data GroupMemberUpdate = GroupMemberUpdate
  { GroupMemberUpdate -> Text
groupMemberUpdate_created_at :: Text, -- todo improve: date
    GroupMemberUpdate -> Text
groupMemberUpdate_updated_at :: Text, -- todo improve: date
    GroupMemberUpdate -> Text
groupMemberUpdate_event_name :: Text,
    GroupMemberUpdate -> Text
groupMemberUpdate_group_access :: Text, -- todo Haskell type for this
    GroupMemberUpdate -> Int
groupMemberUpdate_group_id :: Int,
    GroupMemberUpdate -> Text
groupMemberUpdate_group_name :: Text,
    GroupMemberUpdate -> Text
groupMemberUpdate_group_path :: Text,
    GroupMemberUpdate -> Text
groupMemberUpdate_user_email :: Text,
    GroupMemberUpdate -> Text
groupMemberUpdate_user_name :: Text,
    GroupMemberUpdate -> Text
groupMemberUpdate_user_username :: Text,
    GroupMemberUpdate -> Int
groupMemberUpdate_user_id :: Int
  }
  deriving (Typeable, Int -> GroupMemberUpdate -> ShowS
[GroupMemberUpdate] -> ShowS
GroupMemberUpdate -> String
(Int -> GroupMemberUpdate -> ShowS)
-> (GroupMemberUpdate -> String)
-> ([GroupMemberUpdate] -> ShowS)
-> Show GroupMemberUpdate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GroupMemberUpdate -> ShowS
showsPrec :: Int -> GroupMemberUpdate -> ShowS
$cshow :: GroupMemberUpdate -> String
show :: GroupMemberUpdate -> String
$cshowList :: [GroupMemberUpdate] -> ShowS
showList :: [GroupMemberUpdate] -> ShowS
Show, GroupMemberUpdate -> GroupMemberUpdate -> Bool
(GroupMemberUpdate -> GroupMemberUpdate -> Bool)
-> (GroupMemberUpdate -> GroupMemberUpdate -> Bool)
-> Eq GroupMemberUpdate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GroupMemberUpdate -> GroupMemberUpdate -> Bool
== :: GroupMemberUpdate -> GroupMemberUpdate -> Bool
$c/= :: GroupMemberUpdate -> GroupMemberUpdate -> Bool
/= :: GroupMemberUpdate -> GroupMemberUpdate -> Bool
Eq)

instance SystemHook Push where
  match :: String -> (Push -> GitLab ()) -> Rule
match = String -> (Push -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String -> (Push -> GitLab Bool) -> (Push -> GitLab ()) -> Rule
matchIf = String -> (Push -> GitLab Bool) -> (Push -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | Commits have been pushed to the server.
data Push = Push
  { Push -> Text
push_event_name :: Text,
    Push -> Text
push_before :: Text,
    Push -> Text
push_after :: Text,
    Push -> Text
push_ref :: Text,
    Push -> Maybe Text
push_checkout_sha :: Maybe Text,
    Push -> Int
push_user_id :: Int,
    Push -> Text
push_user_name :: Text,
    Push -> Maybe Text
push_user_username :: Maybe Text,
    Push -> Maybe Text
push_user_email :: Maybe Text,
    Push -> Text
push_user_avatar :: Text,
    Push -> Int
push_project_id :: Int,
    Push -> ProjectEvent
push_project :: ProjectEvent,
    Push -> RepositoryEvent
push_repository :: RepositoryEvent,
    Push -> [CommitEvent]
push_commits :: [CommitEvent],
    Push -> Int
push_total_commits_count :: Int
  }
  deriving (Typeable, Int -> Push -> ShowS
[Push] -> ShowS
Push -> String
(Int -> Push -> ShowS)
-> (Push -> String) -> ([Push] -> ShowS) -> Show Push
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Push -> ShowS
showsPrec :: Int -> Push -> ShowS
$cshow :: Push -> String
show :: Push -> String
$cshowList :: [Push] -> ShowS
showList :: [Push] -> ShowS
Show, Push -> Push -> Bool
(Push -> Push -> Bool) -> (Push -> Push -> Bool) -> Eq Push
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Push -> Push -> Bool
== :: Push -> Push -> Bool
$c/= :: Push -> Push -> Bool
/= :: Push -> Push -> Bool
Eq)

instance SystemHook TagPush where
  match :: String -> (TagPush -> GitLab ()) -> Rule
match = String -> (TagPush -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (TagPush -> GitLab Bool) -> (TagPush -> GitLab ()) -> Rule
matchIf = String
-> (TagPush -> GitLab Bool) -> (TagPush -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | Tags have been pushed to the server.
data TagPush = TagPush
  { TagPush -> Text
tagPush_event_name :: Text,
    TagPush -> Text
tagPush_before :: Text,
    TagPush -> Text
tagPush_after :: Text,
    TagPush -> Text
tagPush_ref :: Text,
    TagPush -> Text
tagPush_checkout_sha :: Text,
    TagPush -> Int
tagPush_user_id :: Int,
    TagPush -> Text
tagPush_user_name :: Text,
    TagPush -> Text
tagPush_user_avatar :: Text,
    TagPush -> Int
tagPush_project_id :: Int,
    TagPush -> ProjectEvent
tagPush_project :: ProjectEvent,
    TagPush -> RepositoryEvent
tagPush_repository :: RepositoryEvent,
    TagPush -> [CommitEvent]
tagPush_commits :: [CommitEvent],
    TagPush -> Int
tagPush_total_commits_count :: Int
  }
  deriving (Typeable, Int -> TagPush -> ShowS
[TagPush] -> ShowS
TagPush -> String
(Int -> TagPush -> ShowS)
-> (TagPush -> String) -> ([TagPush] -> ShowS) -> Show TagPush
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TagPush -> ShowS
showsPrec :: Int -> TagPush -> ShowS
$cshow :: TagPush -> String
show :: TagPush -> String
$cshowList :: [TagPush] -> ShowS
showList :: [TagPush] -> ShowS
Show, TagPush -> TagPush -> Bool
(TagPush -> TagPush -> Bool)
-> (TagPush -> TagPush -> Bool) -> Eq TagPush
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TagPush -> TagPush -> Bool
== :: TagPush -> TagPush -> Bool
$c/= :: TagPush -> TagPush -> Bool
/= :: TagPush -> TagPush -> Bool
Eq)

instance SystemHook RepositoryUpdate where
  match :: String -> (RepositoryUpdate -> GitLab ()) -> Rule
match = String -> (RepositoryUpdate -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (RepositoryUpdate -> GitLab Bool)
-> (RepositoryUpdate -> GitLab ())
-> Rule
matchIf = String
-> (RepositoryUpdate -> GitLab Bool)
-> (RepositoryUpdate -> GitLab ())
-> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | Tags have been pushed to the server.
data RepositoryUpdate = RepositoryUpdate
  { RepositoryUpdate -> Text
repositoryUpdate_event_name :: Text,
    RepositoryUpdate -> Int
repositoryUpdate_user_id :: Int,
    RepositoryUpdate -> Text
repositoryUpdate_user_name :: Text,
    RepositoryUpdate -> Text
repositoryUpdate_user_email :: Text,
    RepositoryUpdate -> Text
repositoryUpdate_user_avatar :: Text,
    RepositoryUpdate -> Int
repositoryUpdate_project_id :: Int,
    RepositoryUpdate -> ProjectEvent
repositoryUpdate_project :: ProjectEvent,
    RepositoryUpdate -> [ProjectChanges]
repositoryUpdate_changes :: [ProjectChanges],
    RepositoryUpdate -> [Text]
repositoryUpdate_refs :: [Text]
  }
  deriving (Typeable, Int -> RepositoryUpdate -> ShowS
[RepositoryUpdate] -> ShowS
RepositoryUpdate -> String
(Int -> RepositoryUpdate -> ShowS)
-> (RepositoryUpdate -> String)
-> ([RepositoryUpdate] -> ShowS)
-> Show RepositoryUpdate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RepositoryUpdate -> ShowS
showsPrec :: Int -> RepositoryUpdate -> ShowS
$cshow :: RepositoryUpdate -> String
show :: RepositoryUpdate -> String
$cshowList :: [RepositoryUpdate] -> ShowS
showList :: [RepositoryUpdate] -> ShowS
Show, RepositoryUpdate -> RepositoryUpdate -> Bool
(RepositoryUpdate -> RepositoryUpdate -> Bool)
-> (RepositoryUpdate -> RepositoryUpdate -> Bool)
-> Eq RepositoryUpdate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RepositoryUpdate -> RepositoryUpdate -> Bool
== :: RepositoryUpdate -> RepositoryUpdate -> Bool
$c/= :: RepositoryUpdate -> RepositoryUpdate -> Bool
/= :: RepositoryUpdate -> RepositoryUpdate -> Bool
Eq)

-- | A project event.
data ProjectEvent = ProjectEvent
  { ProjectEvent -> Maybe Int
projectEvent_id :: Maybe Int,
    ProjectEvent -> Text
projectEvent_name :: Text,
    ProjectEvent -> Maybe Text
projectEvent_description :: Maybe Text,
    ProjectEvent -> Text
projectEvent_web_url :: Text,
    ProjectEvent -> Maybe Text
projectEvent_avatar_url :: Maybe Text,
    ProjectEvent -> Text
projectEvent_git_ssh_url :: Text,
    ProjectEvent -> Text
projectEvent_git_http_url :: Text,
    ProjectEvent -> Text
projectEvent_namespace :: Text,
    ProjectEvent -> Visibility
projectEvent_visibility_level :: Visibility,
    ProjectEvent -> Text
projectEvent_path_with_namespace :: Text,
    ProjectEvent -> Text
projectEvent_default_branch :: Text,
    -- projectEvent_ci_config_path :: Maybe Text,
    ProjectEvent -> Maybe Text
projectEvent_homepage :: Maybe Text,
    ProjectEvent -> Text
projectEvent_url :: Text,
    ProjectEvent -> Text
projectEvent_ssh_url :: Text,
    ProjectEvent -> Text
projectEvent_http_url :: Text
  }
  deriving (Typeable, Int -> ProjectEvent -> ShowS
[ProjectEvent] -> ShowS
ProjectEvent -> String
(Int -> ProjectEvent -> ShowS)
-> (ProjectEvent -> String)
-> ([ProjectEvent] -> ShowS)
-> Show ProjectEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProjectEvent -> ShowS
showsPrec :: Int -> ProjectEvent -> ShowS
$cshow :: ProjectEvent -> String
show :: ProjectEvent -> String
$cshowList :: [ProjectEvent] -> ShowS
showList :: [ProjectEvent] -> ShowS
Show, ProjectEvent -> ProjectEvent -> Bool
(ProjectEvent -> ProjectEvent -> Bool)
-> (ProjectEvent -> ProjectEvent -> Bool) -> Eq ProjectEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProjectEvent -> ProjectEvent -> Bool
== :: ProjectEvent -> ProjectEvent -> Bool
$c/= :: ProjectEvent -> ProjectEvent -> Bool
/= :: ProjectEvent -> ProjectEvent -> Bool
Eq, (forall x. ProjectEvent -> Rep ProjectEvent x)
-> (forall x. Rep ProjectEvent x -> ProjectEvent)
-> Generic ProjectEvent
forall x. Rep ProjectEvent x -> ProjectEvent
forall x. ProjectEvent -> Rep ProjectEvent x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ProjectEvent -> Rep ProjectEvent x
from :: forall x. ProjectEvent -> Rep ProjectEvent x
$cto :: forall x. Rep ProjectEvent x -> ProjectEvent
to :: forall x. Rep ProjectEvent x -> ProjectEvent
Generic)

-- | A project event.
data ProjectChanges = ProjectChanges
  { ProjectChanges -> Text
projectChanges_before :: Text,
    ProjectChanges -> Text
projectChanges_after :: Text,
    ProjectChanges -> Text
projectChanges_ref :: Text
  }
  deriving (Typeable, Int -> ProjectChanges -> ShowS
[ProjectChanges] -> ShowS
ProjectChanges -> String
(Int -> ProjectChanges -> ShowS)
-> (ProjectChanges -> String)
-> ([ProjectChanges] -> ShowS)
-> Show ProjectChanges
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProjectChanges -> ShowS
showsPrec :: Int -> ProjectChanges -> ShowS
$cshow :: ProjectChanges -> String
show :: ProjectChanges -> String
$cshowList :: [ProjectChanges] -> ShowS
showList :: [ProjectChanges] -> ShowS
Show, ProjectChanges -> ProjectChanges -> Bool
(ProjectChanges -> ProjectChanges -> Bool)
-> (ProjectChanges -> ProjectChanges -> Bool) -> Eq ProjectChanges
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProjectChanges -> ProjectChanges -> Bool
== :: ProjectChanges -> ProjectChanges -> Bool
$c/= :: ProjectChanges -> ProjectChanges -> Bool
/= :: ProjectChanges -> ProjectChanges -> Bool
Eq, (forall x. ProjectChanges -> Rep ProjectChanges x)
-> (forall x. Rep ProjectChanges x -> ProjectChanges)
-> Generic ProjectChanges
forall x. Rep ProjectChanges x -> ProjectChanges
forall x. ProjectChanges -> Rep ProjectChanges x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ProjectChanges -> Rep ProjectChanges x
from :: forall x. ProjectChanges -> Rep ProjectChanges x
$cto :: forall x. Rep ProjectChanges x -> ProjectChanges
to :: forall x. Rep ProjectChanges x -> ProjectChanges
Generic)

-- | A repository event.
data RepositoryEvent = RepositoryEvent
  { RepositoryEvent -> Text
repositoryEvent_name :: Text,
    RepositoryEvent -> Text
repositoryEvent_url :: Text,
    RepositoryEvent -> Maybe Text
repositoryEvent_description :: Maybe Text,
    RepositoryEvent -> Maybe Text
repositoryEvent_homepage :: Maybe Text,
    -- these three not in the merge_request event example
    -- in the GitLab documentation. Is the merge_request documentation
    -- out dated?
    RepositoryEvent -> Maybe Text
repositoryEvent_git_http_url :: Maybe Text,
    RepositoryEvent -> Maybe Text
repositoryEvent_git_ssh_url :: Maybe Text,
    RepositoryEvent -> Maybe Visibility
repositoryEvent_visibility_level :: Maybe Visibility
  }
  deriving (Typeable, Int -> RepositoryEvent -> ShowS
[RepositoryEvent] -> ShowS
RepositoryEvent -> String
(Int -> RepositoryEvent -> ShowS)
-> (RepositoryEvent -> String)
-> ([RepositoryEvent] -> ShowS)
-> Show RepositoryEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RepositoryEvent -> ShowS
showsPrec :: Int -> RepositoryEvent -> ShowS
$cshow :: RepositoryEvent -> String
show :: RepositoryEvent -> String
$cshowList :: [RepositoryEvent] -> ShowS
showList :: [RepositoryEvent] -> ShowS
Show, RepositoryEvent -> RepositoryEvent -> Bool
(RepositoryEvent -> RepositoryEvent -> Bool)
-> (RepositoryEvent -> RepositoryEvent -> Bool)
-> Eq RepositoryEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RepositoryEvent -> RepositoryEvent -> Bool
== :: RepositoryEvent -> RepositoryEvent -> Bool
$c/= :: RepositoryEvent -> RepositoryEvent -> Bool
/= :: RepositoryEvent -> RepositoryEvent -> Bool
Eq, (forall x. RepositoryEvent -> Rep RepositoryEvent x)
-> (forall x. Rep RepositoryEvent x -> RepositoryEvent)
-> Generic RepositoryEvent
forall x. Rep RepositoryEvent x -> RepositoryEvent
forall x. RepositoryEvent -> Rep RepositoryEvent x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RepositoryEvent -> Rep RepositoryEvent x
from :: forall x. RepositoryEvent -> Rep RepositoryEvent x
$cto :: forall x. Rep RepositoryEvent x -> RepositoryEvent
to :: forall x. Rep RepositoryEvent x -> RepositoryEvent
Generic)

-- | A commit event.
data CommitEvent = CommitEvent
  { CommitEvent -> Text
commitEvent_id :: Text,
    CommitEvent -> Text
commitEvent_message :: Text,
    CommitEvent -> Text
commitEvent_timestamp :: Text, -- TODO improve.
    CommitEvent -> Text
commitEvent_url :: Text,
    CommitEvent -> CommitAuthorEvent
commitEvent_author :: CommitAuthorEvent
  }
  deriving (Typeable, Int -> CommitEvent -> ShowS
[CommitEvent] -> ShowS
CommitEvent -> String
(Int -> CommitEvent -> ShowS)
-> (CommitEvent -> String)
-> ([CommitEvent] -> ShowS)
-> Show CommitEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CommitEvent -> ShowS
showsPrec :: Int -> CommitEvent -> ShowS
$cshow :: CommitEvent -> String
show :: CommitEvent -> String
$cshowList :: [CommitEvent] -> ShowS
showList :: [CommitEvent] -> ShowS
Show, CommitEvent -> CommitEvent -> Bool
(CommitEvent -> CommitEvent -> Bool)
-> (CommitEvent -> CommitEvent -> Bool) -> Eq CommitEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CommitEvent -> CommitEvent -> Bool
== :: CommitEvent -> CommitEvent -> Bool
$c/= :: CommitEvent -> CommitEvent -> Bool
/= :: CommitEvent -> CommitEvent -> Bool
Eq, (forall x. CommitEvent -> Rep CommitEvent x)
-> (forall x. Rep CommitEvent x -> CommitEvent)
-> Generic CommitEvent
forall x. Rep CommitEvent x -> CommitEvent
forall x. CommitEvent -> Rep CommitEvent x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CommitEvent -> Rep CommitEvent x
from :: forall x. CommitEvent -> Rep CommitEvent x
$cto :: forall x. Rep CommitEvent x -> CommitEvent
to :: forall x. Rep CommitEvent x -> CommitEvent
Generic)

-- | Commit author information.
data CommitAuthorEvent = CommitAuthorEvent
  { CommitAuthorEvent -> Text
commitAuthorEvent_name :: Text,
    CommitAuthorEvent -> Text
commitAuthorEvent_email :: Text
  }
  deriving (Typeable, Int -> CommitAuthorEvent -> ShowS
[CommitAuthorEvent] -> ShowS
CommitAuthorEvent -> String
(Int -> CommitAuthorEvent -> ShowS)
-> (CommitAuthorEvent -> String)
-> ([CommitAuthorEvent] -> ShowS)
-> Show CommitAuthorEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CommitAuthorEvent -> ShowS
showsPrec :: Int -> CommitAuthorEvent -> ShowS
$cshow :: CommitAuthorEvent -> String
show :: CommitAuthorEvent -> String
$cshowList :: [CommitAuthorEvent] -> ShowS
showList :: [CommitAuthorEvent] -> ShowS
Show, CommitAuthorEvent -> CommitAuthorEvent -> Bool
(CommitAuthorEvent -> CommitAuthorEvent -> Bool)
-> (CommitAuthorEvent -> CommitAuthorEvent -> Bool)
-> Eq CommitAuthorEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CommitAuthorEvent -> CommitAuthorEvent -> Bool
== :: CommitAuthorEvent -> CommitAuthorEvent -> Bool
$c/= :: CommitAuthorEvent -> CommitAuthorEvent -> Bool
/= :: CommitAuthorEvent -> CommitAuthorEvent -> Bool
Eq, (forall x. CommitAuthorEvent -> Rep CommitAuthorEvent x)
-> (forall x. Rep CommitAuthorEvent x -> CommitAuthorEvent)
-> Generic CommitAuthorEvent
forall x. Rep CommitAuthorEvent x -> CommitAuthorEvent
forall x. CommitAuthorEvent -> Rep CommitAuthorEvent x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CommitAuthorEvent -> Rep CommitAuthorEvent x
from :: forall x. CommitAuthorEvent -> Rep CommitAuthorEvent x
$cto :: forall x. Rep CommitAuthorEvent x -> CommitAuthorEvent
to :: forall x. Rep CommitAuthorEvent x -> CommitAuthorEvent
Generic)

instance SystemHook MergeRequestEvent where
  match :: String -> (MergeRequestEvent -> GitLab ()) -> Rule
match = String -> (MergeRequestEvent -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (MergeRequestEvent -> GitLab Bool)
-> (MergeRequestEvent -> GitLab ())
-> Rule
matchIf = String
-> (MergeRequestEvent -> GitLab Bool)
-> (MergeRequestEvent -> GitLab ())
-> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | Merge request (named so, since 'MergeRequest' type already used
-- in GitLab.Types.
data MergeRequestEvent = MergeRequestEvent
  { MergeRequestEvent -> Text
mergeRequest_object_kind :: Text,
    MergeRequestEvent -> Text
mergeRequest_event_type :: Text,
    MergeRequestEvent -> UserEvent
mergeRequest_user :: UserEvent,
    MergeRequestEvent -> ProjectEvent
mergeRequest_project :: ProjectEvent,
    MergeRequestEvent -> MergeRequestObjectAttributes
mergeRequest_object_attributes :: MergeRequestObjectAttributes,
    MergeRequestEvent -> Maybe [Label]
mergeRequest_labels :: Maybe [Label],
    MergeRequestEvent -> MergeRequestChanges
mergeRequest_changes :: MergeRequestChanges,
    MergeRequestEvent -> RepositoryEvent
mergeRequest_repository :: RepositoryEvent
  }
  deriving (Typeable, Int -> MergeRequestEvent -> ShowS
[MergeRequestEvent] -> ShowS
MergeRequestEvent -> String
(Int -> MergeRequestEvent -> ShowS)
-> (MergeRequestEvent -> String)
-> ([MergeRequestEvent] -> ShowS)
-> Show MergeRequestEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MergeRequestEvent -> ShowS
showsPrec :: Int -> MergeRequestEvent -> ShowS
$cshow :: MergeRequestEvent -> String
show :: MergeRequestEvent -> String
$cshowList :: [MergeRequestEvent] -> ShowS
showList :: [MergeRequestEvent] -> ShowS
Show, MergeRequestEvent -> MergeRequestEvent -> Bool
(MergeRequestEvent -> MergeRequestEvent -> Bool)
-> (MergeRequestEvent -> MergeRequestEvent -> Bool)
-> Eq MergeRequestEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MergeRequestEvent -> MergeRequestEvent -> Bool
== :: MergeRequestEvent -> MergeRequestEvent -> Bool
$c/= :: MergeRequestEvent -> MergeRequestEvent -> Bool
/= :: MergeRequestEvent -> MergeRequestEvent -> Bool
Eq, (forall x. MergeRequestEvent -> Rep MergeRequestEvent x)
-> (forall x. Rep MergeRequestEvent x -> MergeRequestEvent)
-> Generic MergeRequestEvent
forall x. Rep MergeRequestEvent x -> MergeRequestEvent
forall x. MergeRequestEvent -> Rep MergeRequestEvent x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. MergeRequestEvent -> Rep MergeRequestEvent x
from :: forall x. MergeRequestEvent -> Rep MergeRequestEvent x
$cto :: forall x. Rep MergeRequestEvent x -> MergeRequestEvent
to :: forall x. Rep MergeRequestEvent x -> MergeRequestEvent
Generic)

-- | Label associated with a merge request
data Label = Label
  { Label -> Maybe Int
label_id :: Maybe Int,
    Label -> Maybe Text
label_title :: Maybe Text,
    Label -> Maybe Text
label_color :: Maybe Text,
    Label -> Maybe Int
label_project_id :: Maybe Int,
    Label -> Maybe Text
label_created_at :: Maybe Text, -- TODO date from e.g. "2013-12-03T17:15:43Z"
    Label -> Maybe Text
label_updated_at :: Maybe Text, -- TODO date
    Label -> Maybe Bool
label_template :: Maybe Bool,
    Label -> Maybe Text
label_description :: Maybe Text,
    Label -> Maybe Text
label_type :: Maybe Text, -- TODO type from "ProjectLabel"
    Label -> Maybe Int
label_group_id :: Maybe Int
  }
  deriving (Typeable, Int -> Label -> ShowS
[Label] -> ShowS
Label -> String
(Int -> Label -> ShowS)
-> (Label -> String) -> ([Label] -> ShowS) -> Show Label
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Label -> ShowS
showsPrec :: Int -> Label -> ShowS
$cshow :: Label -> String
show :: Label -> String
$cshowList :: [Label] -> ShowS
showList :: [Label] -> ShowS
Show, Label -> Label -> Bool
(Label -> Label -> Bool) -> (Label -> Label -> Bool) -> Eq Label
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Label -> Label -> Bool
== :: Label -> Label -> Bool
$c/= :: Label -> Label -> Bool
/= :: Label -> Label -> Bool
Eq, (forall x. Label -> Rep Label x)
-> (forall x. Rep Label x -> Label) -> Generic Label
forall x. Rep Label x -> Label
forall x. Label -> Rep Label x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Label -> Rep Label x
from :: forall x. Label -> Rep Label x
$cto :: forall x. Rep Label x -> Label
to :: forall x. Rep Label x -> Label
Generic)

-- | Changes that a merge request will make
data MergeRequestChanges = MergeRequestChanges
  { MergeRequestChanges -> Maybe (MergeRequestChange Int)
mergeRequestChanges_author_id :: Maybe (MergeRequestChange Int),
    MergeRequestChanges -> Maybe (MergeRequestChange Text)
mergeRequestChanges_created_at :: Maybe (MergeRequestChange Text),
    MergeRequestChanges -> Maybe (MergeRequestChange Text)
mergeRequestChanges_description :: Maybe (MergeRequestChange Text),
    MergeRequestChanges -> Maybe (MergeRequestChange Int)
mergeRequestChanges_id :: Maybe (MergeRequestChange Int),
    MergeRequestChanges -> Maybe (MergeRequestChange Int)
mergeRequestChanges_iid :: Maybe (MergeRequestChange Int),
    MergeRequestChanges -> Maybe (MergeRequestChange Text)
mergeRequestChanges_source_branch :: Maybe (MergeRequestChange Text),
    MergeRequestChanges -> Maybe (MergeRequestChange Int)
mergeRequestChanges_source_project_id :: Maybe (MergeRequestChange Int),
    MergeRequestChanges -> Maybe (MergeRequestChange Text)
mergeRequestChanges_target_branch :: Maybe (MergeRequestChange Text),
    MergeRequestChanges -> Maybe (MergeRequestChange Int)
mergeRequestChanges_target_project_id :: Maybe (MergeRequestChange Int),
    MergeRequestChanges -> Maybe (MergeRequestChange Text)
mergeRequestChanges_title :: Maybe (MergeRequestChange Text),
    MergeRequestChanges -> Maybe (MergeRequestChange Text)
mergeRequestChanges_updated_at :: Maybe (MergeRequestChange Text)
  }
  deriving (Typeable, Int -> MergeRequestChanges -> ShowS
[MergeRequestChanges] -> ShowS
MergeRequestChanges -> String
(Int -> MergeRequestChanges -> ShowS)
-> (MergeRequestChanges -> String)
-> ([MergeRequestChanges] -> ShowS)
-> Show MergeRequestChanges
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MergeRequestChanges -> ShowS
showsPrec :: Int -> MergeRequestChanges -> ShowS
$cshow :: MergeRequestChanges -> String
show :: MergeRequestChanges -> String
$cshowList :: [MergeRequestChanges] -> ShowS
showList :: [MergeRequestChanges] -> ShowS
Show, MergeRequestChanges -> MergeRequestChanges -> Bool
(MergeRequestChanges -> MergeRequestChanges -> Bool)
-> (MergeRequestChanges -> MergeRequestChanges -> Bool)
-> Eq MergeRequestChanges
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MergeRequestChanges -> MergeRequestChanges -> Bool
== :: MergeRequestChanges -> MergeRequestChanges -> Bool
$c/= :: MergeRequestChanges -> MergeRequestChanges -> Bool
/= :: MergeRequestChanges -> MergeRequestChanges -> Bool
Eq, (forall x. MergeRequestChanges -> Rep MergeRequestChanges x)
-> (forall x. Rep MergeRequestChanges x -> MergeRequestChanges)
-> Generic MergeRequestChanges
forall x. Rep MergeRequestChanges x -> MergeRequestChanges
forall x. MergeRequestChanges -> Rep MergeRequestChanges x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. MergeRequestChanges -> Rep MergeRequestChanges x
from :: forall x. MergeRequestChanges -> Rep MergeRequestChanges x
$cto :: forall x. Rep MergeRequestChanges x -> MergeRequestChanges
to :: forall x. Rep MergeRequestChanges x -> MergeRequestChanges
Generic)

-- | The change between for a given GitLab data field a merge request
-- will make
data MergeRequestChange a = MergeRequestChange
  { forall a. MergeRequestChange a -> Maybe a
mergeRequestChange_previous :: Maybe a,
    forall a. MergeRequestChange a -> Maybe a
mergeRequestChange_current :: Maybe a
  }
  deriving (Typeable, Int -> MergeRequestChange a -> ShowS
[MergeRequestChange a] -> ShowS
MergeRequestChange a -> String
(Int -> MergeRequestChange a -> ShowS)
-> (MergeRequestChange a -> String)
-> ([MergeRequestChange a] -> ShowS)
-> Show (MergeRequestChange a)
forall a. Show a => Int -> MergeRequestChange a -> ShowS
forall a. Show a => [MergeRequestChange a] -> ShowS
forall a. Show a => MergeRequestChange a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> MergeRequestChange a -> ShowS
showsPrec :: Int -> MergeRequestChange a -> ShowS
$cshow :: forall a. Show a => MergeRequestChange a -> String
show :: MergeRequestChange a -> String
$cshowList :: forall a. Show a => [MergeRequestChange a] -> ShowS
showList :: [MergeRequestChange a] -> ShowS
Show, MergeRequestChange a -> MergeRequestChange a -> Bool
(MergeRequestChange a -> MergeRequestChange a -> Bool)
-> (MergeRequestChange a -> MergeRequestChange a -> Bool)
-> Eq (MergeRequestChange a)
forall a.
Eq a =>
MergeRequestChange a -> MergeRequestChange a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a.
Eq a =>
MergeRequestChange a -> MergeRequestChange a -> Bool
== :: MergeRequestChange a -> MergeRequestChange a -> Bool
$c/= :: forall a.
Eq a =>
MergeRequestChange a -> MergeRequestChange a -> Bool
/= :: MergeRequestChange a -> MergeRequestChange a -> Bool
Eq, (forall x. MergeRequestChange a -> Rep (MergeRequestChange a) x)
-> (forall x. Rep (MergeRequestChange a) x -> MergeRequestChange a)
-> Generic (MergeRequestChange a)
forall x. Rep (MergeRequestChange a) x -> MergeRequestChange a
forall x. MergeRequestChange a -> Rep (MergeRequestChange a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (MergeRequestChange a) x -> MergeRequestChange a
forall a x. MergeRequestChange a -> Rep (MergeRequestChange a) x
$cfrom :: forall a x. MergeRequestChange a -> Rep (MergeRequestChange a) x
from :: forall x. MergeRequestChange a -> Rep (MergeRequestChange a) x
$cto :: forall a x. Rep (MergeRequestChange a) x -> MergeRequestChange a
to :: forall x. Rep (MergeRequestChange a) x -> MergeRequestChange a
Generic)

-- | Attributes associated with a merge request
data MergeRequestObjectAttributes = MergeRequestObjectAttributes
  { MergeRequestObjectAttributes -> Int
objectAttributes_id :: Int,
    MergeRequestObjectAttributes -> Text
objectAttributes_target_branch :: Text,
    MergeRequestObjectAttributes -> Text
objectAttributes_source_branch :: Text,
    MergeRequestObjectAttributes -> Int
objectAttributes_source_project_id :: Int,
    MergeRequestObjectAttributes -> Maybe Int
objectAttributes_author_id :: Maybe Int,
    MergeRequestObjectAttributes -> Maybe Int
objectAttributes_assignee_id :: Maybe Int,
    MergeRequestObjectAttributes -> Maybe [Int]
objectAttributes_assignee_ids :: Maybe [Int],
    MergeRequestObjectAttributes -> Text
objectAttributes_title :: Text,
    MergeRequestObjectAttributes -> Text
objectAttributes_created_at :: Text,
    MergeRequestObjectAttributes -> Text
objectAttributes_updated_at :: Text,
    MergeRequestObjectAttributes -> Maybe Int
objectAttributes_milestone_id :: Maybe Int,
    MergeRequestObjectAttributes -> Text
objectAttributes_state :: Text,
    MergeRequestObjectAttributes -> Maybe Int
objectAttributes_state_id :: Maybe Int,
    MergeRequestObjectAttributes -> Text
objectAttributes_merge_status :: Text,
    MergeRequestObjectAttributes -> Int
objectAttributes_target_project_id :: Int,
    MergeRequestObjectAttributes -> Int
objectAttributes_iid :: Int,
    MergeRequestObjectAttributes -> Text
objectAttributes_description :: Text,
    MergeRequestObjectAttributes -> Maybe Int
objectAttributes_updated_by_id :: Maybe Int,
    MergeRequestObjectAttributes -> Maybe Text
objectAttributes_merge_error :: Maybe Text,
    MergeRequestObjectAttributes -> Maybe MergeParams
objectAttributes_merge_params :: Maybe MergeParams,
    MergeRequestObjectAttributes -> Maybe Bool
objectAttributes_merge_when_pipeline_succeeds :: Maybe Bool,
    MergeRequestObjectAttributes -> Maybe Int
objectAttributes_merge_user_id :: Maybe Int,
    MergeRequestObjectAttributes -> Maybe Text
objectAttributes_merge_commit_sha :: Maybe Text,
    MergeRequestObjectAttributes -> Maybe Text
objectAttributes_deleted_at :: Maybe Text,
    MergeRequestObjectAttributes -> Maybe Text
objectAttributes_in_progress_merge_commit_sha :: Maybe Text,
    MergeRequestObjectAttributes -> Maybe Int
objectAttributes_lock_version :: Maybe Int,
    MergeRequestObjectAttributes -> Maybe Int
objectAttributes_time_estimate :: Maybe Int,
    MergeRequestObjectAttributes -> Maybe Text
objectAttributes_last_edited_at :: Maybe Text,
    MergeRequestObjectAttributes -> Maybe Int
objectAttributes_last_edited_by_id :: Maybe Int,
    MergeRequestObjectAttributes -> Maybe Int
objectAttributes_head_pipeline_id :: Maybe Int,
    MergeRequestObjectAttributes -> Maybe Bool
objectAttributes_ref_fetched :: Maybe Bool,
    MergeRequestObjectAttributes -> Maybe Int
objectAttributes_merge_jid :: Maybe Int,
    MergeRequestObjectAttributes -> ProjectEvent
objectAttributes_source :: ProjectEvent,
    MergeRequestObjectAttributes -> ProjectEvent
objectAttributes_target :: ProjectEvent,
    MergeRequestObjectAttributes -> CommitEvent
objectAttributes_last_commit :: CommitEvent,
    MergeRequestObjectAttributes -> Bool
objectAttributes_work_in_progress :: Bool,
    MergeRequestObjectAttributes -> Maybe Int
objectAttributes_total_time_spent :: Maybe Int,
    MergeRequestObjectAttributes -> Maybe Int
objectAttributes_human_total_time_spent :: Maybe Int,
    MergeRequestObjectAttributes -> Maybe Int
objectAttributes_human_time_estimate :: Maybe Int,
    MergeRequestObjectAttributes -> Maybe Text
objectAttributes_action :: Maybe Text
  }
  deriving (Typeable, Int -> MergeRequestObjectAttributes -> ShowS
[MergeRequestObjectAttributes] -> ShowS
MergeRequestObjectAttributes -> String
(Int -> MergeRequestObjectAttributes -> ShowS)
-> (MergeRequestObjectAttributes -> String)
-> ([MergeRequestObjectAttributes] -> ShowS)
-> Show MergeRequestObjectAttributes
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MergeRequestObjectAttributes -> ShowS
showsPrec :: Int -> MergeRequestObjectAttributes -> ShowS
$cshow :: MergeRequestObjectAttributes -> String
show :: MergeRequestObjectAttributes -> String
$cshowList :: [MergeRequestObjectAttributes] -> ShowS
showList :: [MergeRequestObjectAttributes] -> ShowS
Show, MergeRequestObjectAttributes
-> MergeRequestObjectAttributes -> Bool
(MergeRequestObjectAttributes
 -> MergeRequestObjectAttributes -> Bool)
-> (MergeRequestObjectAttributes
    -> MergeRequestObjectAttributes -> Bool)
-> Eq MergeRequestObjectAttributes
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MergeRequestObjectAttributes
-> MergeRequestObjectAttributes -> Bool
== :: MergeRequestObjectAttributes
-> MergeRequestObjectAttributes -> Bool
$c/= :: MergeRequestObjectAttributes
-> MergeRequestObjectAttributes -> Bool
/= :: MergeRequestObjectAttributes
-> MergeRequestObjectAttributes -> Bool
Eq, (forall x.
 MergeRequestObjectAttributes -> Rep MergeRequestObjectAttributes x)
-> (forall x.
    Rep MergeRequestObjectAttributes x -> MergeRequestObjectAttributes)
-> Generic MergeRequestObjectAttributes
forall x.
Rep MergeRequestObjectAttributes x -> MergeRequestObjectAttributes
forall x.
MergeRequestObjectAttributes -> Rep MergeRequestObjectAttributes x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
MergeRequestObjectAttributes -> Rep MergeRequestObjectAttributes x
from :: forall x.
MergeRequestObjectAttributes -> Rep MergeRequestObjectAttributes x
$cto :: forall x.
Rep MergeRequestObjectAttributes x -> MergeRequestObjectAttributes
to :: forall x.
Rep MergeRequestObjectAttributes x -> MergeRequestObjectAttributes
Generic)

-- | Merge parameters associated with a merge request
newtype MergeParams = MergeParams
  { MergeParams -> Maybe Text
mergeParams_force_remove_source_branch :: Maybe Text
  }
  deriving (Typeable, Int -> MergeParams -> ShowS
[MergeParams] -> ShowS
MergeParams -> String
(Int -> MergeParams -> ShowS)
-> (MergeParams -> String)
-> ([MergeParams] -> ShowS)
-> Show MergeParams
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MergeParams -> ShowS
showsPrec :: Int -> MergeParams -> ShowS
$cshow :: MergeParams -> String
show :: MergeParams -> String
$cshowList :: [MergeParams] -> ShowS
showList :: [MergeParams] -> ShowS
Show, MergeParams -> MergeParams -> Bool
(MergeParams -> MergeParams -> Bool)
-> (MergeParams -> MergeParams -> Bool) -> Eq MergeParams
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MergeParams -> MergeParams -> Bool
== :: MergeParams -> MergeParams -> Bool
$c/= :: MergeParams -> MergeParams -> Bool
/= :: MergeParams -> MergeParams -> Bool
Eq, (forall x. MergeParams -> Rep MergeParams x)
-> (forall x. Rep MergeParams x -> MergeParams)
-> Generic MergeParams
forall x. Rep MergeParams x -> MergeParams
forall x. MergeParams -> Rep MergeParams x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. MergeParams -> Rep MergeParams x
from :: forall x. MergeParams -> Rep MergeParams x
$cto :: forall x. Rep MergeParams x -> MergeParams
to :: forall x. Rep MergeParams x -> MergeParams
Generic)

-- | User associated with a merge request
data UserEvent = UserEvent
  { UserEvent -> Maybe Int
userEvent_id :: Maybe Int,
    UserEvent -> Text
userEvent_name :: Text,
    UserEvent -> Text
userEvent_username :: Text,
    UserEvent -> Text
userEvent_avatar_url :: Text,
    UserEvent -> Maybe Text
userEvent_email :: Maybe Text
  }
  deriving (Typeable, Int -> UserEvent -> ShowS
[UserEvent] -> ShowS
UserEvent -> String
(Int -> UserEvent -> ShowS)
-> (UserEvent -> String)
-> ([UserEvent] -> ShowS)
-> Show UserEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UserEvent -> ShowS
showsPrec :: Int -> UserEvent -> ShowS
$cshow :: UserEvent -> String
show :: UserEvent -> String
$cshowList :: [UserEvent] -> ShowS
showList :: [UserEvent] -> ShowS
Show, UserEvent -> UserEvent -> Bool
(UserEvent -> UserEvent -> Bool)
-> (UserEvent -> UserEvent -> Bool) -> Eq UserEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UserEvent -> UserEvent -> Bool
== :: UserEvent -> UserEvent -> Bool
$c/= :: UserEvent -> UserEvent -> Bool
/= :: UserEvent -> UserEvent -> Bool
Eq, (forall x. UserEvent -> Rep UserEvent x)
-> (forall x. Rep UserEvent x -> UserEvent) -> Generic UserEvent
forall x. Rep UserEvent x -> UserEvent
forall x. UserEvent -> Rep UserEvent x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. UserEvent -> Rep UserEvent x
from :: forall x. UserEvent -> Rep UserEvent x
$cto :: forall x. Rep UserEvent x -> UserEvent
to :: forall x. Rep UserEvent x -> UserEvent
Generic)

data ProjectAction
  = ProjectCreated
  | ProjectDestroyed
  | ProjectRenamed
  | ProjectTransferred
  | ProjectUpdated
  | UserAddedToTeam
  | UserUpdatedForTeam
  | UserRemovedFromTeam
  | UserCreated
  | UserRemoved
  | UserFailedToLogin
  | UserRenamed
  | KeyCreated
  | KeyRemoved
  | GroupCreated
  | GroupRemoved
  | GroupRenamed
  | GroupMemberAdded
  | GroupMemberRemoved
  | GroupMemberUpdated
  | Pushed
  | TagPushed
  | RepositoryUpdated
  | MergeRequested
  | Built
  | Pipelined
  | Noted
  | WikiPaged
  | WorkItemed
  deriving (Int -> ProjectAction -> ShowS
[ProjectAction] -> ShowS
ProjectAction -> String
(Int -> ProjectAction -> ShowS)
-> (ProjectAction -> String)
-> ([ProjectAction] -> ShowS)
-> Show ProjectAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ProjectAction -> ShowS
showsPrec :: Int -> ProjectAction -> ShowS
$cshow :: ProjectAction -> String
show :: ProjectAction -> String
$cshowList :: [ProjectAction] -> ShowS
showList :: [ProjectAction] -> ShowS
Show, ProjectAction -> ProjectAction -> Bool
(ProjectAction -> ProjectAction -> Bool)
-> (ProjectAction -> ProjectAction -> Bool) -> Eq ProjectAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProjectAction -> ProjectAction -> Bool
== :: ProjectAction -> ProjectAction -> Bool
$c/= :: ProjectAction -> ProjectAction -> Bool
/= :: ProjectAction -> ProjectAction -> Bool
Eq)

-- | CI build
data BuildEvent = BuildEvent
  { BuildEvent -> Text
build_event_object_kind :: Text,
    BuildEvent -> Text
build_event_ref :: Text,
    BuildEvent -> Bool
build_event_tag :: Bool,
    BuildEvent -> Text
build_event_before_sha :: Text,
    BuildEvent -> Text
build_event_sha :: Text,
    BuildEvent -> Int
build_event_retries_count :: Int,
    BuildEvent -> Int
build_event_build_event_id :: Int,
    BuildEvent -> Text
build_event_build_event_name :: Text,
    BuildEvent -> Text
build_event_build_event_stage :: Text,
    BuildEvent -> Text
build_event_build_event_status :: Text,
    BuildEvent -> Text
build_event_created_at :: Text,
    BuildEvent -> Maybe Text
build_event_started_at :: Maybe Text,
    BuildEvent -> Maybe Text
build_event_finished_at :: Maybe Text,
    BuildEvent -> Maybe Double
build_event_duration :: Maybe Double,
    BuildEvent -> Maybe Double
build_event_queued_duration :: Maybe Double,
    BuildEvent -> Bool
build_event_allow_failure :: Bool,
    BuildEvent -> Maybe Text
build_event_failure_reason :: Maybe Text,
    BuildEvent -> Int
build_event_pipeline_id :: Int,
    BuildEvent -> Maybe Runner
build_event_runner :: Maybe Runner,
    BuildEvent -> Int
build_event_project_id :: Int,
    BuildEvent -> Text
build_event_project_name :: Text,
    BuildEvent -> User
build_event_user :: User,
    BuildEvent -> BuildCommit
build_event_commit :: BuildCommit,
    BuildEvent -> Repository
build_event_repository :: Repository,
    BuildEvent -> BuildProject
build_event_project :: BuildProject,
    BuildEvent -> Maybe Text
build_event_environment :: Maybe Text
  }
  deriving (Typeable, Int -> BuildEvent -> ShowS
[BuildEvent] -> ShowS
BuildEvent -> String
(Int -> BuildEvent -> ShowS)
-> (BuildEvent -> String)
-> ([BuildEvent] -> ShowS)
-> Show BuildEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BuildEvent -> ShowS
showsPrec :: Int -> BuildEvent -> ShowS
$cshow :: BuildEvent -> String
show :: BuildEvent -> String
$cshowList :: [BuildEvent] -> ShowS
showList :: [BuildEvent] -> ShowS
Show, BuildEvent -> BuildEvent -> Bool
(BuildEvent -> BuildEvent -> Bool)
-> (BuildEvent -> BuildEvent -> Bool) -> Eq BuildEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BuildEvent -> BuildEvent -> Bool
== :: BuildEvent -> BuildEvent -> Bool
$c/= :: BuildEvent -> BuildEvent -> Bool
/= :: BuildEvent -> BuildEvent -> Bool
Eq, (forall x. BuildEvent -> Rep BuildEvent x)
-> (forall x. Rep BuildEvent x -> BuildEvent) -> Generic BuildEvent
forall x. Rep BuildEvent x -> BuildEvent
forall x. BuildEvent -> Rep BuildEvent x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BuildEvent -> Rep BuildEvent x
from :: forall x. BuildEvent -> Rep BuildEvent x
$cto :: forall x. Rep BuildEvent x -> BuildEvent
to :: forall x. Rep BuildEvent x -> BuildEvent
Generic)

instance SystemHook BuildEvent where
  match :: String -> (BuildEvent -> GitLab ()) -> Rule
match = String -> (BuildEvent -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (BuildEvent -> GitLab Bool) -> (BuildEvent -> GitLab ()) -> Rule
matchIf = String
-> (BuildEvent -> GitLab Bool) -> (BuildEvent -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | CI build commit
data BuildCommit = BuildCommit
  { BuildCommit -> Int
build_commit_id :: Int,
    BuildCommit -> Maybe Text
build_commit_name :: Maybe Text,
    BuildCommit -> Text
build_commit_sha :: Text,
    BuildCommit -> Text
build_commit_message :: Text,
    BuildCommit -> Text
build_commit_author_name :: Text,
    BuildCommit -> Text
build_commit_author_email :: Text,
    BuildCommit -> Text
build_commit_author_url :: Text,
    BuildCommit -> Text
build_commit_status :: Text,
    BuildCommit -> Maybe Int
build_commit_duration :: Maybe Int,
    BuildCommit -> Maybe Text
build_commit_started_at :: Maybe Text,
    BuildCommit -> Maybe Text
build_commit_finished_at :: Maybe Text
  }
  deriving (Typeable, Int -> BuildCommit -> ShowS
[BuildCommit] -> ShowS
BuildCommit -> String
(Int -> BuildCommit -> ShowS)
-> (BuildCommit -> String)
-> ([BuildCommit] -> ShowS)
-> Show BuildCommit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BuildCommit -> ShowS
showsPrec :: Int -> BuildCommit -> ShowS
$cshow :: BuildCommit -> String
show :: BuildCommit -> String
$cshowList :: [BuildCommit] -> ShowS
showList :: [BuildCommit] -> ShowS
Show, BuildCommit -> BuildCommit -> Bool
(BuildCommit -> BuildCommit -> Bool)
-> (BuildCommit -> BuildCommit -> Bool) -> Eq BuildCommit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BuildCommit -> BuildCommit -> Bool
== :: BuildCommit -> BuildCommit -> Bool
$c/= :: BuildCommit -> BuildCommit -> Bool
/= :: BuildCommit -> BuildCommit -> Bool
Eq, (forall x. BuildCommit -> Rep BuildCommit x)
-> (forall x. Rep BuildCommit x -> BuildCommit)
-> Generic BuildCommit
forall x. Rep BuildCommit x -> BuildCommit
forall x. BuildCommit -> Rep BuildCommit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BuildCommit -> Rep BuildCommit x
from :: forall x. BuildCommit -> Rep BuildCommit x
$cto :: forall x. Rep BuildCommit x -> BuildCommit
to :: forall x. Rep BuildCommit x -> BuildCommit
Generic)

-- | CI build commit
data BuildProject = BuildProject
  { BuildProject -> Int
build_project_project_id :: Int,
    BuildProject -> Text
build_project_project_name :: Text,
    BuildProject -> Maybe Text
build_project_description :: Maybe Text,
    BuildProject -> Text
build_project_web_url :: Text,
    BuildProject -> Maybe Text
build_project_avatar_url :: Maybe Text,
    BuildProject -> Text
build_project_git_ssh_url :: Text,
    BuildProject -> Text
build_project_git_http_url :: Text,
    BuildProject -> Text
build_project_namespace :: Text,
    BuildProject -> Int
build_project_visibility_level :: Int,
    BuildProject -> Text
build_project_path_with_namespace :: Text,
    BuildProject -> Text
build_project_default_branch :: Text,
    BuildProject -> Maybe Text
build_project_ci_config_path :: Maybe Text
  }
  deriving (Typeable, Int -> BuildProject -> ShowS
[BuildProject] -> ShowS
BuildProject -> String
(Int -> BuildProject -> ShowS)
-> (BuildProject -> String)
-> ([BuildProject] -> ShowS)
-> Show BuildProject
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BuildProject -> ShowS
showsPrec :: Int -> BuildProject -> ShowS
$cshow :: BuildProject -> String
show :: BuildProject -> String
$cshowList :: [BuildProject] -> ShowS
showList :: [BuildProject] -> ShowS
Show, BuildProject -> BuildProject -> Bool
(BuildProject -> BuildProject -> Bool)
-> (BuildProject -> BuildProject -> Bool) -> Eq BuildProject
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BuildProject -> BuildProject -> Bool
== :: BuildProject -> BuildProject -> Bool
$c/= :: BuildProject -> BuildProject -> Bool
/= :: BuildProject -> BuildProject -> Bool
Eq, (forall x. BuildProject -> Rep BuildProject x)
-> (forall x. Rep BuildProject x -> BuildProject)
-> Generic BuildProject
forall x. Rep BuildProject x -> BuildProject
forall x. BuildProject -> Rep BuildProject x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BuildProject -> Rep BuildProject x
from :: forall x. BuildProject -> Rep BuildProject x
$cto :: forall x. Rep BuildProject x -> BuildProject
to :: forall x. Rep BuildProject x -> BuildProject
Generic)

-- | CI pipelines
data PipelineEvent = PipelineEvent
  { PipelineEvent -> Text
pipeline_event_object_kind :: Text,
    PipelineEvent -> PipelineObjectAttributes
pipeline_event_object_attributes :: PipelineObjectAttributes,
    PipelineEvent -> Maybe Text
pipeline_event_merge_request :: Maybe Text,
    PipelineEvent -> User
pipeline_event_user :: User,
    PipelineEvent -> BuildProject
pipeline_event_project :: BuildProject,
    PipelineEvent -> CommitEvent
pipeline_event_commit :: CommitEvent,
    PipelineEvent -> [PipelineBuild]
pipeline_event_builds :: [PipelineBuild]
  }
  deriving (Typeable, Int -> PipelineEvent -> ShowS
[PipelineEvent] -> ShowS
PipelineEvent -> String
(Int -> PipelineEvent -> ShowS)
-> (PipelineEvent -> String)
-> ([PipelineEvent] -> ShowS)
-> Show PipelineEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PipelineEvent -> ShowS
showsPrec :: Int -> PipelineEvent -> ShowS
$cshow :: PipelineEvent -> String
show :: PipelineEvent -> String
$cshowList :: [PipelineEvent] -> ShowS
showList :: [PipelineEvent] -> ShowS
Show, PipelineEvent -> PipelineEvent -> Bool
(PipelineEvent -> PipelineEvent -> Bool)
-> (PipelineEvent -> PipelineEvent -> Bool) -> Eq PipelineEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PipelineEvent -> PipelineEvent -> Bool
== :: PipelineEvent -> PipelineEvent -> Bool
$c/= :: PipelineEvent -> PipelineEvent -> Bool
/= :: PipelineEvent -> PipelineEvent -> Bool
Eq, (forall x. PipelineEvent -> Rep PipelineEvent x)
-> (forall x. Rep PipelineEvent x -> PipelineEvent)
-> Generic PipelineEvent
forall x. Rep PipelineEvent x -> PipelineEvent
forall x. PipelineEvent -> Rep PipelineEvent x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. PipelineEvent -> Rep PipelineEvent x
from :: forall x. PipelineEvent -> Rep PipelineEvent x
$cto :: forall x. Rep PipelineEvent x -> PipelineEvent
to :: forall x. Rep PipelineEvent x -> PipelineEvent
Generic)

instance SystemHook PipelineEvent where
  match :: String -> (PipelineEvent -> GitLab ()) -> Rule
match = String -> (PipelineEvent -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (PipelineEvent -> GitLab Bool)
-> (PipelineEvent -> GitLab ())
-> Rule
matchIf = String
-> (PipelineEvent -> GitLab Bool)
-> (PipelineEvent -> GitLab ())
-> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | CI pipeline attributes
data PipelineObjectAttributes = PipelineObjectAttributes
  { PipelineObjectAttributes -> Int
pipeline_object_attributes_id :: Int,
    PipelineObjectAttributes -> Int
pipeline_object_attributes_iid :: Int,
    PipelineObjectAttributes -> Maybe Text
pipeline_object_attributes_name :: Maybe Text,
    PipelineObjectAttributes -> Text
pipeline_object_attributes_ref :: Text,
    PipelineObjectAttributes -> Bool
pipeline_object_attributes_tag :: Bool,
    PipelineObjectAttributes -> Text
pipeline_object_attributes_sha :: Text,
    PipelineObjectAttributes -> Text
pipeline_object_attributes_before_sha :: Text,
    PipelineObjectAttributes -> Text
pipeline_object_attributes_source :: Text,
    PipelineObjectAttributes -> Text
pipeline_object_attributes_status :: Text,
    PipelineObjectAttributes -> Text
pipeline_object_attributes_detailed_status :: Text,
    PipelineObjectAttributes -> [Text]
pipeline_object_attributes_stages :: [Text],
    PipelineObjectAttributes -> Text
pipeline_object_attributes_created_at :: Text,
    PipelineObjectAttributes -> Maybe Text
pipeline_object_attributes_finished_at :: Maybe Text,
    PipelineObjectAttributes -> Maybe Double
pipeline_object_attributes_duration :: Maybe Double,
    PipelineObjectAttributes -> Maybe Double
pipeline_object_attributes_queued_duration :: Maybe Double,
    PipelineObjectAttributes -> [Text]
pipeline_object_attributes_variables :: [Text],
    PipelineObjectAttributes -> Text
pipeline_object_attributes_url :: Text
  }
  deriving (Typeable, Int -> PipelineObjectAttributes -> ShowS
[PipelineObjectAttributes] -> ShowS
PipelineObjectAttributes -> String
(Int -> PipelineObjectAttributes -> ShowS)
-> (PipelineObjectAttributes -> String)
-> ([PipelineObjectAttributes] -> ShowS)
-> Show PipelineObjectAttributes
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PipelineObjectAttributes -> ShowS
showsPrec :: Int -> PipelineObjectAttributes -> ShowS
$cshow :: PipelineObjectAttributes -> String
show :: PipelineObjectAttributes -> String
$cshowList :: [PipelineObjectAttributes] -> ShowS
showList :: [PipelineObjectAttributes] -> ShowS
Show, PipelineObjectAttributes -> PipelineObjectAttributes -> Bool
(PipelineObjectAttributes -> PipelineObjectAttributes -> Bool)
-> (PipelineObjectAttributes -> PipelineObjectAttributes -> Bool)
-> Eq PipelineObjectAttributes
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PipelineObjectAttributes -> PipelineObjectAttributes -> Bool
== :: PipelineObjectAttributes -> PipelineObjectAttributes -> Bool
$c/= :: PipelineObjectAttributes -> PipelineObjectAttributes -> Bool
/= :: PipelineObjectAttributes -> PipelineObjectAttributes -> Bool
Eq, (forall x.
 PipelineObjectAttributes -> Rep PipelineObjectAttributes x)
-> (forall x.
    Rep PipelineObjectAttributes x -> PipelineObjectAttributes)
-> Generic PipelineObjectAttributes
forall x.
Rep PipelineObjectAttributes x -> PipelineObjectAttributes
forall x.
PipelineObjectAttributes -> Rep PipelineObjectAttributes x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
PipelineObjectAttributes -> Rep PipelineObjectAttributes x
from :: forall x.
PipelineObjectAttributes -> Rep PipelineObjectAttributes x
$cto :: forall x.
Rep PipelineObjectAttributes x -> PipelineObjectAttributes
to :: forall x.
Rep PipelineObjectAttributes x -> PipelineObjectAttributes
Generic)

-- | CI pipeline attributes
data PipelineBuild = PipelineBuild
  { PipelineBuild -> Int
pipeline_build_id :: Int,
    PipelineBuild -> Text
pipeline_build_stage :: Text,
    PipelineBuild -> Text
pipeline_build_name :: Text,
    PipelineBuild -> Text
pipeline_build_status :: Text,
    PipelineBuild -> Text
pipeline_build_created_at :: Text,
    PipelineBuild -> Maybe Text
pipeline_build_started_at :: Maybe Text,
    PipelineBuild -> Maybe Text
pipeline_build_finished_at :: Maybe Text,
    PipelineBuild -> Maybe Double
pipeline_build_duration :: Maybe Double,
    PipelineBuild -> Double
pipeline_build_queued_duration :: Double,
    PipelineBuild -> Maybe Text
pipeline_build_failure_reason :: Maybe Text,
    PipelineBuild -> Text
pipeline_build_when :: Text, -- "on_success"
    PipelineBuild -> Bool
pipeline_build_manual :: Bool,
    PipelineBuild -> Bool
pipeline_build_allow_failure :: Bool,
    PipelineBuild -> UserEvent
pipeline_build_user :: UserEvent,
    PipelineBuild -> Maybe Runner
pipeline_build_runner :: Maybe Runner,
    PipelineBuild -> ArtifactsFile
pipeline_build_artifacts_file :: ArtifactsFile,
    PipelineBuild -> Maybe Text
pipeline_build_environment :: Maybe Text
  }
  deriving (Typeable, Int -> PipelineBuild -> ShowS
[PipelineBuild] -> ShowS
PipelineBuild -> String
(Int -> PipelineBuild -> ShowS)
-> (PipelineBuild -> String)
-> ([PipelineBuild] -> ShowS)
-> Show PipelineBuild
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PipelineBuild -> ShowS
showsPrec :: Int -> PipelineBuild -> ShowS
$cshow :: PipelineBuild -> String
show :: PipelineBuild -> String
$cshowList :: [PipelineBuild] -> ShowS
showList :: [PipelineBuild] -> ShowS
Show, PipelineBuild -> PipelineBuild -> Bool
(PipelineBuild -> PipelineBuild -> Bool)
-> (PipelineBuild -> PipelineBuild -> Bool) -> Eq PipelineBuild
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PipelineBuild -> PipelineBuild -> Bool
== :: PipelineBuild -> PipelineBuild -> Bool
$c/= :: PipelineBuild -> PipelineBuild -> Bool
/= :: PipelineBuild -> PipelineBuild -> Bool
Eq, (forall x. PipelineBuild -> Rep PipelineBuild x)
-> (forall x. Rep PipelineBuild x -> PipelineBuild)
-> Generic PipelineBuild
forall x. Rep PipelineBuild x -> PipelineBuild
forall x. PipelineBuild -> Rep PipelineBuild x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. PipelineBuild -> Rep PipelineBuild x
from :: forall x. PipelineBuild -> Rep PipelineBuild x
$cto :: forall x. Rep PipelineBuild x -> PipelineBuild
to :: forall x. Rep PipelineBuild x -> PipelineBuild
Generic)

-- | CI runner
data Runner = Runner
  { Runner -> Int
runner_id :: Int,
    Runner -> Text
runner_description :: Text,
    Runner -> Text
runner_runner_type :: Text, -- "instance_type"
    Runner -> Bool
runner_active :: Bool,
    Runner -> Bool
runner_is_shared :: Bool,
    Runner -> [Text]
runner_tags :: [Text]
  }
  deriving (Typeable, Int -> Runner -> ShowS
[Runner] -> ShowS
Runner -> String
(Int -> Runner -> ShowS)
-> (Runner -> String) -> ([Runner] -> ShowS) -> Show Runner
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Runner -> ShowS
showsPrec :: Int -> Runner -> ShowS
$cshow :: Runner -> String
show :: Runner -> String
$cshowList :: [Runner] -> ShowS
showList :: [Runner] -> ShowS
Show, Runner -> Runner -> Bool
(Runner -> Runner -> Bool)
-> (Runner -> Runner -> Bool) -> Eq Runner
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Runner -> Runner -> Bool
== :: Runner -> Runner -> Bool
$c/= :: Runner -> Runner -> Bool
/= :: Runner -> Runner -> Bool
Eq, (forall x. Runner -> Rep Runner x)
-> (forall x. Rep Runner x -> Runner) -> Generic Runner
forall x. Rep Runner x -> Runner
forall x. Runner -> Rep Runner x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Runner -> Rep Runner x
from :: forall x. Runner -> Rep Runner x
$cto :: forall x. Rep Runner x -> Runner
to :: forall x. Rep Runner x -> Runner
Generic)

-- | CI artifacts file
data ArtifactsFile = ArtifactsFile
  { ArtifactsFile -> Maybe Text
artifacts_file_filename :: Maybe Text,
    ArtifactsFile -> Maybe Int
artifacts_file_size :: Maybe Int
  }
  deriving (Typeable, Int -> ArtifactsFile -> ShowS
[ArtifactsFile] -> ShowS
ArtifactsFile -> String
(Int -> ArtifactsFile -> ShowS)
-> (ArtifactsFile -> String)
-> ([ArtifactsFile] -> ShowS)
-> Show ArtifactsFile
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ArtifactsFile -> ShowS
showsPrec :: Int -> ArtifactsFile -> ShowS
$cshow :: ArtifactsFile -> String
show :: ArtifactsFile -> String
$cshowList :: [ArtifactsFile] -> ShowS
showList :: [ArtifactsFile] -> ShowS
Show, ArtifactsFile -> ArtifactsFile -> Bool
(ArtifactsFile -> ArtifactsFile -> Bool)
-> (ArtifactsFile -> ArtifactsFile -> Bool) -> Eq ArtifactsFile
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ArtifactsFile -> ArtifactsFile -> Bool
== :: ArtifactsFile -> ArtifactsFile -> Bool
$c/= :: ArtifactsFile -> ArtifactsFile -> Bool
/= :: ArtifactsFile -> ArtifactsFile -> Bool
Eq, (forall x. ArtifactsFile -> Rep ArtifactsFile x)
-> (forall x. Rep ArtifactsFile x -> ArtifactsFile)
-> Generic ArtifactsFile
forall x. Rep ArtifactsFile x -> ArtifactsFile
forall x. ArtifactsFile -> Rep ArtifactsFile x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ArtifactsFile -> Rep ArtifactsFile x
from :: forall x. ArtifactsFile -> Rep ArtifactsFile x
$cto :: forall x. Rep ArtifactsFile x -> ArtifactsFile
to :: forall x. Rep ArtifactsFile x -> ArtifactsFile
Generic)

-- | Issue event
data IssueEvent = IssueEvent
  { IssueEvent -> Text
issue_event_event_type :: Text,
    IssueEvent -> Maybe UserEvent
issue_event_user :: Maybe UserEvent,
    IssueEvent -> Maybe ProjectEvent
issue_event_project :: Maybe ProjectEvent,
    IssueEvent -> Maybe IssueEventObjectAttributes
issue_event_object_attributes :: Maybe IssueEventObjectAttributes,
    IssueEvent -> Maybe [Label]
issue_event_labels :: Maybe [Label],
    IssueEvent -> Maybe IssueEventChanges
issue_event_changes :: Maybe IssueEventChanges,
    IssueEvent -> Maybe RepositoryEvent
issue_event_repository :: Maybe RepositoryEvent,
    IssueEvent -> Maybe [UserEvent]
issue_event_assignees :: Maybe [UserEvent]
  }
  deriving (Typeable, Int -> IssueEvent -> ShowS
[IssueEvent] -> ShowS
IssueEvent -> String
(Int -> IssueEvent -> ShowS)
-> (IssueEvent -> String)
-> ([IssueEvent] -> ShowS)
-> Show IssueEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IssueEvent -> ShowS
showsPrec :: Int -> IssueEvent -> ShowS
$cshow :: IssueEvent -> String
show :: IssueEvent -> String
$cshowList :: [IssueEvent] -> ShowS
showList :: [IssueEvent] -> ShowS
Show, IssueEvent -> IssueEvent -> Bool
(IssueEvent -> IssueEvent -> Bool)
-> (IssueEvent -> IssueEvent -> Bool) -> Eq IssueEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IssueEvent -> IssueEvent -> Bool
== :: IssueEvent -> IssueEvent -> Bool
$c/= :: IssueEvent -> IssueEvent -> Bool
/= :: IssueEvent -> IssueEvent -> Bool
Eq, (forall x. IssueEvent -> Rep IssueEvent x)
-> (forall x. Rep IssueEvent x -> IssueEvent) -> Generic IssueEvent
forall x. Rep IssueEvent x -> IssueEvent
forall x. IssueEvent -> Rep IssueEvent x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IssueEvent -> Rep IssueEvent x
from :: forall x. IssueEvent -> Rep IssueEvent x
$cto :: forall x. Rep IssueEvent x -> IssueEvent
to :: forall x. Rep IssueEvent x -> IssueEvent
Generic)

instance SystemHook IssueEvent where
  match :: String -> (IssueEvent -> GitLab ()) -> Rule
match = String -> (IssueEvent -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (IssueEvent -> GitLab Bool) -> (IssueEvent -> GitLab ()) -> Rule
matchIf = String
-> (IssueEvent -> GitLab Bool) -> (IssueEvent -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | Issue event object attributes
data IssueEventObjectAttributes = IssueEventObjectAttributes
  { IssueEventObjectAttributes -> Int
issue_event_object_attributes_author_id :: Int,
    IssueEventObjectAttributes -> Maybe Text
issue_event_object_attributes_closed_at :: Maybe Text, -- change to UTCTime
    IssueEventObjectAttributes -> Bool
issue_event_object_attributes_confidential :: Bool,
    IssueEventObjectAttributes -> Text
issue_event_object_attributes_created_at :: Text, -- change to UTCTime
    IssueEventObjectAttributes -> Maybe Text
issue_event_object_attributes_description :: Maybe Text,
    IssueEventObjectAttributes -> Maybe Bool
issue_event_object_attributes_discussion_locked :: Maybe Bool,
    IssueEventObjectAttributes -> Maybe Text
issue_event_object_attributes_due_date :: Maybe Text, -- change to UTCTime
    IssueEventObjectAttributes -> Int
issue_event_object_attributes_id :: Int,
    IssueEventObjectAttributes -> Int
issue_event_object_attributes_iid :: Int,
    IssueEventObjectAttributes -> Maybe Text
issue_event_object_attributes_last_edited_at :: Maybe Text, -- change to UTCTime
    IssueEventObjectAttributes -> Maybe Int
issue_event_object_attributes_last_edited_by_id :: Maybe Int,
    IssueEventObjectAttributes -> Maybe Int
issue_event_object_attributes_milestone_id :: Maybe Int,
    IssueEventObjectAttributes -> Maybe Int
issue_event_object_attributes_move_to_id :: Maybe Int,
    IssueEventObjectAttributes -> Maybe Int
issue_event_object_attributes_duplicated_to_id :: Maybe Int,
    IssueEventObjectAttributes -> Int
issue_event_object_attributes_project_id :: Int,
    IssueEventObjectAttributes -> Maybe Int
issue_event_object_attributes_relative_position :: Maybe Int,
    IssueEventObjectAttributes -> Int
issue_event_object_attributes_state_id :: Int,
    IssueEventObjectAttributes -> Int
issue_event_object_attributes_time_estimate :: Int,
    IssueEventObjectAttributes -> Text
issue_event_object_attributes_title :: Text,
    IssueEventObjectAttributes -> Text
issue_event_object_attributes_updated_at :: Text, -- change to UTCTime
    IssueEventObjectAttributes -> Maybe Int
issue_event_object_attributes_updated_by_id :: Maybe Int,
    IssueEventObjectAttributes -> Text
issue_event_object_attributes_type :: Text, -- "Issue"
    IssueEventObjectAttributes -> Text
issue_event_object_attributes_url :: Text,
    IssueEventObjectAttributes -> Int
issue_event_object_attributes_total_time_spent :: Int,
    IssueEventObjectAttributes -> Int
issue_event_object_attributes_time_change :: Int,
    IssueEventObjectAttributes -> Maybe Int
issue_event_object_attributes_human_total_time_spent :: Maybe Int,
    IssueEventObjectAttributes -> Maybe Int
issue_event_object_attributes_human_time_change :: Maybe Int,
    IssueEventObjectAttributes -> Maybe Int
issue_event_object_attributes_human_time_estimate :: Maybe Int
  }
  deriving (Typeable, Int -> IssueEventObjectAttributes -> ShowS
[IssueEventObjectAttributes] -> ShowS
IssueEventObjectAttributes -> String
(Int -> IssueEventObjectAttributes -> ShowS)
-> (IssueEventObjectAttributes -> String)
-> ([IssueEventObjectAttributes] -> ShowS)
-> Show IssueEventObjectAttributes
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IssueEventObjectAttributes -> ShowS
showsPrec :: Int -> IssueEventObjectAttributes -> ShowS
$cshow :: IssueEventObjectAttributes -> String
show :: IssueEventObjectAttributes -> String
$cshowList :: [IssueEventObjectAttributes] -> ShowS
showList :: [IssueEventObjectAttributes] -> ShowS
Show, IssueEventObjectAttributes -> IssueEventObjectAttributes -> Bool
(IssueEventObjectAttributes -> IssueEventObjectAttributes -> Bool)
-> (IssueEventObjectAttributes
    -> IssueEventObjectAttributes -> Bool)
-> Eq IssueEventObjectAttributes
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IssueEventObjectAttributes -> IssueEventObjectAttributes -> Bool
== :: IssueEventObjectAttributes -> IssueEventObjectAttributes -> Bool
$c/= :: IssueEventObjectAttributes -> IssueEventObjectAttributes -> Bool
/= :: IssueEventObjectAttributes -> IssueEventObjectAttributes -> Bool
Eq, (forall x.
 IssueEventObjectAttributes -> Rep IssueEventObjectAttributes x)
-> (forall x.
    Rep IssueEventObjectAttributes x -> IssueEventObjectAttributes)
-> Generic IssueEventObjectAttributes
forall x.
Rep IssueEventObjectAttributes x -> IssueEventObjectAttributes
forall x.
IssueEventObjectAttributes -> Rep IssueEventObjectAttributes x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
IssueEventObjectAttributes -> Rep IssueEventObjectAttributes x
from :: forall x.
IssueEventObjectAttributes -> Rep IssueEventObjectAttributes x
$cto :: forall x.
Rep IssueEventObjectAttributes x -> IssueEventObjectAttributes
to :: forall x.
Rep IssueEventObjectAttributes x -> IssueEventObjectAttributes
Generic)

-- | Issue event changes
data IssueEventChanges = IssueEventChanges
  { IssueEventChanges -> Maybe IssueChangesAuthorId
issue_event_changes_author_id :: Maybe IssueChangesAuthorId,
    IssueEventChanges -> Maybe IssueChangesCreatedAt
issue_event_changes_created_at :: Maybe IssueChangesCreatedAt,
    IssueEventChanges -> Maybe IssueChangesDescription
issue_event_changes_description :: Maybe IssueChangesDescription,
    IssueEventChanges -> Maybe IssueChangesId
issue_event_changes_id :: Maybe IssueChangesId,
    IssueEventChanges -> Maybe IssueChangesIid
issue_event_changes_iid :: Maybe IssueChangesIid,
    IssueEventChanges -> Maybe IssueChangesProjectId
issue_event_changes_project_id :: Maybe IssueChangesProjectId,
    IssueEventChanges -> Maybe IssueChangesTitle
issue_event_changes_title :: Maybe IssueChangesTitle,
    IssueEventChanges -> Maybe IssueChangesClosedAt
issue_event_changes_closed_at :: Maybe IssueChangesClosedAt,
    IssueEventChanges -> Maybe IssueChangesStateId
issue_event_changes_state_id :: Maybe IssueChangesStateId,
    IssueEventChanges -> Maybe IssueChangesUpdatedAt
issue_event_changes_updated_at :: Maybe IssueChangesUpdatedAt
  }
  deriving (Typeable, Int -> IssueEventChanges -> ShowS
[IssueEventChanges] -> ShowS
IssueEventChanges -> String
(Int -> IssueEventChanges -> ShowS)
-> (IssueEventChanges -> String)
-> ([IssueEventChanges] -> ShowS)
-> Show IssueEventChanges
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IssueEventChanges -> ShowS
showsPrec :: Int -> IssueEventChanges -> ShowS
$cshow :: IssueEventChanges -> String
show :: IssueEventChanges -> String
$cshowList :: [IssueEventChanges] -> ShowS
showList :: [IssueEventChanges] -> ShowS
Show, IssueEventChanges -> IssueEventChanges -> Bool
(IssueEventChanges -> IssueEventChanges -> Bool)
-> (IssueEventChanges -> IssueEventChanges -> Bool)
-> Eq IssueEventChanges
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IssueEventChanges -> IssueEventChanges -> Bool
== :: IssueEventChanges -> IssueEventChanges -> Bool
$c/= :: IssueEventChanges -> IssueEventChanges -> Bool
/= :: IssueEventChanges -> IssueEventChanges -> Bool
Eq, (forall x. IssueEventChanges -> Rep IssueEventChanges x)
-> (forall x. Rep IssueEventChanges x -> IssueEventChanges)
-> Generic IssueEventChanges
forall x. Rep IssueEventChanges x -> IssueEventChanges
forall x. IssueEventChanges -> Rep IssueEventChanges x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IssueEventChanges -> Rep IssueEventChanges x
from :: forall x. IssueEventChanges -> Rep IssueEventChanges x
$cto :: forall x. Rep IssueEventChanges x -> IssueEventChanges
to :: forall x. Rep IssueEventChanges x -> IssueEventChanges
Generic)

-- | Issue event author ID
data IssueChangesAuthorId = IssueChangesAuthorId
  { IssueChangesAuthorId -> Maybe Int
issue_event_author_id_previous :: Maybe Int,
    IssueChangesAuthorId -> Int
issue_event_author_id_current :: Int
  }
  deriving (Typeable, Int -> IssueChangesAuthorId -> ShowS
[IssueChangesAuthorId] -> ShowS
IssueChangesAuthorId -> String
(Int -> IssueChangesAuthorId -> ShowS)
-> (IssueChangesAuthorId -> String)
-> ([IssueChangesAuthorId] -> ShowS)
-> Show IssueChangesAuthorId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IssueChangesAuthorId -> ShowS
showsPrec :: Int -> IssueChangesAuthorId -> ShowS
$cshow :: IssueChangesAuthorId -> String
show :: IssueChangesAuthorId -> String
$cshowList :: [IssueChangesAuthorId] -> ShowS
showList :: [IssueChangesAuthorId] -> ShowS
Show, IssueChangesAuthorId -> IssueChangesAuthorId -> Bool
(IssueChangesAuthorId -> IssueChangesAuthorId -> Bool)
-> (IssueChangesAuthorId -> IssueChangesAuthorId -> Bool)
-> Eq IssueChangesAuthorId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IssueChangesAuthorId -> IssueChangesAuthorId -> Bool
== :: IssueChangesAuthorId -> IssueChangesAuthorId -> Bool
$c/= :: IssueChangesAuthorId -> IssueChangesAuthorId -> Bool
/= :: IssueChangesAuthorId -> IssueChangesAuthorId -> Bool
Eq, (forall x. IssueChangesAuthorId -> Rep IssueChangesAuthorId x)
-> (forall x. Rep IssueChangesAuthorId x -> IssueChangesAuthorId)
-> Generic IssueChangesAuthorId
forall x. Rep IssueChangesAuthorId x -> IssueChangesAuthorId
forall x. IssueChangesAuthorId -> Rep IssueChangesAuthorId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IssueChangesAuthorId -> Rep IssueChangesAuthorId x
from :: forall x. IssueChangesAuthorId -> Rep IssueChangesAuthorId x
$cto :: forall x. Rep IssueChangesAuthorId x -> IssueChangesAuthorId
to :: forall x. Rep IssueChangesAuthorId x -> IssueChangesAuthorId
Generic)

-- | Issue event created at
data IssueChangesCreatedAt = IssueChangesCreatedAt
  { IssueChangesCreatedAt -> Maybe Text
issue_event_created_at_previous :: Maybe Text, -- change to URLTime
    IssueChangesCreatedAt -> Text
issue_event_created_at_current :: Text -- change to URLTime
  }
  deriving (Typeable, Int -> IssueChangesCreatedAt -> ShowS
[IssueChangesCreatedAt] -> ShowS
IssueChangesCreatedAt -> String
(Int -> IssueChangesCreatedAt -> ShowS)
-> (IssueChangesCreatedAt -> String)
-> ([IssueChangesCreatedAt] -> ShowS)
-> Show IssueChangesCreatedAt
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IssueChangesCreatedAt -> ShowS
showsPrec :: Int -> IssueChangesCreatedAt -> ShowS
$cshow :: IssueChangesCreatedAt -> String
show :: IssueChangesCreatedAt -> String
$cshowList :: [IssueChangesCreatedAt] -> ShowS
showList :: [IssueChangesCreatedAt] -> ShowS
Show, IssueChangesCreatedAt -> IssueChangesCreatedAt -> Bool
(IssueChangesCreatedAt -> IssueChangesCreatedAt -> Bool)
-> (IssueChangesCreatedAt -> IssueChangesCreatedAt -> Bool)
-> Eq IssueChangesCreatedAt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IssueChangesCreatedAt -> IssueChangesCreatedAt -> Bool
== :: IssueChangesCreatedAt -> IssueChangesCreatedAt -> Bool
$c/= :: IssueChangesCreatedAt -> IssueChangesCreatedAt -> Bool
/= :: IssueChangesCreatedAt -> IssueChangesCreatedAt -> Bool
Eq, (forall x. IssueChangesCreatedAt -> Rep IssueChangesCreatedAt x)
-> (forall x. Rep IssueChangesCreatedAt x -> IssueChangesCreatedAt)
-> Generic IssueChangesCreatedAt
forall x. Rep IssueChangesCreatedAt x -> IssueChangesCreatedAt
forall x. IssueChangesCreatedAt -> Rep IssueChangesCreatedAt x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IssueChangesCreatedAt -> Rep IssueChangesCreatedAt x
from :: forall x. IssueChangesCreatedAt -> Rep IssueChangesCreatedAt x
$cto :: forall x. Rep IssueChangesCreatedAt x -> IssueChangesCreatedAt
to :: forall x. Rep IssueChangesCreatedAt x -> IssueChangesCreatedAt
Generic)

-- | Issue event description
data IssueChangesDescription = IssueChangesDescription
  { IssueChangesDescription -> Maybe Text
issue_event_description_previous :: Maybe Text,
    IssueChangesDescription -> Text
issue_event_description_current :: Text
  }
  deriving (Typeable, Int -> IssueChangesDescription -> ShowS
[IssueChangesDescription] -> ShowS
IssueChangesDescription -> String
(Int -> IssueChangesDescription -> ShowS)
-> (IssueChangesDescription -> String)
-> ([IssueChangesDescription] -> ShowS)
-> Show IssueChangesDescription
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IssueChangesDescription -> ShowS
showsPrec :: Int -> IssueChangesDescription -> ShowS
$cshow :: IssueChangesDescription -> String
show :: IssueChangesDescription -> String
$cshowList :: [IssueChangesDescription] -> ShowS
showList :: [IssueChangesDescription] -> ShowS
Show, IssueChangesDescription -> IssueChangesDescription -> Bool
(IssueChangesDescription -> IssueChangesDescription -> Bool)
-> (IssueChangesDescription -> IssueChangesDescription -> Bool)
-> Eq IssueChangesDescription
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IssueChangesDescription -> IssueChangesDescription -> Bool
== :: IssueChangesDescription -> IssueChangesDescription -> Bool
$c/= :: IssueChangesDescription -> IssueChangesDescription -> Bool
/= :: IssueChangesDescription -> IssueChangesDescription -> Bool
Eq, (forall x.
 IssueChangesDescription -> Rep IssueChangesDescription x)
-> (forall x.
    Rep IssueChangesDescription x -> IssueChangesDescription)
-> Generic IssueChangesDescription
forall x. Rep IssueChangesDescription x -> IssueChangesDescription
forall x. IssueChangesDescription -> Rep IssueChangesDescription x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IssueChangesDescription -> Rep IssueChangesDescription x
from :: forall x. IssueChangesDescription -> Rep IssueChangesDescription x
$cto :: forall x. Rep IssueChangesDescription x -> IssueChangesDescription
to :: forall x. Rep IssueChangesDescription x -> IssueChangesDescription
Generic)

-- | Issue event ID
data IssueChangesId = IssueChangesId
  { IssueChangesId -> Maybe Int
issue_event_id_previous :: Maybe Int,
    IssueChangesId -> Int
issue_event_id_current :: Int
  }
  deriving (Typeable, Int -> IssueChangesId -> ShowS
[IssueChangesId] -> ShowS
IssueChangesId -> String
(Int -> IssueChangesId -> ShowS)
-> (IssueChangesId -> String)
-> ([IssueChangesId] -> ShowS)
-> Show IssueChangesId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IssueChangesId -> ShowS
showsPrec :: Int -> IssueChangesId -> ShowS
$cshow :: IssueChangesId -> String
show :: IssueChangesId -> String
$cshowList :: [IssueChangesId] -> ShowS
showList :: [IssueChangesId] -> ShowS
Show, IssueChangesId -> IssueChangesId -> Bool
(IssueChangesId -> IssueChangesId -> Bool)
-> (IssueChangesId -> IssueChangesId -> Bool) -> Eq IssueChangesId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IssueChangesId -> IssueChangesId -> Bool
== :: IssueChangesId -> IssueChangesId -> Bool
$c/= :: IssueChangesId -> IssueChangesId -> Bool
/= :: IssueChangesId -> IssueChangesId -> Bool
Eq, (forall x. IssueChangesId -> Rep IssueChangesId x)
-> (forall x. Rep IssueChangesId x -> IssueChangesId)
-> Generic IssueChangesId
forall x. Rep IssueChangesId x -> IssueChangesId
forall x. IssueChangesId -> Rep IssueChangesId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IssueChangesId -> Rep IssueChangesId x
from :: forall x. IssueChangesId -> Rep IssueChangesId x
$cto :: forall x. Rep IssueChangesId x -> IssueChangesId
to :: forall x. Rep IssueChangesId x -> IssueChangesId
Generic)

-- | Issue event IID
data IssueChangesIid = IssueChangesIid
  { IssueChangesIid -> Maybe Int
issue_event_iid_previous :: Maybe Int,
    IssueChangesIid -> Int
issue_event_iid_current :: Int
  }
  deriving (Typeable, Int -> IssueChangesIid -> ShowS
[IssueChangesIid] -> ShowS
IssueChangesIid -> String
(Int -> IssueChangesIid -> ShowS)
-> (IssueChangesIid -> String)
-> ([IssueChangesIid] -> ShowS)
-> Show IssueChangesIid
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IssueChangesIid -> ShowS
showsPrec :: Int -> IssueChangesIid -> ShowS
$cshow :: IssueChangesIid -> String
show :: IssueChangesIid -> String
$cshowList :: [IssueChangesIid] -> ShowS
showList :: [IssueChangesIid] -> ShowS
Show, IssueChangesIid -> IssueChangesIid -> Bool
(IssueChangesIid -> IssueChangesIid -> Bool)
-> (IssueChangesIid -> IssueChangesIid -> Bool)
-> Eq IssueChangesIid
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IssueChangesIid -> IssueChangesIid -> Bool
== :: IssueChangesIid -> IssueChangesIid -> Bool
$c/= :: IssueChangesIid -> IssueChangesIid -> Bool
/= :: IssueChangesIid -> IssueChangesIid -> Bool
Eq, (forall x. IssueChangesIid -> Rep IssueChangesIid x)
-> (forall x. Rep IssueChangesIid x -> IssueChangesIid)
-> Generic IssueChangesIid
forall x. Rep IssueChangesIid x -> IssueChangesIid
forall x. IssueChangesIid -> Rep IssueChangesIid x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IssueChangesIid -> Rep IssueChangesIid x
from :: forall x. IssueChangesIid -> Rep IssueChangesIid x
$cto :: forall x. Rep IssueChangesIid x -> IssueChangesIid
to :: forall x. Rep IssueChangesIid x -> IssueChangesIid
Generic)

-- | Issue event project ID
data IssueChangesProjectId = IssueChangesProjectId
  { IssueChangesProjectId -> Maybe Int
issue_event_project_id_previous :: Maybe Int,
    IssueChangesProjectId -> Int
issue_event_project_id_current :: Int
  }
  deriving (Typeable, Int -> IssueChangesProjectId -> ShowS
[IssueChangesProjectId] -> ShowS
IssueChangesProjectId -> String
(Int -> IssueChangesProjectId -> ShowS)
-> (IssueChangesProjectId -> String)
-> ([IssueChangesProjectId] -> ShowS)
-> Show IssueChangesProjectId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IssueChangesProjectId -> ShowS
showsPrec :: Int -> IssueChangesProjectId -> ShowS
$cshow :: IssueChangesProjectId -> String
show :: IssueChangesProjectId -> String
$cshowList :: [IssueChangesProjectId] -> ShowS
showList :: [IssueChangesProjectId] -> ShowS
Show, IssueChangesProjectId -> IssueChangesProjectId -> Bool
(IssueChangesProjectId -> IssueChangesProjectId -> Bool)
-> (IssueChangesProjectId -> IssueChangesProjectId -> Bool)
-> Eq IssueChangesProjectId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IssueChangesProjectId -> IssueChangesProjectId -> Bool
== :: IssueChangesProjectId -> IssueChangesProjectId -> Bool
$c/= :: IssueChangesProjectId -> IssueChangesProjectId -> Bool
/= :: IssueChangesProjectId -> IssueChangesProjectId -> Bool
Eq, (forall x. IssueChangesProjectId -> Rep IssueChangesProjectId x)
-> (forall x. Rep IssueChangesProjectId x -> IssueChangesProjectId)
-> Generic IssueChangesProjectId
forall x. Rep IssueChangesProjectId x -> IssueChangesProjectId
forall x. IssueChangesProjectId -> Rep IssueChangesProjectId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IssueChangesProjectId -> Rep IssueChangesProjectId x
from :: forall x. IssueChangesProjectId -> Rep IssueChangesProjectId x
$cto :: forall x. Rep IssueChangesProjectId x -> IssueChangesProjectId
to :: forall x. Rep IssueChangesProjectId x -> IssueChangesProjectId
Generic)

-- | Issue event title
data IssueChangesTitle = IssueChangesTitle
  { IssueChangesTitle -> Maybe Text
issue_event_title_previous :: Maybe Text,
    IssueChangesTitle -> Text
issue_event_title_current :: Text
  }
  deriving (Typeable, Int -> IssueChangesTitle -> ShowS
[IssueChangesTitle] -> ShowS
IssueChangesTitle -> String
(Int -> IssueChangesTitle -> ShowS)
-> (IssueChangesTitle -> String)
-> ([IssueChangesTitle] -> ShowS)
-> Show IssueChangesTitle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IssueChangesTitle -> ShowS
showsPrec :: Int -> IssueChangesTitle -> ShowS
$cshow :: IssueChangesTitle -> String
show :: IssueChangesTitle -> String
$cshowList :: [IssueChangesTitle] -> ShowS
showList :: [IssueChangesTitle] -> ShowS
Show, IssueChangesTitle -> IssueChangesTitle -> Bool
(IssueChangesTitle -> IssueChangesTitle -> Bool)
-> (IssueChangesTitle -> IssueChangesTitle -> Bool)
-> Eq IssueChangesTitle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IssueChangesTitle -> IssueChangesTitle -> Bool
== :: IssueChangesTitle -> IssueChangesTitle -> Bool
$c/= :: IssueChangesTitle -> IssueChangesTitle -> Bool
/= :: IssueChangesTitle -> IssueChangesTitle -> Bool
Eq, (forall x. IssueChangesTitle -> Rep IssueChangesTitle x)
-> (forall x. Rep IssueChangesTitle x -> IssueChangesTitle)
-> Generic IssueChangesTitle
forall x. Rep IssueChangesTitle x -> IssueChangesTitle
forall x. IssueChangesTitle -> Rep IssueChangesTitle x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IssueChangesTitle -> Rep IssueChangesTitle x
from :: forall x. IssueChangesTitle -> Rep IssueChangesTitle x
$cto :: forall x. Rep IssueChangesTitle x -> IssueChangesTitle
to :: forall x. Rep IssueChangesTitle x -> IssueChangesTitle
Generic)

-- | Issue event closed at
data IssueChangesClosedAt = IssueChangesClosedAt
  { IssueChangesClosedAt -> Maybe Text
issue_event_closed_at_previous :: Maybe Text, -- change to URLTime
    IssueChangesClosedAt -> Maybe Text
issue_event_closed_at_current :: Maybe Text -- change to URLTime
  }
  deriving (Typeable, Int -> IssueChangesClosedAt -> ShowS
[IssueChangesClosedAt] -> ShowS
IssueChangesClosedAt -> String
(Int -> IssueChangesClosedAt -> ShowS)
-> (IssueChangesClosedAt -> String)
-> ([IssueChangesClosedAt] -> ShowS)
-> Show IssueChangesClosedAt
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IssueChangesClosedAt -> ShowS
showsPrec :: Int -> IssueChangesClosedAt -> ShowS
$cshow :: IssueChangesClosedAt -> String
show :: IssueChangesClosedAt -> String
$cshowList :: [IssueChangesClosedAt] -> ShowS
showList :: [IssueChangesClosedAt] -> ShowS
Show, IssueChangesClosedAt -> IssueChangesClosedAt -> Bool
(IssueChangesClosedAt -> IssueChangesClosedAt -> Bool)
-> (IssueChangesClosedAt -> IssueChangesClosedAt -> Bool)
-> Eq IssueChangesClosedAt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IssueChangesClosedAt -> IssueChangesClosedAt -> Bool
== :: IssueChangesClosedAt -> IssueChangesClosedAt -> Bool
$c/= :: IssueChangesClosedAt -> IssueChangesClosedAt -> Bool
/= :: IssueChangesClosedAt -> IssueChangesClosedAt -> Bool
Eq, (forall x. IssueChangesClosedAt -> Rep IssueChangesClosedAt x)
-> (forall x. Rep IssueChangesClosedAt x -> IssueChangesClosedAt)
-> Generic IssueChangesClosedAt
forall x. Rep IssueChangesClosedAt x -> IssueChangesClosedAt
forall x. IssueChangesClosedAt -> Rep IssueChangesClosedAt x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IssueChangesClosedAt -> Rep IssueChangesClosedAt x
from :: forall x. IssueChangesClosedAt -> Rep IssueChangesClosedAt x
$cto :: forall x. Rep IssueChangesClosedAt x -> IssueChangesClosedAt
to :: forall x. Rep IssueChangesClosedAt x -> IssueChangesClosedAt
Generic)

-- | Issue event state id
data IssueChangesStateId = IssueChangesStateId
  { IssueChangesStateId -> Maybe Int
issue_event_state_id_previous :: Maybe Int,
    IssueChangesStateId -> Int
issue_event_state_id_current :: Int
  }
  deriving (Typeable, Int -> IssueChangesStateId -> ShowS
[IssueChangesStateId] -> ShowS
IssueChangesStateId -> String
(Int -> IssueChangesStateId -> ShowS)
-> (IssueChangesStateId -> String)
-> ([IssueChangesStateId] -> ShowS)
-> Show IssueChangesStateId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IssueChangesStateId -> ShowS
showsPrec :: Int -> IssueChangesStateId -> ShowS
$cshow :: IssueChangesStateId -> String
show :: IssueChangesStateId -> String
$cshowList :: [IssueChangesStateId] -> ShowS
showList :: [IssueChangesStateId] -> ShowS
Show, IssueChangesStateId -> IssueChangesStateId -> Bool
(IssueChangesStateId -> IssueChangesStateId -> Bool)
-> (IssueChangesStateId -> IssueChangesStateId -> Bool)
-> Eq IssueChangesStateId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IssueChangesStateId -> IssueChangesStateId -> Bool
== :: IssueChangesStateId -> IssueChangesStateId -> Bool
$c/= :: IssueChangesStateId -> IssueChangesStateId -> Bool
/= :: IssueChangesStateId -> IssueChangesStateId -> Bool
Eq, (forall x. IssueChangesStateId -> Rep IssueChangesStateId x)
-> (forall x. Rep IssueChangesStateId x -> IssueChangesStateId)
-> Generic IssueChangesStateId
forall x. Rep IssueChangesStateId x -> IssueChangesStateId
forall x. IssueChangesStateId -> Rep IssueChangesStateId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IssueChangesStateId -> Rep IssueChangesStateId x
from :: forall x. IssueChangesStateId -> Rep IssueChangesStateId x
$cto :: forall x. Rep IssueChangesStateId x -> IssueChangesStateId
to :: forall x. Rep IssueChangesStateId x -> IssueChangesStateId
Generic)

-- | Issue event updated at
data IssueChangesUpdatedAt = IssueChangesUpdatedAt
  { IssueChangesUpdatedAt -> Maybe Text
issue_event_updated_at_previous :: Maybe Text, -- change to URLTime
    IssueChangesUpdatedAt -> Text
issue_event_updated_at_current :: Text -- change to URLTime
  }
  deriving (Typeable, Int -> IssueChangesUpdatedAt -> ShowS
[IssueChangesUpdatedAt] -> ShowS
IssueChangesUpdatedAt -> String
(Int -> IssueChangesUpdatedAt -> ShowS)
-> (IssueChangesUpdatedAt -> String)
-> ([IssueChangesUpdatedAt] -> ShowS)
-> Show IssueChangesUpdatedAt
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IssueChangesUpdatedAt -> ShowS
showsPrec :: Int -> IssueChangesUpdatedAt -> ShowS
$cshow :: IssueChangesUpdatedAt -> String
show :: IssueChangesUpdatedAt -> String
$cshowList :: [IssueChangesUpdatedAt] -> ShowS
showList :: [IssueChangesUpdatedAt] -> ShowS
Show, IssueChangesUpdatedAt -> IssueChangesUpdatedAt -> Bool
(IssueChangesUpdatedAt -> IssueChangesUpdatedAt -> Bool)
-> (IssueChangesUpdatedAt -> IssueChangesUpdatedAt -> Bool)
-> Eq IssueChangesUpdatedAt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IssueChangesUpdatedAt -> IssueChangesUpdatedAt -> Bool
== :: IssueChangesUpdatedAt -> IssueChangesUpdatedAt -> Bool
$c/= :: IssueChangesUpdatedAt -> IssueChangesUpdatedAt -> Bool
/= :: IssueChangesUpdatedAt -> IssueChangesUpdatedAt -> Bool
Eq, (forall x. IssueChangesUpdatedAt -> Rep IssueChangesUpdatedAt x)
-> (forall x. Rep IssueChangesUpdatedAt x -> IssueChangesUpdatedAt)
-> Generic IssueChangesUpdatedAt
forall x. Rep IssueChangesUpdatedAt x -> IssueChangesUpdatedAt
forall x. IssueChangesUpdatedAt -> Rep IssueChangesUpdatedAt x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IssueChangesUpdatedAt -> Rep IssueChangesUpdatedAt x
from :: forall x. IssueChangesUpdatedAt -> Rep IssueChangesUpdatedAt x
$cto :: forall x. Rep IssueChangesUpdatedAt x -> IssueChangesUpdatedAt
to :: forall x. Rep IssueChangesUpdatedAt x -> IssueChangesUpdatedAt
Generic)

-- -- | Issue event state id
-- data IssueEventUpdatedAt = IssueEventUpdatedAt
--   { issue_event_closed_at_previous :: Maybe Text, -- change to URLTime
--     issue_event_closed_at_current :: Text -- change to URLTime
--   }
--   deriving (Typeable, Show, Eq, Generic)

-- | Note event
data NoteEvent = NoteEvent
  { NoteEvent -> Text
note_event_object_kind :: Text,
    NoteEvent -> Text
note_event_event_type :: Text,
    NoteEvent -> User
note_event_user :: User,
    NoteEvent -> Int
note_event_project_id :: Int,
    NoteEvent -> ProjectEvent
note_event_project :: ProjectEvent,
    NoteEvent -> NoteObjectAttributes
note_event_object_attributes :: NoteObjectAttributes,
    NoteEvent -> RepositoryEvent
note_event_repository :: RepositoryEvent,
    NoteEvent -> Maybe IssueEventObjectAttributes
note_event_issue :: Maybe IssueEventObjectAttributes
  }
  deriving (Typeable, Int -> NoteEvent -> ShowS
[NoteEvent] -> ShowS
NoteEvent -> String
(Int -> NoteEvent -> ShowS)
-> (NoteEvent -> String)
-> ([NoteEvent] -> ShowS)
-> Show NoteEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NoteEvent -> ShowS
showsPrec :: Int -> NoteEvent -> ShowS
$cshow :: NoteEvent -> String
show :: NoteEvent -> String
$cshowList :: [NoteEvent] -> ShowS
showList :: [NoteEvent] -> ShowS
Show, NoteEvent -> NoteEvent -> Bool
(NoteEvent -> NoteEvent -> Bool)
-> (NoteEvent -> NoteEvent -> Bool) -> Eq NoteEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NoteEvent -> NoteEvent -> Bool
== :: NoteEvent -> NoteEvent -> Bool
$c/= :: NoteEvent -> NoteEvent -> Bool
/= :: NoteEvent -> NoteEvent -> Bool
Eq, (forall x. NoteEvent -> Rep NoteEvent x)
-> (forall x. Rep NoteEvent x -> NoteEvent) -> Generic NoteEvent
forall x. Rep NoteEvent x -> NoteEvent
forall x. NoteEvent -> Rep NoteEvent x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NoteEvent -> Rep NoteEvent x
from :: forall x. NoteEvent -> Rep NoteEvent x
$cto :: forall x. Rep NoteEvent x -> NoteEvent
to :: forall x. Rep NoteEvent x -> NoteEvent
Generic)

instance SystemHook NoteEvent where
  match :: String -> (NoteEvent -> GitLab ()) -> Rule
match = String -> (NoteEvent -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (NoteEvent -> GitLab Bool) -> (NoteEvent -> GitLab ()) -> Rule
matchIf = String
-> (NoteEvent -> GitLab Bool) -> (NoteEvent -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

-- | CI pipeline attributes
data NoteObjectAttributes = NoteObjectAttributes
  { NoteObjectAttributes -> Maybe Text
note_object_attributes_attachment :: Maybe Text, -- ?
    NoteObjectAttributes -> Int
note_object_attributes_author_id :: Int,
    NoteObjectAttributes -> Maybe Text
note_object_attributes_change_position :: Maybe Text, -- ?
    NoteObjectAttributes -> Maybe String
note_object_attributes_commit_id :: Maybe String,
    NoteObjectAttributes -> Text
note_object_attributes_created_at :: Text, -- change to date
    NoteObjectAttributes -> Text
note_object_attributes_discussion_id :: Text,
    NoteObjectAttributes -> Int
note_object_attributes_id :: Int,
    NoteObjectAttributes -> Maybe Int
note_object_attributes_line_code :: Maybe Int, -- ?
    NoteObjectAttributes -> Text
note_object_attributes_note :: Text,
    NoteObjectAttributes -> Maybe Int
note_object_attributes_noteable_id :: Maybe Int,
    NoteObjectAttributes -> Text
note_object_attributes_noteable_type :: Text, -- "Issue"
    NoteObjectAttributes -> Maybe Int
note_object_attributes_original_position :: Maybe Int, -- ?
    NoteObjectAttributes -> Maybe Int
note_object_attributes_position :: Maybe Int, -- ?
    NoteObjectAttributes -> Int
note_object_attributes_project_id :: Int,
    NoteObjectAttributes -> Maybe Text
note_object_attributes_resolved_at :: Maybe Text, -- date?
    NoteObjectAttributes -> Maybe Int
note_object_attributes_resolved_by_id :: Maybe Int,
    NoteObjectAttributes -> Maybe Int
note_object_attributes_resolved_by_push :: Maybe Int, -- ?
    NoteObjectAttributes -> Maybe Text
note_object_attributes_st_diff :: Maybe Text, -- ?
    NoteObjectAttributes -> Bool
note_object_attributes_system :: Bool,
    NoteObjectAttributes -> Maybe Text
note_object_attributes_type :: Maybe Text, -- ?
    NoteObjectAttributes -> Maybe Text
note_object_attributes_updated_at :: Maybe Text, -- date?
    NoteObjectAttributes -> Maybe Int
note_object_attributes_updated_by_id :: Maybe Int, -- ?
    NoteObjectAttributes -> Text
note_object_attributes_description :: Text,
    NoteObjectAttributes -> Text
note_object_attributes_url :: Text,
    NoteObjectAttributes -> Text
note_object_attributes_action :: Text -- "create"
  }
  deriving (Typeable, Int -> NoteObjectAttributes -> ShowS
[NoteObjectAttributes] -> ShowS
NoteObjectAttributes -> String
(Int -> NoteObjectAttributes -> ShowS)
-> (NoteObjectAttributes -> String)
-> ([NoteObjectAttributes] -> ShowS)
-> Show NoteObjectAttributes
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NoteObjectAttributes -> ShowS
showsPrec :: Int -> NoteObjectAttributes -> ShowS
$cshow :: NoteObjectAttributes -> String
show :: NoteObjectAttributes -> String
$cshowList :: [NoteObjectAttributes] -> ShowS
showList :: [NoteObjectAttributes] -> ShowS
Show, NoteObjectAttributes -> NoteObjectAttributes -> Bool
(NoteObjectAttributes -> NoteObjectAttributes -> Bool)
-> (NoteObjectAttributes -> NoteObjectAttributes -> Bool)
-> Eq NoteObjectAttributes
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NoteObjectAttributes -> NoteObjectAttributes -> Bool
== :: NoteObjectAttributes -> NoteObjectAttributes -> Bool
$c/= :: NoteObjectAttributes -> NoteObjectAttributes -> Bool
/= :: NoteObjectAttributes -> NoteObjectAttributes -> Bool
Eq, (forall x. NoteObjectAttributes -> Rep NoteObjectAttributes x)
-> (forall x. Rep NoteObjectAttributes x -> NoteObjectAttributes)
-> Generic NoteObjectAttributes
forall x. Rep NoteObjectAttributes x -> NoteObjectAttributes
forall x. NoteObjectAttributes -> Rep NoteObjectAttributes x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NoteObjectAttributes -> Rep NoteObjectAttributes x
from :: forall x. NoteObjectAttributes -> Rep NoteObjectAttributes x
$cto :: forall x. Rep NoteObjectAttributes x -> NoteObjectAttributes
to :: forall x. Rep NoteObjectAttributes x -> NoteObjectAttributes
Generic)

-- | Note event
data WikiPageEvent = WikiPageEvent
  { WikiPageEvent -> Text
wiki_page_event_object_kind :: Text,
    WikiPageEvent -> User
wiki_page_event_user :: User,
    -- wiki_page_event_project :: Maybe Project, -- this will not parse but the JSON elements are too different from Project type
    WikiPageEvent -> Wiki
wiki_page_event_wiki :: Wiki,
    WikiPageEvent -> WikiPageObjectAttributes
wiki_page_event_object_attributes :: WikiPageObjectAttributes
  }
  deriving (Typeable, Int -> WikiPageEvent -> ShowS
[WikiPageEvent] -> ShowS
WikiPageEvent -> String
(Int -> WikiPageEvent -> ShowS)
-> (WikiPageEvent -> String)
-> ([WikiPageEvent] -> ShowS)
-> Show WikiPageEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WikiPageEvent -> ShowS
showsPrec :: Int -> WikiPageEvent -> ShowS
$cshow :: WikiPageEvent -> String
show :: WikiPageEvent -> String
$cshowList :: [WikiPageEvent] -> ShowS
showList :: [WikiPageEvent] -> ShowS
Show, WikiPageEvent -> WikiPageEvent -> Bool
(WikiPageEvent -> WikiPageEvent -> Bool)
-> (WikiPageEvent -> WikiPageEvent -> Bool) -> Eq WikiPageEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WikiPageEvent -> WikiPageEvent -> Bool
== :: WikiPageEvent -> WikiPageEvent -> Bool
$c/= :: WikiPageEvent -> WikiPageEvent -> Bool
/= :: WikiPageEvent -> WikiPageEvent -> Bool
Eq, (forall x. WikiPageEvent -> Rep WikiPageEvent x)
-> (forall x. Rep WikiPageEvent x -> WikiPageEvent)
-> Generic WikiPageEvent
forall x. Rep WikiPageEvent x -> WikiPageEvent
forall x. WikiPageEvent -> Rep WikiPageEvent x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. WikiPageEvent -> Rep WikiPageEvent x
from :: forall x. WikiPageEvent -> Rep WikiPageEvent x
$cto :: forall x. Rep WikiPageEvent x -> WikiPageEvent
to :: forall x. Rep WikiPageEvent x -> WikiPageEvent
Generic)

instance SystemHook WikiPageEvent where
  match :: String -> (WikiPageEvent -> GitLab ()) -> Rule
match = String -> (WikiPageEvent -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (WikiPageEvent -> GitLab Bool)
-> (WikiPageEvent -> GitLab ())
-> Rule
matchIf = String
-> (WikiPageEvent -> GitLab Bool)
-> (WikiPageEvent -> GitLab ())
-> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

data Wiki = Wiki
  { Wiki -> Maybe Text
wiki_web_url :: Maybe Text, -- use URL related type in future for these
    Wiki -> Maybe Text
wiki_git_ssh_url :: Maybe Text,
    Wiki -> Maybe Text
wiki_git_http_url :: Maybe Text,
    Wiki -> Maybe Text
wiki_path_with_namespace :: Maybe Text,
    Wiki -> Maybe Text
wiki_default_branch :: Maybe Text
  }
  deriving (Typeable, Int -> Wiki -> ShowS
[Wiki] -> ShowS
Wiki -> String
(Int -> Wiki -> ShowS)
-> (Wiki -> String) -> ([Wiki] -> ShowS) -> Show Wiki
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Wiki -> ShowS
showsPrec :: Int -> Wiki -> ShowS
$cshow :: Wiki -> String
show :: Wiki -> String
$cshowList :: [Wiki] -> ShowS
showList :: [Wiki] -> ShowS
Show, Wiki -> Wiki -> Bool
(Wiki -> Wiki -> Bool) -> (Wiki -> Wiki -> Bool) -> Eq Wiki
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Wiki -> Wiki -> Bool
== :: Wiki -> Wiki -> Bool
$c/= :: Wiki -> Wiki -> Bool
/= :: Wiki -> Wiki -> Bool
Eq, (forall x. Wiki -> Rep Wiki x)
-> (forall x. Rep Wiki x -> Wiki) -> Generic Wiki
forall x. Rep Wiki x -> Wiki
forall x. Wiki -> Rep Wiki x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Wiki -> Rep Wiki x
from :: forall x. Wiki -> Rep Wiki x
$cto :: forall x. Rep Wiki x -> Wiki
to :: forall x. Rep Wiki x -> Wiki
Generic)

data WikiPageObjectAttributes = WikiPageObjectAttributes
  { WikiPageObjectAttributes -> Maybe Text
wiki_page_object_attributes_slug :: Maybe Text,
    WikiPageObjectAttributes -> Maybe Text
wiki_page_object_attributes_title :: Maybe Text,
    WikiPageObjectAttributes -> Maybe Text
wiki_page_object_attributes_format :: Maybe Text,
    WikiPageObjectAttributes -> Maybe Text
wiki_page_object_attributes_message :: Maybe Text,
    WikiPageObjectAttributes -> Maybe Text
wiki_page_object_attributes_version_id :: Maybe Text,
    WikiPageObjectAttributes -> Maybe Text
wiki_page_object_attributes_url :: Maybe Text,
    WikiPageObjectAttributes -> Maybe Text
wiki_page_object_attributes_action :: Maybe Text, -- 'update' .. better type in future?
    WikiPageObjectAttributes -> Maybe Text
wiki_page_object_attributes_diff_url :: Maybe Text
  }
  deriving (Typeable, Int -> WikiPageObjectAttributes -> ShowS
[WikiPageObjectAttributes] -> ShowS
WikiPageObjectAttributes -> String
(Int -> WikiPageObjectAttributes -> ShowS)
-> (WikiPageObjectAttributes -> String)
-> ([WikiPageObjectAttributes] -> ShowS)
-> Show WikiPageObjectAttributes
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WikiPageObjectAttributes -> ShowS
showsPrec :: Int -> WikiPageObjectAttributes -> ShowS
$cshow :: WikiPageObjectAttributes -> String
show :: WikiPageObjectAttributes -> String
$cshowList :: [WikiPageObjectAttributes] -> ShowS
showList :: [WikiPageObjectAttributes] -> ShowS
Show, WikiPageObjectAttributes -> WikiPageObjectAttributes -> Bool
(WikiPageObjectAttributes -> WikiPageObjectAttributes -> Bool)
-> (WikiPageObjectAttributes -> WikiPageObjectAttributes -> Bool)
-> Eq WikiPageObjectAttributes
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WikiPageObjectAttributes -> WikiPageObjectAttributes -> Bool
== :: WikiPageObjectAttributes -> WikiPageObjectAttributes -> Bool
$c/= :: WikiPageObjectAttributes -> WikiPageObjectAttributes -> Bool
/= :: WikiPageObjectAttributes -> WikiPageObjectAttributes -> Bool
Eq, (forall x.
 WikiPageObjectAttributes -> Rep WikiPageObjectAttributes x)
-> (forall x.
    Rep WikiPageObjectAttributes x -> WikiPageObjectAttributes)
-> Generic WikiPageObjectAttributes
forall x.
Rep WikiPageObjectAttributes x -> WikiPageObjectAttributes
forall x.
WikiPageObjectAttributes -> Rep WikiPageObjectAttributes x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
WikiPageObjectAttributes -> Rep WikiPageObjectAttributes x
from :: forall x.
WikiPageObjectAttributes -> Rep WikiPageObjectAttributes x
$cto :: forall x.
Rep WikiPageObjectAttributes x -> WikiPageObjectAttributes
to :: forall x.
Rep WikiPageObjectAttributes x -> WikiPageObjectAttributes
Generic)

-- TODO remove object_kind fields, they can be discarded after checking their values.

data WorkItemEvent = WorkItemEvent
  { WorkItemEvent -> User
work_item_event_user :: User,
    WorkItemEvent -> WorkItemObjectAttributes
work_item_event_object_attributes :: WorkItemObjectAttributes,
    WorkItemEvent -> [Label]
work_item_event_labels :: [Label],
    -- work_item_event_changes :: Change,
    WorkItemEvent -> Repository
work_item_event_repository :: Repository,
    WorkItemEvent -> [User]
work_item_event_assignees :: [User]
  }
  deriving (Typeable, Int -> WorkItemEvent -> ShowS
[WorkItemEvent] -> ShowS
WorkItemEvent -> String
(Int -> WorkItemEvent -> ShowS)
-> (WorkItemEvent -> String)
-> ([WorkItemEvent] -> ShowS)
-> Show WorkItemEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WorkItemEvent -> ShowS
showsPrec :: Int -> WorkItemEvent -> ShowS
$cshow :: WorkItemEvent -> String
show :: WorkItemEvent -> String
$cshowList :: [WorkItemEvent] -> ShowS
showList :: [WorkItemEvent] -> ShowS
Show, WorkItemEvent -> WorkItemEvent -> Bool
(WorkItemEvent -> WorkItemEvent -> Bool)
-> (WorkItemEvent -> WorkItemEvent -> Bool) -> Eq WorkItemEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WorkItemEvent -> WorkItemEvent -> Bool
== :: WorkItemEvent -> WorkItemEvent -> Bool
$c/= :: WorkItemEvent -> WorkItemEvent -> Bool
/= :: WorkItemEvent -> WorkItemEvent -> Bool
Eq, (forall x. WorkItemEvent -> Rep WorkItemEvent x)
-> (forall x. Rep WorkItemEvent x -> WorkItemEvent)
-> Generic WorkItemEvent
forall x. Rep WorkItemEvent x -> WorkItemEvent
forall x. WorkItemEvent -> Rep WorkItemEvent x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. WorkItemEvent -> Rep WorkItemEvent x
from :: forall x. WorkItemEvent -> Rep WorkItemEvent x
$cto :: forall x. Rep WorkItemEvent x -> WorkItemEvent
to :: forall x. Rep WorkItemEvent x -> WorkItemEvent
Generic)

instance SystemHook WorkItemEvent where
  match :: String -> (WorkItemEvent -> GitLab ()) -> Rule
match = String -> (WorkItemEvent -> GitLab ()) -> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab ()) -> Rule
Match
  matchIf :: String
-> (WorkItemEvent -> GitLab Bool)
-> (WorkItemEvent -> GitLab ())
-> Rule
matchIf = String
-> (WorkItemEvent -> GitLab Bool)
-> (WorkItemEvent -> GitLab ())
-> Rule
forall a.
(Typeable a, SystemHook a) =>
String -> (a -> GitLab Bool) -> (a -> GitLab ()) -> Rule
MatchIf

data WorkItemObjectAttributes = WorkItemObjectAttributes
  { WorkItemObjectAttributes -> Int
work_item_object_author_id :: Int,
    WorkItemObjectAttributes -> Text
work_item_object_closed_at :: Text, -- change to date type
    WorkItemObjectAttributes -> Bool
work_item_object_confidential :: Bool,
    WorkItemObjectAttributes -> Text
work_item_object_created_at :: Text, -- change to date type
    WorkItemObjectAttributes -> Maybe Text
work_item_object_description :: Maybe Text,
    WorkItemObjectAttributes -> Maybe Bool
work_item_object_discussion_locked :: Maybe Bool,
    WorkItemObjectAttributes -> Maybe Text
work_item_object_due_date :: Maybe Text, -- chanage to date type
    WorkItemObjectAttributes -> Int
work_item_object_id :: Int,
    WorkItemObjectAttributes -> Int
work_item_object_iid :: Int,
    WorkItemObjectAttributes -> Maybe Text
work_item_object_last_edited_at :: Maybe Text,
    WorkItemObjectAttributes -> Maybe Int
work_item_object_last_edited_by_id :: Maybe Int,
    WorkItemObjectAttributes -> Maybe Int
work_item_object_milestone_id :: Maybe Int,
    WorkItemObjectAttributes -> Maybe Int
work_item_object_moved_to_id :: Maybe Int,
    WorkItemObjectAttributes -> Maybe Int
work_item_object_duplicated_to_id :: Maybe Int,
    WorkItemObjectAttributes -> Int
work_item_object_project_id :: Int,
    WorkItemObjectAttributes -> Int
work_item_object_relative_position :: Int,
    WorkItemObjectAttributes -> Int
work_item_object_state_id :: Int,
    WorkItemObjectAttributes -> Int
work_item_object_time_estimate :: Int,
    WorkItemObjectAttributes -> Text
work_item_object_title :: Text,
    WorkItemObjectAttributes -> Text
work_item_object_updated_at :: Text,
    WorkItemObjectAttributes -> Int
work_item_object_updated_by_id :: Int,
    WorkItemObjectAttributes -> Text
work_item_object_type :: Text, -- change to own type e.g. "Task"
    WorkItemObjectAttributes -> Text
work_item_object_url :: Text,
    WorkItemObjectAttributes -> Int
work_item_object_total_time_spent :: Int,
    WorkItemObjectAttributes -> Int
work_item_object_time_change :: Int,
    WorkItemObjectAttributes -> Maybe Int
work_item_object_human_total_time_spent :: Maybe Int,
    WorkItemObjectAttributes -> Maybe Int
work_item_object_human_time_change :: Maybe Int,
    WorkItemObjectAttributes -> Maybe Int
work_item_object_human_time_estimate :: Maybe Int,
    WorkItemObjectAttributes -> [Int]
work_item_object_assignee_ids :: [Int],
    WorkItemObjectAttributes -> Int
work_item_object_assignee_id :: Int,
    WorkItemObjectAttributes -> [Label]
work_item_object_labels :: [Label],
    WorkItemObjectAttributes -> Text
work_item_object_state :: Text, -- change to own type e.g. "closed"
    WorkItemObjectAttributes -> Text
work_item_object_severity :: Text, -- change to own type e.g. "unknown"
    WorkItemObjectAttributes -> [Text]
work_item_object_customer_relations_contacts :: [Text],
    WorkItemObjectAttributes -> Text
work_item_object_action :: Text -- change to own type e.g. "close"
  }
  deriving (Typeable, Int -> WorkItemObjectAttributes -> ShowS
[WorkItemObjectAttributes] -> ShowS
WorkItemObjectAttributes -> String
(Int -> WorkItemObjectAttributes -> ShowS)
-> (WorkItemObjectAttributes -> String)
-> ([WorkItemObjectAttributes] -> ShowS)
-> Show WorkItemObjectAttributes
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WorkItemObjectAttributes -> ShowS
showsPrec :: Int -> WorkItemObjectAttributes -> ShowS
$cshow :: WorkItemObjectAttributes -> String
show :: WorkItemObjectAttributes -> String
$cshowList :: [WorkItemObjectAttributes] -> ShowS
showList :: [WorkItemObjectAttributes] -> ShowS
Show, WorkItemObjectAttributes -> WorkItemObjectAttributes -> Bool
(WorkItemObjectAttributes -> WorkItemObjectAttributes -> Bool)
-> (WorkItemObjectAttributes -> WorkItemObjectAttributes -> Bool)
-> Eq WorkItemObjectAttributes
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WorkItemObjectAttributes -> WorkItemObjectAttributes -> Bool
== :: WorkItemObjectAttributes -> WorkItemObjectAttributes -> Bool
$c/= :: WorkItemObjectAttributes -> WorkItemObjectAttributes -> Bool
/= :: WorkItemObjectAttributes -> WorkItemObjectAttributes -> Bool
Eq, (forall x.
 WorkItemObjectAttributes -> Rep WorkItemObjectAttributes x)
-> (forall x.
    Rep WorkItemObjectAttributes x -> WorkItemObjectAttributes)
-> Generic WorkItemObjectAttributes
forall x.
Rep WorkItemObjectAttributes x -> WorkItemObjectAttributes
forall x.
WorkItemObjectAttributes -> Rep WorkItemObjectAttributes x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
WorkItemObjectAttributes -> Rep WorkItemObjectAttributes x
from :: forall x.
WorkItemObjectAttributes -> Rep WorkItemObjectAttributes x
$cto :: forall x.
Rep WorkItemObjectAttributes x -> WorkItemObjectAttributes
to :: forall x.
Rep WorkItemObjectAttributes x -> WorkItemObjectAttributes
Generic)

instance FromJSON ProjectCreate where
  parseJSON :: Value -> Parser ProjectCreate
parseJSON =
    String
-> (Object -> Parser ProjectCreate)
-> Value
-> Parser ProjectCreate
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ProjectCreate" ((Object -> Parser ProjectCreate) -> Value -> Parser ProjectCreate)
-> (Object -> Parser ProjectCreate)
-> Value
-> Parser ProjectCreate
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
ProjectCreated ->
              Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Int
-> Visibility
-> ProjectCreate
ProjectCreate
                (Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> Visibility
 -> ProjectCreate)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> ProjectCreate)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> ProjectCreate)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> ProjectCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> ProjectCreate)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> ProjectCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> ProjectCreate)
-> Parser Text
-> Parser
     (Text
      -> Text -> Text -> Text -> Int -> Visibility -> ProjectCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
                Parser
  (Text
   -> Text -> Text -> Text -> Int -> Visibility -> ProjectCreate)
-> Parser Text
-> Parser
     (Text -> Text -> Text -> Int -> Visibility -> ProjectCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"owner_email"
                Parser (Text -> Text -> Text -> Int -> Visibility -> ProjectCreate)
-> Parser Text
-> Parser (Text -> Text -> Int -> Visibility -> ProjectCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"owner_name"
                Parser (Text -> Text -> Int -> Visibility -> ProjectCreate)
-> Parser Text
-> Parser (Text -> Int -> Visibility -> ProjectCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"path"
                Parser (Text -> Int -> Visibility -> ProjectCreate)
-> Parser Text -> Parser (Int -> Visibility -> ProjectCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"path_with_namespace"
                Parser (Int -> Visibility -> ProjectCreate)
-> Parser Int -> Parser (Visibility -> ProjectCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_id"
                Parser (Visibility -> ProjectCreate)
-> Parser Visibility -> Parser ProjectCreate
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Visibility
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_visibility"
            ProjectAction
_unexpected -> String -> Parser ProjectCreate
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"project_create parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser ProjectCreate
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"project_create parsing failed"

instance FromJSON ProjectDestroy where
  parseJSON :: Value -> Parser ProjectDestroy
parseJSON =
    String
-> (Object -> Parser ProjectDestroy)
-> Value
-> Parser ProjectDestroy
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ProjectDestroy" ((Object -> Parser ProjectDestroy)
 -> Value -> Parser ProjectDestroy)
-> (Object -> Parser ProjectDestroy)
-> Value
-> Parser ProjectDestroy
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
ProjectDestroyed ->
              Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Int
-> Visibility
-> ProjectDestroy
ProjectDestroy
                (Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> Visibility
 -> ProjectDestroy)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> ProjectDestroy)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> ProjectDestroy)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> ProjectDestroy)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> ProjectDestroy)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> ProjectDestroy)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> ProjectDestroy)
-> Parser Text
-> Parser
     (Text
      -> Text -> Text -> Text -> Int -> Visibility -> ProjectDestroy)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
                Parser
  (Text
   -> Text -> Text -> Text -> Int -> Visibility -> ProjectDestroy)
-> Parser Text
-> Parser
     (Text -> Text -> Text -> Int -> Visibility -> ProjectDestroy)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"owner_email"
                Parser
  (Text -> Text -> Text -> Int -> Visibility -> ProjectDestroy)
-> Parser Text
-> Parser (Text -> Text -> Int -> Visibility -> ProjectDestroy)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"owner_name"
                Parser (Text -> Text -> Int -> Visibility -> ProjectDestroy)
-> Parser Text
-> Parser (Text -> Int -> Visibility -> ProjectDestroy)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"path"
                Parser (Text -> Int -> Visibility -> ProjectDestroy)
-> Parser Text -> Parser (Int -> Visibility -> ProjectDestroy)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"path_with_namespace"
                Parser (Int -> Visibility -> ProjectDestroy)
-> Parser Int -> Parser (Visibility -> ProjectDestroy)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_id"
                Parser (Visibility -> ProjectDestroy)
-> Parser Visibility -> Parser ProjectDestroy
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Visibility
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_visibility"
            ProjectAction
_unexpected -> String -> Parser ProjectDestroy
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"project_destroy parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser ProjectDestroy
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"project_destroy parsing failed"

instance FromJSON ProjectRename where
  parseJSON :: Value -> Parser ProjectRename
parseJSON =
    String
-> (Object -> Parser ProjectRename)
-> Value
-> Parser ProjectRename
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ProjectRename" ((Object -> Parser ProjectRename) -> Value -> Parser ProjectRename)
-> (Object -> Parser ProjectRename)
-> Value
-> Parser ProjectRename
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
ProjectRenamed ->
              Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Int
-> Text
-> Text
-> Visibility
-> Text
-> ProjectRename
ProjectRename
                (Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> Text
 -> Text
 -> Visibility
 -> Text
 -> ProjectRename)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Visibility
      -> Text
      -> ProjectRename)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Visibility
   -> Text
   -> ProjectRename)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Visibility
      -> Text
      -> ProjectRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Visibility
   -> Text
   -> ProjectRename)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Visibility
      -> Text
      -> ProjectRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser
  (Text
   -> Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Visibility
   -> Text
   -> ProjectRename)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Visibility
      -> Text
      -> ProjectRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
                Parser
  (Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Visibility
   -> Text
   -> ProjectRename)
-> Parser Text
-> Parser
     (Text
      -> Int -> Text -> Text -> Visibility -> Text -> ProjectRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"path"
                Parser
  (Text
   -> Int -> Text -> Text -> Visibility -> Text -> ProjectRename)
-> Parser Text
-> Parser
     (Int -> Text -> Text -> Visibility -> Text -> ProjectRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"path_with_namespace"
                Parser (Int -> Text -> Text -> Visibility -> Text -> ProjectRename)
-> Parser Int
-> Parser (Text -> Text -> Visibility -> Text -> ProjectRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_id"
                Parser (Text -> Text -> Visibility -> Text -> ProjectRename)
-> Parser Text
-> Parser (Text -> Visibility -> Text -> ProjectRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"owner_name"
                Parser (Text -> Visibility -> Text -> ProjectRename)
-> Parser Text -> Parser (Visibility -> Text -> ProjectRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"owner_email"
                Parser (Visibility -> Text -> ProjectRename)
-> Parser Visibility -> Parser (Text -> ProjectRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Visibility
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_visibility"
                Parser (Text -> ProjectRename)
-> Parser Text -> Parser ProjectRename
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"old_path_with_namespace"
            ProjectAction
_unexpected -> String -> Parser ProjectRename
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"project_rename parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser ProjectRename
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"project_rename parsing failed"

instance FromJSON ProjectTransfer where
  parseJSON :: Value -> Parser ProjectTransfer
parseJSON =
    String
-> (Object -> Parser ProjectTransfer)
-> Value
-> Parser ProjectTransfer
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ProjectTransfer" ((Object -> Parser ProjectTransfer)
 -> Value -> Parser ProjectTransfer)
-> (Object -> Parser ProjectTransfer)
-> Value
-> Parser ProjectTransfer
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
ProjectTransferred ->
              Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Int
-> Text
-> Text
-> Visibility
-> Text
-> ProjectTransfer
ProjectTransfer
                (Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> Text
 -> Text
 -> Visibility
 -> Text
 -> ProjectTransfer)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Visibility
      -> Text
      -> ProjectTransfer)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Visibility
   -> Text
   -> ProjectTransfer)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Visibility
      -> Text
      -> ProjectTransfer)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Visibility
   -> Text
   -> ProjectTransfer)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Visibility
      -> Text
      -> ProjectTransfer)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser
  (Text
   -> Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Visibility
   -> Text
   -> ProjectTransfer)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Visibility
      -> Text
      -> ProjectTransfer)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
                Parser
  (Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Visibility
   -> Text
   -> ProjectTransfer)
-> Parser Text
-> Parser
     (Text
      -> Int -> Text -> Text -> Visibility -> Text -> ProjectTransfer)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"path"
                Parser
  (Text
   -> Int -> Text -> Text -> Visibility -> Text -> ProjectTransfer)
-> Parser Text
-> Parser
     (Int -> Text -> Text -> Visibility -> Text -> ProjectTransfer)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"path_with_namespace"
                Parser
  (Int -> Text -> Text -> Visibility -> Text -> ProjectTransfer)
-> Parser Int
-> Parser (Text -> Text -> Visibility -> Text -> ProjectTransfer)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_id"
                Parser (Text -> Text -> Visibility -> Text -> ProjectTransfer)
-> Parser Text
-> Parser (Text -> Visibility -> Text -> ProjectTransfer)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"owner_name"
                Parser (Text -> Visibility -> Text -> ProjectTransfer)
-> Parser Text -> Parser (Visibility -> Text -> ProjectTransfer)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"owner_email"
                Parser (Visibility -> Text -> ProjectTransfer)
-> Parser Visibility -> Parser (Text -> ProjectTransfer)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Visibility
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_visibility"
                Parser (Text -> ProjectTransfer)
-> Parser Text -> Parser ProjectTransfer
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"old_path_with_namespace"
            ProjectAction
_unexpected -> String -> Parser ProjectTransfer
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"project_transfer parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser ProjectTransfer
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"project_transfer parsing failed"

instance FromJSON ProjectUpdate where
  parseJSON :: Value -> Parser ProjectUpdate
parseJSON =
    String
-> (Object -> Parser ProjectUpdate)
-> Value
-> Parser ProjectUpdate
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"ProjectUpdate" ((Object -> Parser ProjectUpdate) -> Value -> Parser ProjectUpdate)
-> (Object -> Parser ProjectUpdate)
-> Value
-> Parser ProjectUpdate
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
ProjectUpdated ->
              Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Int
-> Visibility
-> ProjectUpdate
ProjectUpdate
                (Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> Visibility
 -> ProjectUpdate)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> ProjectUpdate)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> ProjectUpdate)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> ProjectUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> ProjectUpdate)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> ProjectUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> ProjectUpdate)
-> Parser Text
-> Parser
     (Text
      -> Text -> Text -> Text -> Int -> Visibility -> ProjectUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
                Parser
  (Text
   -> Text -> Text -> Text -> Int -> Visibility -> ProjectUpdate)
-> Parser Text
-> Parser
     (Text -> Text -> Text -> Int -> Visibility -> ProjectUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"owner_email"
                Parser (Text -> Text -> Text -> Int -> Visibility -> ProjectUpdate)
-> Parser Text
-> Parser (Text -> Text -> Int -> Visibility -> ProjectUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"owner_name"
                Parser (Text -> Text -> Int -> Visibility -> ProjectUpdate)
-> Parser Text
-> Parser (Text -> Int -> Visibility -> ProjectUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"path"
                Parser (Text -> Int -> Visibility -> ProjectUpdate)
-> Parser Text -> Parser (Int -> Visibility -> ProjectUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"path_with_namespace"
                Parser (Int -> Visibility -> ProjectUpdate)
-> Parser Int -> Parser (Visibility -> ProjectUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_id"
                Parser (Visibility -> ProjectUpdate)
-> Parser Visibility -> Parser ProjectUpdate
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Visibility
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_visibility"
            ProjectAction
_unexpected -> String -> Parser ProjectUpdate
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"project_update parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser ProjectUpdate
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"project_update parsing failed"

instance FromJSON UserAddToTeam where
  parseJSON :: Value -> Parser UserAddToTeam
parseJSON =
    String
-> (Object -> Parser UserAddToTeam)
-> Value
-> Parser UserAddToTeam
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"UserAddToTeam" ((Object -> Parser UserAddToTeam) -> Value -> Parser UserAddToTeam)
-> (Object -> Parser UserAddToTeam)
-> Value
-> Parser UserAddToTeam
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
UserAddedToTeam ->
              Text
-> Text
-> Text
-> Text
-> Int
-> Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Int
-> Visibility
-> UserAddToTeam
UserAddToTeam
                (Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> Visibility
 -> UserAddToTeam)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> UserAddToTeam)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
                Parser
  (Text
   -> Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> UserAddToTeam)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> UserAddToTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
                Parser
  (Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> UserAddToTeam)
-> Parser Text
-> Parser
     (Text
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> UserAddToTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser
  (Text
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> UserAddToTeam)
-> Parser Text
-> Parser
     (Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> UserAddToTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"access_level"
                Parser
  (Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> UserAddToTeam)
-> Parser Int
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> UserAddToTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_id"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> UserAddToTeam)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> UserAddToTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_name"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> UserAddToTeam)
-> Parser Text
-> Parser
     (Text
      -> Text -> Text -> Text -> Int -> Visibility -> UserAddToTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_path"
                Parser
  (Text
   -> Text -> Text -> Text -> Int -> Visibility -> UserAddToTeam)
-> Parser Text
-> Parser
     (Text -> Text -> Text -> Int -> Visibility -> UserAddToTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_path_with_namespace"
                Parser (Text -> Text -> Text -> Int -> Visibility -> UserAddToTeam)
-> Parser Text
-> Parser (Text -> Text -> Int -> Visibility -> UserAddToTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_email"
                Parser (Text -> Text -> Int -> Visibility -> UserAddToTeam)
-> Parser Text
-> Parser (Text -> Int -> Visibility -> UserAddToTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_name"
                Parser (Text -> Int -> Visibility -> UserAddToTeam)
-> Parser Text -> Parser (Int -> Visibility -> UserAddToTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_username"
                Parser (Int -> Visibility -> UserAddToTeam)
-> Parser Int -> Parser (Visibility -> UserAddToTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_id"
                Parser (Visibility -> UserAddToTeam)
-> Parser Visibility -> Parser UserAddToTeam
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Visibility
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_visibility"
            ProjectAction
_unexpected -> String -> Parser UserAddToTeam
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"user_add_to_team parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser UserAddToTeam
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"user_add_to_team parsing failed"

instance FromJSON UserUpdateForTeam where
  parseJSON :: Value -> Parser UserUpdateForTeam
parseJSON =
    String
-> (Object -> Parser UserUpdateForTeam)
-> Value
-> Parser UserUpdateForTeam
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"UserUpdateForTeam" ((Object -> Parser UserUpdateForTeam)
 -> Value -> Parser UserUpdateForTeam)
-> (Object -> Parser UserUpdateForTeam)
-> Value
-> Parser UserUpdateForTeam
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
UserUpdatedForTeam ->
              Text
-> Text
-> Text
-> Text
-> Int
-> Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Int
-> Visibility
-> UserUpdateForTeam
UserUpdateForTeam
                (Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> Visibility
 -> UserUpdateForTeam)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> UserUpdateForTeam)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
                Parser
  (Text
   -> Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> UserUpdateForTeam)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> UserUpdateForTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
                Parser
  (Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> UserUpdateForTeam)
-> Parser Text
-> Parser
     (Text
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> UserUpdateForTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser
  (Text
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> UserUpdateForTeam)
-> Parser Text
-> Parser
     (Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> UserUpdateForTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"access_level"
                Parser
  (Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> UserUpdateForTeam)
-> Parser Int
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> UserUpdateForTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_id"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> UserUpdateForTeam)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> UserUpdateForTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_name"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> UserUpdateForTeam)
-> Parser Text
-> Parser
     (Text
      -> Text -> Text -> Text -> Int -> Visibility -> UserUpdateForTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_path"
                Parser
  (Text
   -> Text -> Text -> Text -> Int -> Visibility -> UserUpdateForTeam)
-> Parser Text
-> Parser
     (Text -> Text -> Text -> Int -> Visibility -> UserUpdateForTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_path_with_namespace"
                Parser
  (Text -> Text -> Text -> Int -> Visibility -> UserUpdateForTeam)
-> Parser Text
-> Parser (Text -> Text -> Int -> Visibility -> UserUpdateForTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_email"
                Parser (Text -> Text -> Int -> Visibility -> UserUpdateForTeam)
-> Parser Text
-> Parser (Text -> Int -> Visibility -> UserUpdateForTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_name"
                Parser (Text -> Int -> Visibility -> UserUpdateForTeam)
-> Parser Text -> Parser (Int -> Visibility -> UserUpdateForTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_username"
                Parser (Int -> Visibility -> UserUpdateForTeam)
-> Parser Int -> Parser (Visibility -> UserUpdateForTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_id"
                Parser (Visibility -> UserUpdateForTeam)
-> Parser Visibility -> Parser UserUpdateForTeam
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Visibility
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_visibility"
            ProjectAction
_unexpected -> String -> Parser UserUpdateForTeam
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"user_update_for_team parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser UserUpdateForTeam
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"user_update_for_team parsing failed"

instance FromJSON UserRemoveFromTeam where
  parseJSON :: Value -> Parser UserRemoveFromTeam
parseJSON =
    String
-> (Object -> Parser UserRemoveFromTeam)
-> Value
-> Parser UserRemoveFromTeam
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"UserRemoveFromTeam" ((Object -> Parser UserRemoveFromTeam)
 -> Value -> Parser UserRemoveFromTeam)
-> (Object -> Parser UserRemoveFromTeam)
-> Value
-> Parser UserRemoveFromTeam
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
UserRemovedFromTeam ->
              Text
-> Text
-> Text
-> Text
-> Int
-> Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Int
-> Visibility
-> UserRemoveFromTeam
UserRemoveFromTeam
                (Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> Visibility
 -> UserRemoveFromTeam)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> UserRemoveFromTeam)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
                Parser
  (Text
   -> Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> UserRemoveFromTeam)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> UserRemoveFromTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
                Parser
  (Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> UserRemoveFromTeam)
-> Parser Text
-> Parser
     (Text
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> UserRemoveFromTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser
  (Text
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> UserRemoveFromTeam)
-> Parser Text
-> Parser
     (Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> UserRemoveFromTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"access_level"
                Parser
  (Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> UserRemoveFromTeam)
-> Parser Int
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> UserRemoveFromTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_id"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> UserRemoveFromTeam)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Visibility
      -> UserRemoveFromTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_name"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Visibility
   -> UserRemoveFromTeam)
-> Parser Text
-> Parser
     (Text
      -> Text -> Text -> Text -> Int -> Visibility -> UserRemoveFromTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_path"
                Parser
  (Text
   -> Text -> Text -> Text -> Int -> Visibility -> UserRemoveFromTeam)
-> Parser Text
-> Parser
     (Text -> Text -> Text -> Int -> Visibility -> UserRemoveFromTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_path_with_namespace"
                Parser
  (Text -> Text -> Text -> Int -> Visibility -> UserRemoveFromTeam)
-> Parser Text
-> Parser (Text -> Text -> Int -> Visibility -> UserRemoveFromTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_email"
                Parser (Text -> Text -> Int -> Visibility -> UserRemoveFromTeam)
-> Parser Text
-> Parser (Text -> Int -> Visibility -> UserRemoveFromTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_name"
                Parser (Text -> Int -> Visibility -> UserRemoveFromTeam)
-> Parser Text -> Parser (Int -> Visibility -> UserRemoveFromTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_username"
                Parser (Int -> Visibility -> UserRemoveFromTeam)
-> Parser Int -> Parser (Visibility -> UserRemoveFromTeam)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_id"
                Parser (Visibility -> UserRemoveFromTeam)
-> Parser Visibility -> Parser UserRemoveFromTeam
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Visibility
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_visibility"
            ProjectAction
_unexpected -> String -> Parser UserRemoveFromTeam
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"user_remove_from_team parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser UserRemoveFromTeam
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"user_remove_from_team parsing failed"

instance FromJSON UserCreate where
  parseJSON :: Value -> Parser UserCreate
parseJSON =
    String
-> (Object -> Parser UserCreate) -> Value -> Parser UserCreate
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"UserCreate" ((Object -> Parser UserCreate) -> Value -> Parser UserCreate)
-> (Object -> Parser UserCreate) -> Value -> Parser UserCreate
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
UserCreated ->
              Text -> Text -> Text -> Text -> Text -> Text -> Int -> UserCreate
UserCreate
                (Text -> Text -> Text -> Text -> Text -> Text -> Int -> UserCreate)
-> Parser Text
-> Parser
     (Text -> Text -> Text -> Text -> Text -> Int -> UserCreate)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
                Parser (Text -> Text -> Text -> Text -> Text -> Int -> UserCreate)
-> Parser Text
-> Parser (Text -> Text -> Text -> Text -> Int -> UserCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
                Parser (Text -> Text -> Text -> Text -> Int -> UserCreate)
-> Parser Text
-> Parser (Text -> Text -> Text -> Int -> UserCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"email"
                Parser (Text -> Text -> Text -> Int -> UserCreate)
-> Parser Text -> Parser (Text -> Text -> Int -> UserCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser (Text -> Text -> Int -> UserCreate)
-> Parser Text -> Parser (Text -> Int -> UserCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
                Parser (Text -> Int -> UserCreate)
-> Parser Text -> Parser (Int -> UserCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"username"
                Parser (Int -> UserCreate) -> Parser Int -> Parser UserCreate
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_id"
            ProjectAction
_unexpected -> String -> Parser UserCreate
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"user_create parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser UserCreate
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"user_create parsing failed"

instance FromJSON UserRemove where
  parseJSON :: Value -> Parser UserRemove
parseJSON =
    String
-> (Object -> Parser UserRemove) -> Value -> Parser UserRemove
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"UserRemove" ((Object -> Parser UserRemove) -> Value -> Parser UserRemove)
-> (Object -> Parser UserRemove) -> Value -> Parser UserRemove
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
UserRemoved ->
              Text -> Text -> Text -> Text -> Text -> Text -> Int -> UserRemove
UserRemove
                (Text -> Text -> Text -> Text -> Text -> Text -> Int -> UserRemove)
-> Parser Text
-> Parser
     (Text -> Text -> Text -> Text -> Text -> Int -> UserRemove)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
                Parser (Text -> Text -> Text -> Text -> Text -> Int -> UserRemove)
-> Parser Text
-> Parser (Text -> Text -> Text -> Text -> Int -> UserRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
                Parser (Text -> Text -> Text -> Text -> Int -> UserRemove)
-> Parser Text
-> Parser (Text -> Text -> Text -> Int -> UserRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"email"
                Parser (Text -> Text -> Text -> Int -> UserRemove)
-> Parser Text -> Parser (Text -> Text -> Int -> UserRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser (Text -> Text -> Int -> UserRemove)
-> Parser Text -> Parser (Text -> Int -> UserRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
                Parser (Text -> Int -> UserRemove)
-> Parser Text -> Parser (Int -> UserRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"username"
                Parser (Int -> UserRemove) -> Parser Int -> Parser UserRemove
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_id"
            ProjectAction
_unexpected -> String -> Parser UserRemove
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"user_destroy parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser UserRemove
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"user_destroy parsing failed"

instance FromJSON UserFailedLogin where
  parseJSON :: Value -> Parser UserFailedLogin
parseJSON =
    String
-> (Object -> Parser UserFailedLogin)
-> Value
-> Parser UserFailedLogin
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"UserFailedLogin" ((Object -> Parser UserFailedLogin)
 -> Value -> Parser UserFailedLogin)
-> (Object -> Parser UserFailedLogin)
-> Value
-> Parser UserFailedLogin
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
UserFailedToLogin ->
              Text
-> Text
-> Text
-> Text
-> Text
-> Int
-> Text
-> Text
-> UserFailedLogin
UserFailedLogin
                (Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> Text
 -> Text
 -> UserFailedLogin)
-> Parser Text
-> Parser
     (Text
      -> Text -> Text -> Text -> Int -> Text -> Text -> UserFailedLogin)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser
  (Text
   -> Text -> Text -> Text -> Int -> Text -> Text -> UserFailedLogin)
-> Parser Text
-> Parser
     (Text -> Text -> Text -> Int -> Text -> Text -> UserFailedLogin)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
                Parser
  (Text -> Text -> Text -> Int -> Text -> Text -> UserFailedLogin)
-> Parser Text
-> Parser (Text -> Text -> Int -> Text -> Text -> UserFailedLogin)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
                Parser (Text -> Text -> Int -> Text -> Text -> UserFailedLogin)
-> Parser Text
-> Parser (Text -> Int -> Text -> Text -> UserFailedLogin)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
                Parser (Text -> Int -> Text -> Text -> UserFailedLogin)
-> Parser Text -> Parser (Int -> Text -> Text -> UserFailedLogin)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"email"
                Parser (Int -> Text -> Text -> UserFailedLogin)
-> Parser Int -> Parser (Text -> Text -> UserFailedLogin)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_id"
                Parser (Text -> Text -> UserFailedLogin)
-> Parser Text -> Parser (Text -> UserFailedLogin)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"username"
                Parser (Text -> UserFailedLogin)
-> Parser Text -> Parser UserFailedLogin
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"state"
            ProjectAction
_unexpected -> String -> Parser UserFailedLogin
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"user_failed_login parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser UserFailedLogin
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"user_failed_login parsing failed"

instance FromJSON UserRename where
  parseJSON :: Value -> Parser UserRename
parseJSON =
    String
-> (Object -> Parser UserRename) -> Value -> Parser UserRename
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"UserRename" ((Object -> Parser UserRename) -> Value -> Parser UserRename)
-> (Object -> Parser UserRename) -> Value -> Parser UserRename
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
UserRenamed ->
              Text
-> Text
-> Text
-> Text
-> Text
-> Int
-> Text
-> Text
-> UserRename
UserRename
                (Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> Text
 -> Text
 -> UserRename)
-> Parser Text
-> Parser
     (Text -> Text -> Text -> Text -> Int -> Text -> Text -> UserRename)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser
  (Text -> Text -> Text -> Text -> Int -> Text -> Text -> UserRename)
-> Parser Text
-> Parser
     (Text -> Text -> Text -> Int -> Text -> Text -> UserRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
                Parser (Text -> Text -> Text -> Int -> Text -> Text -> UserRename)
-> Parser Text
-> Parser (Text -> Text -> Int -> Text -> Text -> UserRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
                Parser (Text -> Text -> Int -> Text -> Text -> UserRename)
-> Parser Text
-> Parser (Text -> Int -> Text -> Text -> UserRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
                Parser (Text -> Int -> Text -> Text -> UserRename)
-> Parser Text -> Parser (Int -> Text -> Text -> UserRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"email"
                Parser (Int -> Text -> Text -> UserRename)
-> Parser Int -> Parser (Text -> Text -> UserRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_id"
                Parser (Text -> Text -> UserRename)
-> Parser Text -> Parser (Text -> UserRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"username"
                Parser (Text -> UserRename) -> Parser Text -> Parser UserRename
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"old_username"
            ProjectAction
_unexpected -> String -> Parser UserRename
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"user_rename parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser UserRename
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"user_rename parsing failed"

instance FromJSON KeyCreate where
  parseJSON :: Value -> Parser KeyCreate
parseJSON =
    String -> (Object -> Parser KeyCreate) -> Value -> Parser KeyCreate
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"KeyCreate" ((Object -> Parser KeyCreate) -> Value -> Parser KeyCreate)
-> (Object -> Parser KeyCreate) -> Value -> Parser KeyCreate
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
KeyCreated ->
              Text -> Text -> Text -> Text -> Text -> Int -> KeyCreate
KeyCreate
                (Text -> Text -> Text -> Text -> Text -> Int -> KeyCreate)
-> Parser Text
-> Parser (Text -> Text -> Text -> Text -> Int -> KeyCreate)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser (Text -> Text -> Text -> Text -> Int -> KeyCreate)
-> Parser Text -> Parser (Text -> Text -> Text -> Int -> KeyCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
                Parser (Text -> Text -> Text -> Int -> KeyCreate)
-> Parser Text -> Parser (Text -> Text -> Int -> KeyCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
                Parser (Text -> Text -> Int -> KeyCreate)
-> Parser Text -> Parser (Text -> Int -> KeyCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"username"
                Parser (Text -> Int -> KeyCreate)
-> Parser Text -> Parser (Int -> KeyCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"key"
                Parser (Int -> KeyCreate) -> Parser Int -> Parser KeyCreate
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
            ProjectAction
_unexpected -> String -> Parser KeyCreate
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"key_create parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser KeyCreate
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"key_create parsing failed"

instance FromJSON KeyRemove where
  parseJSON :: Value -> Parser KeyRemove
parseJSON =
    String -> (Object -> Parser KeyRemove) -> Value -> Parser KeyRemove
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"KeyRemove" ((Object -> Parser KeyRemove) -> Value -> Parser KeyRemove)
-> (Object -> Parser KeyRemove) -> Value -> Parser KeyRemove
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
KeyRemoved ->
              Text -> Text -> Text -> Text -> Text -> Int -> KeyRemove
KeyRemove
                (Text -> Text -> Text -> Text -> Text -> Int -> KeyRemove)
-> Parser Text
-> Parser (Text -> Text -> Text -> Text -> Int -> KeyRemove)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser (Text -> Text -> Text -> Text -> Int -> KeyRemove)
-> Parser Text -> Parser (Text -> Text -> Text -> Int -> KeyRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
                Parser (Text -> Text -> Text -> Int -> KeyRemove)
-> Parser Text -> Parser (Text -> Text -> Int -> KeyRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
                Parser (Text -> Text -> Int -> KeyRemove)
-> Parser Text -> Parser (Text -> Int -> KeyRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"username"
                Parser (Text -> Int -> KeyRemove)
-> Parser Text -> Parser (Int -> KeyRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"key"
                Parser (Int -> KeyRemove) -> Parser Int -> Parser KeyRemove
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"id"
            ProjectAction
_unexpected -> String -> Parser KeyRemove
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"key_destroy parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser KeyRemove
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"key_destroy parsing failed"

instance FromJSON GroupCreate where
  parseJSON :: Value -> Parser GroupCreate
parseJSON =
    String
-> (Object -> Parser GroupCreate) -> Value -> Parser GroupCreate
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"GroupCreate" ((Object -> Parser GroupCreate) -> Value -> Parser GroupCreate)
-> (Object -> Parser GroupCreate) -> Value -> Parser GroupCreate
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
GroupCreated ->
              Text
-> Text
-> Text
-> Text
-> Maybe Text
-> Maybe Text
-> Text
-> Int
-> GroupCreate
GroupCreate
                (Text
 -> Text
 -> Text
 -> Text
 -> Maybe Text
 -> Maybe Text
 -> Text
 -> Int
 -> GroupCreate)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Maybe Text
      -> Maybe Text
      -> Text
      -> Int
      -> GroupCreate)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
                Parser
  (Text
   -> Text
   -> Text
   -> Maybe Text
   -> Maybe Text
   -> Text
   -> Int
   -> GroupCreate)
-> Parser Text
-> Parser
     (Text
      -> Text -> Maybe Text -> Maybe Text -> Text -> Int -> GroupCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
                Parser
  (Text
   -> Text -> Maybe Text -> Maybe Text -> Text -> Int -> GroupCreate)
-> Parser Text
-> Parser
     (Text -> Maybe Text -> Maybe Text -> Text -> Int -> GroupCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser
  (Text -> Maybe Text -> Maybe Text -> Text -> Int -> GroupCreate)
-> Parser Text
-> Parser (Maybe Text -> Maybe Text -> Text -> Int -> GroupCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
                Parser (Maybe Text -> Maybe Text -> Text -> Int -> GroupCreate)
-> Parser (Maybe Text)
-> Parser (Maybe Text -> Text -> Int -> GroupCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"owner_email"
                Parser (Maybe Text -> Text -> Int -> GroupCreate)
-> Parser (Maybe Text) -> Parser (Text -> Int -> GroupCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"owner_name"
                Parser (Text -> Int -> GroupCreate)
-> Parser Text -> Parser (Int -> GroupCreate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"path"
                Parser (Int -> GroupCreate) -> Parser Int -> Parser GroupCreate
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"group_id"
            ProjectAction
_unexpected -> String -> Parser GroupCreate
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"group_create parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser GroupCreate
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"group_create parsing failed"

instance FromJSON GroupRemove where
  parseJSON :: Value -> Parser GroupRemove
parseJSON =
    String
-> (Object -> Parser GroupRemove) -> Value -> Parser GroupRemove
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"GroupRemove" ((Object -> Parser GroupRemove) -> Value -> Parser GroupRemove)
-> (Object -> Parser GroupRemove) -> Value -> Parser GroupRemove
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
GroupRemoved ->
              Text
-> Text
-> Text
-> Text
-> Maybe Text
-> Maybe Text
-> Text
-> Int
-> GroupRemove
GroupRemove
                (Text
 -> Text
 -> Text
 -> Text
 -> Maybe Text
 -> Maybe Text
 -> Text
 -> Int
 -> GroupRemove)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Maybe Text
      -> Maybe Text
      -> Text
      -> Int
      -> GroupRemove)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
                Parser
  (Text
   -> Text
   -> Text
   -> Maybe Text
   -> Maybe Text
   -> Text
   -> Int
   -> GroupRemove)
-> Parser Text
-> Parser
     (Text
      -> Text -> Maybe Text -> Maybe Text -> Text -> Int -> GroupRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
                Parser
  (Text
   -> Text -> Maybe Text -> Maybe Text -> Text -> Int -> GroupRemove)
-> Parser Text
-> Parser
     (Text -> Maybe Text -> Maybe Text -> Text -> Int -> GroupRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser
  (Text -> Maybe Text -> Maybe Text -> Text -> Int -> GroupRemove)
-> Parser Text
-> Parser (Maybe Text -> Maybe Text -> Text -> Int -> GroupRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
                Parser (Maybe Text -> Maybe Text -> Text -> Int -> GroupRemove)
-> Parser (Maybe Text)
-> Parser (Maybe Text -> Text -> Int -> GroupRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"owner_email"
                Parser (Maybe Text -> Text -> Int -> GroupRemove)
-> Parser (Maybe Text) -> Parser (Text -> Int -> GroupRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"owner_name"
                Parser (Text -> Int -> GroupRemove)
-> Parser Text -> Parser (Int -> GroupRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"path"
                Parser (Int -> GroupRemove) -> Parser Int -> Parser GroupRemove
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"group_id"
            ProjectAction
_unexpected -> String -> Parser GroupRemove
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"group_remove parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser GroupRemove
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"group_remove parsing failed"

instance FromJSON GroupRename where
  parseJSON :: Value -> Parser GroupRename
parseJSON =
    String
-> (Object -> Parser GroupRename) -> Value -> Parser GroupRename
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"GroupRename" ((Object -> Parser GroupRename) -> Value -> Parser GroupRename)
-> (Object -> Parser GroupRename) -> Value -> Parser GroupRename
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
GroupRenamed ->
              Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Int
-> Maybe Text
-> Maybe Text
-> Text
-> Text
-> GroupRename
GroupRename
                (Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> Maybe Text
 -> Maybe Text
 -> Text
 -> Text
 -> GroupRename)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Maybe Text
      -> Maybe Text
      -> Text
      -> Text
      -> GroupRename)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Maybe Text
   -> Maybe Text
   -> Text
   -> Text
   -> GroupRename)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Maybe Text
      -> Maybe Text
      -> Text
      -> Text
      -> GroupRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Maybe Text
   -> Maybe Text
   -> Text
   -> Text
   -> GroupRename)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Int
      -> Maybe Text
      -> Maybe Text
      -> Text
      -> Text
      -> GroupRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
                Parser
  (Text
   -> Text
   -> Text
   -> Int
   -> Maybe Text
   -> Maybe Text
   -> Text
   -> Text
   -> GroupRename)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Int
      -> Maybe Text
      -> Maybe Text
      -> Text
      -> Text
      -> GroupRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"name"
                Parser
  (Text
   -> Text
   -> Int
   -> Maybe Text
   -> Maybe Text
   -> Text
   -> Text
   -> GroupRename)
-> Parser Text
-> Parser
     (Text
      -> Int -> Maybe Text -> Maybe Text -> Text -> Text -> GroupRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"path"
                Parser
  (Text
   -> Int -> Maybe Text -> Maybe Text -> Text -> Text -> GroupRename)
-> Parser Text
-> Parser
     (Int -> Maybe Text -> Maybe Text -> Text -> Text -> GroupRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"full_path"
                Parser
  (Int -> Maybe Text -> Maybe Text -> Text -> Text -> GroupRename)
-> Parser Int
-> Parser (Maybe Text -> Maybe Text -> Text -> Text -> GroupRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"group_id"
                Parser (Maybe Text -> Maybe Text -> Text -> Text -> GroupRename)
-> Parser (Maybe Text)
-> Parser (Maybe Text -> Text -> Text -> GroupRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"owner_name"
                Parser (Maybe Text -> Text -> Text -> GroupRename)
-> Parser (Maybe Text) -> Parser (Text -> Text -> GroupRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"owner_email"
                Parser (Text -> Text -> GroupRename)
-> Parser Text -> Parser (Text -> GroupRename)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"old_path"
                Parser (Text -> GroupRename) -> Parser Text -> Parser GroupRename
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"old_full_path"
            ProjectAction
_unexpected -> String -> Parser GroupRename
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"group_rename parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser GroupRename
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"group_rename parsing failed"

instance FromJSON NewGroupMember where
  parseJSON :: Value -> Parser NewGroupMember
parseJSON =
    String
-> (Object -> Parser NewGroupMember)
-> Value
-> Parser NewGroupMember
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"NewGroupMember" ((Object -> Parser NewGroupMember)
 -> Value -> Parser NewGroupMember)
-> (Object -> Parser NewGroupMember)
-> Value
-> Parser NewGroupMember
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
GroupMemberAdded ->
              Text
-> Text
-> Text
-> Text
-> Int
-> Text
-> Text
-> Text
-> Text
-> Text
-> Int
-> NewGroupMember
NewGroupMember
                (Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> NewGroupMember)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> NewGroupMember)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
                Parser
  (Text
   -> Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> NewGroupMember)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> NewGroupMember)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
                Parser
  (Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> NewGroupMember)
-> Parser Text
-> Parser
     (Text
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> NewGroupMember)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser
  (Text
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> NewGroupMember)
-> Parser Text
-> Parser
     (Int
      -> Text -> Text -> Text -> Text -> Text -> Int -> NewGroupMember)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"group_access"
                Parser
  (Int
   -> Text -> Text -> Text -> Text -> Text -> Int -> NewGroupMember)
-> Parser Int
-> Parser
     (Text -> Text -> Text -> Text -> Text -> Int -> NewGroupMember)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"group_id"
                Parser
  (Text -> Text -> Text -> Text -> Text -> Int -> NewGroupMember)
-> Parser Text
-> Parser (Text -> Text -> Text -> Text -> Int -> NewGroupMember)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"group_name"
                Parser (Text -> Text -> Text -> Text -> Int -> NewGroupMember)
-> Parser Text
-> Parser (Text -> Text -> Text -> Int -> NewGroupMember)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"group_path"
                Parser (Text -> Text -> Text -> Int -> NewGroupMember)
-> Parser Text -> Parser (Text -> Text -> Int -> NewGroupMember)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_email"
                Parser (Text -> Text -> Int -> NewGroupMember)
-> Parser Text -> Parser (Text -> Int -> NewGroupMember)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_name"
                Parser (Text -> Int -> NewGroupMember)
-> Parser Text -> Parser (Int -> NewGroupMember)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_username"
                Parser (Int -> NewGroupMember)
-> Parser Int -> Parser NewGroupMember
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_id"
            ProjectAction
_unexpected -> String -> Parser NewGroupMember
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"user_add_to_group parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser NewGroupMember
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"user_add_to_group parsing failed"

instance FromJSON GroupMemberRemove where
  parseJSON :: Value -> Parser GroupMemberRemove
parseJSON =
    String
-> (Object -> Parser GroupMemberRemove)
-> Value
-> Parser GroupMemberRemove
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"GroupMemberRemove" ((Object -> Parser GroupMemberRemove)
 -> Value -> Parser GroupMemberRemove)
-> (Object -> Parser GroupMemberRemove)
-> Value
-> Parser GroupMemberRemove
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
GroupMemberRemoved ->
              Text
-> Text
-> Text
-> Text
-> Int
-> Text
-> Text
-> Text
-> Text
-> Text
-> Int
-> GroupMemberRemove
GroupMemberRemove
                (Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> GroupMemberRemove)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> GroupMemberRemove)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
                Parser
  (Text
   -> Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> GroupMemberRemove)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> GroupMemberRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
                Parser
  (Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> GroupMemberRemove)
-> Parser Text
-> Parser
     (Text
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> GroupMemberRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser
  (Text
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> GroupMemberRemove)
-> Parser Text
-> Parser
     (Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> GroupMemberRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"group_access"
                Parser
  (Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> GroupMemberRemove)
-> Parser Int
-> Parser
     (Text -> Text -> Text -> Text -> Text -> Int -> GroupMemberRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"group_id"
                Parser
  (Text -> Text -> Text -> Text -> Text -> Int -> GroupMemberRemove)
-> Parser Text
-> Parser
     (Text -> Text -> Text -> Text -> Int -> GroupMemberRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"group_name"
                Parser (Text -> Text -> Text -> Text -> Int -> GroupMemberRemove)
-> Parser Text
-> Parser (Text -> Text -> Text -> Int -> GroupMemberRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"group_path"
                Parser (Text -> Text -> Text -> Int -> GroupMemberRemove)
-> Parser Text -> Parser (Text -> Text -> Int -> GroupMemberRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_email"
                Parser (Text -> Text -> Int -> GroupMemberRemove)
-> Parser Text -> Parser (Text -> Int -> GroupMemberRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_name"
                Parser (Text -> Int -> GroupMemberRemove)
-> Parser Text -> Parser (Int -> GroupMemberRemove)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_username"
                Parser (Int -> GroupMemberRemove)
-> Parser Int -> Parser GroupMemberRemove
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_id"
            ProjectAction
_unexpected -> String -> Parser GroupMemberRemove
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"user_remove_from_group parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser GroupMemberRemove
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"user_remove_from_group parsing failed"

instance FromJSON GroupMemberUpdate where
  parseJSON :: Value -> Parser GroupMemberUpdate
parseJSON =
    String
-> (Object -> Parser GroupMemberUpdate)
-> Value
-> Parser GroupMemberUpdate
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"GroupMemberUpdate" ((Object -> Parser GroupMemberUpdate)
 -> Value -> Parser GroupMemberUpdate)
-> (Object -> Parser GroupMemberUpdate)
-> Value
-> Parser GroupMemberUpdate
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
GroupMemberUpdated ->
              Text
-> Text
-> Text
-> Text
-> Int
-> Text
-> Text
-> Text
-> Text
-> Text
-> Int
-> GroupMemberUpdate
GroupMemberUpdate
                (Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> GroupMemberUpdate)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> GroupMemberUpdate)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"created_at"
                Parser
  (Text
   -> Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> GroupMemberUpdate)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> GroupMemberUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"updated_at"
                Parser
  (Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> GroupMemberUpdate)
-> Parser Text
-> Parser
     (Text
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> GroupMemberUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser
  (Text
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> GroupMemberUpdate)
-> Parser Text
-> Parser
     (Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> GroupMemberUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"group_access"
                Parser
  (Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> GroupMemberUpdate)
-> Parser Int
-> Parser
     (Text -> Text -> Text -> Text -> Text -> Int -> GroupMemberUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"group_id"
                Parser
  (Text -> Text -> Text -> Text -> Text -> Int -> GroupMemberUpdate)
-> Parser Text
-> Parser
     (Text -> Text -> Text -> Text -> Int -> GroupMemberUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"group_name"
                Parser (Text -> Text -> Text -> Text -> Int -> GroupMemberUpdate)
-> Parser Text
-> Parser (Text -> Text -> Text -> Int -> GroupMemberUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"group_path"
                Parser (Text -> Text -> Text -> Int -> GroupMemberUpdate)
-> Parser Text -> Parser (Text -> Text -> Int -> GroupMemberUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_email"
                Parser (Text -> Text -> Int -> GroupMemberUpdate)
-> Parser Text -> Parser (Text -> Int -> GroupMemberUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_name"
                Parser (Text -> Int -> GroupMemberUpdate)
-> Parser Text -> Parser (Int -> GroupMemberUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_username"
                Parser (Int -> GroupMemberUpdate)
-> Parser Int -> Parser GroupMemberUpdate
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_id"
            ProjectAction
_unexpected -> String -> Parser GroupMemberUpdate
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"user_update_for_group parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser GroupMemberUpdate
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"user_update_for_group parsing failed"

instance FromJSON Push where
  parseJSON :: Value -> Parser Push
parseJSON =
    String -> (Object -> Parser Push) -> Value -> Parser Push
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Push" ((Object -> Parser Push) -> Value -> Parser Push)
-> (Object -> Parser Push) -> Value -> Parser Push
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
Pushed ->
              Text
-> Text
-> Text
-> Text
-> Maybe Text
-> Int
-> Text
-> Maybe Text
-> Maybe Text
-> Text
-> Int
-> ProjectEvent
-> RepositoryEvent
-> [CommitEvent]
-> Int
-> Push
Push
                (Text
 -> Text
 -> Text
 -> Text
 -> Maybe Text
 -> Int
 -> Text
 -> Maybe Text
 -> Maybe Text
 -> Text
 -> Int
 -> ProjectEvent
 -> RepositoryEvent
 -> [CommitEvent]
 -> Int
 -> Push)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Maybe Text
      -> Int
      -> Text
      -> Maybe Text
      -> Maybe Text
      -> Text
      -> Int
      -> ProjectEvent
      -> RepositoryEvent
      -> [CommitEvent]
      -> Int
      -> Push)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser
  (Text
   -> Text
   -> Text
   -> Maybe Text
   -> Int
   -> Text
   -> Maybe Text
   -> Maybe Text
   -> Text
   -> Int
   -> ProjectEvent
   -> RepositoryEvent
   -> [CommitEvent]
   -> Int
   -> Push)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Maybe Text
      -> Int
      -> Text
      -> Maybe Text
      -> Maybe Text
      -> Text
      -> Int
      -> ProjectEvent
      -> RepositoryEvent
      -> [CommitEvent]
      -> Int
      -> Push)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"before"
                Parser
  (Text
   -> Text
   -> Maybe Text
   -> Int
   -> Text
   -> Maybe Text
   -> Maybe Text
   -> Text
   -> Int
   -> ProjectEvent
   -> RepositoryEvent
   -> [CommitEvent]
   -> Int
   -> Push)
-> Parser Text
-> Parser
     (Text
      -> Maybe Text
      -> Int
      -> Text
      -> Maybe Text
      -> Maybe Text
      -> Text
      -> Int
      -> ProjectEvent
      -> RepositoryEvent
      -> [CommitEvent]
      -> Int
      -> Push)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"after"
                Parser
  (Text
   -> Maybe Text
   -> Int
   -> Text
   -> Maybe Text
   -> Maybe Text
   -> Text
   -> Int
   -> ProjectEvent
   -> RepositoryEvent
   -> [CommitEvent]
   -> Int
   -> Push)
-> Parser Text
-> Parser
     (Maybe Text
      -> Int
      -> Text
      -> Maybe Text
      -> Maybe Text
      -> Text
      -> Int
      -> ProjectEvent
      -> RepositoryEvent
      -> [CommitEvent]
      -> Int
      -> Push)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"ref"
                Parser
  (Maybe Text
   -> Int
   -> Text
   -> Maybe Text
   -> Maybe Text
   -> Text
   -> Int
   -> ProjectEvent
   -> RepositoryEvent
   -> [CommitEvent]
   -> Int
   -> Push)
-> Parser (Maybe Text)
-> Parser
     (Int
      -> Text
      -> Maybe Text
      -> Maybe Text
      -> Text
      -> Int
      -> ProjectEvent
      -> RepositoryEvent
      -> [CommitEvent]
      -> Int
      -> Push)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"checkout_sha"
                Parser
  (Int
   -> Text
   -> Maybe Text
   -> Maybe Text
   -> Text
   -> Int
   -> ProjectEvent
   -> RepositoryEvent
   -> [CommitEvent]
   -> Int
   -> Push)
-> Parser Int
-> Parser
     (Text
      -> Maybe Text
      -> Maybe Text
      -> Text
      -> Int
      -> ProjectEvent
      -> RepositoryEvent
      -> [CommitEvent]
      -> Int
      -> Push)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_id"
                Parser
  (Text
   -> Maybe Text
   -> Maybe Text
   -> Text
   -> Int
   -> ProjectEvent
   -> RepositoryEvent
   -> [CommitEvent]
   -> Int
   -> Push)
-> Parser Text
-> Parser
     (Maybe Text
      -> Maybe Text
      -> Text
      -> Int
      -> ProjectEvent
      -> RepositoryEvent
      -> [CommitEvent]
      -> Int
      -> Push)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_name"
                Parser
  (Maybe Text
   -> Maybe Text
   -> Text
   -> Int
   -> ProjectEvent
   -> RepositoryEvent
   -> [CommitEvent]
   -> Int
   -> Push)
-> Parser (Maybe Text)
-> Parser
     (Maybe Text
      -> Text
      -> Int
      -> ProjectEvent
      -> RepositoryEvent
      -> [CommitEvent]
      -> Int
      -> Push)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_username"
                Parser
  (Maybe Text
   -> Text
   -> Int
   -> ProjectEvent
   -> RepositoryEvent
   -> [CommitEvent]
   -> Int
   -> Push)
-> Parser (Maybe Text)
-> Parser
     (Text
      -> Int
      -> ProjectEvent
      -> RepositoryEvent
      -> [CommitEvent]
      -> Int
      -> Push)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_email"
                Parser
  (Text
   -> Int
   -> ProjectEvent
   -> RepositoryEvent
   -> [CommitEvent]
   -> Int
   -> Push)
-> Parser Text
-> Parser
     (Int
      -> ProjectEvent -> RepositoryEvent -> [CommitEvent] -> Int -> Push)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_avatar"
                Parser
  (Int
   -> ProjectEvent -> RepositoryEvent -> [CommitEvent] -> Int -> Push)
-> Parser Int
-> Parser
     (ProjectEvent -> RepositoryEvent -> [CommitEvent] -> Int -> Push)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_id"
                Parser
  (ProjectEvent -> RepositoryEvent -> [CommitEvent] -> Int -> Push)
-> Parser ProjectEvent
-> Parser (RepositoryEvent -> [CommitEvent] -> Int -> Push)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser ProjectEvent
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project"
                Parser (RepositoryEvent -> [CommitEvent] -> Int -> Push)
-> Parser RepositoryEvent -> Parser ([CommitEvent] -> Int -> Push)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser RepositoryEvent
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"repository"
                Parser ([CommitEvent] -> Int -> Push)
-> Parser [CommitEvent] -> Parser (Int -> Push)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser [CommitEvent]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"commits"
                Parser (Int -> Push) -> Parser Int -> Parser Push
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"total_commits_count"
            ProjectAction
_unexpected -> String -> Parser Push
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"push parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser Push
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"push parsing failed"

instance FromJSON TagPush where
  parseJSON :: Value -> Parser TagPush
parseJSON =
    String -> (Object -> Parser TagPush) -> Value -> Parser TagPush
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"TagPush" ((Object -> Parser TagPush) -> Value -> Parser TagPush)
-> (Object -> Parser TagPush) -> Value -> Parser TagPush
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
TagPushed ->
              Text
-> Text
-> Text
-> Text
-> Text
-> Int
-> Text
-> Text
-> Int
-> ProjectEvent
-> RepositoryEvent
-> [CommitEvent]
-> Int
-> TagPush
TagPush
                (Text
 -> Text
 -> Text
 -> Text
 -> Text
 -> Int
 -> Text
 -> Text
 -> Int
 -> ProjectEvent
 -> RepositoryEvent
 -> [CommitEvent]
 -> Int
 -> TagPush)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Int
      -> ProjectEvent
      -> RepositoryEvent
      -> [CommitEvent]
      -> Int
      -> TagPush)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Int
   -> ProjectEvent
   -> RepositoryEvent
   -> [CommitEvent]
   -> Int
   -> TagPush)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Int
      -> ProjectEvent
      -> RepositoryEvent
      -> [CommitEvent]
      -> Int
      -> TagPush)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"before"
                Parser
  (Text
   -> Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Int
   -> ProjectEvent
   -> RepositoryEvent
   -> [CommitEvent]
   -> Int
   -> TagPush)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Int
      -> Text
      -> Text
      -> Int
      -> ProjectEvent
      -> RepositoryEvent
      -> [CommitEvent]
      -> Int
      -> TagPush)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"after"
                Parser
  (Text
   -> Text
   -> Int
   -> Text
   -> Text
   -> Int
   -> ProjectEvent
   -> RepositoryEvent
   -> [CommitEvent]
   -> Int
   -> TagPush)
-> Parser Text
-> Parser
     (Text
      -> Int
      -> Text
      -> Text
      -> Int
      -> ProjectEvent
      -> RepositoryEvent
      -> [CommitEvent]
      -> Int
      -> TagPush)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"ref"
                Parser
  (Text
   -> Int
   -> Text
   -> Text
   -> Int
   -> ProjectEvent
   -> RepositoryEvent
   -> [CommitEvent]
   -> Int
   -> TagPush)
-> Parser Text
-> Parser
     (Int
      -> Text
      -> Text
      -> Int
      -> ProjectEvent
      -> RepositoryEvent
      -> [CommitEvent]
      -> Int
      -> TagPush)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"checkout_sha"
                Parser
  (Int
   -> Text
   -> Text
   -> Int
   -> ProjectEvent
   -> RepositoryEvent
   -> [CommitEvent]
   -> Int
   -> TagPush)
-> Parser Int
-> Parser
     (Text
      -> Text
      -> Int
      -> ProjectEvent
      -> RepositoryEvent
      -> [CommitEvent]
      -> Int
      -> TagPush)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_id"
                Parser
  (Text
   -> Text
   -> Int
   -> ProjectEvent
   -> RepositoryEvent
   -> [CommitEvent]
   -> Int
   -> TagPush)
-> Parser Text
-> Parser
     (Text
      -> Int
      -> ProjectEvent
      -> RepositoryEvent
      -> [CommitEvent]
      -> Int
      -> TagPush)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_name"
                Parser
  (Text
   -> Int
   -> ProjectEvent
   -> RepositoryEvent
   -> [CommitEvent]
   -> Int
   -> TagPush)
-> Parser Text
-> Parser
     (Int
      -> ProjectEvent
      -> RepositoryEvent
      -> [CommitEvent]
      -> Int
      -> TagPush)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_avatar"
                Parser
  (Int
   -> ProjectEvent
   -> RepositoryEvent
   -> [CommitEvent]
   -> Int
   -> TagPush)
-> Parser Int
-> Parser
     (ProjectEvent
      -> RepositoryEvent -> [CommitEvent] -> Int -> TagPush)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_id"
                Parser
  (ProjectEvent
   -> RepositoryEvent -> [CommitEvent] -> Int -> TagPush)
-> Parser ProjectEvent
-> Parser (RepositoryEvent -> [CommitEvent] -> Int -> TagPush)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser ProjectEvent
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project"
                Parser (RepositoryEvent -> [CommitEvent] -> Int -> TagPush)
-> Parser RepositoryEvent
-> Parser ([CommitEvent] -> Int -> TagPush)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser RepositoryEvent
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"repository"
                Parser ([CommitEvent] -> Int -> TagPush)
-> Parser [CommitEvent] -> Parser (Int -> TagPush)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser [CommitEvent]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"commits"
                Parser (Int -> TagPush) -> Parser Int -> Parser TagPush
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"total_commits_count"
            ProjectAction
_unexpected -> String -> Parser TagPush
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"tag_push parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser TagPush
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"tag_push parsing failed"

instance FromJSON RepositoryUpdate where
  parseJSON :: Value -> Parser RepositoryUpdate
parseJSON =
    String
-> (Object -> Parser RepositoryUpdate)
-> Value
-> Parser RepositoryUpdate
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"RepositoryUpdate" ((Object -> Parser RepositoryUpdate)
 -> Value -> Parser RepositoryUpdate)
-> (Object -> Parser RepositoryUpdate)
-> Value
-> Parser RepositoryUpdate
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"event_name"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
RepositoryUpdated ->
              Text
-> Int
-> Text
-> Text
-> Text
-> Int
-> ProjectEvent
-> [ProjectChanges]
-> [Text]
-> RepositoryUpdate
RepositoryUpdate
                (Text
 -> Int
 -> Text
 -> Text
 -> Text
 -> Int
 -> ProjectEvent
 -> [ProjectChanges]
 -> [Text]
 -> RepositoryUpdate)
-> Parser Text
-> Parser
     (Int
      -> Text
      -> Text
      -> Text
      -> Int
      -> ProjectEvent
      -> [ProjectChanges]
      -> [Text]
      -> RepositoryUpdate)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_name"
                Parser
  (Int
   -> Text
   -> Text
   -> Text
   -> Int
   -> ProjectEvent
   -> [ProjectChanges]
   -> [Text]
   -> RepositoryUpdate)
-> Parser Int
-> Parser
     (Text
      -> Text
      -> Text
      -> Int
      -> ProjectEvent
      -> [ProjectChanges]
      -> [Text]
      -> RepositoryUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_id"
                Parser
  (Text
   -> Text
   -> Text
   -> Int
   -> ProjectEvent
   -> [ProjectChanges]
   -> [Text]
   -> RepositoryUpdate)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Int
      -> ProjectEvent
      -> [ProjectChanges]
      -> [Text]
      -> RepositoryUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_name"
                Parser
  (Text
   -> Text
   -> Int
   -> ProjectEvent
   -> [ProjectChanges]
   -> [Text]
   -> RepositoryUpdate)
-> Parser Text
-> Parser
     (Text
      -> Int
      -> ProjectEvent
      -> [ProjectChanges]
      -> [Text]
      -> RepositoryUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_email"
                Parser
  (Text
   -> Int
   -> ProjectEvent
   -> [ProjectChanges]
   -> [Text]
   -> RepositoryUpdate)
-> Parser Text
-> Parser
     (Int
      -> ProjectEvent -> [ProjectChanges] -> [Text] -> RepositoryUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user_avatar"
                Parser
  (Int
   -> ProjectEvent -> [ProjectChanges] -> [Text] -> RepositoryUpdate)
-> Parser Int
-> Parser
     (ProjectEvent -> [ProjectChanges] -> [Text] -> RepositoryUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_id"
                Parser
  (ProjectEvent -> [ProjectChanges] -> [Text] -> RepositoryUpdate)
-> Parser ProjectEvent
-> Parser ([ProjectChanges] -> [Text] -> RepositoryUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser ProjectEvent
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project"
                Parser ([ProjectChanges] -> [Text] -> RepositoryUpdate)
-> Parser [ProjectChanges] -> Parser ([Text] -> RepositoryUpdate)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser [ProjectChanges]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"changes"
                Parser ([Text] -> RepositoryUpdate)
-> Parser [Text] -> Parser RepositoryUpdate
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser [Text]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"refs"
            ProjectAction
_unexpected -> String -> Parser RepositoryUpdate
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"repository_update parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser RepositoryUpdate
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"repository_update parsing failed"

instance FromJSON MergeRequestEvent where
  parseJSON :: Value -> Parser MergeRequestEvent
parseJSON =
    String
-> (Object -> Parser MergeRequestEvent)
-> Value
-> Parser MergeRequestEvent
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"MergeRequestEvent" ((Object -> Parser MergeRequestEvent)
 -> Value -> Parser MergeRequestEvent)
-> (Object -> Parser MergeRequestEvent)
-> Value
-> Parser MergeRequestEvent
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      -- Note: it's `event_name` in all other examples, but the GitLab
      -- documentation for MergeRequests says `object_kind`.
      --
      -- `object_kind` has been tried.
      --
      -- Bug in GitLab system hooks documentation?
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"object_kind"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
MergeRequested ->
              Text
-> Text
-> UserEvent
-> ProjectEvent
-> MergeRequestObjectAttributes
-> Maybe [Label]
-> MergeRequestChanges
-> RepositoryEvent
-> MergeRequestEvent
MergeRequestEvent
                (Text
 -> Text
 -> UserEvent
 -> ProjectEvent
 -> MergeRequestObjectAttributes
 -> Maybe [Label]
 -> MergeRequestChanges
 -> RepositoryEvent
 -> MergeRequestEvent)
-> Parser Text
-> Parser
     (Text
      -> UserEvent
      -> ProjectEvent
      -> MergeRequestObjectAttributes
      -> Maybe [Label]
      -> MergeRequestChanges
      -> RepositoryEvent
      -> MergeRequestEvent)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"object_kind"
                Parser
  (Text
   -> UserEvent
   -> ProjectEvent
   -> MergeRequestObjectAttributes
   -> Maybe [Label]
   -> MergeRequestChanges
   -> RepositoryEvent
   -> MergeRequestEvent)
-> Parser Text
-> Parser
     (UserEvent
      -> ProjectEvent
      -> MergeRequestObjectAttributes
      -> Maybe [Label]
      -> MergeRequestChanges
      -> RepositoryEvent
      -> MergeRequestEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_type"
                Parser
  (UserEvent
   -> ProjectEvent
   -> MergeRequestObjectAttributes
   -> Maybe [Label]
   -> MergeRequestChanges
   -> RepositoryEvent
   -> MergeRequestEvent)
-> Parser UserEvent
-> Parser
     (ProjectEvent
      -> MergeRequestObjectAttributes
      -> Maybe [Label]
      -> MergeRequestChanges
      -> RepositoryEvent
      -> MergeRequestEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser UserEvent
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user"
                Parser
  (ProjectEvent
   -> MergeRequestObjectAttributes
   -> Maybe [Label]
   -> MergeRequestChanges
   -> RepositoryEvent
   -> MergeRequestEvent)
-> Parser ProjectEvent
-> Parser
     (MergeRequestObjectAttributes
      -> Maybe [Label]
      -> MergeRequestChanges
      -> RepositoryEvent
      -> MergeRequestEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser ProjectEvent
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project"
                Parser
  (MergeRequestObjectAttributes
   -> Maybe [Label]
   -> MergeRequestChanges
   -> RepositoryEvent
   -> MergeRequestEvent)
-> Parser MergeRequestObjectAttributes
-> Parser
     (Maybe [Label]
      -> MergeRequestChanges -> RepositoryEvent -> MergeRequestEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser MergeRequestObjectAttributes
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"object_attributes"
                Parser
  (Maybe [Label]
   -> MergeRequestChanges -> RepositoryEvent -> MergeRequestEvent)
-> Parser (Maybe [Label])
-> Parser
     (MergeRequestChanges -> RepositoryEvent -> MergeRequestEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe [Label])
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"labels"
                Parser
  (MergeRequestChanges -> RepositoryEvent -> MergeRequestEvent)
-> Parser MergeRequestChanges
-> Parser (RepositoryEvent -> MergeRequestEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser MergeRequestChanges
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"changes"
                Parser (RepositoryEvent -> MergeRequestEvent)
-> Parser RepositoryEvent -> Parser MergeRequestEvent
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser RepositoryEvent
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"repository"
            ProjectAction
_unexpected -> String -> Parser MergeRequestEvent
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"merge_request parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser MergeRequestEvent
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"merge_request parsing failed"

instance FromJSON BuildEvent where
  parseJSON :: Value -> Parser BuildEvent
parseJSON =
    String
-> (Object -> Parser BuildEvent) -> Value -> Parser BuildEvent
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"BuildEvent" ((Object -> Parser BuildEvent) -> Value -> Parser BuildEvent)
-> (Object -> Parser BuildEvent) -> Value -> Parser BuildEvent
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"object_kind"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
Built ->
              Text
-> Text
-> Bool
-> Text
-> Text
-> Int
-> Int
-> Text
-> Text
-> Text
-> Text
-> Maybe Text
-> Maybe Text
-> Maybe Double
-> Maybe Double
-> Bool
-> Maybe Text
-> Int
-> Maybe Runner
-> Int
-> Text
-> User
-> BuildCommit
-> Repository
-> BuildProject
-> Maybe Text
-> BuildEvent
BuildEvent
                (Text
 -> Text
 -> Bool
 -> Text
 -> Text
 -> Int
 -> Int
 -> Text
 -> Text
 -> Text
 -> Text
 -> Maybe Text
 -> Maybe Text
 -> Maybe Double
 -> Maybe Double
 -> Bool
 -> Maybe Text
 -> Int
 -> Maybe Runner
 -> Int
 -> Text
 -> User
 -> BuildCommit
 -> Repository
 -> BuildProject
 -> Maybe Text
 -> BuildEvent)
-> Parser Text
-> Parser
     (Text
      -> Bool
      -> Text
      -> Text
      -> Int
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Double
      -> Maybe Double
      -> Bool
      -> Maybe Text
      -> Int
      -> Maybe Runner
      -> Int
      -> Text
      -> User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"object_kind"
                Parser
  (Text
   -> Bool
   -> Text
   -> Text
   -> Int
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Double
   -> Maybe Double
   -> Bool
   -> Maybe Text
   -> Int
   -> Maybe Runner
   -> Int
   -> Text
   -> User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser Text
-> Parser
     (Bool
      -> Text
      -> Text
      -> Int
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Double
      -> Maybe Double
      -> Bool
      -> Maybe Text
      -> Int
      -> Maybe Runner
      -> Int
      -> Text
      -> User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"ref"
                Parser
  (Bool
   -> Text
   -> Text
   -> Int
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Double
   -> Maybe Double
   -> Bool
   -> Maybe Text
   -> Int
   -> Maybe Runner
   -> Int
   -> Text
   -> User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser Bool
-> Parser
     (Text
      -> Text
      -> Int
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Double
      -> Maybe Double
      -> Bool
      -> Maybe Text
      -> Int
      -> Maybe Runner
      -> Int
      -> Text
      -> User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"tag"
                Parser
  (Text
   -> Text
   -> Int
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Double
   -> Maybe Double
   -> Bool
   -> Maybe Text
   -> Int
   -> Maybe Runner
   -> Int
   -> Text
   -> User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser Text
-> Parser
     (Text
      -> Int
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Double
      -> Maybe Double
      -> Bool
      -> Maybe Text
      -> Int
      -> Maybe Runner
      -> Int
      -> Text
      -> User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"before_sha"
                Parser
  (Text
   -> Int
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Double
   -> Maybe Double
   -> Bool
   -> Maybe Text
   -> Int
   -> Maybe Runner
   -> Int
   -> Text
   -> User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser Text
-> Parser
     (Int
      -> Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Double
      -> Maybe Double
      -> Bool
      -> Maybe Text
      -> Int
      -> Maybe Runner
      -> Int
      -> Text
      -> User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"sha"
                Parser
  (Int
   -> Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Double
   -> Maybe Double
   -> Bool
   -> Maybe Text
   -> Int
   -> Maybe Runner
   -> Int
   -> Text
   -> User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser Int
-> Parser
     (Int
      -> Text
      -> Text
      -> Text
      -> Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Double
      -> Maybe Double
      -> Bool
      -> Maybe Text
      -> Int
      -> Maybe Runner
      -> Int
      -> Text
      -> User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"retries_count"
                Parser
  (Int
   -> Text
   -> Text
   -> Text
   -> Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Double
   -> Maybe Double
   -> Bool
   -> Maybe Text
   -> Int
   -> Maybe Runner
   -> Int
   -> Text
   -> User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser Int
-> Parser
     (Text
      -> Text
      -> Text
      -> Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Double
      -> Maybe Double
      -> Bool
      -> Maybe Text
      -> Int
      -> Maybe Runner
      -> Int
      -> Text
      -> User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"build_id"
                Parser
  (Text
   -> Text
   -> Text
   -> Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Double
   -> Maybe Double
   -> Bool
   -> Maybe Text
   -> Int
   -> Maybe Runner
   -> Int
   -> Text
   -> User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Double
      -> Maybe Double
      -> Bool
      -> Maybe Text
      -> Int
      -> Maybe Runner
      -> Int
      -> Text
      -> User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"build_name"
                Parser
  (Text
   -> Text
   -> Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Double
   -> Maybe Double
   -> Bool
   -> Maybe Text
   -> Int
   -> Maybe Runner
   -> Int
   -> Text
   -> User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser Text
-> Parser
     (Text
      -> Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Double
      -> Maybe Double
      -> Bool
      -> Maybe Text
      -> Int
      -> Maybe Runner
      -> Int
      -> Text
      -> User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"build_stage"
                Parser
  (Text
   -> Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Double
   -> Maybe Double
   -> Bool
   -> Maybe Text
   -> Int
   -> Maybe Runner
   -> Int
   -> Text
   -> User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser Text
-> Parser
     (Text
      -> Maybe Text
      -> Maybe Text
      -> Maybe Double
      -> Maybe Double
      -> Bool
      -> Maybe Text
      -> Int
      -> Maybe Runner
      -> Int
      -> Text
      -> User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"build_status"
                Parser
  (Text
   -> Maybe Text
   -> Maybe Text
   -> Maybe Double
   -> Maybe Double
   -> Bool
   -> Maybe Text
   -> Int
   -> Maybe Runner
   -> Int
   -> Text
   -> User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser Text
-> Parser
     (Maybe Text
      -> Maybe Text
      -> Maybe Double
      -> Maybe Double
      -> Bool
      -> Maybe Text
      -> Int
      -> Maybe Runner
      -> Int
      -> Text
      -> User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"build_created_at"
                Parser
  (Maybe Text
   -> Maybe Text
   -> Maybe Double
   -> Maybe Double
   -> Bool
   -> Maybe Text
   -> Int
   -> Maybe Runner
   -> Int
   -> Text
   -> User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser (Maybe Text)
-> Parser
     (Maybe Text
      -> Maybe Double
      -> Maybe Double
      -> Bool
      -> Maybe Text
      -> Int
      -> Maybe Runner
      -> Int
      -> Text
      -> User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"build_started_at"
                Parser
  (Maybe Text
   -> Maybe Double
   -> Maybe Double
   -> Bool
   -> Maybe Text
   -> Int
   -> Maybe Runner
   -> Int
   -> Text
   -> User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser (Maybe Text)
-> Parser
     (Maybe Double
      -> Maybe Double
      -> Bool
      -> Maybe Text
      -> Int
      -> Maybe Runner
      -> Int
      -> Text
      -> User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"build_finished_at"
                Parser
  (Maybe Double
   -> Maybe Double
   -> Bool
   -> Maybe Text
   -> Int
   -> Maybe Runner
   -> Int
   -> Text
   -> User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser (Maybe Double)
-> Parser
     (Maybe Double
      -> Bool
      -> Maybe Text
      -> Int
      -> Maybe Runner
      -> Int
      -> Text
      -> User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Double)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"build_duration"
                Parser
  (Maybe Double
   -> Bool
   -> Maybe Text
   -> Int
   -> Maybe Runner
   -> Int
   -> Text
   -> User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser (Maybe Double)
-> Parser
     (Bool
      -> Maybe Text
      -> Int
      -> Maybe Runner
      -> Int
      -> Text
      -> User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Double)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"build_queued_duration"
                Parser
  (Bool
   -> Maybe Text
   -> Int
   -> Maybe Runner
   -> Int
   -> Text
   -> User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser Bool
-> Parser
     (Maybe Text
      -> Int
      -> Maybe Runner
      -> Int
      -> Text
      -> User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"build_allow_failure"
                Parser
  (Maybe Text
   -> Int
   -> Maybe Runner
   -> Int
   -> Text
   -> User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser (Maybe Text)
-> Parser
     (Int
      -> Maybe Runner
      -> Int
      -> Text
      -> User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"build_failure_reason"
                Parser
  (Int
   -> Maybe Runner
   -> Int
   -> Text
   -> User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser Int
-> Parser
     (Maybe Runner
      -> Int
      -> Text
      -> User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"pipeline_id"
                Parser
  (Maybe Runner
   -> Int
   -> Text
   -> User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser (Maybe Runner)
-> Parser
     (Int
      -> Text
      -> User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Runner)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"runner"
                Parser
  (Int
   -> Text
   -> User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser Int
-> Parser
     (Text
      -> User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_id"
                Parser
  (Text
   -> User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser Text
-> Parser
     (User
      -> BuildCommit
      -> Repository
      -> BuildProject
      -> Maybe Text
      -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_name"
                Parser
  (User
   -> BuildCommit
   -> Repository
   -> BuildProject
   -> Maybe Text
   -> BuildEvent)
-> Parser User
-> Parser
     (BuildCommit
      -> Repository -> BuildProject -> Maybe Text -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser User
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user"
                Parser
  (BuildCommit
   -> Repository -> BuildProject -> Maybe Text -> BuildEvent)
-> Parser BuildCommit
-> Parser (Repository -> BuildProject -> Maybe Text -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser BuildCommit
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"commit"
                Parser (Repository -> BuildProject -> Maybe Text -> BuildEvent)
-> Parser Repository
-> Parser (BuildProject -> Maybe Text -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Repository
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"repository"
                Parser (BuildProject -> Maybe Text -> BuildEvent)
-> Parser BuildProject -> Parser (Maybe Text -> BuildEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser BuildProject
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project"
                Parser (Maybe Text -> BuildEvent)
-> Parser (Maybe Text) -> Parser BuildEvent
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"environment"
            ProjectAction
unexpected -> String -> Parser BuildEvent
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"build parsing failed: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> ProjectAction -> String
forall a. Show a => a -> String
show ProjectAction
unexpected)
        Maybe ProjectAction
unexpected -> String -> Parser BuildEvent
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"build parsing failed: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Maybe ProjectAction -> String
forall a. Show a => a -> String
show Maybe ProjectAction
unexpected)

instance FromJSON PipelineEvent where
  parseJSON :: Value -> Parser PipelineEvent
parseJSON =
    String
-> (Object -> Parser PipelineEvent)
-> Value
-> Parser PipelineEvent
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Pipeline" ((Object -> Parser PipelineEvent) -> Value -> Parser PipelineEvent)
-> (Object -> Parser PipelineEvent)
-> Value
-> Parser PipelineEvent
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isProjectEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"object_kind"
      case Maybe ProjectAction
isProjectEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
Pipelined ->
              Text
-> PipelineObjectAttributes
-> Maybe Text
-> User
-> BuildProject
-> CommitEvent
-> [PipelineBuild]
-> PipelineEvent
PipelineEvent
                (Text
 -> PipelineObjectAttributes
 -> Maybe Text
 -> User
 -> BuildProject
 -> CommitEvent
 -> [PipelineBuild]
 -> PipelineEvent)
-> Parser Text
-> Parser
     (PipelineObjectAttributes
      -> Maybe Text
      -> User
      -> BuildProject
      -> CommitEvent
      -> [PipelineBuild]
      -> PipelineEvent)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"object_kind"
                Parser
  (PipelineObjectAttributes
   -> Maybe Text
   -> User
   -> BuildProject
   -> CommitEvent
   -> [PipelineBuild]
   -> PipelineEvent)
-> Parser PipelineObjectAttributes
-> Parser
     (Maybe Text
      -> User
      -> BuildProject
      -> CommitEvent
      -> [PipelineBuild]
      -> PipelineEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser PipelineObjectAttributes
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"object_attributes"
                Parser
  (Maybe Text
   -> User
   -> BuildProject
   -> CommitEvent
   -> [PipelineBuild]
   -> PipelineEvent)
-> Parser (Maybe Text)
-> Parser
     (User
      -> BuildProject -> CommitEvent -> [PipelineBuild] -> PipelineEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"merge_request"
                Parser
  (User
   -> BuildProject -> CommitEvent -> [PipelineBuild] -> PipelineEvent)
-> Parser User
-> Parser
     (BuildProject -> CommitEvent -> [PipelineBuild] -> PipelineEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser User
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user"
                Parser
  (BuildProject -> CommitEvent -> [PipelineBuild] -> PipelineEvent)
-> Parser BuildProject
-> Parser (CommitEvent -> [PipelineBuild] -> PipelineEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser BuildProject
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project"
                Parser (CommitEvent -> [PipelineBuild] -> PipelineEvent)
-> Parser CommitEvent -> Parser ([PipelineBuild] -> PipelineEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser CommitEvent
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"commit"
                Parser ([PipelineBuild] -> PipelineEvent)
-> Parser [PipelineBuild] -> Parser PipelineEvent
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser [PipelineBuild]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"builds"
            ProjectAction
_unexpected -> String -> Parser PipelineEvent
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"build parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser PipelineEvent
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"build parsing failed"

instance FromJSON NoteEvent where
  parseJSON :: Value -> Parser NoteEvent
parseJSON =
    String -> (Object -> Parser NoteEvent) -> Value -> Parser NoteEvent
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"NoteEvent" ((Object -> Parser NoteEvent) -> Value -> Parser NoteEvent)
-> (Object -> Parser NoteEvent) -> Value -> Parser NoteEvent
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isNoteEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"object_kind"
      case Maybe ProjectAction
isNoteEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
Noted ->
              Text
-> Text
-> User
-> Int
-> ProjectEvent
-> NoteObjectAttributes
-> RepositoryEvent
-> Maybe IssueEventObjectAttributes
-> NoteEvent
NoteEvent
                (Text
 -> Text
 -> User
 -> Int
 -> ProjectEvent
 -> NoteObjectAttributes
 -> RepositoryEvent
 -> Maybe IssueEventObjectAttributes
 -> NoteEvent)
-> Parser Text
-> Parser
     (Text
      -> User
      -> Int
      -> ProjectEvent
      -> NoteObjectAttributes
      -> RepositoryEvent
      -> Maybe IssueEventObjectAttributes
      -> NoteEvent)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"object_kind"
                Parser
  (Text
   -> User
   -> Int
   -> ProjectEvent
   -> NoteObjectAttributes
   -> RepositoryEvent
   -> Maybe IssueEventObjectAttributes
   -> NoteEvent)
-> Parser Text
-> Parser
     (User
      -> Int
      -> ProjectEvent
      -> NoteObjectAttributes
      -> RepositoryEvent
      -> Maybe IssueEventObjectAttributes
      -> NoteEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"event_type"
                Parser
  (User
   -> Int
   -> ProjectEvent
   -> NoteObjectAttributes
   -> RepositoryEvent
   -> Maybe IssueEventObjectAttributes
   -> NoteEvent)
-> Parser User
-> Parser
     (Int
      -> ProjectEvent
      -> NoteObjectAttributes
      -> RepositoryEvent
      -> Maybe IssueEventObjectAttributes
      -> NoteEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser User
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user"
                Parser
  (Int
   -> ProjectEvent
   -> NoteObjectAttributes
   -> RepositoryEvent
   -> Maybe IssueEventObjectAttributes
   -> NoteEvent)
-> Parser Int
-> Parser
     (ProjectEvent
      -> NoteObjectAttributes
      -> RepositoryEvent
      -> Maybe IssueEventObjectAttributes
      -> NoteEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Int
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project_id"
                Parser
  (ProjectEvent
   -> NoteObjectAttributes
   -> RepositoryEvent
   -> Maybe IssueEventObjectAttributes
   -> NoteEvent)
-> Parser ProjectEvent
-> Parser
     (NoteObjectAttributes
      -> RepositoryEvent
      -> Maybe IssueEventObjectAttributes
      -> NoteEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser ProjectEvent
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"project"
                Parser
  (NoteObjectAttributes
   -> RepositoryEvent
   -> Maybe IssueEventObjectAttributes
   -> NoteEvent)
-> Parser NoteObjectAttributes
-> Parser
     (RepositoryEvent -> Maybe IssueEventObjectAttributes -> NoteEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser NoteObjectAttributes
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"object_attributes"
                Parser
  (RepositoryEvent -> Maybe IssueEventObjectAttributes -> NoteEvent)
-> Parser RepositoryEvent
-> Parser (Maybe IssueEventObjectAttributes -> NoteEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser RepositoryEvent
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"repository"
                Parser (Maybe IssueEventObjectAttributes -> NoteEvent)
-> Parser (Maybe IssueEventObjectAttributes) -> Parser NoteEvent
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser (Maybe IssueEventObjectAttributes)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"issue"
            ProjectAction
_unexpected -> String -> Parser NoteEvent
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"note parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser NoteEvent
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"note parsing failed"

instance FromJSON WikiPageEvent where
  parseJSON :: Value -> Parser WikiPageEvent
parseJSON =
    String
-> (Object -> Parser WikiPageEvent)
-> Value
-> Parser WikiPageEvent
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"WikiPageEvent" ((Object -> Parser WikiPageEvent) -> Value -> Parser WikiPageEvent)
-> (Object -> Parser WikiPageEvent)
-> Value
-> Parser WikiPageEvent
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isWikiPageEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"object_kind"
      case Maybe ProjectAction
isWikiPageEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
WikiPaged ->
              Text -> User -> Wiki -> WikiPageObjectAttributes -> WikiPageEvent
WikiPageEvent
                (Text -> User -> Wiki -> WikiPageObjectAttributes -> WikiPageEvent)
-> Parser Text
-> Parser
     (User -> Wiki -> WikiPageObjectAttributes -> WikiPageEvent)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"object_kind"
                Parser (User -> Wiki -> WikiPageObjectAttributes -> WikiPageEvent)
-> Parser User
-> Parser (Wiki -> WikiPageObjectAttributes -> WikiPageEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser User
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user"
                Parser (Wiki -> WikiPageObjectAttributes -> WikiPageEvent)
-> Parser Wiki
-> Parser (WikiPageObjectAttributes -> WikiPageEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Wiki
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"wiki"
                Parser (WikiPageObjectAttributes -> WikiPageEvent)
-> Parser WikiPageObjectAttributes -> Parser WikiPageEvent
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser WikiPageObjectAttributes
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"object_attributes"
            ProjectAction
_unexpected -> String -> Parser WikiPageEvent
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"wiki page parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser WikiPageEvent
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"wiki page parsing failed"

instance FromJSON WorkItemEvent where
  parseJSON :: Value -> Parser WorkItemEvent
parseJSON =
    String
-> (Object -> Parser WorkItemEvent)
-> Value
-> Parser WorkItemEvent
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"WorkItemEvent" ((Object -> Parser WorkItemEvent) -> Value -> Parser WorkItemEvent)
-> (Object -> Parser WorkItemEvent)
-> Value
-> Parser WorkItemEvent
forall a b. (a -> b) -> a -> b
$ \Object
v -> do
      Maybe ProjectAction
isWorkItemEvent <- Object
v Object -> Key -> Parser (Maybe ProjectAction)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"object_kind"
      case Maybe ProjectAction
isWorkItemEvent of
        Just ProjectAction
theEvent ->
          case ProjectAction
theEvent of
            ProjectAction
WorkItemed ->
              User
-> WorkItemObjectAttributes
-> [Label]
-> Repository
-> [User]
-> WorkItemEvent
WorkItemEvent
                (User
 -> WorkItemObjectAttributes
 -> [Label]
 -> Repository
 -> [User]
 -> WorkItemEvent)
-> Parser User
-> Parser
     (WorkItemObjectAttributes
      -> [Label] -> Repository -> [User] -> WorkItemEvent)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser User
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"user"
                Parser
  (WorkItemObjectAttributes
   -> [Label] -> Repository -> [User] -> WorkItemEvent)
-> Parser WorkItemObjectAttributes
-> Parser ([Label] -> Repository -> [User] -> WorkItemEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser WorkItemObjectAttributes
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"object_attributes"
                Parser ([Label] -> Repository -> [User] -> WorkItemEvent)
-> Parser [Label] -> Parser (Repository -> [User] -> WorkItemEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser [Label]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"labels"
                -- <*> v .: "changes"
                Parser (Repository -> [User] -> WorkItemEvent)
-> Parser Repository -> Parser ([User] -> WorkItemEvent)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser Repository
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"repository"
                Parser ([User] -> WorkItemEvent)
-> Parser [User] -> Parser WorkItemEvent
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
v Object -> Key -> Parser [User]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"assignees"
            ProjectAction
_unexpected -> String -> Parser WorkItemEvent
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"work item parsing failed"
        Maybe ProjectAction
_unexpected -> String -> Parser WorkItemEvent
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"work item parsing failed"

-- TODO: replace bodyNoPrefix with a template Haskell based approach in src/GitLab/Types.hs
-- e.g.

-- $(deriveJSON defaultOptions {fieldLabelModifier = drop (T.length "event_"), omitNothingFields = True} ''Event)

bodyNoPrefix :: String -> String
bodyNoPrefix :: ShowS
bodyNoPrefix String
"projectEvent_id" = String
"id"
bodyNoPrefix String
"projectEvent_name" = String
"name"
bodyNoPrefix String
"projectEvent_description" = String
"description"
bodyNoPrefix String
"projectEvent_web_url" = String
"web_url"
bodyNoPrefix String
"projectEvent_avatar_url" = String
"avatar_url"
bodyNoPrefix String
"projectEvent_git_ssh_url" = String
"git_ssh_url"
bodyNoPrefix String
"projectEvent_git_http_url" = String
"git_http_url"
bodyNoPrefix String
"projectEvent_namespace" = String
"namespace"
bodyNoPrefix String
"projectEvent_visibility_level" = String
"visibility_level"
bodyNoPrefix String
"projectEvent_path_with_namespace" = String
"path_with_namespace"
bodyNoPrefix String
"projectEvent_default_branch" = String
"default_branch"
-- bodyNoPrefix "projectEvent_ci_config_path" = "ci_config_path"
bodyNoPrefix String
"projectEvent_homepage" = String
"homepage"
bodyNoPrefix String
"projectEvent_url" = String
"url"
bodyNoPrefix String
"projectEvent_ssh_url" = String
"ssh_url"
bodyNoPrefix String
"projectEvent_http_url" = String
"http_url"
bodyNoPrefix String
"projectChanges_before" = String
"before"
bodyNoPrefix String
"projectChanges_after" = String
"after"
bodyNoPrefix String
"projectChanges_ref" = String
"ref"
bodyNoPrefix String
"repositoryEvent_name" = String
"name"
bodyNoPrefix String
"repositoryEvent_url" = String
"url"
bodyNoPrefix String
"repositoryEvent_description" = String
"description"
bodyNoPrefix String
"repositoryEvent_homepage" = String
"homepage"
bodyNoPrefix String
"repositoryEvent_git_http_url" = String
"git_http_url"
bodyNoPrefix String
"repositoryEvent_git_ssh_url" = String
"git_ssh_url"
bodyNoPrefix String
"repositoryEvent_visibility_level" = String
"visibility_level"
bodyNoPrefix String
"commitEvent_id" = String
"id"
bodyNoPrefix String
"commitEvent_message" = String
"message"
bodyNoPrefix String
"commitEvent_timestamp" = String
"timestamp"
bodyNoPrefix String
"commitEvent_url" = String
"url"
bodyNoPrefix String
"commitEvent_author" = String
"author"
bodyNoPrefix String
"commitAuthorEvent_name" = String
"name"
bodyNoPrefix String
"commitAuthorEvent_email" = String
"email"
bodyNoPrefix String
"mergeParams_force_remove_source_branch" = String
"force_remove_source_branch"
bodyNoPrefix String
"userEvent_name" = String
"name"
bodyNoPrefix String
"userEvent_username" = String
"username"
bodyNoPrefix String
"userEvent_avatar_url" = String
"avatar_url"
bodyNoPrefix String
"objectAttributes_id" = String
"id"
bodyNoPrefix String
"objectAttributes_target_branch" = String
"target_branch"
bodyNoPrefix String
"objectAttributes_source_branch" = String
"source_branch"
bodyNoPrefix String
"objectAttributes_source_project_id" = String
"source_project_id"
bodyNoPrefix String
"objectAttributes_author_id" = String
"author_id"
bodyNoPrefix String
"objectAttributes_assignee_id" = String
"assignee_id"
bodyNoPrefix String
"objectAttributes_assignee_ids" = String
"assignee_ids"
bodyNoPrefix String
"objectAttributes_title" = String
"title"
bodyNoPrefix String
"objectAttributes_created_at" = String
"created_at"
bodyNoPrefix String
"objectAttributes_updated_at" = String
"updated_at"
bodyNoPrefix String
"objectAttributes_milestone_id" = String
"milestone_id"
bodyNoPrefix String
"objectAttributes_state" = String
"state"
bodyNoPrefix String
"objectAttributes_state_id" = String
"state_id"
bodyNoPrefix String
"objectAttributes_merge_status" = String
"merge_status"
bodyNoPrefix String
"objectAttributes_target_project_id" = String
"target_project_id"
bodyNoPrefix String
"objectAttributes_iid" = String
"iid"
bodyNoPrefix String
"objectAttributes_description" = String
"description"
bodyNoPrefix String
"objectAttributes_updated_by_id" = String
"updated_by_id"
bodyNoPrefix String
"objectAttributes_merge_error" = String
"merge_error"
bodyNoPrefix String
"objectAttributes_merge_params" = String
"merge_params"
bodyNoPrefix String
"objectAttributes_merge_when_pipeline_succeeds" = String
"merge_when_pipeline_succeeds"
bodyNoPrefix String
"objectAttributes_merge_user_id" = String
"merge_user_id"
bodyNoPrefix String
"objectAttributes_merge_commit_sha" = String
"merge_commit_sha"
bodyNoPrefix String
"objectAttributes_deleted_at" = String
"deleted_at"
bodyNoPrefix String
"objectAttributes_in_progress_merge_commit_sha" = String
"in_progress_merge_commit_sha"
bodyNoPrefix String
"objectAttributes_lock_version" = String
"lock_version"
bodyNoPrefix String
"objectAttributes_time_estimate" = String
"time_estimate"
bodyNoPrefix String
"objectAttributes_last_edited_at" = String
"last_edited_at"
bodyNoPrefix String
"objectAttributes_last_edited_by_id" = String
"last_edited_by_id"
bodyNoPrefix String
"objectAttributes_head_pipeline_id" = String
"head_pipeline_id"
bodyNoPrefix String
"objectAttributes_ref_fetched" = String
"ref_fetched"
bodyNoPrefix String
"objectAttributes_merge_jid" = String
"merge_jid"
bodyNoPrefix String
"objectAttributes_source" = String
"source"
bodyNoPrefix String
"objectAttributes_target" = String
"target"
bodyNoPrefix String
"objectAttributes_last_commit" = String
"last_commit"
bodyNoPrefix String
"objectAttributes_work_in_progress" = String
"work_in_progress"
bodyNoPrefix String
"objectAttributes_total_time_spent" = String
"total_time_spent"
bodyNoPrefix String
"objectAttributes_human_total_time_spent" = String
"human_total_time_spent"
bodyNoPrefix String
"objectAttributes_human_time_estimate" = String
"human_time_estimate"
bodyNoPrefix String
"objectAttributes_action" = String
"action"
bodyNoPrefix String
"mergeRequestChanges_author_id" = String
"author_id"
bodyNoPrefix String
"mergeRequestChanges_created_at" = String
"created_at"
bodyNoPrefix String
"mergeRequestChanges_description" = String
"description"
bodyNoPrefix String
"mergeRequestChanges_id" = String
"id"
bodyNoPrefix String
"mergeRequestChanges_iid" = String
"iid"
bodyNoPrefix String
"mergeRequestChanges_source_branch" = String
"source_branch"
bodyNoPrefix String
"mergeRequestChanges_source_project_id" = String
"source_project_id"
bodyNoPrefix String
"mergeRequestChanges_target_branch" = String
"target_branch"
bodyNoPrefix String
"mergeRequestChanges_target_project_id" = String
"target_project_id"
bodyNoPrefix String
"mergeRequestChanges_title" = String
"title"
bodyNoPrefix String
"mergeRequestChanges_updated_at" = String
"updated_at"
bodyNoPrefix String
"mergeRequestChange_previous" = String
"previous"
bodyNoPrefix String
"mergeRequestChange_current" = String
"current"
bodyNoPrefix String
"build_commit_id" = String
"id"
bodyNoPrefix String
"build_commit_name" = String
"name"
bodyNoPrefix String
"build_commit_sha" = String
"sha"
bodyNoPrefix String
"build_commit_message" = String
"message"
bodyNoPrefix String
"build_commit_author_name" = String
"author_name"
bodyNoPrefix String
"build_commit_author_email" = String
"author_email"
bodyNoPrefix String
"build_commit_author_url" = String
"author_url"
bodyNoPrefix String
"build_commit_status" = String
"status"
bodyNoPrefix String
"build_commit_duration" = String
"duration"
bodyNoPrefix String
"build_commit_started_at" = String
"started_at"
bodyNoPrefix String
"build_commit_finished_at" = String
"finished_at"
bodyNoPrefix String
"build_project_project_id" = String
"id"
bodyNoPrefix String
"build_project_project_name" = String
"name"
bodyNoPrefix String
"build_project_description" = String
"description"
bodyNoPrefix String
"build_project_web_url" = String
"web_url"
bodyNoPrefix String
"build_project_avatar_url" = String
"avatar_url"
bodyNoPrefix String
"build_project_git_ssh_url" = String
"git_ssh_url"
bodyNoPrefix String
"build_project_git_http_url" = String
"git_http_url"
bodyNoPrefix String
"build_project_namespace" = String
"namespace"
bodyNoPrefix String
"build_project_visibility_level" = String
"visibility_level"
bodyNoPrefix String
"build_project_path_with_namespace" = String
"path_with_namespace"
bodyNoPrefix String
"build_project_default_branch" = String
"default_branch"
bodyNoPrefix String
"build_project_ci_config_path" = String
"ci_config_path"
bodyNoPrefix String
"pipeline_object_attributes_id" = String
"id"
bodyNoPrefix String
"pipeline_object_attributes_iid" = String
"iid"
bodyNoPrefix String
"pipeline_object_attributes_name" = String
"name"
bodyNoPrefix String
"pipeline_object_attributes_ref" = String
"ref"
bodyNoPrefix String
"pipeline_object_attributes_tag" = String
"tag"
bodyNoPrefix String
"pipeline_object_attributes_sha" = String
"sha"
bodyNoPrefix String
"pipeline_object_attributes_before_sha" = String
"before_sha"
bodyNoPrefix String
"pipeline_object_attributes_source" = String
"source"
bodyNoPrefix String
"pipeline_object_attributes_status" = String
"status"
bodyNoPrefix String
"pipeline_object_attributes_detailed_status" = String
"detailed_status"
bodyNoPrefix String
"pipeline_object_attributes_stages" = String
"stages"
bodyNoPrefix String
"pipeline_object_attributes_created_at" = String
"created_at"
bodyNoPrefix String
"pipeline_object_attributes_finished_at" = String
"finished_at"
bodyNoPrefix String
"pipeline_object_attributes_duration" = String
"duration"
bodyNoPrefix String
"pipeline_object_attributes_queued_duration" = String
"queued_duration"
bodyNoPrefix String
"pipeline_object_attributes_variables" = String
"variables"
bodyNoPrefix String
"pipeline_object_attributes_url" = String
"url"
bodyNoPrefix String
"pipeline_build_id" = String
"id"
bodyNoPrefix String
"pipeline_build_stage" = String
"stage"
bodyNoPrefix String
"pipeline_build_name" = String
"name"
bodyNoPrefix String
"pipeline_build_status" = String
"status"
bodyNoPrefix String
"pipeline_build_created_at" = String
"created_at"
bodyNoPrefix String
"pipeline_build_started_at" = String
"started_at"
bodyNoPrefix String
"pipeline_build_finished_at" = String
"finished_at"
bodyNoPrefix String
"pipeline_build_duration" = String
"duration"
bodyNoPrefix String
"pipeline_build_queued_duration" = String
"queued_duration"
bodyNoPrefix String
"pipeline_build_failure_reason" = String
"failure_reason"
bodyNoPrefix String
"pipeline_build_when" = String
"when"
bodyNoPrefix String
"pipeline_build_manual" = String
"manual"
bodyNoPrefix String
"pipeline_build_allow_failure" = String
"allow_failure"
bodyNoPrefix String
"pipeline_build_user" = String
"user"
bodyNoPrefix String
"pipeline_build_runner" = String
"runner"
bodyNoPrefix String
"pipeline_build_artifacts_file" = String
"artifacts_file"
bodyNoPrefix String
"pipeline_build_environment" = String
"environment"
bodyNoPrefix String
"runner_id" = String
"id"
bodyNoPrefix String
"runner_description" = String
"description"
bodyNoPrefix String
"runner_runner_type" = String
"runner_type"
bodyNoPrefix String
"runner_active" = String
"active"
bodyNoPrefix String
"runner_is_shared" = String
"is_shared"
bodyNoPrefix String
"runner_tags" = String
"tags"
bodyNoPrefix String
"artifacts_file_filename" = String
"filename"
bodyNoPrefix String
"artifacts_file_size" = String
"size"
bodyNoPrefix String
"issue_event_event_type" = String
"event_type"
bodyNoPrefix String
"issue_event_user" = String
"user"
bodyNoPrefix String
"issue_event_project" = String
"project"
bodyNoPrefix String
"issue_event_object_attributes" = String
"object_attributes"
bodyNoPrefix String
"issue_event_labels" = String
"labels"
bodyNoPrefix String
"issue_event_changes" = String
"changes"
bodyNoPrefix String
"issue_event_repository" = String
"repository"
bodyNoPrefix String
"issue_event_assignees" = String
"assignees"
bodyNoPrefix String
"issue_event_object_attributes_author_id" = String
"author_id"
bodyNoPrefix String
"issue_event_object_attributes_closed_at" = String
"closed_at"
bodyNoPrefix String
"issue_event_object_attributes_confidential" = String
"confidential"
bodyNoPrefix String
"issue_event_object_attributes_created_at" = String
"created_at"
bodyNoPrefix String
"issue_event_object_attributes_description" = String
"description"
bodyNoPrefix String
"issue_event_object_attributes_discussion_locked" = String
"discussion_locked"
bodyNoPrefix String
"issue_event_object_attributes_due_date" = String
"due_date"
bodyNoPrefix String
"issue_event_object_attributes_id" = String
"id"
bodyNoPrefix String
"issue_event_object_attributes_iid" = String
"iid"
bodyNoPrefix String
"issue_event_object_attributes_last_edited_at" = String
"last_edited_at"
bodyNoPrefix String
"issue_event_object_attributes_last_edited_by" = String
"last_edited_by"
bodyNoPrefix String
"issue_event_object_attributes_milestone_id" = String
"milestone_id"
bodyNoPrefix String
"issue_event_object_attributes_move_to_id" = String
"move_to_id"
bodyNoPrefix String
"issue_event_object_attributes_duplicated_to_id" = String
"duplicated_to_id"
bodyNoPrefix String
"issue_event_object_attributes_project_id" = String
"project_id"
bodyNoPrefix String
"issue_event_object_attributes_relative_position" = String
"relative_position"
bodyNoPrefix String
"issue_event_object_attributes_state_id" = String
"state_id"
bodyNoPrefix String
"issue_event_object_attributes_time_estimate" = String
"time_estimate"
bodyNoPrefix String
"issue_event_object_attributes_title" = String
"title"
bodyNoPrefix String
"issue_event_object_attributes_updated_at" = String
"updated_at"
bodyNoPrefix String
"issue_event_object_attributes_updated_by_id" = String
"updated_by_id"
bodyNoPrefix String
"issue_event_object_attributes_type" = String
"type"
bodyNoPrefix String
"issue_event_object_attributes_url" = String
"url"
bodyNoPrefix String
"issue_event_object_attributes_total_time_spent" = String
"total_time_spent"
bodyNoPrefix String
"issue_event_object_attributes_time_change" = String
"time_change"
bodyNoPrefix String
"issue_event_object_attributes_human_total_time_spent" = String
"human_total_time_spent"
bodyNoPrefix String
"issue_event_object_attributes_human_time_change" = String
"human_time_change"
bodyNoPrefix String
"issue_event_object_attributes_human_time_estimate" = String
"human_time_estimate"
bodyNoPrefix String
"issue_event_changes_author_id" = String
"author_id"
bodyNoPrefix String
"issue_event_author_id_previous" = String
"previous"
bodyNoPrefix String
"issue_event_author_id_current" = String
"current"
bodyNoPrefix String
"issue_event_changes_created_at" = String
"created_at"
bodyNoPrefix String
"issue_event_created_at_previous" = String
"previous"
bodyNoPrefix String
"issue_event_created_at_current" = String
"current"
bodyNoPrefix String
"issue_event_changes_description" = String
"description"
bodyNoPrefix String
"issue_event_description_previous" = String
"previous"
bodyNoPrefix String
"issue_event_description_current" = String
"current"
bodyNoPrefix String
"issue_event_changes_id" = String
"id"
bodyNoPrefix String
"issue_event_id_previous" = String
"previous"
bodyNoPrefix String
"issue_event_id_current" = String
"current"
bodyNoPrefix String
"issue_event_changes_iid" = String
"iid"
bodyNoPrefix String
"issue_event_iid_previous" = String
"previous"
bodyNoPrefix String
"issue_event_iid_current" = String
"current"
bodyNoPrefix String
"issue_event_changes_project_id" = String
"project_id"
bodyNoPrefix String
"issue_event_project_id_previous" = String
"previous"
bodyNoPrefix String
"issue_event_project_id_current" = String
"current"
bodyNoPrefix String
"issue_event_changes_title" = String
"title"
bodyNoPrefix String
"issue_event_title_previous" = String
"previous"
bodyNoPrefix String
"issue_event_title_current" = String
"current"
bodyNoPrefix String
"issue_event_changes_updated_at" = String
"updated_at"
bodyNoPrefix String
"issue_event_updated_at_previous" = String
"previous"
bodyNoPrefix String
"issue_event_updated_at_current" = String
"current"
bodyNoPrefix String
"issue_event_changes_closed_at" = String
"closed_at"
bodyNoPrefix String
"issue_event_closed_at_previous" = String
"previous"
bodyNoPrefix String
"issue_event_closed_at_current" = String
"current"
bodyNoPrefix String
"issue_event_changes_state_id" = String
"state_id"
bodyNoPrefix String
"issue_event_state_id_previous" = String
"previous"
bodyNoPrefix String
"issue_event_state_id_current" = String
"current"
bodyNoPrefix String
"issue_event_changes_updated_at" = String
"updated_at"
bodyNoPrefix String
"issue_event_updated_at_previous" = String
"previous"
bodyNoPrefix String
"issue_event_updated_at_current" = String
"current"
bodyNoPrefix String
"note_object_attributes_attachment" = String
"attachment"
bodyNoPrefix String
"note_object_attributes_author_id" = String
"author_id"
bodyNoPrefix String
"note_object_attributes_change_position" = String
"change_position"
bodyNoPrefix String
"note_object_attributes_commit_id" = String
"commit_id"
bodyNoPrefix String
"note_object_attributes_created_at" = String
"created_at"
bodyNoPrefix String
"note_object_attributes_discussion_id" = String
"discussion_id"
bodyNoPrefix String
"note_object_attributes_id" = String
"id"
bodyNoPrefix String
"note_object_attributes_line_code" = String
"line_code"
bodyNoPrefix String
"note_object_attributes_note" = String
"note"
bodyNoPrefix String
"note_object_attributes_noteable_id" = String
"noteable_id"
bodyNoPrefix String
"note_object_attributes_noteable_type" = String
"noteable_type"
bodyNoPrefix String
"note_object_attributes_original_position" = String
"original_position"
bodyNoPrefix String
"note_object_attributes_position" = String
"position"
bodyNoPrefix String
"note_object_attributes_project_id" = String
"project_id"
bodyNoPrefix String
"note_object_attributes_resolved_at" = String
"resolved_at"
bodyNoPrefix String
"note_object_attributes_resolved_by_id" = String
"resolved_by_id"
bodyNoPrefix String
"note_object_attributes_resolved_by_push" = String
"resolved_by_push"
bodyNoPrefix String
"note_object_attributes_st_diff" = String
"st_diff"
bodyNoPrefix String
"note_object_attributes_system" = String
"system"
bodyNoPrefix String
"note_object_attributes_type" = String
"type"
bodyNoPrefix String
"note_object_attributes_updated_at" = String
"updated_at"
bodyNoPrefix String
"note_object_attributes_updated_by_id" = String
"updated_by_id"
bodyNoPrefix String
"note_object_attributes_description" = String
"description"
bodyNoPrefix String
"note_object_attributes_url" = String
"url"
bodyNoPrefix String
"note_object_attributes_action" = String
"action"
bodyNoPrefix String
"wiki_web_url" = String
"web_url"
bodyNoPrefix String
"wiki_git_ssh_url" = String
"git_ssh_url"
bodyNoPrefix String
"wiki_git_http_url" = String
"git_http_url"
bodyNoPrefix String
"wiki_path_with_namespace" = String
"path_with_namespace"
bodyNoPrefix String
"wiki_default_branch" = String
"default_branch"
bodyNoPrefix String
"wiki_page_object_attributes_slug" = String
"slug"
bodyNoPrefix String
"wiki_page_object_attributes_title" = String
"title"
bodyNoPrefix String
"wiki_page_object_attributes_format" = String
"format"
bodyNoPrefix String
"wiki_page_object_attributes_message" = String
"message"
bodyNoPrefix String
"wiki_page_object_attributes_version_id" = String
"version_id"
bodyNoPrefix String
"wiki_page_object_attributes_url" = String
"url"
bodyNoPrefix String
"wiki_page_object_attributes_action" = String
"action"
bodyNoPrefix String
"wiki_page_object_attributes_diff_url" = String
"diff_url"
bodyNoPrefix String
"work_item_object_author_id" = String
"author_id"
bodyNoPrefix String
"work_item_object_closed_at" = String
"closed_at"
bodyNoPrefix String
"work_item_object_confidential" = String
"confidential"
bodyNoPrefix String
"work_item_object_created_at" = String
"created_at"
bodyNoPrefix String
"work_item_object_description" = String
"description"
bodyNoPrefix String
"work_item_object_discussion_locked" = String
"discussion_locked"
bodyNoPrefix String
"work_item_object_due_date" = String
"due_date"
bodyNoPrefix String
"work_item_object_id" = String
"id"
bodyNoPrefix String
"work_item_object_iid" = String
"iid"
bodyNoPrefix String
"work_item_object_last_edited_at" = String
"last_edited_at"
bodyNoPrefix String
"work_item_object_last_edited_at_by_id" = String
"edited_at_by_id"
bodyNoPrefix String
"work_item_object_milestone_id" = String
"milestone_id"
bodyNoPrefix String
"work_item_object_moved_to_id" = String
"moved_to_id"
bodyNoPrefix String
"work_item_object_duplicated_to_id" = String
"duplicated_to_id"
bodyNoPrefix String
"work_item_object_project_id" = String
"project_id"
bodyNoPrefix String
"work_item_object_relative_position" = String
"relative_position"
bodyNoPrefix String
"work_item_object_state_id" = String
"state_id"
bodyNoPrefix String
"work_item_object_time_estimate" = String
"time_estimate"
bodyNoPrefix String
"work_item_object_title" = String
"title"
bodyNoPrefix String
"work_item_object_updated_at" = String
"updated_at"
bodyNoPrefix String
"work_item_object_updated_by_id" = String
"updated_by_id"
bodyNoPrefix String
"work_item_object_type" = String
"type"
bodyNoPrefix String
"work_item_object_url" = String
"url"
bodyNoPrefix String
"work_item_object_total_time_spent" = String
"total_time_spent"
bodyNoPrefix String
"work_item_object_time_change" = String
"time_change"
bodyNoPrefix String
"work_item_object_human_total_time_spent" = String
"human_total_time_spent"
bodyNoPrefix String
"work_item_object_human_time_change" = String
"human_time_change"
bodyNoPrefix String
"work_item_object_human_time_estimate" = String
"human_time_estimate"
bodyNoPrefix String
"work_item_object_assignee_ids" = String
"assignee_ids"
bodyNoPrefix String
"work_item_object_assignee_id" = String
"assignee_id"
bodyNoPrefix String
"work_item_object_labels" = String
"labels"
bodyNoPrefix String
"work_item_object_state" = String
"state"
bodyNoPrefix String
"work_item_object_severity" = String
"severity"
bodyNoPrefix String
"work_item_object_customer_relations_contacts" = String
"customer_relations_contacts"
bodyNoPrefix String
"work_item_object_action" = String
"action"
bodyNoPrefix String
s = ShowS
forall a. String -> [a]
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"uexpected JSON field prefix: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
s)

instance FromJSON ProjectEvent where
  parseJSON :: Value -> Parser ProjectEvent
parseJSON =
    Options -> Value -> Parser ProjectEvent
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON ProjectChanges where
  parseJSON :: Value -> Parser ProjectChanges
parseJSON =
    Options -> Value -> Parser ProjectChanges
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON CommitEvent where
  parseJSON :: Value -> Parser CommitEvent
parseJSON =
    Options -> Value -> Parser CommitEvent
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON RepositoryEvent where
  parseJSON :: Value -> Parser RepositoryEvent
parseJSON =
    Options -> Value -> Parser RepositoryEvent
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON CommitAuthorEvent where
  parseJSON :: Value -> Parser CommitAuthorEvent
parseJSON =
    Options -> Value -> Parser CommitAuthorEvent
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON MergeRequestObjectAttributes where
  parseJSON :: Value -> Parser MergeRequestObjectAttributes
parseJSON =
    Options -> Value -> Parser MergeRequestObjectAttributes
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON MergeParams where
  parseJSON :: Value -> Parser MergeParams
parseJSON =
    Options -> Value -> Parser MergeParams
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON UserEvent where
  parseJSON :: Value -> Parser UserEvent
parseJSON =
    Options -> Value -> Parser UserEvent
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON MergeRequestChanges where
  parseJSON :: Value -> Parser MergeRequestChanges
parseJSON =
    Options -> Value -> Parser MergeRequestChanges
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON BuildCommit where
  parseJSON :: Value -> Parser BuildCommit
parseJSON =
    Options -> Value -> Parser BuildCommit
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON BuildProject where
  parseJSON :: Value -> Parser BuildProject
parseJSON =
    Options -> Value -> Parser BuildProject
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance (FromJSON a) => FromJSON (MergeRequestChange a) where
  parseJSON :: Value -> Parser (MergeRequestChange a)
parseJSON =
    Options -> Value -> Parser (MergeRequestChange a)
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON PipelineObjectAttributes where
  parseJSON :: Value -> Parser PipelineObjectAttributes
parseJSON =
    Options -> Value -> Parser PipelineObjectAttributes
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON PipelineBuild where
  parseJSON :: Value -> Parser PipelineBuild
parseJSON =
    Options -> Value -> Parser PipelineBuild
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON Runner where
  parseJSON :: Value -> Parser Runner
parseJSON =
    Options -> Value -> Parser Runner
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON ArtifactsFile where
  parseJSON :: Value -> Parser ArtifactsFile
parseJSON =
    Options -> Value -> Parser ArtifactsFile
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON IssueEvent where
  parseJSON :: Value -> Parser IssueEvent
parseJSON =
    Options -> Value -> Parser IssueEvent
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON IssueEventObjectAttributes where
  parseJSON :: Value -> Parser IssueEventObjectAttributes
parseJSON =
    Options -> Value -> Parser IssueEventObjectAttributes
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON IssueEventChanges where
  parseJSON :: Value -> Parser IssueEventChanges
parseJSON =
    Options -> Value -> Parser IssueEventChanges
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON IssueChangesAuthorId where
  parseJSON :: Value -> Parser IssueChangesAuthorId
parseJSON =
    Options -> Value -> Parser IssueChangesAuthorId
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON IssueChangesCreatedAt where
  parseJSON :: Value -> Parser IssueChangesCreatedAt
parseJSON =
    Options -> Value -> Parser IssueChangesCreatedAt
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON IssueChangesDescription where
  parseJSON :: Value -> Parser IssueChangesDescription
parseJSON =
    Options -> Value -> Parser IssueChangesDescription
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON IssueChangesId where
  parseJSON :: Value -> Parser IssueChangesId
parseJSON =
    Options -> Value -> Parser IssueChangesId
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON IssueChangesIid where
  parseJSON :: Value -> Parser IssueChangesIid
parseJSON =
    Options -> Value -> Parser IssueChangesIid
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON IssueChangesProjectId where
  parseJSON :: Value -> Parser IssueChangesProjectId
parseJSON =
    Options -> Value -> Parser IssueChangesProjectId
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON IssueChangesTitle where
  parseJSON :: Value -> Parser IssueChangesTitle
parseJSON =
    Options -> Value -> Parser IssueChangesTitle
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON IssueChangesClosedAt where
  parseJSON :: Value -> Parser IssueChangesClosedAt
parseJSON =
    Options -> Value -> Parser IssueChangesClosedAt
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON IssueChangesStateId where
  parseJSON :: Value -> Parser IssueChangesStateId
parseJSON =
    Options -> Value -> Parser IssueChangesStateId
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON IssueChangesUpdatedAt where
  parseJSON :: Value -> Parser IssueChangesUpdatedAt
parseJSON =
    Options -> Value -> Parser IssueChangesUpdatedAt
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON NoteObjectAttributes where
  parseJSON :: Value -> Parser NoteObjectAttributes
parseJSON =
    Options -> Value -> Parser NoteObjectAttributes
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON Wiki where
  parseJSON :: Value -> Parser Wiki
parseJSON =
    Options -> Value -> Parser Wiki
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON WikiPageObjectAttributes where
  parseJSON :: Value -> Parser WikiPageObjectAttributes
parseJSON =
    Options -> Value -> Parser WikiPageObjectAttributes
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON WorkItemObjectAttributes where
  parseJSON :: Value -> Parser WorkItemObjectAttributes
parseJSON =
    Options -> Value -> Parser WorkItemObjectAttributes
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON
      ( Options
defaultOptions
          { fieldLabelModifier = bodyNoPrefix
          }
      )

instance FromJSON Label where
  parseJSON :: Value -> Parser Label
parseJSON = String -> (Object -> Parser Label) -> Value -> Parser Label
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Label" ((Object -> Parser Label) -> Value -> Parser Label)
-> (Object -> Parser Label) -> Value -> Parser Label
forall a b. (a -> b) -> a -> b
$ \Object
obj -> do
    Maybe Int
labelId <- Object
obj Object -> Key -> Parser (Maybe Int)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"id"
    Maybe Text
labelTitle <- Object
obj Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"title"
    Maybe Text
labelColor <- Object
obj Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"color"
    Maybe Int
labelProjectId <- Object
obj Object -> Key -> Parser (Maybe Int)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"project_id"
    Maybe Text
labelCreatedAt <- Object
obj Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"created_at"
    Maybe Text
labelUpdatedAt <- Object
obj Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"updated_at"
    Maybe Bool
labelTemplate <- Object
obj Object -> Key -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"template"
    Maybe Text
labelDescription <- Object
obj Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"description"
    Maybe Text
labelType <- Object
obj Object -> Key -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"type"
    Maybe Int
labelGroupId <- Object
obj Object -> Key -> Parser (Maybe Int)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"group_id"
    Label -> Parser Label
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return (Label -> Parser Label) -> Label -> Parser Label
forall a b. (a -> b) -> a -> b
$
      Label
        { $sel:label_id:Label :: Maybe Int
label_id = Maybe Int
labelId,
          $sel:label_title:Label :: Maybe Text
label_title = Maybe Text
labelTitle,
          $sel:label_color:Label :: Maybe Text
label_color = Maybe Text
labelColor,
          $sel:label_project_id:Label :: Maybe Int
label_project_id = Maybe Int
labelProjectId,
          $sel:label_created_at:Label :: Maybe Text
label_created_at = Maybe Text
labelCreatedAt,
          $sel:label_updated_at:Label :: Maybe Text
label_updated_at = Maybe Text
labelUpdatedAt,
          $sel:label_template:Label :: Maybe Bool
label_template = Maybe Bool
labelTemplate,
          $sel:label_description:Label :: Maybe Text
label_description = Maybe Text
labelDescription,
          $sel:label_type:Label :: Maybe Text
label_type = Maybe Text
labelType,
          $sel:label_group_id:Label :: Maybe Int
label_group_id = Maybe Int
labelGroupId
        }

instance FromJSON ProjectAction where
  parseJSON :: Value -> Parser ProjectAction
parseJSON (String Text
"project_create") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
ProjectCreated
  parseJSON (String Text
"project_destroy") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
ProjectDestroyed
  parseJSON (String Text
"project_rename") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
ProjectRenamed
  parseJSON (String Text
"project_transfer") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
ProjectTransferred
  parseJSON (String Text
"project_update") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
ProjectUpdated
  parseJSON (String Text
"user_add_to_team") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
UserAddedToTeam
  parseJSON (String Text
"user_update_for_team") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
UserUpdatedForTeam
  parseJSON (String Text
"user_remove_from_team") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
UserRemovedFromTeam
  parseJSON (String Text
"user_create") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
UserCreated
  parseJSON (String Text
"user_destroy") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
UserRemoved
  parseJSON (String Text
"user_failed_login") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
UserFailedToLogin
  parseJSON (String Text
"user_rename") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
UserRenamed
  parseJSON (String Text
"key_create") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
KeyCreated
  parseJSON (String Text
"key_destroy") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
KeyRemoved
  parseJSON (String Text
"group_create") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
GroupCreated
  parseJSON (String Text
"group_destroy") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
GroupRemoved
  parseJSON (String Text
"group_rename") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
GroupRenamed
  parseJSON (String Text
"user_add_to_group") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
GroupMemberAdded
  parseJSON (String Text
"user_remove_from_group") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
GroupMemberRemoved
  parseJSON (String Text
"user_update_for_group") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
GroupMemberUpdated
  parseJSON (String Text
"push") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
Pushed
  parseJSON (String Text
"tag_push") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
TagPushed
  parseJSON (String Text
"repository_update") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
RepositoryUpdated
  parseJSON (String Text
"merge_request") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
MergeRequested
  parseJSON (String Text
"build") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
Built
  parseJSON (String Text
"pipeline") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
Pipelined
  parseJSON (String Text
"note") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
Noted
  parseJSON (String Text
"wiki_page") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
WikiPaged
  parseJSON (String Text
"work_item") = ProjectAction -> Parser ProjectAction
forall a. a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectAction
WorkItemed
  parseJSON Value
s = String -> Parser ProjectAction
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String
"unexpected system hook event: " String -> ShowS
forall a. Semigroup a => a -> a -> a
<> Value -> String
forall a. Show a => a -> String
show Value
s)