diff --git a/gen/template_webhook_event.go.tmpl b/gen/template_webhook_event.go.tmpl
index ccc834d5..5976326e 100644
--- a/gen/template_webhook_event.go.tmpl
+++ b/gen/template_webhook_event.go.tmpl
@@ -93,29 +93,7 @@ func (g *EventHandler) handleBeforeAny(ctx context.Context, deliveryID string, e
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onBeforeAny[EventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onBeforeAny[EventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[any](ctx, deliveryID, eventName, event, g.onBeforeAny[EventAnyAction])
 }
 
 // OnAfterAny registers callbacks which are triggered after any event.
@@ -157,29 +135,7 @@ func (g *EventHandler) handleAfterAny(ctx context.Context, deliveryID string, ev
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onAfterAny[EventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onAfterAny[EventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[any](ctx, deliveryID, eventName, event, g.onAfterAny[EventAnyAction])
 }
 
 // ErrorEventHandleFunc represents a generic callback function which receives any event and an error thrown by
diff --git a/gen/template_webhook_event_types.go.tmpl b/gen/template_webhook_event_types.go.tmpl
index 7c72cfdd..d6b1494c 100644
--- a/gen/template_webhook_event_types.go.tmpl
+++ b/gen/template_webhook_event_types.go.tmpl
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"{{ .GoGithubImport }}"
-	"golang.org/x/sync/errgroup"
 )
 
 {{ range $_, $webhook := .Webhooks }}
@@ -96,33 +95,10 @@ func (g *EventHandler) handle{{ $action.Handler }}(ctx context.Context, delivery
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		{{ $action.Handler }}Action,
-		{{ $webhook.Event }}AnyAction,
-	} {
-		if _, ok := g.on{{ $webhook.Event }}[action]; ok {
-			for _, h := range g.on{{ $webhook.Event }}[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.{{ $webhook.Event }}](ctx, deliveryID, eventName, event,
+		g.on{{ $webhook.Event }}[{{ $action.Handler }}Action],
+		g.on{{ $webhook.Event }}[{{ $webhook.Event }}AnyAction],
+	)
 }
 
 {{ end }}
@@ -177,29 +153,7 @@ func (g *EventHandler) handle{{ $webhook.Event }}Any(ctx context.Context, delive
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.on{{ $webhook.Event }}[{{ $webhook.Event }}AnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.on{{ $webhook.Event }}[{{ $webhook.Event }}AnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.{{ $webhook.Event }}](ctx, deliveryID, eventName, event, g.on{{ $webhook.Event }}[{{ $webhook.Event }}AnyAction])
 }
 
 // {{ $webhook.Event }} handles github.{{ $webhook.Event }}.
diff --git a/githubevents/dispatch.go b/githubevents/dispatch.go
new file mode 100644
index 00000000..cbd290ab
--- /dev/null
+++ b/githubevents/dispatch.go
@@ -0,0 +1,38 @@
+// Copyright 2022 The GithubEvents Authors. All rights reserved.
+// Use of this source code is governed by the MIT License
+// that can be found in the LICENSE file.
+
+package githubevents
+
+import (
+	"context"
+	"fmt"
+
+	"golang.org/x/sync/errgroup"
+)
+
+// dispatch runs every callback across the given groups in parallel, recovers
+// from panics as errors, and returns the first non-nil error. It is the single
+// implementation of the concurrency semantics shared by all generated handlers.
+func dispatch[T any, F ~func(ctx context.Context, deliveryID, eventName string, event T) error](
+	ctx context.Context,
+	deliveryID string,
+	eventName string,
+	event T,
+	groups ...[]F,
+) error {
+	eg := new(errgroup.Group)
+	for _, group := range groups {
+		for _, h := range group {
+			eg.Go(func() (err error) {
+				defer func() {
+					if r := recover(); r != nil {
+						err = fmt.Errorf("recovered from panic: %v", r)
+					}
+				}()
+				return h(ctx, deliveryID, eventName, event)
+			})
+		}
+	}
+	return eg.Wait()
+}
diff --git a/githubevents/dispatch_test.go b/githubevents/dispatch_test.go
new file mode 100644
index 00000000..9c2ca90b
--- /dev/null
+++ b/githubevents/dispatch_test.go
@@ -0,0 +1,81 @@
+package githubevents
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"sync/atomic"
+	"testing"
+
+	"github.com/google/go-github/v89/github"
+)
+
+func labelEvent(action string) *github.LabelEvent {
+	return &github.LabelEvent{Action: github.Ptr(action)}
+}
+
+// panic in one callback surfaces as a recovered-from-panic error.
+func TestDispatchRecoversPanic(t *testing.T) {
+	g := New("")
+	g.OnLabelEventCreated(func(ctx context.Context, id, name string, e *github.LabelEvent) error {
+		panic("boom")
+	})
+	err := g.LabelEvent(context.Background(), "id", "label", labelEvent("created"))
+	if err == nil || !strings.Contains(err.Error(), "recovered from panic:") {
+		t.Fatalf("want recovered-from-panic error, got %v", err)
+	}
+}
+
+// every registered callback runs (parallel fan-out).
+func TestDispatchRunsAll(t *testing.T) {
+	g := New("")
+	var n atomic.Int32
+	inc := func(ctx context.Context, id, name string, e *github.LabelEvent) error {
+		n.Add(1)
+		return nil
+	}
+	g.OnLabelEventCreated(inc, inc, inc)
+	if err := g.LabelEvent(context.Background(), "id", "label", labelEvent("created")); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if n.Load() != 3 {
+		t.Fatalf("want 3 callbacks run, got %d", n.Load())
+	}
+}
+
+// a returned error propagates.
+func TestDispatchPropagatesError(t *testing.T) {
+	g := New("")
+	want := errors.New("nope")
+	g.OnLabelEventCreated(func(ctx context.Context, id, name string, e *github.LabelEvent) error {
+		return want
+	})
+	if err := g.LabelEvent(context.Background(), "id", "label", labelEvent("created")); !errors.Is(err, want) {
+		t.Fatalf("want %v to propagate, got %v", want, err)
+	}
+}
+
+// wrong / empty action is rejected by the action handler contract.
+func TestDispatchRejectsEmptyAction(t *testing.T) {
+	g := New("")
+	err := g.LabelEvent(context.Background(), "id", "label", &github.LabelEvent{})
+	if err == nil || !strings.Contains(err.Error(), "empty or nil") {
+		t.Fatalf("want empty-action error, got %v", err)
+	}
+}
+
+// the Any path (event without a matching action handler) still fans out.
+func TestDispatchAnyPath(t *testing.T) {
+	g := New("")
+	var n atomic.Int32
+	g.OnLabelEventAny(func(ctx context.Context, id, name string, e *github.LabelEvent) error {
+		n.Add(1)
+		return nil
+	})
+	if err := g.LabelEvent(context.Background(), "id", "label", labelEvent("created")); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if n.Load() != 1 {
+		t.Fatalf("want Any callback to run once, got %d", n.Load())
+	}
+}
diff --git a/githubevents/events.go b/githubevents/events.go
index fec55850..227ba4a6 100644
--- a/githubevents/events.go
+++ b/githubevents/events.go
@@ -143,29 +143,7 @@ func (g *EventHandler) handleBeforeAny(ctx context.Context, deliveryID string, e
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onBeforeAny[EventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onBeforeAny[EventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[any](ctx, deliveryID, eventName, event, g.onBeforeAny[EventAnyAction])
 }
 
 // OnAfterAny registers callbacks which are triggered after any event.
@@ -207,29 +185,7 @@ func (g *EventHandler) handleAfterAny(ctx context.Context, deliveryID string, ev
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onAfterAny[EventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onAfterAny[EventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[any](ctx, deliveryID, eventName, event, g.onAfterAny[EventAnyAction])
 }
 
 // ErrorEventHandleFunc represents a generic callback function which receives any event and an error thrown by
diff --git a/githubevents/events_branch_protection_rule.go b/githubevents/events_branch_protection_rule.go
index d84dc31f..b53edfc2 100644
--- a/githubevents/events_branch_protection_rule.go
+++ b/githubevents/events_branch_protection_rule.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -99,33 +98,10 @@ func (g *EventHandler) handleBranchProtectionRuleEventCreated(ctx context.Contex
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		BranchProtectionRuleEventCreatedAction,
-		BranchProtectionRuleEventAnyAction,
-	} {
-		if _, ok := g.onBranchProtectionRuleEvent[action]; ok {
-			for _, h := range g.onBranchProtectionRuleEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.BranchProtectionRuleEvent](ctx, deliveryID, eventName, event,
+		g.onBranchProtectionRuleEvent[BranchProtectionRuleEventCreatedAction],
+		g.onBranchProtectionRuleEvent[BranchProtectionRuleEventAnyAction],
+	)
 }
 
 // OnBranchProtectionRuleEventEdited registers callbacks listening to events of type github.BranchProtectionRuleEvent and action 'edited'.
@@ -185,33 +161,10 @@ func (g *EventHandler) handleBranchProtectionRuleEventEdited(ctx context.Context
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		BranchProtectionRuleEventEditedAction,
-		BranchProtectionRuleEventAnyAction,
-	} {
-		if _, ok := g.onBranchProtectionRuleEvent[action]; ok {
-			for _, h := range g.onBranchProtectionRuleEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.BranchProtectionRuleEvent](ctx, deliveryID, eventName, event,
+		g.onBranchProtectionRuleEvent[BranchProtectionRuleEventEditedAction],
+		g.onBranchProtectionRuleEvent[BranchProtectionRuleEventAnyAction],
+	)
 }
 
 // OnBranchProtectionRuleEventDeleted registers callbacks listening to events of type github.BranchProtectionRuleEvent and action 'deleted'.
@@ -271,33 +224,10 @@ func (g *EventHandler) handleBranchProtectionRuleEventDeleted(ctx context.Contex
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		BranchProtectionRuleEventDeletedAction,
-		BranchProtectionRuleEventAnyAction,
-	} {
-		if _, ok := g.onBranchProtectionRuleEvent[action]; ok {
-			for _, h := range g.onBranchProtectionRuleEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.BranchProtectionRuleEvent](ctx, deliveryID, eventName, event,
+		g.onBranchProtectionRuleEvent[BranchProtectionRuleEventDeletedAction],
+		g.onBranchProtectionRuleEvent[BranchProtectionRuleEventAnyAction],
+	)
 }
 
 // OnBranchProtectionRuleEventAny registers callbacks listening to any events of type github.BranchProtectionRuleEvent
@@ -350,29 +280,7 @@ func (g *EventHandler) handleBranchProtectionRuleEventAny(ctx context.Context, d
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onBranchProtectionRuleEvent[BranchProtectionRuleEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onBranchProtectionRuleEvent[BranchProtectionRuleEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.BranchProtectionRuleEvent](ctx, deliveryID, eventName, event, g.onBranchProtectionRuleEvent[BranchProtectionRuleEventAnyAction])
 }
 
 // BranchProtectionRuleEvent handles github.BranchProtectionRuleEvent.
diff --git a/githubevents/events_check_run.go b/githubevents/events_check_run.go
index 9a23d65b..e6ace4a2 100644
--- a/githubevents/events_check_run.go
+++ b/githubevents/events_check_run.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -103,33 +102,10 @@ func (g *EventHandler) handleCheckRunEventCreated(ctx context.Context, deliveryI
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		CheckRunEventCreatedAction,
-		CheckRunEventAnyAction,
-	} {
-		if _, ok := g.onCheckRunEvent[action]; ok {
-			for _, h := range g.onCheckRunEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.CheckRunEvent](ctx, deliveryID, eventName, event,
+		g.onCheckRunEvent[CheckRunEventCreatedAction],
+		g.onCheckRunEvent[CheckRunEventAnyAction],
+	)
 }
 
 // OnCheckRunEventCompleted registers callbacks listening to events of type github.CheckRunEvent and action 'completed'.
@@ -189,33 +165,10 @@ func (g *EventHandler) handleCheckRunEventCompleted(ctx context.Context, deliver
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		CheckRunEventCompletedAction,
-		CheckRunEventAnyAction,
-	} {
-		if _, ok := g.onCheckRunEvent[action]; ok {
-			for _, h := range g.onCheckRunEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.CheckRunEvent](ctx, deliveryID, eventName, event,
+		g.onCheckRunEvent[CheckRunEventCompletedAction],
+		g.onCheckRunEvent[CheckRunEventAnyAction],
+	)
 }
 
 // OnCheckRunEventReRequested registers callbacks listening to events of type github.CheckRunEvent and action 'rerequested'.
@@ -275,33 +228,10 @@ func (g *EventHandler) handleCheckRunEventReRequested(ctx context.Context, deliv
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		CheckRunEventReRequestedAction,
-		CheckRunEventAnyAction,
-	} {
-		if _, ok := g.onCheckRunEvent[action]; ok {
-			for _, h := range g.onCheckRunEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.CheckRunEvent](ctx, deliveryID, eventName, event,
+		g.onCheckRunEvent[CheckRunEventReRequestedAction],
+		g.onCheckRunEvent[CheckRunEventAnyAction],
+	)
 }
 
 // OnCheckRunEventRequestAction registers callbacks listening to events of type github.CheckRunEvent and action 'requested_action'.
@@ -361,33 +291,10 @@ func (g *EventHandler) handleCheckRunEventRequestAction(ctx context.Context, del
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		CheckRunEventRequestActionAction,
-		CheckRunEventAnyAction,
-	} {
-		if _, ok := g.onCheckRunEvent[action]; ok {
-			for _, h := range g.onCheckRunEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.CheckRunEvent](ctx, deliveryID, eventName, event,
+		g.onCheckRunEvent[CheckRunEventRequestActionAction],
+		g.onCheckRunEvent[CheckRunEventAnyAction],
+	)
 }
 
 // OnCheckRunEventAny registers callbacks listening to any events of type github.CheckRunEvent
@@ -440,29 +347,7 @@ func (g *EventHandler) handleCheckRunEventAny(ctx context.Context, deliveryID st
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onCheckRunEvent[CheckRunEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onCheckRunEvent[CheckRunEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.CheckRunEvent](ctx, deliveryID, eventName, event, g.onCheckRunEvent[CheckRunEventAnyAction])
 }
 
 // CheckRunEvent handles github.CheckRunEvent.
diff --git a/githubevents/events_check_suite.go b/githubevents/events_check_suite.go
index 424dfee1..026b7ad2 100644
--- a/githubevents/events_check_suite.go
+++ b/githubevents/events_check_suite.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -99,33 +98,10 @@ func (g *EventHandler) handleCheckSuiteEventCompleted(ctx context.Context, deliv
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		CheckSuiteEventCompletedAction,
-		CheckSuiteEventAnyAction,
-	} {
-		if _, ok := g.onCheckSuiteEvent[action]; ok {
-			for _, h := range g.onCheckSuiteEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.CheckSuiteEvent](ctx, deliveryID, eventName, event,
+		g.onCheckSuiteEvent[CheckSuiteEventCompletedAction],
+		g.onCheckSuiteEvent[CheckSuiteEventAnyAction],
+	)
 }
 
 // OnCheckSuiteEventRequested registers callbacks listening to events of type github.CheckSuiteEvent and action 'requested'.
@@ -185,33 +161,10 @@ func (g *EventHandler) handleCheckSuiteEventRequested(ctx context.Context, deliv
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		CheckSuiteEventRequestedAction,
-		CheckSuiteEventAnyAction,
-	} {
-		if _, ok := g.onCheckSuiteEvent[action]; ok {
-			for _, h := range g.onCheckSuiteEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.CheckSuiteEvent](ctx, deliveryID, eventName, event,
+		g.onCheckSuiteEvent[CheckSuiteEventRequestedAction],
+		g.onCheckSuiteEvent[CheckSuiteEventAnyAction],
+	)
 }
 
 // OnCheckSuiteEventReRequested registers callbacks listening to events of type github.CheckSuiteEvent and action 'rerequested'.
@@ -271,33 +224,10 @@ func (g *EventHandler) handleCheckSuiteEventReRequested(ctx context.Context, del
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		CheckSuiteEventReRequestedAction,
-		CheckSuiteEventAnyAction,
-	} {
-		if _, ok := g.onCheckSuiteEvent[action]; ok {
-			for _, h := range g.onCheckSuiteEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.CheckSuiteEvent](ctx, deliveryID, eventName, event,
+		g.onCheckSuiteEvent[CheckSuiteEventReRequestedAction],
+		g.onCheckSuiteEvent[CheckSuiteEventAnyAction],
+	)
 }
 
 // OnCheckSuiteEventAny registers callbacks listening to any events of type github.CheckSuiteEvent
@@ -350,29 +280,7 @@ func (g *EventHandler) handleCheckSuiteEventAny(ctx context.Context, deliveryID
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onCheckSuiteEvent[CheckSuiteEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onCheckSuiteEvent[CheckSuiteEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.CheckSuiteEvent](ctx, deliveryID, eventName, event, g.onCheckSuiteEvent[CheckSuiteEventAnyAction])
 }
 
 // CheckSuiteEvent handles github.CheckSuiteEvent.
diff --git a/githubevents/events_commit_comment.go b/githubevents/events_commit_comment.go
index ae8d2bad..46ad48b2 100644
--- a/githubevents/events_commit_comment.go
+++ b/githubevents/events_commit_comment.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -91,33 +90,10 @@ func (g *EventHandler) handleCommitCommentEventCreated(ctx context.Context, deli
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		CommitCommentEventCreatedAction,
-		CommitCommentEventAnyAction,
-	} {
-		if _, ok := g.onCommitCommentEvent[action]; ok {
-			for _, h := range g.onCommitCommentEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.CommitCommentEvent](ctx, deliveryID, eventName, event,
+		g.onCommitCommentEvent[CommitCommentEventCreatedAction],
+		g.onCommitCommentEvent[CommitCommentEventAnyAction],
+	)
 }
 
 // OnCommitCommentEventAny registers callbacks listening to any events of type github.CommitCommentEvent
@@ -170,29 +146,7 @@ func (g *EventHandler) handleCommitCommentEventAny(ctx context.Context, delivery
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onCommitCommentEvent[CommitCommentEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onCommitCommentEvent[CommitCommentEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.CommitCommentEvent](ctx, deliveryID, eventName, event, g.onCommitCommentEvent[CommitCommentEventAnyAction])
 }
 
 // CommitCommentEvent handles github.CommitCommentEvent.
diff --git a/githubevents/events_create.go b/githubevents/events_create.go
index ec6e9243..71ebaf4b 100644
--- a/githubevents/events_create.go
+++ b/githubevents/events_create.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -80,29 +79,7 @@ func (g *EventHandler) handleCreateEventAny(ctx context.Context, deliveryID stri
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onCreateEvent[CreateEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onCreateEvent[CreateEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.CreateEvent](ctx, deliveryID, eventName, event, g.onCreateEvent[CreateEventAnyAction])
 }
 
 // CreateEvent handles github.CreateEvent.
diff --git a/githubevents/events_custom_property.go b/githubevents/events_custom_property.go
index 3e660e3b..c064e09d 100644
--- a/githubevents/events_custom_property.go
+++ b/githubevents/events_custom_property.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -103,33 +102,10 @@ func (g *EventHandler) handleCustomPropertyEventCreated(ctx context.Context, del
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		CustomPropertyEventCreatedAction,
-		CustomPropertyEventAnyAction,
-	} {
-		if _, ok := g.onCustomPropertyEvent[action]; ok {
-			for _, h := range g.onCustomPropertyEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.CustomPropertyEvent](ctx, deliveryID, eventName, event,
+		g.onCustomPropertyEvent[CustomPropertyEventCreatedAction],
+		g.onCustomPropertyEvent[CustomPropertyEventAnyAction],
+	)
 }
 
 // OnCustomPropertyDeleted registers callbacks listening to events of type github.CustomPropertyEvent and action 'deleted'.
@@ -189,33 +165,10 @@ func (g *EventHandler) handleCustomPropertyDeleted(ctx context.Context, delivery
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		CustomPropertyDeletedAction,
-		CustomPropertyEventAnyAction,
-	} {
-		if _, ok := g.onCustomPropertyEvent[action]; ok {
-			for _, h := range g.onCustomPropertyEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.CustomPropertyEvent](ctx, deliveryID, eventName, event,
+		g.onCustomPropertyEvent[CustomPropertyDeletedAction],
+		g.onCustomPropertyEvent[CustomPropertyEventAnyAction],
+	)
 }
 
 // OnCustomPropertyEventPromoteToEnterprise registers callbacks listening to events of type github.CustomPropertyEvent and action 'promote_to_enterprise'.
@@ -275,33 +228,10 @@ func (g *EventHandler) handleCustomPropertyEventPromoteToEnterprise(ctx context.
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		CustomPropertyEventPromoteToEnterpriseAction,
-		CustomPropertyEventAnyAction,
-	} {
-		if _, ok := g.onCustomPropertyEvent[action]; ok {
-			for _, h := range g.onCustomPropertyEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.CustomPropertyEvent](ctx, deliveryID, eventName, event,
+		g.onCustomPropertyEvent[CustomPropertyEventPromoteToEnterpriseAction],
+		g.onCustomPropertyEvent[CustomPropertyEventAnyAction],
+	)
 }
 
 // OnCustomPropertyEventUpdated registers callbacks listening to events of type github.CustomPropertyEvent and action 'updated'.
@@ -361,33 +291,10 @@ func (g *EventHandler) handleCustomPropertyEventUpdated(ctx context.Context, del
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		CustomPropertyEventUpdatedAction,
-		CustomPropertyEventAnyAction,
-	} {
-		if _, ok := g.onCustomPropertyEvent[action]; ok {
-			for _, h := range g.onCustomPropertyEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.CustomPropertyEvent](ctx, deliveryID, eventName, event,
+		g.onCustomPropertyEvent[CustomPropertyEventUpdatedAction],
+		g.onCustomPropertyEvent[CustomPropertyEventAnyAction],
+	)
 }
 
 // OnCustomPropertyEventAny registers callbacks listening to any events of type github.CustomPropertyEvent
@@ -440,29 +347,7 @@ func (g *EventHandler) handleCustomPropertyEventAny(ctx context.Context, deliver
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onCustomPropertyEvent[CustomPropertyEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onCustomPropertyEvent[CustomPropertyEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.CustomPropertyEvent](ctx, deliveryID, eventName, event, g.onCustomPropertyEvent[CustomPropertyEventAnyAction])
 }
 
 // CustomPropertyEvent handles github.CustomPropertyEvent.
diff --git a/githubevents/events_custom_property_values.go b/githubevents/events_custom_property_values.go
index c0e956ab..daa56118 100644
--- a/githubevents/events_custom_property_values.go
+++ b/githubevents/events_custom_property_values.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -91,33 +90,10 @@ func (g *EventHandler) handleCustomPropertyValuesEventUpdated(ctx context.Contex
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		CustomPropertyValuesEventUpdatedAction,
-		CustomPropertyValuesEventAnyAction,
-	} {
-		if _, ok := g.onCustomPropertyValuesEvent[action]; ok {
-			for _, h := range g.onCustomPropertyValuesEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.CustomPropertyValuesEvent](ctx, deliveryID, eventName, event,
+		g.onCustomPropertyValuesEvent[CustomPropertyValuesEventUpdatedAction],
+		g.onCustomPropertyValuesEvent[CustomPropertyValuesEventAnyAction],
+	)
 }
 
 // OnCustomPropertyValuesEventAny registers callbacks listening to any events of type github.CustomPropertyValuesEvent
@@ -170,29 +146,7 @@ func (g *EventHandler) handleCustomPropertyValuesEventAny(ctx context.Context, d
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onCustomPropertyValuesEvent[CustomPropertyValuesEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onCustomPropertyValuesEvent[CustomPropertyValuesEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.CustomPropertyValuesEvent](ctx, deliveryID, eventName, event, g.onCustomPropertyValuesEvent[CustomPropertyValuesEventAnyAction])
 }
 
 // CustomPropertyValuesEvent handles github.CustomPropertyValuesEvent.
diff --git a/githubevents/events_delete.go b/githubevents/events_delete.go
index 8d967bd5..325665d6 100644
--- a/githubevents/events_delete.go
+++ b/githubevents/events_delete.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -80,29 +79,7 @@ func (g *EventHandler) handleDeleteEventAny(ctx context.Context, deliveryID stri
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onDeleteEvent[DeleteEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onDeleteEvent[DeleteEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.DeleteEvent](ctx, deliveryID, eventName, event, g.onDeleteEvent[DeleteEventAnyAction])
 }
 
 // DeleteEvent handles github.DeleteEvent.
diff --git a/githubevents/events_deploy_key.go b/githubevents/events_deploy_key.go
index b5dabe1c..907748b3 100644
--- a/githubevents/events_deploy_key.go
+++ b/githubevents/events_deploy_key.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -95,33 +94,10 @@ func (g *EventHandler) handleDeployKeyEventCreated(ctx context.Context, delivery
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		DeployKeyEventCreatedAction,
-		DeployKeyEventAnyAction,
-	} {
-		if _, ok := g.onDeployKeyEvent[action]; ok {
-			for _, h := range g.onDeployKeyEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.DeployKeyEvent](ctx, deliveryID, eventName, event,
+		g.onDeployKeyEvent[DeployKeyEventCreatedAction],
+		g.onDeployKeyEvent[DeployKeyEventAnyAction],
+	)
 }
 
 // OnDeployKeyEventDeleted registers callbacks listening to events of type github.DeployKeyEvent and action 'deleted'.
@@ -181,33 +157,10 @@ func (g *EventHandler) handleDeployKeyEventDeleted(ctx context.Context, delivery
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		DeployKeyEventDeletedAction,
-		DeployKeyEventAnyAction,
-	} {
-		if _, ok := g.onDeployKeyEvent[action]; ok {
-			for _, h := range g.onDeployKeyEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.DeployKeyEvent](ctx, deliveryID, eventName, event,
+		g.onDeployKeyEvent[DeployKeyEventDeletedAction],
+		g.onDeployKeyEvent[DeployKeyEventAnyAction],
+	)
 }
 
 // OnDeployKeyEventAny registers callbacks listening to any events of type github.DeployKeyEvent
@@ -260,29 +213,7 @@ func (g *EventHandler) handleDeployKeyEventAny(ctx context.Context, deliveryID s
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onDeployKeyEvent[DeployKeyEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onDeployKeyEvent[DeployKeyEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.DeployKeyEvent](ctx, deliveryID, eventName, event, g.onDeployKeyEvent[DeployKeyEventAnyAction])
 }
 
 // DeployKeyEvent handles github.DeployKeyEvent.
diff --git a/githubevents/events_deployment.go b/githubevents/events_deployment.go
index 9de215b9..ef023961 100644
--- a/githubevents/events_deployment.go
+++ b/githubevents/events_deployment.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -80,29 +79,7 @@ func (g *EventHandler) handleDeploymentEventAny(ctx context.Context, deliveryID
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onDeploymentEvent[DeploymentEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onDeploymentEvent[DeploymentEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.DeploymentEvent](ctx, deliveryID, eventName, event, g.onDeploymentEvent[DeploymentEventAnyAction])
 }
 
 // DeploymentEvent handles github.DeploymentEvent.
diff --git a/githubevents/events_deployment_status.go b/githubevents/events_deployment_status.go
index b35edacd..0e8a717e 100644
--- a/githubevents/events_deployment_status.go
+++ b/githubevents/events_deployment_status.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -80,29 +79,7 @@ func (g *EventHandler) handleDeploymentStatusEventAny(ctx context.Context, deliv
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onDeploymentStatusEvent[DeploymentStatusEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onDeploymentStatusEvent[DeploymentStatusEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.DeploymentStatusEvent](ctx, deliveryID, eventName, event, g.onDeploymentStatusEvent[DeploymentStatusEventAnyAction])
 }
 
 // DeploymentStatusEvent handles github.DeploymentStatusEvent.
diff --git a/githubevents/events_discussion.go b/githubevents/events_discussion.go
index 7170585c..f3dd7a19 100644
--- a/githubevents/events_discussion.go
+++ b/githubevents/events_discussion.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -139,33 +138,10 @@ func (g *EventHandler) handleDiscussionEventCreated(ctx context.Context, deliver
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		DiscussionEventCreatedAction,
-		DiscussionEventAnyAction,
-	} {
-		if _, ok := g.onDiscussionEvent[action]; ok {
-			for _, h := range g.onDiscussionEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.DiscussionEvent](ctx, deliveryID, eventName, event,
+		g.onDiscussionEvent[DiscussionEventCreatedAction],
+		g.onDiscussionEvent[DiscussionEventAnyAction],
+	)
 }
 
 // OnDiscussionEventEdited registers callbacks listening to events of type github.DiscussionEvent and action 'edited'.
@@ -225,33 +201,10 @@ func (g *EventHandler) handleDiscussionEventEdited(ctx context.Context, delivery
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		DiscussionEventEditedAction,
-		DiscussionEventAnyAction,
-	} {
-		if _, ok := g.onDiscussionEvent[action]; ok {
-			for _, h := range g.onDiscussionEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.DiscussionEvent](ctx, deliveryID, eventName, event,
+		g.onDiscussionEvent[DiscussionEventEditedAction],
+		g.onDiscussionEvent[DiscussionEventAnyAction],
+	)
 }
 
 // OnDiscussionEventDeleted registers callbacks listening to events of type github.DiscussionEvent and action 'deleted'.
@@ -311,33 +264,10 @@ func (g *EventHandler) handleDiscussionEventDeleted(ctx context.Context, deliver
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		DiscussionEventDeletedAction,
-		DiscussionEventAnyAction,
-	} {
-		if _, ok := g.onDiscussionEvent[action]; ok {
-			for _, h := range g.onDiscussionEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.DiscussionEvent](ctx, deliveryID, eventName, event,
+		g.onDiscussionEvent[DiscussionEventDeletedAction],
+		g.onDiscussionEvent[DiscussionEventAnyAction],
+	)
 }
 
 // OnDiscussionEventPinned registers callbacks listening to events of type github.DiscussionEvent and action 'pinned'.
@@ -397,33 +327,10 @@ func (g *EventHandler) handleDiscussionEventPinned(ctx context.Context, delivery
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		DiscussionEventPinnedAction,
-		DiscussionEventAnyAction,
-	} {
-		if _, ok := g.onDiscussionEvent[action]; ok {
-			for _, h := range g.onDiscussionEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.DiscussionEvent](ctx, deliveryID, eventName, event,
+		g.onDiscussionEvent[DiscussionEventPinnedAction],
+		g.onDiscussionEvent[DiscussionEventAnyAction],
+	)
 }
 
 // OnDiscussionEventUnpinned registers callbacks listening to events of type github.DiscussionEvent and action 'unpinned'.
@@ -483,33 +390,10 @@ func (g *EventHandler) handleDiscussionEventUnpinned(ctx context.Context, delive
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		DiscussionEventUnpinnedAction,
-		DiscussionEventAnyAction,
-	} {
-		if _, ok := g.onDiscussionEvent[action]; ok {
-			for _, h := range g.onDiscussionEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.DiscussionEvent](ctx, deliveryID, eventName, event,
+		g.onDiscussionEvent[DiscussionEventUnpinnedAction],
+		g.onDiscussionEvent[DiscussionEventAnyAction],
+	)
 }
 
 // OnDiscussionEventLocked registers callbacks listening to events of type github.DiscussionEvent and action 'locked'.
@@ -569,33 +453,10 @@ func (g *EventHandler) handleDiscussionEventLocked(ctx context.Context, delivery
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		DiscussionEventLockedAction,
-		DiscussionEventAnyAction,
-	} {
-		if _, ok := g.onDiscussionEvent[action]; ok {
-			for _, h := range g.onDiscussionEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.DiscussionEvent](ctx, deliveryID, eventName, event,
+		g.onDiscussionEvent[DiscussionEventLockedAction],
+		g.onDiscussionEvent[DiscussionEventAnyAction],
+	)
 }
 
 // OnDiscussionEventUnlocked registers callbacks listening to events of type github.DiscussionEvent and action 'unlocked'.
@@ -655,33 +516,10 @@ func (g *EventHandler) handleDiscussionEventUnlocked(ctx context.Context, delive
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		DiscussionEventUnlockedAction,
-		DiscussionEventAnyAction,
-	} {
-		if _, ok := g.onDiscussionEvent[action]; ok {
-			for _, h := range g.onDiscussionEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.DiscussionEvent](ctx, deliveryID, eventName, event,
+		g.onDiscussionEvent[DiscussionEventUnlockedAction],
+		g.onDiscussionEvent[DiscussionEventAnyAction],
+	)
 }
 
 // OnDiscussionEventTransferred registers callbacks listening to events of type github.DiscussionEvent and action 'transferred'.
@@ -741,33 +579,10 @@ func (g *EventHandler) handleDiscussionEventTransferred(ctx context.Context, del
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		DiscussionEventTransferredAction,
-		DiscussionEventAnyAction,
-	} {
-		if _, ok := g.onDiscussionEvent[action]; ok {
-			for _, h := range g.onDiscussionEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.DiscussionEvent](ctx, deliveryID, eventName, event,
+		g.onDiscussionEvent[DiscussionEventTransferredAction],
+		g.onDiscussionEvent[DiscussionEventAnyAction],
+	)
 }
 
 // OnDiscussionEventCategoryChanged registers callbacks listening to events of type github.DiscussionEvent and action 'category_changed'.
@@ -827,33 +642,10 @@ func (g *EventHandler) handleDiscussionEventCategoryChanged(ctx context.Context,
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		DiscussionEventCategoryChangedAction,
-		DiscussionEventAnyAction,
-	} {
-		if _, ok := g.onDiscussionEvent[action]; ok {
-			for _, h := range g.onDiscussionEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.DiscussionEvent](ctx, deliveryID, eventName, event,
+		g.onDiscussionEvent[DiscussionEventCategoryChangedAction],
+		g.onDiscussionEvent[DiscussionEventAnyAction],
+	)
 }
 
 // OnDiscussionEventAnswered registers callbacks listening to events of type github.DiscussionEvent and action 'answered'.
@@ -913,33 +705,10 @@ func (g *EventHandler) handleDiscussionEventAnswered(ctx context.Context, delive
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		DiscussionEventAnsweredAction,
-		DiscussionEventAnyAction,
-	} {
-		if _, ok := g.onDiscussionEvent[action]; ok {
-			for _, h := range g.onDiscussionEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.DiscussionEvent](ctx, deliveryID, eventName, event,
+		g.onDiscussionEvent[DiscussionEventAnsweredAction],
+		g.onDiscussionEvent[DiscussionEventAnyAction],
+	)
 }
 
 // OnDiscussionEventUnanswered registers callbacks listening to events of type github.DiscussionEvent and action 'unanswered'.
@@ -999,33 +768,10 @@ func (g *EventHandler) handleDiscussionEventUnanswered(ctx context.Context, deli
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		DiscussionEventUnansweredAction,
-		DiscussionEventAnyAction,
-	} {
-		if _, ok := g.onDiscussionEvent[action]; ok {
-			for _, h := range g.onDiscussionEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.DiscussionEvent](ctx, deliveryID, eventName, event,
+		g.onDiscussionEvent[DiscussionEventUnansweredAction],
+		g.onDiscussionEvent[DiscussionEventAnyAction],
+	)
 }
 
 // OnDiscussionEventLabeled registers callbacks listening to events of type github.DiscussionEvent and action 'labeled'.
@@ -1085,33 +831,10 @@ func (g *EventHandler) handleDiscussionEventLabeled(ctx context.Context, deliver
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		DiscussionEventLabeledAction,
-		DiscussionEventAnyAction,
-	} {
-		if _, ok := g.onDiscussionEvent[action]; ok {
-			for _, h := range g.onDiscussionEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.DiscussionEvent](ctx, deliveryID, eventName, event,
+		g.onDiscussionEvent[DiscussionEventLabeledAction],
+		g.onDiscussionEvent[DiscussionEventAnyAction],
+	)
 }
 
 // OnDiscussionEventUnlabeled registers callbacks listening to events of type github.DiscussionEvent and action 'unlabeled'.
@@ -1171,33 +894,10 @@ func (g *EventHandler) handleDiscussionEventUnlabeled(ctx context.Context, deliv
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		DiscussionEventUnlabeledAction,
-		DiscussionEventAnyAction,
-	} {
-		if _, ok := g.onDiscussionEvent[action]; ok {
-			for _, h := range g.onDiscussionEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.DiscussionEvent](ctx, deliveryID, eventName, event,
+		g.onDiscussionEvent[DiscussionEventUnlabeledAction],
+		g.onDiscussionEvent[DiscussionEventAnyAction],
+	)
 }
 
 // OnDiscussionEventAny registers callbacks listening to any events of type github.DiscussionEvent
@@ -1250,29 +950,7 @@ func (g *EventHandler) handleDiscussionEventAny(ctx context.Context, deliveryID
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onDiscussionEvent[DiscussionEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onDiscussionEvent[DiscussionEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.DiscussionEvent](ctx, deliveryID, eventName, event, g.onDiscussionEvent[DiscussionEventAnyAction])
 }
 
 // DiscussionEvent handles github.DiscussionEvent.
diff --git a/githubevents/events_fork.go b/githubevents/events_fork.go
index 4676710b..9dc14b47 100644
--- a/githubevents/events_fork.go
+++ b/githubevents/events_fork.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -80,29 +79,7 @@ func (g *EventHandler) handleForkEventAny(ctx context.Context, deliveryID string
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onForkEvent[ForkEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onForkEvent[ForkEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ForkEvent](ctx, deliveryID, eventName, event, g.onForkEvent[ForkEventAnyAction])
 }
 
 // ForkEvent handles github.ForkEvent.
diff --git a/githubevents/events_github_app_authorization.go b/githubevents/events_github_app_authorization.go
index b1b10f0e..faf48b5b 100644
--- a/githubevents/events_github_app_authorization.go
+++ b/githubevents/events_github_app_authorization.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -91,33 +90,10 @@ func (g *EventHandler) handleGitHubAppAuthorizationEventRevoked(ctx context.Cont
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		GitHubAppAuthorizationEventRevokedAction,
-		GitHubAppAuthorizationEventAnyAction,
-	} {
-		if _, ok := g.onGitHubAppAuthorizationEvent[action]; ok {
-			for _, h := range g.onGitHubAppAuthorizationEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.GitHubAppAuthorizationEvent](ctx, deliveryID, eventName, event,
+		g.onGitHubAppAuthorizationEvent[GitHubAppAuthorizationEventRevokedAction],
+		g.onGitHubAppAuthorizationEvent[GitHubAppAuthorizationEventAnyAction],
+	)
 }
 
 // OnGitHubAppAuthorizationEventAny registers callbacks listening to any events of type github.GitHubAppAuthorizationEvent
@@ -170,29 +146,7 @@ func (g *EventHandler) handleGitHubAppAuthorizationEventAny(ctx context.Context,
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onGitHubAppAuthorizationEvent[GitHubAppAuthorizationEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onGitHubAppAuthorizationEvent[GitHubAppAuthorizationEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.GitHubAppAuthorizationEvent](ctx, deliveryID, eventName, event, g.onGitHubAppAuthorizationEvent[GitHubAppAuthorizationEventAnyAction])
 }
 
 // GitHubAppAuthorizationEvent handles github.GitHubAppAuthorizationEvent.
diff --git a/githubevents/events_gollum.go b/githubevents/events_gollum.go
index 91c3cd71..2047d280 100644
--- a/githubevents/events_gollum.go
+++ b/githubevents/events_gollum.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -80,29 +79,7 @@ func (g *EventHandler) handleGollumEventAny(ctx context.Context, deliveryID stri
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onGollumEvent[GollumEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onGollumEvent[GollumEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.GollumEvent](ctx, deliveryID, eventName, event, g.onGollumEvent[GollumEventAnyAction])
 }
 
 // GollumEvent handles github.GollumEvent.
diff --git a/githubevents/events_installation.go b/githubevents/events_installation.go
index e19a65c3..39f1b2ac 100644
--- a/githubevents/events_installation.go
+++ b/githubevents/events_installation.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -107,33 +106,10 @@ func (g *EventHandler) handleInstallationEventCreated(ctx context.Context, deliv
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		InstallationEventCreatedAction,
-		InstallationEventAnyAction,
-	} {
-		if _, ok := g.onInstallationEvent[action]; ok {
-			for _, h := range g.onInstallationEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.InstallationEvent](ctx, deliveryID, eventName, event,
+		g.onInstallationEvent[InstallationEventCreatedAction],
+		g.onInstallationEvent[InstallationEventAnyAction],
+	)
 }
 
 // OnInstallationEventDeleted registers callbacks listening to events of type github.InstallationEvent and action 'deleted'.
@@ -193,33 +169,10 @@ func (g *EventHandler) handleInstallationEventDeleted(ctx context.Context, deliv
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		InstallationEventDeletedAction,
-		InstallationEventAnyAction,
-	} {
-		if _, ok := g.onInstallationEvent[action]; ok {
-			for _, h := range g.onInstallationEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.InstallationEvent](ctx, deliveryID, eventName, event,
+		g.onInstallationEvent[InstallationEventDeletedAction],
+		g.onInstallationEvent[InstallationEventAnyAction],
+	)
 }
 
 // OnInstallationEventEventSuspend registers callbacks listening to events of type github.InstallationEvent and action 'suspend'.
@@ -279,33 +232,10 @@ func (g *EventHandler) handleInstallationEventEventSuspend(ctx context.Context,
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		InstallationEventEventSuspendAction,
-		InstallationEventAnyAction,
-	} {
-		if _, ok := g.onInstallationEvent[action]; ok {
-			for _, h := range g.onInstallationEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.InstallationEvent](ctx, deliveryID, eventName, event,
+		g.onInstallationEvent[InstallationEventEventSuspendAction],
+		g.onInstallationEvent[InstallationEventAnyAction],
+	)
 }
 
 // OnInstallationEventEventUnsuspend registers callbacks listening to events of type github.InstallationEvent and action 'unsuspend'.
@@ -365,33 +295,10 @@ func (g *EventHandler) handleInstallationEventEventUnsuspend(ctx context.Context
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		InstallationEventEventUnsuspendAction,
-		InstallationEventAnyAction,
-	} {
-		if _, ok := g.onInstallationEvent[action]; ok {
-			for _, h := range g.onInstallationEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.InstallationEvent](ctx, deliveryID, eventName, event,
+		g.onInstallationEvent[InstallationEventEventUnsuspendAction],
+		g.onInstallationEvent[InstallationEventAnyAction],
+	)
 }
 
 // OnInstallationEventNewPermissionsAccepted registers callbacks listening to events of type github.InstallationEvent and action 'new_permissions_accepted'.
@@ -451,33 +358,10 @@ func (g *EventHandler) handleInstallationEventNewPermissionsAccepted(ctx context
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		InstallationEventNewPermissionsAcceptedAction,
-		InstallationEventAnyAction,
-	} {
-		if _, ok := g.onInstallationEvent[action]; ok {
-			for _, h := range g.onInstallationEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.InstallationEvent](ctx, deliveryID, eventName, event,
+		g.onInstallationEvent[InstallationEventNewPermissionsAcceptedAction],
+		g.onInstallationEvent[InstallationEventAnyAction],
+	)
 }
 
 // OnInstallationEventAny registers callbacks listening to any events of type github.InstallationEvent
@@ -530,29 +414,7 @@ func (g *EventHandler) handleInstallationEventAny(ctx context.Context, deliveryI
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onInstallationEvent[InstallationEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onInstallationEvent[InstallationEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.InstallationEvent](ctx, deliveryID, eventName, event, g.onInstallationEvent[InstallationEventAnyAction])
 }
 
 // InstallationEvent handles github.InstallationEvent.
diff --git a/githubevents/events_installation_repositories.go b/githubevents/events_installation_repositories.go
index 4148bd9a..f18e3aa3 100644
--- a/githubevents/events_installation_repositories.go
+++ b/githubevents/events_installation_repositories.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -95,33 +94,10 @@ func (g *EventHandler) handleInstallationRepositoriesEventAdded(ctx context.Cont
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		InstallationRepositoriesEventAddedAction,
-		InstallationRepositoriesEventAnyAction,
-	} {
-		if _, ok := g.onInstallationRepositoriesEvent[action]; ok {
-			for _, h := range g.onInstallationRepositoriesEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.InstallationRepositoriesEvent](ctx, deliveryID, eventName, event,
+		g.onInstallationRepositoriesEvent[InstallationRepositoriesEventAddedAction],
+		g.onInstallationRepositoriesEvent[InstallationRepositoriesEventAnyAction],
+	)
 }
 
 // OnInstallationRepositoriesEventRemoved registers callbacks listening to events of type github.InstallationRepositoriesEvent and action 'removed'.
@@ -181,33 +157,10 @@ func (g *EventHandler) handleInstallationRepositoriesEventRemoved(ctx context.Co
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		InstallationRepositoriesEventRemovedAction,
-		InstallationRepositoriesEventAnyAction,
-	} {
-		if _, ok := g.onInstallationRepositoriesEvent[action]; ok {
-			for _, h := range g.onInstallationRepositoriesEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.InstallationRepositoriesEvent](ctx, deliveryID, eventName, event,
+		g.onInstallationRepositoriesEvent[InstallationRepositoriesEventRemovedAction],
+		g.onInstallationRepositoriesEvent[InstallationRepositoriesEventAnyAction],
+	)
 }
 
 // OnInstallationRepositoriesEventAny registers callbacks listening to any events of type github.InstallationRepositoriesEvent
@@ -260,29 +213,7 @@ func (g *EventHandler) handleInstallationRepositoriesEventAny(ctx context.Contex
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onInstallationRepositoriesEvent[InstallationRepositoriesEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onInstallationRepositoriesEvent[InstallationRepositoriesEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.InstallationRepositoriesEvent](ctx, deliveryID, eventName, event, g.onInstallationRepositoriesEvent[InstallationRepositoriesEventAnyAction])
 }
 
 // InstallationRepositoriesEvent handles github.InstallationRepositoriesEvent.
diff --git a/githubevents/events_issue_comment.go b/githubevents/events_issue_comment.go
index 4a4b6830..5cee5381 100644
--- a/githubevents/events_issue_comment.go
+++ b/githubevents/events_issue_comment.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -99,33 +98,10 @@ func (g *EventHandler) handleIssueCommentCreated(ctx context.Context, deliveryID
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		IssueCommentCreatedAction,
-		IssueCommentEventAnyAction,
-	} {
-		if _, ok := g.onIssueCommentEvent[action]; ok {
-			for _, h := range g.onIssueCommentEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssueCommentEvent](ctx, deliveryID, eventName, event,
+		g.onIssueCommentEvent[IssueCommentCreatedAction],
+		g.onIssueCommentEvent[IssueCommentEventAnyAction],
+	)
 }
 
 // OnIssueCommentEdited registers callbacks listening to events of type github.IssueCommentEvent and action 'edited'.
@@ -185,33 +161,10 @@ func (g *EventHandler) handleIssueCommentEdited(ctx context.Context, deliveryID
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		IssueCommentEditedAction,
-		IssueCommentEventAnyAction,
-	} {
-		if _, ok := g.onIssueCommentEvent[action]; ok {
-			for _, h := range g.onIssueCommentEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssueCommentEvent](ctx, deliveryID, eventName, event,
+		g.onIssueCommentEvent[IssueCommentEditedAction],
+		g.onIssueCommentEvent[IssueCommentEventAnyAction],
+	)
 }
 
 // OnIssueCommentDeleted registers callbacks listening to events of type github.IssueCommentEvent and action 'deleted'.
@@ -271,33 +224,10 @@ func (g *EventHandler) handleIssueCommentDeleted(ctx context.Context, deliveryID
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		IssueCommentDeletedAction,
-		IssueCommentEventAnyAction,
-	} {
-		if _, ok := g.onIssueCommentEvent[action]; ok {
-			for _, h := range g.onIssueCommentEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssueCommentEvent](ctx, deliveryID, eventName, event,
+		g.onIssueCommentEvent[IssueCommentDeletedAction],
+		g.onIssueCommentEvent[IssueCommentEventAnyAction],
+	)
 }
 
 // OnIssueCommentEventAny registers callbacks listening to any events of type github.IssueCommentEvent
@@ -350,29 +280,7 @@ func (g *EventHandler) handleIssueCommentEventAny(ctx context.Context, deliveryI
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onIssueCommentEvent[IssueCommentEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onIssueCommentEvent[IssueCommentEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssueCommentEvent](ctx, deliveryID, eventName, event, g.onIssueCommentEvent[IssueCommentEventAnyAction])
 }
 
 // IssueCommentEvent handles github.IssueCommentEvent.
diff --git a/githubevents/events_issues.go b/githubevents/events_issues.go
index a1a9960a..51ff7195 100644
--- a/githubevents/events_issues.go
+++ b/githubevents/events_issues.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -151,33 +150,10 @@ func (g *EventHandler) handleIssuesEventOpened(ctx context.Context, deliveryID s
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		IssuesEventOpenedAction,
-		IssuesEventAnyAction,
-	} {
-		if _, ok := g.onIssuesEvent[action]; ok {
-			for _, h := range g.onIssuesEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssuesEvent](ctx, deliveryID, eventName, event,
+		g.onIssuesEvent[IssuesEventOpenedAction],
+		g.onIssuesEvent[IssuesEventAnyAction],
+	)
 }
 
 // OnIssuesEventEdited registers callbacks listening to events of type github.IssuesEvent and action 'edited'.
@@ -237,33 +213,10 @@ func (g *EventHandler) handleIssuesEventEdited(ctx context.Context, deliveryID s
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		IssuesEventEditedAction,
-		IssuesEventAnyAction,
-	} {
-		if _, ok := g.onIssuesEvent[action]; ok {
-			for _, h := range g.onIssuesEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssuesEvent](ctx, deliveryID, eventName, event,
+		g.onIssuesEvent[IssuesEventEditedAction],
+		g.onIssuesEvent[IssuesEventAnyAction],
+	)
 }
 
 // OnIssuesEventDeleted registers callbacks listening to events of type github.IssuesEvent and action 'deleted'.
@@ -323,33 +276,10 @@ func (g *EventHandler) handleIssuesEventDeleted(ctx context.Context, deliveryID
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		IssuesEventDeletedAction,
-		IssuesEventAnyAction,
-	} {
-		if _, ok := g.onIssuesEvent[action]; ok {
-			for _, h := range g.onIssuesEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssuesEvent](ctx, deliveryID, eventName, event,
+		g.onIssuesEvent[IssuesEventDeletedAction],
+		g.onIssuesEvent[IssuesEventAnyAction],
+	)
 }
 
 // OnIssuesEventPinned registers callbacks listening to events of type github.IssuesEvent and action 'pinned'.
@@ -409,33 +339,10 @@ func (g *EventHandler) handleIssuesEventPinned(ctx context.Context, deliveryID s
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		IssuesEventPinnedAction,
-		IssuesEventAnyAction,
-	} {
-		if _, ok := g.onIssuesEvent[action]; ok {
-			for _, h := range g.onIssuesEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssuesEvent](ctx, deliveryID, eventName, event,
+		g.onIssuesEvent[IssuesEventPinnedAction],
+		g.onIssuesEvent[IssuesEventAnyAction],
+	)
 }
 
 // OnIssuesEventUnpinned registers callbacks listening to events of type github.IssuesEvent and action 'unpinned'.
@@ -495,33 +402,10 @@ func (g *EventHandler) handleIssuesEventUnpinned(ctx context.Context, deliveryID
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		IssuesEventUnpinnedAction,
-		IssuesEventAnyAction,
-	} {
-		if _, ok := g.onIssuesEvent[action]; ok {
-			for _, h := range g.onIssuesEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssuesEvent](ctx, deliveryID, eventName, event,
+		g.onIssuesEvent[IssuesEventUnpinnedAction],
+		g.onIssuesEvent[IssuesEventAnyAction],
+	)
 }
 
 // OnIssuesEventClosed registers callbacks listening to events of type github.IssuesEvent and action 'closed'.
@@ -581,33 +465,10 @@ func (g *EventHandler) handleIssuesEventClosed(ctx context.Context, deliveryID s
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		IssuesEventClosedAction,
-		IssuesEventAnyAction,
-	} {
-		if _, ok := g.onIssuesEvent[action]; ok {
-			for _, h := range g.onIssuesEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssuesEvent](ctx, deliveryID, eventName, event,
+		g.onIssuesEvent[IssuesEventClosedAction],
+		g.onIssuesEvent[IssuesEventAnyAction],
+	)
 }
 
 // OnIssuesEventReopened registers callbacks listening to events of type github.IssuesEvent and action 'reopened'.
@@ -667,33 +528,10 @@ func (g *EventHandler) handleIssuesEventReopened(ctx context.Context, deliveryID
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		IssuesEventReopenedAction,
-		IssuesEventAnyAction,
-	} {
-		if _, ok := g.onIssuesEvent[action]; ok {
-			for _, h := range g.onIssuesEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssuesEvent](ctx, deliveryID, eventName, event,
+		g.onIssuesEvent[IssuesEventReopenedAction],
+		g.onIssuesEvent[IssuesEventAnyAction],
+	)
 }
 
 // OnIssuesEventAssigned registers callbacks listening to events of type github.IssuesEvent and action 'assigned'.
@@ -753,33 +591,10 @@ func (g *EventHandler) handleIssuesEventAssigned(ctx context.Context, deliveryID
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		IssuesEventAssignedAction,
-		IssuesEventAnyAction,
-	} {
-		if _, ok := g.onIssuesEvent[action]; ok {
-			for _, h := range g.onIssuesEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssuesEvent](ctx, deliveryID, eventName, event,
+		g.onIssuesEvent[IssuesEventAssignedAction],
+		g.onIssuesEvent[IssuesEventAnyAction],
+	)
 }
 
 // OnIssuesEventUnassigned registers callbacks listening to events of type github.IssuesEvent and action 'unassigned'.
@@ -839,33 +654,10 @@ func (g *EventHandler) handleIssuesEventUnassigned(ctx context.Context, delivery
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		IssuesEventUnassignedAction,
-		IssuesEventAnyAction,
-	} {
-		if _, ok := g.onIssuesEvent[action]; ok {
-			for _, h := range g.onIssuesEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssuesEvent](ctx, deliveryID, eventName, event,
+		g.onIssuesEvent[IssuesEventUnassignedAction],
+		g.onIssuesEvent[IssuesEventAnyAction],
+	)
 }
 
 // OnIssuesEventLabeled registers callbacks listening to events of type github.IssuesEvent and action 'labeled'.
@@ -925,33 +717,10 @@ func (g *EventHandler) handleIssuesEventLabeled(ctx context.Context, deliveryID
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		IssuesEventLabeledAction,
-		IssuesEventAnyAction,
-	} {
-		if _, ok := g.onIssuesEvent[action]; ok {
-			for _, h := range g.onIssuesEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssuesEvent](ctx, deliveryID, eventName, event,
+		g.onIssuesEvent[IssuesEventLabeledAction],
+		g.onIssuesEvent[IssuesEventAnyAction],
+	)
 }
 
 // OnIssuesEventUnlabeled registers callbacks listening to events of type github.IssuesEvent and action 'unlabeled'.
@@ -1011,33 +780,10 @@ func (g *EventHandler) handleIssuesEventUnlabeled(ctx context.Context, deliveryI
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		IssuesEventUnlabeledAction,
-		IssuesEventAnyAction,
-	} {
-		if _, ok := g.onIssuesEvent[action]; ok {
-			for _, h := range g.onIssuesEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssuesEvent](ctx, deliveryID, eventName, event,
+		g.onIssuesEvent[IssuesEventUnlabeledAction],
+		g.onIssuesEvent[IssuesEventAnyAction],
+	)
 }
 
 // OnIssuesEventLocked registers callbacks listening to events of type github.IssuesEvent and action 'locked'.
@@ -1097,33 +843,10 @@ func (g *EventHandler) handleIssuesEventLocked(ctx context.Context, deliveryID s
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		IssuesEventLockedAction,
-		IssuesEventAnyAction,
-	} {
-		if _, ok := g.onIssuesEvent[action]; ok {
-			for _, h := range g.onIssuesEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssuesEvent](ctx, deliveryID, eventName, event,
+		g.onIssuesEvent[IssuesEventLockedAction],
+		g.onIssuesEvent[IssuesEventAnyAction],
+	)
 }
 
 // OnIssuesEventUnlocked registers callbacks listening to events of type github.IssuesEvent and action 'unlocked'.
@@ -1183,33 +906,10 @@ func (g *EventHandler) handleIssuesEventUnlocked(ctx context.Context, deliveryID
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		IssuesEventUnlockedAction,
-		IssuesEventAnyAction,
-	} {
-		if _, ok := g.onIssuesEvent[action]; ok {
-			for _, h := range g.onIssuesEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssuesEvent](ctx, deliveryID, eventName, event,
+		g.onIssuesEvent[IssuesEventUnlockedAction],
+		g.onIssuesEvent[IssuesEventAnyAction],
+	)
 }
 
 // OnIssuesEventTransferred registers callbacks listening to events of type github.IssuesEvent and action 'transferred'.
@@ -1269,33 +969,10 @@ func (g *EventHandler) handleIssuesEventTransferred(ctx context.Context, deliver
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		IssuesEventTransferredAction,
-		IssuesEventAnyAction,
-	} {
-		if _, ok := g.onIssuesEvent[action]; ok {
-			for _, h := range g.onIssuesEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssuesEvent](ctx, deliveryID, eventName, event,
+		g.onIssuesEvent[IssuesEventTransferredAction],
+		g.onIssuesEvent[IssuesEventAnyAction],
+	)
 }
 
 // OnIssuesEventMilestoned registers callbacks listening to events of type github.IssuesEvent and action 'milestoned'.
@@ -1355,33 +1032,10 @@ func (g *EventHandler) handleIssuesEventMilestoned(ctx context.Context, delivery
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		IssuesEventMilestonedAction,
-		IssuesEventAnyAction,
-	} {
-		if _, ok := g.onIssuesEvent[action]; ok {
-			for _, h := range g.onIssuesEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssuesEvent](ctx, deliveryID, eventName, event,
+		g.onIssuesEvent[IssuesEventMilestonedAction],
+		g.onIssuesEvent[IssuesEventAnyAction],
+	)
 }
 
 // OnIssuesEventDeMilestoned registers callbacks listening to events of type github.IssuesEvent and action 'demilestoned'.
@@ -1441,33 +1095,10 @@ func (g *EventHandler) handleIssuesEventDeMilestoned(ctx context.Context, delive
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		IssuesEventDeMilestonedAction,
-		IssuesEventAnyAction,
-	} {
-		if _, ok := g.onIssuesEvent[action]; ok {
-			for _, h := range g.onIssuesEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssuesEvent](ctx, deliveryID, eventName, event,
+		g.onIssuesEvent[IssuesEventDeMilestonedAction],
+		g.onIssuesEvent[IssuesEventAnyAction],
+	)
 }
 
 // OnIssuesEventAny registers callbacks listening to any events of type github.IssuesEvent
@@ -1520,29 +1151,7 @@ func (g *EventHandler) handleIssuesEventAny(ctx context.Context, deliveryID stri
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onIssuesEvent[IssuesEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onIssuesEvent[IssuesEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.IssuesEvent](ctx, deliveryID, eventName, event, g.onIssuesEvent[IssuesEventAnyAction])
 }
 
 // IssuesEvent handles github.IssuesEvent.
diff --git a/githubevents/events_label.go b/githubevents/events_label.go
index 8c81fb3c..82b5b5d0 100644
--- a/githubevents/events_label.go
+++ b/githubevents/events_label.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -99,33 +98,10 @@ func (g *EventHandler) handleLabelEventCreated(ctx context.Context, deliveryID s
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		LabelEventCreatedAction,
-		LabelEventAnyAction,
-	} {
-		if _, ok := g.onLabelEvent[action]; ok {
-			for _, h := range g.onLabelEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.LabelEvent](ctx, deliveryID, eventName, event,
+		g.onLabelEvent[LabelEventCreatedAction],
+		g.onLabelEvent[LabelEventAnyAction],
+	)
 }
 
 // OnLabelEventEdited registers callbacks listening to events of type github.LabelEvent and action 'edited'.
@@ -185,33 +161,10 @@ func (g *EventHandler) handleLabelEventEdited(ctx context.Context, deliveryID st
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		LabelEventEditedAction,
-		LabelEventAnyAction,
-	} {
-		if _, ok := g.onLabelEvent[action]; ok {
-			for _, h := range g.onLabelEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.LabelEvent](ctx, deliveryID, eventName, event,
+		g.onLabelEvent[LabelEventEditedAction],
+		g.onLabelEvent[LabelEventAnyAction],
+	)
 }
 
 // OnLabelEventDeleted registers callbacks listening to events of type github.LabelEvent and action 'deleted'.
@@ -271,33 +224,10 @@ func (g *EventHandler) handleLabelEventDeleted(ctx context.Context, deliveryID s
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		LabelEventDeletedAction,
-		LabelEventAnyAction,
-	} {
-		if _, ok := g.onLabelEvent[action]; ok {
-			for _, h := range g.onLabelEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.LabelEvent](ctx, deliveryID, eventName, event,
+		g.onLabelEvent[LabelEventDeletedAction],
+		g.onLabelEvent[LabelEventAnyAction],
+	)
 }
 
 // OnLabelEventAny registers callbacks listening to any events of type github.LabelEvent
@@ -350,29 +280,7 @@ func (g *EventHandler) handleLabelEventAny(ctx context.Context, deliveryID strin
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onLabelEvent[LabelEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onLabelEvent[LabelEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.LabelEvent](ctx, deliveryID, eventName, event, g.onLabelEvent[LabelEventAnyAction])
 }
 
 // LabelEvent handles github.LabelEvent.
diff --git a/githubevents/events_marketplace_purchase.go b/githubevents/events_marketplace_purchase.go
index d0edd950..54dab3f2 100644
--- a/githubevents/events_marketplace_purchase.go
+++ b/githubevents/events_marketplace_purchase.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -107,33 +106,10 @@ func (g *EventHandler) handleMarketplacePurchaseEventPurchased(ctx context.Conte
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		MarketplacePurchaseEventPurchasedAction,
-		MarketplacePurchaseEventAnyAction,
-	} {
-		if _, ok := g.onMarketplacePurchaseEvent[action]; ok {
-			for _, h := range g.onMarketplacePurchaseEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MarketplacePurchaseEvent](ctx, deliveryID, eventName, event,
+		g.onMarketplacePurchaseEvent[MarketplacePurchaseEventPurchasedAction],
+		g.onMarketplacePurchaseEvent[MarketplacePurchaseEventAnyAction],
+	)
 }
 
 // OnMarketplacePurchaseEventPendingChange registers callbacks listening to events of type github.MarketplacePurchaseEvent and action 'pending_change'.
@@ -193,33 +169,10 @@ func (g *EventHandler) handleMarketplacePurchaseEventPendingChange(ctx context.C
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		MarketplacePurchaseEventPendingChangeAction,
-		MarketplacePurchaseEventAnyAction,
-	} {
-		if _, ok := g.onMarketplacePurchaseEvent[action]; ok {
-			for _, h := range g.onMarketplacePurchaseEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MarketplacePurchaseEvent](ctx, deliveryID, eventName, event,
+		g.onMarketplacePurchaseEvent[MarketplacePurchaseEventPendingChangeAction],
+		g.onMarketplacePurchaseEvent[MarketplacePurchaseEventAnyAction],
+	)
 }
 
 // OnMarketplacePurchaseEventPendingChangeCanceled registers callbacks listening to events of type github.MarketplacePurchaseEvent and action 'pending_change_canceled'.
@@ -279,33 +232,10 @@ func (g *EventHandler) handleMarketplacePurchaseEventPendingChangeCanceled(ctx c
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		MarketplacePurchaseEventPendingChangeCanceledAction,
-		MarketplacePurchaseEventAnyAction,
-	} {
-		if _, ok := g.onMarketplacePurchaseEvent[action]; ok {
-			for _, h := range g.onMarketplacePurchaseEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MarketplacePurchaseEvent](ctx, deliveryID, eventName, event,
+		g.onMarketplacePurchaseEvent[MarketplacePurchaseEventPendingChangeCanceledAction],
+		g.onMarketplacePurchaseEvent[MarketplacePurchaseEventAnyAction],
+	)
 }
 
 // OnMarketplacePurchaseEventChanged registers callbacks listening to events of type github.MarketplacePurchaseEvent and action 'changed'.
@@ -365,33 +295,10 @@ func (g *EventHandler) handleMarketplacePurchaseEventChanged(ctx context.Context
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		MarketplacePurchaseEventChangedAction,
-		MarketplacePurchaseEventAnyAction,
-	} {
-		if _, ok := g.onMarketplacePurchaseEvent[action]; ok {
-			for _, h := range g.onMarketplacePurchaseEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MarketplacePurchaseEvent](ctx, deliveryID, eventName, event,
+		g.onMarketplacePurchaseEvent[MarketplacePurchaseEventChangedAction],
+		g.onMarketplacePurchaseEvent[MarketplacePurchaseEventAnyAction],
+	)
 }
 
 // OnMarketplacePurchaseEventCanceled registers callbacks listening to events of type github.MarketplacePurchaseEvent and action 'canceled'.
@@ -451,33 +358,10 @@ func (g *EventHandler) handleMarketplacePurchaseEventCanceled(ctx context.Contex
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		MarketplacePurchaseEventCanceledAction,
-		MarketplacePurchaseEventAnyAction,
-	} {
-		if _, ok := g.onMarketplacePurchaseEvent[action]; ok {
-			for _, h := range g.onMarketplacePurchaseEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MarketplacePurchaseEvent](ctx, deliveryID, eventName, event,
+		g.onMarketplacePurchaseEvent[MarketplacePurchaseEventCanceledAction],
+		g.onMarketplacePurchaseEvent[MarketplacePurchaseEventAnyAction],
+	)
 }
 
 // OnMarketplacePurchaseEventAny registers callbacks listening to any events of type github.MarketplacePurchaseEvent
@@ -530,29 +414,7 @@ func (g *EventHandler) handleMarketplacePurchaseEventAny(ctx context.Context, de
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onMarketplacePurchaseEvent[MarketplacePurchaseEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onMarketplacePurchaseEvent[MarketplacePurchaseEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MarketplacePurchaseEvent](ctx, deliveryID, eventName, event, g.onMarketplacePurchaseEvent[MarketplacePurchaseEventAnyAction])
 }
 
 // MarketplacePurchaseEvent handles github.MarketplacePurchaseEvent.
diff --git a/githubevents/events_member.go b/githubevents/events_member.go
index 9a69c4be..0cc8acb2 100644
--- a/githubevents/events_member.go
+++ b/githubevents/events_member.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -99,33 +98,10 @@ func (g *EventHandler) handleMemberEventAdded(ctx context.Context, deliveryID st
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		MemberEventAddedAction,
-		MemberEventAnyAction,
-	} {
-		if _, ok := g.onMemberEvent[action]; ok {
-			for _, h := range g.onMemberEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MemberEvent](ctx, deliveryID, eventName, event,
+		g.onMemberEvent[MemberEventAddedAction],
+		g.onMemberEvent[MemberEventAnyAction],
+	)
 }
 
 // OnMemberEventRemoved registers callbacks listening to events of type github.MemberEvent and action 'removed'.
@@ -185,33 +161,10 @@ func (g *EventHandler) handleMemberEventRemoved(ctx context.Context, deliveryID
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		MemberEventRemovedAction,
-		MemberEventAnyAction,
-	} {
-		if _, ok := g.onMemberEvent[action]; ok {
-			for _, h := range g.onMemberEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MemberEvent](ctx, deliveryID, eventName, event,
+		g.onMemberEvent[MemberEventRemovedAction],
+		g.onMemberEvent[MemberEventAnyAction],
+	)
 }
 
 // OnMemberEventEdited registers callbacks listening to events of type github.MemberEvent and action 'edited'.
@@ -271,33 +224,10 @@ func (g *EventHandler) handleMemberEventEdited(ctx context.Context, deliveryID s
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		MemberEventEditedAction,
-		MemberEventAnyAction,
-	} {
-		if _, ok := g.onMemberEvent[action]; ok {
-			for _, h := range g.onMemberEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MemberEvent](ctx, deliveryID, eventName, event,
+		g.onMemberEvent[MemberEventEditedAction],
+		g.onMemberEvent[MemberEventAnyAction],
+	)
 }
 
 // OnMemberEventAny registers callbacks listening to any events of type github.MemberEvent
@@ -350,29 +280,7 @@ func (g *EventHandler) handleMemberEventAny(ctx context.Context, deliveryID stri
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onMemberEvent[MemberEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onMemberEvent[MemberEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MemberEvent](ctx, deliveryID, eventName, event, g.onMemberEvent[MemberEventAnyAction])
 }
 
 // MemberEvent handles github.MemberEvent.
diff --git a/githubevents/events_membership.go b/githubevents/events_membership.go
index 3cd12117..634dbb17 100644
--- a/githubevents/events_membership.go
+++ b/githubevents/events_membership.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -95,33 +94,10 @@ func (g *EventHandler) handleMembershipEventAdded(ctx context.Context, deliveryI
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		MembershipEventAddedAction,
-		MembershipEventAnyAction,
-	} {
-		if _, ok := g.onMembershipEvent[action]; ok {
-			for _, h := range g.onMembershipEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MembershipEvent](ctx, deliveryID, eventName, event,
+		g.onMembershipEvent[MembershipEventAddedAction],
+		g.onMembershipEvent[MembershipEventAnyAction],
+	)
 }
 
 // OnMembershipEventRemoved registers callbacks listening to events of type github.MembershipEvent and action 'removed'.
@@ -181,33 +157,10 @@ func (g *EventHandler) handleMembershipEventRemoved(ctx context.Context, deliver
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		MembershipEventRemovedAction,
-		MembershipEventAnyAction,
-	} {
-		if _, ok := g.onMembershipEvent[action]; ok {
-			for _, h := range g.onMembershipEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MembershipEvent](ctx, deliveryID, eventName, event,
+		g.onMembershipEvent[MembershipEventRemovedAction],
+		g.onMembershipEvent[MembershipEventAnyAction],
+	)
 }
 
 // OnMembershipEventAny registers callbacks listening to any events of type github.MembershipEvent
@@ -260,29 +213,7 @@ func (g *EventHandler) handleMembershipEventAny(ctx context.Context, deliveryID
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onMembershipEvent[MembershipEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onMembershipEvent[MembershipEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MembershipEvent](ctx, deliveryID, eventName, event, g.onMembershipEvent[MembershipEventAnyAction])
 }
 
 // MembershipEvent handles github.MembershipEvent.
diff --git a/githubevents/events_merge_group_event.go b/githubevents/events_merge_group_event.go
index 3fe00980..b6812d7e 100644
--- a/githubevents/events_merge_group_event.go
+++ b/githubevents/events_merge_group_event.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -95,33 +94,10 @@ func (g *EventHandler) handleMergeGroupEventChecksRequested(ctx context.Context,
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		MergeGroupEventChecksRequestedAction,
-		MergeGroupEventAnyAction,
-	} {
-		if _, ok := g.onMergeGroupEvent[action]; ok {
-			for _, h := range g.onMergeGroupEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MergeGroupEvent](ctx, deliveryID, eventName, event,
+		g.onMergeGroupEvent[MergeGroupEventChecksRequestedAction],
+		g.onMergeGroupEvent[MergeGroupEventAnyAction],
+	)
 }
 
 // OnMergeGroupEventDestroyed registers callbacks listening to events of type github.MergeGroupEvent and action 'destroyed'.
@@ -181,33 +157,10 @@ func (g *EventHandler) handleMergeGroupEventDestroyed(ctx context.Context, deliv
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		MergeGroupEventDestroyedAction,
-		MergeGroupEventAnyAction,
-	} {
-		if _, ok := g.onMergeGroupEvent[action]; ok {
-			for _, h := range g.onMergeGroupEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MergeGroupEvent](ctx, deliveryID, eventName, event,
+		g.onMergeGroupEvent[MergeGroupEventDestroyedAction],
+		g.onMergeGroupEvent[MergeGroupEventAnyAction],
+	)
 }
 
 // OnMergeGroupEventAny registers callbacks listening to any events of type github.MergeGroupEvent
@@ -260,29 +213,7 @@ func (g *EventHandler) handleMergeGroupEventAny(ctx context.Context, deliveryID
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onMergeGroupEvent[MergeGroupEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onMergeGroupEvent[MergeGroupEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MergeGroupEvent](ctx, deliveryID, eventName, event, g.onMergeGroupEvent[MergeGroupEventAnyAction])
 }
 
 // MergeGroupEvent handles github.MergeGroupEvent.
diff --git a/githubevents/events_meta.go b/githubevents/events_meta.go
index 10e49221..86c466ea 100644
--- a/githubevents/events_meta.go
+++ b/githubevents/events_meta.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -80,29 +79,7 @@ func (g *EventHandler) handleMetaEventAny(ctx context.Context, deliveryID string
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onMetaEvent[MetaEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onMetaEvent[MetaEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MetaEvent](ctx, deliveryID, eventName, event, g.onMetaEvent[MetaEventAnyAction])
 }
 
 // MetaEvent handles github.MetaEvent.
diff --git a/githubevents/events_milestone.go b/githubevents/events_milestone.go
index 96b02b68..2cacb53d 100644
--- a/githubevents/events_milestone.go
+++ b/githubevents/events_milestone.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -107,33 +106,10 @@ func (g *EventHandler) handleMilestoneEventCreated(ctx context.Context, delivery
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		MilestoneEventCreatedAction,
-		MilestoneEventAnyAction,
-	} {
-		if _, ok := g.onMilestoneEvent[action]; ok {
-			for _, h := range g.onMilestoneEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MilestoneEvent](ctx, deliveryID, eventName, event,
+		g.onMilestoneEvent[MilestoneEventCreatedAction],
+		g.onMilestoneEvent[MilestoneEventAnyAction],
+	)
 }
 
 // OnMilestoneEventClosed registers callbacks listening to events of type github.MilestoneEvent and action 'closed'.
@@ -193,33 +169,10 @@ func (g *EventHandler) handleMilestoneEventClosed(ctx context.Context, deliveryI
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		MilestoneEventClosedAction,
-		MilestoneEventAnyAction,
-	} {
-		if _, ok := g.onMilestoneEvent[action]; ok {
-			for _, h := range g.onMilestoneEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MilestoneEvent](ctx, deliveryID, eventName, event,
+		g.onMilestoneEvent[MilestoneEventClosedAction],
+		g.onMilestoneEvent[MilestoneEventAnyAction],
+	)
 }
 
 // OnMilestoneEventOpened registers callbacks listening to events of type github.MilestoneEvent and action 'opened'.
@@ -279,33 +232,10 @@ func (g *EventHandler) handleMilestoneEventOpened(ctx context.Context, deliveryI
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		MilestoneEventOpenedAction,
-		MilestoneEventAnyAction,
-	} {
-		if _, ok := g.onMilestoneEvent[action]; ok {
-			for _, h := range g.onMilestoneEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MilestoneEvent](ctx, deliveryID, eventName, event,
+		g.onMilestoneEvent[MilestoneEventOpenedAction],
+		g.onMilestoneEvent[MilestoneEventAnyAction],
+	)
 }
 
 // OnMilestoneEventEdited registers callbacks listening to events of type github.MilestoneEvent and action 'edited'.
@@ -365,33 +295,10 @@ func (g *EventHandler) handleMilestoneEventEdited(ctx context.Context, deliveryI
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		MilestoneEventEditedAction,
-		MilestoneEventAnyAction,
-	} {
-		if _, ok := g.onMilestoneEvent[action]; ok {
-			for _, h := range g.onMilestoneEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MilestoneEvent](ctx, deliveryID, eventName, event,
+		g.onMilestoneEvent[MilestoneEventEditedAction],
+		g.onMilestoneEvent[MilestoneEventAnyAction],
+	)
 }
 
 // OnMilestoneEventDeleted registers callbacks listening to events of type github.MilestoneEvent and action 'deleted'.
@@ -451,33 +358,10 @@ func (g *EventHandler) handleMilestoneEventDeleted(ctx context.Context, delivery
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		MilestoneEventDeletedAction,
-		MilestoneEventAnyAction,
-	} {
-		if _, ok := g.onMilestoneEvent[action]; ok {
-			for _, h := range g.onMilestoneEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MilestoneEvent](ctx, deliveryID, eventName, event,
+		g.onMilestoneEvent[MilestoneEventDeletedAction],
+		g.onMilestoneEvent[MilestoneEventAnyAction],
+	)
 }
 
 // OnMilestoneEventAny registers callbacks listening to any events of type github.MilestoneEvent
@@ -530,29 +414,7 @@ func (g *EventHandler) handleMilestoneEventAny(ctx context.Context, deliveryID s
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onMilestoneEvent[MilestoneEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onMilestoneEvent[MilestoneEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.MilestoneEvent](ctx, deliveryID, eventName, event, g.onMilestoneEvent[MilestoneEventAnyAction])
 }
 
 // MilestoneEvent handles github.MilestoneEvent.
diff --git a/githubevents/events_org_block.go b/githubevents/events_org_block.go
index 3837f815..b0871ce7 100644
--- a/githubevents/events_org_block.go
+++ b/githubevents/events_org_block.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -95,33 +94,10 @@ func (g *EventHandler) handleOrgBlockEventBlocked(ctx context.Context, deliveryI
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		OrgBlockEventBlockedAction,
-		OrgBlockEventAnyAction,
-	} {
-		if _, ok := g.onOrgBlockEvent[action]; ok {
-			for _, h := range g.onOrgBlockEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.OrgBlockEvent](ctx, deliveryID, eventName, event,
+		g.onOrgBlockEvent[OrgBlockEventBlockedAction],
+		g.onOrgBlockEvent[OrgBlockEventAnyAction],
+	)
 }
 
 // OnOrgBlockEventUnblocked registers callbacks listening to events of type github.OrgBlockEvent and action 'unblocked'.
@@ -181,33 +157,10 @@ func (g *EventHandler) handleOrgBlockEventUnblocked(ctx context.Context, deliver
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		OrgBlockEventUnblockedAction,
-		OrgBlockEventAnyAction,
-	} {
-		if _, ok := g.onOrgBlockEvent[action]; ok {
-			for _, h := range g.onOrgBlockEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.OrgBlockEvent](ctx, deliveryID, eventName, event,
+		g.onOrgBlockEvent[OrgBlockEventUnblockedAction],
+		g.onOrgBlockEvent[OrgBlockEventAnyAction],
+	)
 }
 
 // OnOrgBlockEventAny registers callbacks listening to any events of type github.OrgBlockEvent
@@ -260,29 +213,7 @@ func (g *EventHandler) handleOrgBlockEventAny(ctx context.Context, deliveryID st
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onOrgBlockEvent[OrgBlockEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onOrgBlockEvent[OrgBlockEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.OrgBlockEvent](ctx, deliveryID, eventName, event, g.onOrgBlockEvent[OrgBlockEventAnyAction])
 }
 
 // OrgBlockEvent handles github.OrgBlockEvent.
diff --git a/githubevents/events_organization.go b/githubevents/events_organization.go
index f77e25d1..1d4750c1 100644
--- a/githubevents/events_organization.go
+++ b/githubevents/events_organization.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -107,33 +106,10 @@ func (g *EventHandler) handleOrganizationEventDeleted(ctx context.Context, deliv
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		OrganizationEventDeletedAction,
-		OrganizationEventAnyAction,
-	} {
-		if _, ok := g.onOrganizationEvent[action]; ok {
-			for _, h := range g.onOrganizationEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.OrganizationEvent](ctx, deliveryID, eventName, event,
+		g.onOrganizationEvent[OrganizationEventDeletedAction],
+		g.onOrganizationEvent[OrganizationEventAnyAction],
+	)
 }
 
 // OnOrganizationEventRenamed registers callbacks listening to events of type github.OrganizationEvent and action 'renamed'.
@@ -193,33 +169,10 @@ func (g *EventHandler) handleOrganizationEventRenamed(ctx context.Context, deliv
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		OrganizationEventRenamedAction,
-		OrganizationEventAnyAction,
-	} {
-		if _, ok := g.onOrganizationEvent[action]; ok {
-			for _, h := range g.onOrganizationEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.OrganizationEvent](ctx, deliveryID, eventName, event,
+		g.onOrganizationEvent[OrganizationEventRenamedAction],
+		g.onOrganizationEvent[OrganizationEventAnyAction],
+	)
 }
 
 // OnOrganizationEventMemberAdded registers callbacks listening to events of type github.OrganizationEvent and action 'member_added'.
@@ -279,33 +232,10 @@ func (g *EventHandler) handleOrganizationEventMemberAdded(ctx context.Context, d
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		OrganizationEventMemberAddedAction,
-		OrganizationEventAnyAction,
-	} {
-		if _, ok := g.onOrganizationEvent[action]; ok {
-			for _, h := range g.onOrganizationEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.OrganizationEvent](ctx, deliveryID, eventName, event,
+		g.onOrganizationEvent[OrganizationEventMemberAddedAction],
+		g.onOrganizationEvent[OrganizationEventAnyAction],
+	)
 }
 
 // OnOrganizationEventMemberRemoved registers callbacks listening to events of type github.OrganizationEvent and action 'member_removed'.
@@ -365,33 +295,10 @@ func (g *EventHandler) handleOrganizationEventMemberRemoved(ctx context.Context,
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		OrganizationEventMemberRemovedAction,
-		OrganizationEventAnyAction,
-	} {
-		if _, ok := g.onOrganizationEvent[action]; ok {
-			for _, h := range g.onOrganizationEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.OrganizationEvent](ctx, deliveryID, eventName, event,
+		g.onOrganizationEvent[OrganizationEventMemberRemovedAction],
+		g.onOrganizationEvent[OrganizationEventAnyAction],
+	)
 }
 
 // OnOrganizationEventMemberInvited registers callbacks listening to events of type github.OrganizationEvent and action 'member_invited'.
@@ -451,33 +358,10 @@ func (g *EventHandler) handleOrganizationEventMemberInvited(ctx context.Context,
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		OrganizationEventMemberInvitedAction,
-		OrganizationEventAnyAction,
-	} {
-		if _, ok := g.onOrganizationEvent[action]; ok {
-			for _, h := range g.onOrganizationEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.OrganizationEvent](ctx, deliveryID, eventName, event,
+		g.onOrganizationEvent[OrganizationEventMemberInvitedAction],
+		g.onOrganizationEvent[OrganizationEventAnyAction],
+	)
 }
 
 // OnOrganizationEventAny registers callbacks listening to any events of type github.OrganizationEvent
@@ -530,29 +414,7 @@ func (g *EventHandler) handleOrganizationEventAny(ctx context.Context, deliveryI
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onOrganizationEvent[OrganizationEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onOrganizationEvent[OrganizationEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.OrganizationEvent](ctx, deliveryID, eventName, event, g.onOrganizationEvent[OrganizationEventAnyAction])
 }
 
 // OrganizationEvent handles github.OrganizationEvent.
diff --git a/githubevents/events_package.go b/githubevents/events_package.go
index 4b8ea80d..cf4501d1 100644
--- a/githubevents/events_package.go
+++ b/githubevents/events_package.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -95,33 +94,10 @@ func (g *EventHandler) handlePackageEventPublished(ctx context.Context, delivery
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PackageEventPublishedAction,
-		PackageEventAnyAction,
-	} {
-		if _, ok := g.onPackageEvent[action]; ok {
-			for _, h := range g.onPackageEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PackageEvent](ctx, deliveryID, eventName, event,
+		g.onPackageEvent[PackageEventPublishedAction],
+		g.onPackageEvent[PackageEventAnyAction],
+	)
 }
 
 // OnPackageEventUpdated registers callbacks listening to events of type github.PackageEvent and action 'updated'.
@@ -181,33 +157,10 @@ func (g *EventHandler) handlePackageEventUpdated(ctx context.Context, deliveryID
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PackageEventUpdatedAction,
-		PackageEventAnyAction,
-	} {
-		if _, ok := g.onPackageEvent[action]; ok {
-			for _, h := range g.onPackageEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PackageEvent](ctx, deliveryID, eventName, event,
+		g.onPackageEvent[PackageEventUpdatedAction],
+		g.onPackageEvent[PackageEventAnyAction],
+	)
 }
 
 // OnPackageEventAny registers callbacks listening to any events of type github.PackageEvent
@@ -260,29 +213,7 @@ func (g *EventHandler) handlePackageEventAny(ctx context.Context, deliveryID str
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onPackageEvent[PackageEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onPackageEvent[PackageEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PackageEvent](ctx, deliveryID, eventName, event, g.onPackageEvent[PackageEventAnyAction])
 }
 
 // PackageEvent handles github.PackageEvent.
diff --git a/githubevents/events_page_build.go b/githubevents/events_page_build.go
index 42629259..b2c884a6 100644
--- a/githubevents/events_page_build.go
+++ b/githubevents/events_page_build.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -80,29 +79,7 @@ func (g *EventHandler) handlePageBuildEventAny(ctx context.Context, deliveryID s
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onPageBuildEvent[PageBuildEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onPageBuildEvent[PageBuildEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PageBuildEvent](ctx, deliveryID, eventName, event, g.onPageBuildEvent[PageBuildEventAnyAction])
 }
 
 // PageBuildEvent handles github.PageBuildEvent.
diff --git a/githubevents/events_ping.go b/githubevents/events_ping.go
index c7873e10..e916033f 100644
--- a/githubevents/events_ping.go
+++ b/githubevents/events_ping.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -80,29 +79,7 @@ func (g *EventHandler) handlePingEventAny(ctx context.Context, deliveryID string
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onPingEvent[PingEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onPingEvent[PingEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PingEvent](ctx, deliveryID, eventName, event, g.onPingEvent[PingEventAnyAction])
 }
 
 // PingEvent handles github.PingEvent.
diff --git a/githubevents/events_project_v2.go b/githubevents/events_project_v2.go
index 24777b05..6a6763b6 100644
--- a/githubevents/events_project_v2.go
+++ b/githubevents/events_project_v2.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -107,33 +106,10 @@ func (g *EventHandler) handleProjectEventCreated(ctx context.Context, deliveryID
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		ProjectEventCreatedAction,
-		ProjectV2EventAnyAction,
-	} {
-		if _, ok := g.onProjectV2Event[action]; ok {
-			for _, h := range g.onProjectV2Event[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ProjectV2Event](ctx, deliveryID, eventName, event,
+		g.onProjectV2Event[ProjectEventCreatedAction],
+		g.onProjectV2Event[ProjectV2EventAnyAction],
+	)
 }
 
 // OnProjectEventEdited registers callbacks listening to events of type github.ProjectV2Event and action 'edited'.
@@ -193,33 +169,10 @@ func (g *EventHandler) handleProjectEventEdited(ctx context.Context, deliveryID
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		ProjectEventEditedAction,
-		ProjectV2EventAnyAction,
-	} {
-		if _, ok := g.onProjectV2Event[action]; ok {
-			for _, h := range g.onProjectV2Event[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ProjectV2Event](ctx, deliveryID, eventName, event,
+		g.onProjectV2Event[ProjectEventEditedAction],
+		g.onProjectV2Event[ProjectV2EventAnyAction],
+	)
 }
 
 // OnProjectEventClosed registers callbacks listening to events of type github.ProjectV2Event and action 'closed'.
@@ -279,33 +232,10 @@ func (g *EventHandler) handleProjectEventClosed(ctx context.Context, deliveryID
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		ProjectEventClosedAction,
-		ProjectV2EventAnyAction,
-	} {
-		if _, ok := g.onProjectV2Event[action]; ok {
-			for _, h := range g.onProjectV2Event[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ProjectV2Event](ctx, deliveryID, eventName, event,
+		g.onProjectV2Event[ProjectEventClosedAction],
+		g.onProjectV2Event[ProjectV2EventAnyAction],
+	)
 }
 
 // OnProjectEventReopened registers callbacks listening to events of type github.ProjectV2Event and action 'reopened'.
@@ -365,33 +295,10 @@ func (g *EventHandler) handleProjectEventReopened(ctx context.Context, deliveryI
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		ProjectEventReopenedAction,
-		ProjectV2EventAnyAction,
-	} {
-		if _, ok := g.onProjectV2Event[action]; ok {
-			for _, h := range g.onProjectV2Event[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ProjectV2Event](ctx, deliveryID, eventName, event,
+		g.onProjectV2Event[ProjectEventReopenedAction],
+		g.onProjectV2Event[ProjectV2EventAnyAction],
+	)
 }
 
 // OnProjectEventDeleted registers callbacks listening to events of type github.ProjectV2Event and action 'deleted'.
@@ -451,33 +358,10 @@ func (g *EventHandler) handleProjectEventDeleted(ctx context.Context, deliveryID
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		ProjectEventDeletedAction,
-		ProjectV2EventAnyAction,
-	} {
-		if _, ok := g.onProjectV2Event[action]; ok {
-			for _, h := range g.onProjectV2Event[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ProjectV2Event](ctx, deliveryID, eventName, event,
+		g.onProjectV2Event[ProjectEventDeletedAction],
+		g.onProjectV2Event[ProjectV2EventAnyAction],
+	)
 }
 
 // OnProjectV2EventAny registers callbacks listening to any events of type github.ProjectV2Event
@@ -530,29 +414,7 @@ func (g *EventHandler) handleProjectV2EventAny(ctx context.Context, deliveryID s
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onProjectV2Event[ProjectV2EventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onProjectV2Event[ProjectV2EventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ProjectV2Event](ctx, deliveryID, eventName, event, g.onProjectV2Event[ProjectV2EventAnyAction])
 }
 
 // ProjectV2Event handles github.ProjectV2Event.
diff --git a/githubevents/events_project_v2_item.go b/githubevents/events_project_v2_item.go
index 32976933..2a24f90d 100644
--- a/githubevents/events_project_v2_item.go
+++ b/githubevents/events_project_v2_item.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -115,33 +114,10 @@ func (g *EventHandler) handleProjectItemEventCreated(ctx context.Context, delive
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		ProjectItemEventCreatedAction,
-		ProjectV2ItemEventAnyAction,
-	} {
-		if _, ok := g.onProjectV2ItemEvent[action]; ok {
-			for _, h := range g.onProjectV2ItemEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ProjectV2ItemEvent](ctx, deliveryID, eventName, event,
+		g.onProjectV2ItemEvent[ProjectItemEventCreatedAction],
+		g.onProjectV2ItemEvent[ProjectV2ItemEventAnyAction],
+	)
 }
 
 // OnProjectItemEventEdited registers callbacks listening to events of type github.ProjectV2ItemEvent and action 'edited'.
@@ -201,33 +177,10 @@ func (g *EventHandler) handleProjectItemEventEdited(ctx context.Context, deliver
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		ProjectItemEventEditedAction,
-		ProjectV2ItemEventAnyAction,
-	} {
-		if _, ok := g.onProjectV2ItemEvent[action]; ok {
-			for _, h := range g.onProjectV2ItemEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ProjectV2ItemEvent](ctx, deliveryID, eventName, event,
+		g.onProjectV2ItemEvent[ProjectItemEventEditedAction],
+		g.onProjectV2ItemEvent[ProjectV2ItemEventAnyAction],
+	)
 }
 
 // OnProjectItemEventClosed registers callbacks listening to events of type github.ProjectV2ItemEvent and action 'closed'.
@@ -287,33 +240,10 @@ func (g *EventHandler) handleProjectItemEventClosed(ctx context.Context, deliver
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		ProjectItemEventClosedAction,
-		ProjectV2ItemEventAnyAction,
-	} {
-		if _, ok := g.onProjectV2ItemEvent[action]; ok {
-			for _, h := range g.onProjectV2ItemEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ProjectV2ItemEvent](ctx, deliveryID, eventName, event,
+		g.onProjectV2ItemEvent[ProjectItemEventClosedAction],
+		g.onProjectV2ItemEvent[ProjectV2ItemEventAnyAction],
+	)
 }
 
 // OnProjectItemEventReopened registers callbacks listening to events of type github.ProjectV2ItemEvent and action 'reopened'.
@@ -373,33 +303,10 @@ func (g *EventHandler) handleProjectItemEventReopened(ctx context.Context, deliv
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		ProjectItemEventReopenedAction,
-		ProjectV2ItemEventAnyAction,
-	} {
-		if _, ok := g.onProjectV2ItemEvent[action]; ok {
-			for _, h := range g.onProjectV2ItemEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ProjectV2ItemEvent](ctx, deliveryID, eventName, event,
+		g.onProjectV2ItemEvent[ProjectItemEventReopenedAction],
+		g.onProjectV2ItemEvent[ProjectV2ItemEventAnyAction],
+	)
 }
 
 // OnProjectItemEventDeleted registers callbacks listening to events of type github.ProjectV2ItemEvent and action 'deleted'.
@@ -459,33 +366,10 @@ func (g *EventHandler) handleProjectItemEventDeleted(ctx context.Context, delive
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		ProjectItemEventDeletedAction,
-		ProjectV2ItemEventAnyAction,
-	} {
-		if _, ok := g.onProjectV2ItemEvent[action]; ok {
-			for _, h := range g.onProjectV2ItemEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ProjectV2ItemEvent](ctx, deliveryID, eventName, event,
+		g.onProjectV2ItemEvent[ProjectItemEventDeletedAction],
+		g.onProjectV2ItemEvent[ProjectV2ItemEventAnyAction],
+	)
 }
 
 // OnProjectItemEventConverted registers callbacks listening to events of type github.ProjectV2ItemEvent and action 'converted'.
@@ -545,33 +429,10 @@ func (g *EventHandler) handleProjectItemEventConverted(ctx context.Context, deli
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		ProjectItemEventConvertedAction,
-		ProjectV2ItemEventAnyAction,
-	} {
-		if _, ok := g.onProjectV2ItemEvent[action]; ok {
-			for _, h := range g.onProjectV2ItemEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ProjectV2ItemEvent](ctx, deliveryID, eventName, event,
+		g.onProjectV2ItemEvent[ProjectItemEventConvertedAction],
+		g.onProjectV2ItemEvent[ProjectV2ItemEventAnyAction],
+	)
 }
 
 // OnProjectItemEventRestored registers callbacks listening to events of type github.ProjectV2ItemEvent and action 'restored'.
@@ -631,33 +492,10 @@ func (g *EventHandler) handleProjectItemEventRestored(ctx context.Context, deliv
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		ProjectItemEventRestoredAction,
-		ProjectV2ItemEventAnyAction,
-	} {
-		if _, ok := g.onProjectV2ItemEvent[action]; ok {
-			for _, h := range g.onProjectV2ItemEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ProjectV2ItemEvent](ctx, deliveryID, eventName, event,
+		g.onProjectV2ItemEvent[ProjectItemEventRestoredAction],
+		g.onProjectV2ItemEvent[ProjectV2ItemEventAnyAction],
+	)
 }
 
 // OnProjectV2ItemEventAny registers callbacks listening to any events of type github.ProjectV2ItemEvent
@@ -710,29 +548,7 @@ func (g *EventHandler) handleProjectV2ItemEventAny(ctx context.Context, delivery
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onProjectV2ItemEvent[ProjectV2ItemEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onProjectV2ItemEvent[ProjectV2ItemEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ProjectV2ItemEvent](ctx, deliveryID, eventName, event, g.onProjectV2ItemEvent[ProjectV2ItemEventAnyAction])
 }
 
 // ProjectV2ItemEvent handles github.ProjectV2ItemEvent.
diff --git a/githubevents/events_public.go b/githubevents/events_public.go
index b5e55267..08d165b0 100644
--- a/githubevents/events_public.go
+++ b/githubevents/events_public.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -80,29 +79,7 @@ func (g *EventHandler) handlePublicEventAny(ctx context.Context, deliveryID stri
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onPublicEvent[PublicEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onPublicEvent[PublicEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PublicEvent](ctx, deliveryID, eventName, event, g.onPublicEvent[PublicEventAnyAction])
 }
 
 // PublicEvent handles github.PublicEvent.
diff --git a/githubevents/events_pull_request.go b/githubevents/events_pull_request.go
index 06383bf4..e4a4b577 100644
--- a/githubevents/events_pull_request.go
+++ b/githubevents/events_pull_request.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -155,33 +154,10 @@ func (g *EventHandler) handlePullRequestEventAssigned(ctx context.Context, deliv
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestEventAssignedAction,
-		PullRequestEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestEvent[action]; ok {
-			for _, h := range g.onPullRequestEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestEvent[PullRequestEventAssignedAction],
+		g.onPullRequestEvent[PullRequestEventAnyAction],
+	)
 }
 
 // OnPullRequestEventAutoMergeDisabled registers callbacks listening to events of type github.PullRequestEvent and action 'auto_merge_disabled'.
@@ -241,33 +217,10 @@ func (g *EventHandler) handlePullRequestEventAutoMergeDisabled(ctx context.Conte
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestEventAutoMergeDisabledAction,
-		PullRequestEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestEvent[action]; ok {
-			for _, h := range g.onPullRequestEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestEvent[PullRequestEventAutoMergeDisabledAction],
+		g.onPullRequestEvent[PullRequestEventAnyAction],
+	)
 }
 
 // OnPullRequestEventAutoMergeEnabled registers callbacks listening to events of type github.PullRequestEvent and action 'auto_merge_enabled'.
@@ -327,33 +280,10 @@ func (g *EventHandler) handlePullRequestEventAutoMergeEnabled(ctx context.Contex
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestEventAutoMergeEnabledAction,
-		PullRequestEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestEvent[action]; ok {
-			for _, h := range g.onPullRequestEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestEvent[PullRequestEventAutoMergeEnabledAction],
+		g.onPullRequestEvent[PullRequestEventAnyAction],
+	)
 }
 
 // OnPullRequestEventClosed registers callbacks listening to events of type github.PullRequestEvent and action 'closed'.
@@ -413,33 +343,10 @@ func (g *EventHandler) handlePullRequestEventClosed(ctx context.Context, deliver
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestEventClosedAction,
-		PullRequestEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestEvent[action]; ok {
-			for _, h := range g.onPullRequestEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestEvent[PullRequestEventClosedAction],
+		g.onPullRequestEvent[PullRequestEventAnyAction],
+	)
 }
 
 // OnPullRequestEventConvertedToDraft registers callbacks listening to events of type github.PullRequestEvent and action 'converted_to_draft'.
@@ -499,33 +406,10 @@ func (g *EventHandler) handlePullRequestEventConvertedToDraft(ctx context.Contex
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestEventConvertedToDraftAction,
-		PullRequestEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestEvent[action]; ok {
-			for _, h := range g.onPullRequestEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestEvent[PullRequestEventConvertedToDraftAction],
+		g.onPullRequestEvent[PullRequestEventAnyAction],
+	)
 }
 
 // OnPullRequestEventEdited registers callbacks listening to events of type github.PullRequestEvent and action 'edited'.
@@ -585,33 +469,10 @@ func (g *EventHandler) handlePullRequestEventEdited(ctx context.Context, deliver
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestEventEditedAction,
-		PullRequestEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestEvent[action]; ok {
-			for _, h := range g.onPullRequestEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestEvent[PullRequestEventEditedAction],
+		g.onPullRequestEvent[PullRequestEventAnyAction],
+	)
 }
 
 // OnPullRequestEventLabeled registers callbacks listening to events of type github.PullRequestEvent and action 'labeled'.
@@ -671,33 +532,10 @@ func (g *EventHandler) handlePullRequestEventLabeled(ctx context.Context, delive
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestEventLabeledAction,
-		PullRequestEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestEvent[action]; ok {
-			for _, h := range g.onPullRequestEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestEvent[PullRequestEventLabeledAction],
+		g.onPullRequestEvent[PullRequestEventAnyAction],
+	)
 }
 
 // OnPullRequestEventLocked registers callbacks listening to events of type github.PullRequestEvent and action 'locked'.
@@ -757,33 +595,10 @@ func (g *EventHandler) handlePullRequestEventLocked(ctx context.Context, deliver
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestEventLockedAction,
-		PullRequestEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestEvent[action]; ok {
-			for _, h := range g.onPullRequestEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestEvent[PullRequestEventLockedAction],
+		g.onPullRequestEvent[PullRequestEventAnyAction],
+	)
 }
 
 // OnPullRequestEventOpened registers callbacks listening to events of type github.PullRequestEvent and action 'opened'.
@@ -843,33 +658,10 @@ func (g *EventHandler) handlePullRequestEventOpened(ctx context.Context, deliver
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestEventOpenedAction,
-		PullRequestEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestEvent[action]; ok {
-			for _, h := range g.onPullRequestEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestEvent[PullRequestEventOpenedAction],
+		g.onPullRequestEvent[PullRequestEventAnyAction],
+	)
 }
 
 // OnPullRequestEventReadyForReview registers callbacks listening to events of type github.PullRequestEvent and action 'ready_for_review'.
@@ -929,33 +721,10 @@ func (g *EventHandler) handlePullRequestEventReadyForReview(ctx context.Context,
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestEventReadyForReviewAction,
-		PullRequestEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestEvent[action]; ok {
-			for _, h := range g.onPullRequestEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestEvent[PullRequestEventReadyForReviewAction],
+		g.onPullRequestEvent[PullRequestEventAnyAction],
+	)
 }
 
 // OnPullRequestEventReopened registers callbacks listening to events of type github.PullRequestEvent and action 'reopened'.
@@ -1015,33 +784,10 @@ func (g *EventHandler) handlePullRequestEventReopened(ctx context.Context, deliv
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestEventReopenedAction,
-		PullRequestEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestEvent[action]; ok {
-			for _, h := range g.onPullRequestEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestEvent[PullRequestEventReopenedAction],
+		g.onPullRequestEvent[PullRequestEventAnyAction],
+	)
 }
 
 // OnPullRequestEventReviewRequestRemoved registers callbacks listening to events of type github.PullRequestEvent and action 'review_request_removed'.
@@ -1101,33 +847,10 @@ func (g *EventHandler) handlePullRequestEventReviewRequestRemoved(ctx context.Co
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestEventReviewRequestRemovedAction,
-		PullRequestEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestEvent[action]; ok {
-			for _, h := range g.onPullRequestEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestEvent[PullRequestEventReviewRequestRemovedAction],
+		g.onPullRequestEvent[PullRequestEventAnyAction],
+	)
 }
 
 // OnPullRequestEventReviewRequested registers callbacks listening to events of type github.PullRequestEvent and action 'review_requested'.
@@ -1187,33 +910,10 @@ func (g *EventHandler) handlePullRequestEventReviewRequested(ctx context.Context
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestEventReviewRequestedAction,
-		PullRequestEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestEvent[action]; ok {
-			for _, h := range g.onPullRequestEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestEvent[PullRequestEventReviewRequestedAction],
+		g.onPullRequestEvent[PullRequestEventAnyAction],
+	)
 }
 
 // OnPullRequestEventSynchronize registers callbacks listening to events of type github.PullRequestEvent and action 'synchronize'.
@@ -1273,33 +973,10 @@ func (g *EventHandler) handlePullRequestEventSynchronize(ctx context.Context, de
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestEventSynchronizeAction,
-		PullRequestEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestEvent[action]; ok {
-			for _, h := range g.onPullRequestEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestEvent[PullRequestEventSynchronizeAction],
+		g.onPullRequestEvent[PullRequestEventAnyAction],
+	)
 }
 
 // OnPullRequestEventUnassigned registers callbacks listening to events of type github.PullRequestEvent and action 'unassigned'.
@@ -1359,33 +1036,10 @@ func (g *EventHandler) handlePullRequestEventUnassigned(ctx context.Context, del
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestEventUnassignedAction,
-		PullRequestEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestEvent[action]; ok {
-			for _, h := range g.onPullRequestEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestEvent[PullRequestEventUnassignedAction],
+		g.onPullRequestEvent[PullRequestEventAnyAction],
+	)
 }
 
 // OnPullRequestEventUnlabeled registers callbacks listening to events of type github.PullRequestEvent and action 'unlabeled'.
@@ -1445,33 +1099,10 @@ func (g *EventHandler) handlePullRequestEventUnlabeled(ctx context.Context, deli
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestEventUnlabeledAction,
-		PullRequestEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestEvent[action]; ok {
-			for _, h := range g.onPullRequestEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestEvent[PullRequestEventUnlabeledAction],
+		g.onPullRequestEvent[PullRequestEventAnyAction],
+	)
 }
 
 // OnPullRequestEventUnlocked registers callbacks listening to events of type github.PullRequestEvent and action 'unlocked'.
@@ -1531,33 +1162,10 @@ func (g *EventHandler) handlePullRequestEventUnlocked(ctx context.Context, deliv
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestEventUnlockedAction,
-		PullRequestEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestEvent[action]; ok {
-			for _, h := range g.onPullRequestEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestEvent[PullRequestEventUnlockedAction],
+		g.onPullRequestEvent[PullRequestEventAnyAction],
+	)
 }
 
 // OnPullRequestEventAny registers callbacks listening to any events of type github.PullRequestEvent
@@ -1610,29 +1218,7 @@ func (g *EventHandler) handlePullRequestEventAny(ctx context.Context, deliveryID
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onPullRequestEvent[PullRequestEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onPullRequestEvent[PullRequestEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestEvent](ctx, deliveryID, eventName, event, g.onPullRequestEvent[PullRequestEventAnyAction])
 }
 
 // PullRequestEvent handles github.PullRequestEvent.
diff --git a/githubevents/events_pull_request_review.go b/githubevents/events_pull_request_review.go
index 613dbf36..6ce0fa4c 100644
--- a/githubevents/events_pull_request_review.go
+++ b/githubevents/events_pull_request_review.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -99,33 +98,10 @@ func (g *EventHandler) handlePullRequestReviewEventSubmitted(ctx context.Context
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestReviewEventSubmittedAction,
-		PullRequestReviewEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestReviewEvent[action]; ok {
-			for _, h := range g.onPullRequestReviewEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestReviewEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestReviewEvent[PullRequestReviewEventSubmittedAction],
+		g.onPullRequestReviewEvent[PullRequestReviewEventAnyAction],
+	)
 }
 
 // OnPullRequestReviewEventEdited registers callbacks listening to events of type github.PullRequestReviewEvent and action 'edited'.
@@ -185,33 +161,10 @@ func (g *EventHandler) handlePullRequestReviewEventEdited(ctx context.Context, d
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestReviewEventEditedAction,
-		PullRequestReviewEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestReviewEvent[action]; ok {
-			for _, h := range g.onPullRequestReviewEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestReviewEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestReviewEvent[PullRequestReviewEventEditedAction],
+		g.onPullRequestReviewEvent[PullRequestReviewEventAnyAction],
+	)
 }
 
 // OnPullRequestReviewEventDismissed registers callbacks listening to events of type github.PullRequestReviewEvent and action 'dismissed'.
@@ -271,33 +224,10 @@ func (g *EventHandler) handlePullRequestReviewEventDismissed(ctx context.Context
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestReviewEventDismissedAction,
-		PullRequestReviewEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestReviewEvent[action]; ok {
-			for _, h := range g.onPullRequestReviewEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestReviewEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestReviewEvent[PullRequestReviewEventDismissedAction],
+		g.onPullRequestReviewEvent[PullRequestReviewEventAnyAction],
+	)
 }
 
 // OnPullRequestReviewEventAny registers callbacks listening to any events of type github.PullRequestReviewEvent
@@ -350,29 +280,7 @@ func (g *EventHandler) handlePullRequestReviewEventAny(ctx context.Context, deli
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onPullRequestReviewEvent[PullRequestReviewEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onPullRequestReviewEvent[PullRequestReviewEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestReviewEvent](ctx, deliveryID, eventName, event, g.onPullRequestReviewEvent[PullRequestReviewEventAnyAction])
 }
 
 // PullRequestReviewEvent handles github.PullRequestReviewEvent.
diff --git a/githubevents/events_pull_request_review_comment.go b/githubevents/events_pull_request_review_comment.go
index 4767dff1..37f95b8b 100644
--- a/githubevents/events_pull_request_review_comment.go
+++ b/githubevents/events_pull_request_review_comment.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -99,33 +98,10 @@ func (g *EventHandler) handlePullRequestReviewCommentEventCreated(ctx context.Co
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestReviewCommentEventCreatedAction,
-		PullRequestReviewCommentEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestReviewCommentEvent[action]; ok {
-			for _, h := range g.onPullRequestReviewCommentEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestReviewCommentEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestReviewCommentEvent[PullRequestReviewCommentEventCreatedAction],
+		g.onPullRequestReviewCommentEvent[PullRequestReviewCommentEventAnyAction],
+	)
 }
 
 // OnPullRequestReviewCommentEventEdited registers callbacks listening to events of type github.PullRequestReviewCommentEvent and action 'edited'.
@@ -185,33 +161,10 @@ func (g *EventHandler) handlePullRequestReviewCommentEventEdited(ctx context.Con
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestReviewCommentEventEditedAction,
-		PullRequestReviewCommentEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestReviewCommentEvent[action]; ok {
-			for _, h := range g.onPullRequestReviewCommentEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestReviewCommentEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestReviewCommentEvent[PullRequestReviewCommentEventEditedAction],
+		g.onPullRequestReviewCommentEvent[PullRequestReviewCommentEventAnyAction],
+	)
 }
 
 // OnPullRequestReviewCommentEventDeleted registers callbacks listening to events of type github.PullRequestReviewCommentEvent and action 'deleted'.
@@ -271,33 +224,10 @@ func (g *EventHandler) handlePullRequestReviewCommentEventDeleted(ctx context.Co
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		PullRequestReviewCommentEventDeletedAction,
-		PullRequestReviewCommentEventAnyAction,
-	} {
-		if _, ok := g.onPullRequestReviewCommentEvent[action]; ok {
-			for _, h := range g.onPullRequestReviewCommentEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestReviewCommentEvent](ctx, deliveryID, eventName, event,
+		g.onPullRequestReviewCommentEvent[PullRequestReviewCommentEventDeletedAction],
+		g.onPullRequestReviewCommentEvent[PullRequestReviewCommentEventAnyAction],
+	)
 }
 
 // OnPullRequestReviewCommentEventAny registers callbacks listening to any events of type github.PullRequestReviewCommentEvent
@@ -350,29 +280,7 @@ func (g *EventHandler) handlePullRequestReviewCommentEventAny(ctx context.Contex
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onPullRequestReviewCommentEvent[PullRequestReviewCommentEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onPullRequestReviewCommentEvent[PullRequestReviewCommentEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PullRequestReviewCommentEvent](ctx, deliveryID, eventName, event, g.onPullRequestReviewCommentEvent[PullRequestReviewCommentEventAnyAction])
 }
 
 // PullRequestReviewCommentEvent handles github.PullRequestReviewCommentEvent.
diff --git a/githubevents/events_push.go b/githubevents/events_push.go
index 7dec0a0a..c6a9c0db 100644
--- a/githubevents/events_push.go
+++ b/githubevents/events_push.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -80,29 +79,7 @@ func (g *EventHandler) handlePushEventAny(ctx context.Context, deliveryID string
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onPushEvent[PushEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onPushEvent[PushEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.PushEvent](ctx, deliveryID, eventName, event, g.onPushEvent[PushEventAnyAction])
 }
 
 // PushEvent handles github.PushEvent.
diff --git a/githubevents/events_release.go b/githubevents/events_release.go
index 6fe0037b..7355f534 100644
--- a/githubevents/events_release.go
+++ b/githubevents/events_release.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -115,33 +114,10 @@ func (g *EventHandler) handleReleaseEventPublished(ctx context.Context, delivery
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		ReleaseEventPublishedAction,
-		ReleaseEventAnyAction,
-	} {
-		if _, ok := g.onReleaseEvent[action]; ok {
-			for _, h := range g.onReleaseEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ReleaseEvent](ctx, deliveryID, eventName, event,
+		g.onReleaseEvent[ReleaseEventPublishedAction],
+		g.onReleaseEvent[ReleaseEventAnyAction],
+	)
 }
 
 // OnReleaseEventUnpublished registers callbacks listening to events of type github.ReleaseEvent and action 'unpublished'.
@@ -201,33 +177,10 @@ func (g *EventHandler) handleReleaseEventUnpublished(ctx context.Context, delive
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		ReleaseEventUnpublishedAction,
-		ReleaseEventAnyAction,
-	} {
-		if _, ok := g.onReleaseEvent[action]; ok {
-			for _, h := range g.onReleaseEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ReleaseEvent](ctx, deliveryID, eventName, event,
+		g.onReleaseEvent[ReleaseEventUnpublishedAction],
+		g.onReleaseEvent[ReleaseEventAnyAction],
+	)
 }
 
 // OnReleaseEventCreated registers callbacks listening to events of type github.ReleaseEvent and action 'created'.
@@ -287,33 +240,10 @@ func (g *EventHandler) handleReleaseEventCreated(ctx context.Context, deliveryID
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		ReleaseEventCreatedAction,
-		ReleaseEventAnyAction,
-	} {
-		if _, ok := g.onReleaseEvent[action]; ok {
-			for _, h := range g.onReleaseEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ReleaseEvent](ctx, deliveryID, eventName, event,
+		g.onReleaseEvent[ReleaseEventCreatedAction],
+		g.onReleaseEvent[ReleaseEventAnyAction],
+	)
 }
 
 // OnReleaseEventEdited registers callbacks listening to events of type github.ReleaseEvent and action 'edited'.
@@ -373,33 +303,10 @@ func (g *EventHandler) handleReleaseEventEdited(ctx context.Context, deliveryID
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		ReleaseEventEditedAction,
-		ReleaseEventAnyAction,
-	} {
-		if _, ok := g.onReleaseEvent[action]; ok {
-			for _, h := range g.onReleaseEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ReleaseEvent](ctx, deliveryID, eventName, event,
+		g.onReleaseEvent[ReleaseEventEditedAction],
+		g.onReleaseEvent[ReleaseEventAnyAction],
+	)
 }
 
 // OnReleaseEventDeleted registers callbacks listening to events of type github.ReleaseEvent and action 'deleted'.
@@ -459,33 +366,10 @@ func (g *EventHandler) handleReleaseEventDeleted(ctx context.Context, deliveryID
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		ReleaseEventDeletedAction,
-		ReleaseEventAnyAction,
-	} {
-		if _, ok := g.onReleaseEvent[action]; ok {
-			for _, h := range g.onReleaseEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ReleaseEvent](ctx, deliveryID, eventName, event,
+		g.onReleaseEvent[ReleaseEventDeletedAction],
+		g.onReleaseEvent[ReleaseEventAnyAction],
+	)
 }
 
 // OnReleaseEventPreReleased registers callbacks listening to events of type github.ReleaseEvent and action 'prereleased'.
@@ -545,33 +429,10 @@ func (g *EventHandler) handleReleaseEventPreReleased(ctx context.Context, delive
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		ReleaseEventPreReleasedAction,
-		ReleaseEventAnyAction,
-	} {
-		if _, ok := g.onReleaseEvent[action]; ok {
-			for _, h := range g.onReleaseEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ReleaseEvent](ctx, deliveryID, eventName, event,
+		g.onReleaseEvent[ReleaseEventPreReleasedAction],
+		g.onReleaseEvent[ReleaseEventAnyAction],
+	)
 }
 
 // OnReleaseEventReleased registers callbacks listening to events of type github.ReleaseEvent and action 'released'.
@@ -631,33 +492,10 @@ func (g *EventHandler) handleReleaseEventReleased(ctx context.Context, deliveryI
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		ReleaseEventReleasedAction,
-		ReleaseEventAnyAction,
-	} {
-		if _, ok := g.onReleaseEvent[action]; ok {
-			for _, h := range g.onReleaseEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ReleaseEvent](ctx, deliveryID, eventName, event,
+		g.onReleaseEvent[ReleaseEventReleasedAction],
+		g.onReleaseEvent[ReleaseEventAnyAction],
+	)
 }
 
 // OnReleaseEventAny registers callbacks listening to any events of type github.ReleaseEvent
@@ -710,29 +548,7 @@ func (g *EventHandler) handleReleaseEventAny(ctx context.Context, deliveryID str
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onReleaseEvent[ReleaseEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onReleaseEvent[ReleaseEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.ReleaseEvent](ctx, deliveryID, eventName, event, g.onReleaseEvent[ReleaseEventAnyAction])
 }
 
 // ReleaseEvent handles github.ReleaseEvent.
diff --git a/githubevents/events_repository.go b/githubevents/events_repository.go
index f7f3d9af..5bb2c3ed 100644
--- a/githubevents/events_repository.go
+++ b/githubevents/events_repository.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -123,33 +122,10 @@ func (g *EventHandler) handleRepositoryEventCreated(ctx context.Context, deliver
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		RepositoryEventCreatedAction,
-		RepositoryEventAnyAction,
-	} {
-		if _, ok := g.onRepositoryEvent[action]; ok {
-			for _, h := range g.onRepositoryEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.RepositoryEvent](ctx, deliveryID, eventName, event,
+		g.onRepositoryEvent[RepositoryEventCreatedAction],
+		g.onRepositoryEvent[RepositoryEventAnyAction],
+	)
 }
 
 // OnRepositoryEventDeleted registers callbacks listening to events of type github.RepositoryEvent and action 'deleted'.
@@ -209,33 +185,10 @@ func (g *EventHandler) handleRepositoryEventDeleted(ctx context.Context, deliver
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		RepositoryEventDeletedAction,
-		RepositoryEventAnyAction,
-	} {
-		if _, ok := g.onRepositoryEvent[action]; ok {
-			for _, h := range g.onRepositoryEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.RepositoryEvent](ctx, deliveryID, eventName, event,
+		g.onRepositoryEvent[RepositoryEventDeletedAction],
+		g.onRepositoryEvent[RepositoryEventAnyAction],
+	)
 }
 
 // OnRepositoryEventArchived registers callbacks listening to events of type github.RepositoryEvent and action 'archived'.
@@ -295,33 +248,10 @@ func (g *EventHandler) handleRepositoryEventArchived(ctx context.Context, delive
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		RepositoryEventArchivedAction,
-		RepositoryEventAnyAction,
-	} {
-		if _, ok := g.onRepositoryEvent[action]; ok {
-			for _, h := range g.onRepositoryEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.RepositoryEvent](ctx, deliveryID, eventName, event,
+		g.onRepositoryEvent[RepositoryEventArchivedAction],
+		g.onRepositoryEvent[RepositoryEventAnyAction],
+	)
 }
 
 // OnRepositoryEventUnarchived registers callbacks listening to events of type github.RepositoryEvent and action 'unarchived'.
@@ -381,33 +311,10 @@ func (g *EventHandler) handleRepositoryEventUnarchived(ctx context.Context, deli
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		RepositoryEventUnarchivedAction,
-		RepositoryEventAnyAction,
-	} {
-		if _, ok := g.onRepositoryEvent[action]; ok {
-			for _, h := range g.onRepositoryEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.RepositoryEvent](ctx, deliveryID, eventName, event,
+		g.onRepositoryEvent[RepositoryEventUnarchivedAction],
+		g.onRepositoryEvent[RepositoryEventAnyAction],
+	)
 }
 
 // OnRepositoryEventEdited registers callbacks listening to events of type github.RepositoryEvent and action 'edited'.
@@ -467,33 +374,10 @@ func (g *EventHandler) handleRepositoryEventEdited(ctx context.Context, delivery
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		RepositoryEventEditedAction,
-		RepositoryEventAnyAction,
-	} {
-		if _, ok := g.onRepositoryEvent[action]; ok {
-			for _, h := range g.onRepositoryEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.RepositoryEvent](ctx, deliveryID, eventName, event,
+		g.onRepositoryEvent[RepositoryEventEditedAction],
+		g.onRepositoryEvent[RepositoryEventAnyAction],
+	)
 }
 
 // OnRepositoryEventRenamed registers callbacks listening to events of type github.RepositoryEvent and action 'renamed'.
@@ -553,33 +437,10 @@ func (g *EventHandler) handleRepositoryEventRenamed(ctx context.Context, deliver
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		RepositoryEventRenamedAction,
-		RepositoryEventAnyAction,
-	} {
-		if _, ok := g.onRepositoryEvent[action]; ok {
-			for _, h := range g.onRepositoryEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.RepositoryEvent](ctx, deliveryID, eventName, event,
+		g.onRepositoryEvent[RepositoryEventRenamedAction],
+		g.onRepositoryEvent[RepositoryEventAnyAction],
+	)
 }
 
 // OnRepositoryEventTransferred registers callbacks listening to events of type github.RepositoryEvent and action 'transferred'.
@@ -639,33 +500,10 @@ func (g *EventHandler) handleRepositoryEventTransferred(ctx context.Context, del
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		RepositoryEventTransferredAction,
-		RepositoryEventAnyAction,
-	} {
-		if _, ok := g.onRepositoryEvent[action]; ok {
-			for _, h := range g.onRepositoryEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.RepositoryEvent](ctx, deliveryID, eventName, event,
+		g.onRepositoryEvent[RepositoryEventTransferredAction],
+		g.onRepositoryEvent[RepositoryEventAnyAction],
+	)
 }
 
 // OnRepositoryEventPublicized registers callbacks listening to events of type github.RepositoryEvent and action 'publicized'.
@@ -725,33 +563,10 @@ func (g *EventHandler) handleRepositoryEventPublicized(ctx context.Context, deli
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		RepositoryEventPublicizedAction,
-		RepositoryEventAnyAction,
-	} {
-		if _, ok := g.onRepositoryEvent[action]; ok {
-			for _, h := range g.onRepositoryEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.RepositoryEvent](ctx, deliveryID, eventName, event,
+		g.onRepositoryEvent[RepositoryEventPublicizedAction],
+		g.onRepositoryEvent[RepositoryEventAnyAction],
+	)
 }
 
 // OnRepositoryEventPrivatized registers callbacks listening to events of type github.RepositoryEvent and action 'privatized'.
@@ -811,33 +626,10 @@ func (g *EventHandler) handleRepositoryEventPrivatized(ctx context.Context, deli
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		RepositoryEventPrivatizedAction,
-		RepositoryEventAnyAction,
-	} {
-		if _, ok := g.onRepositoryEvent[action]; ok {
-			for _, h := range g.onRepositoryEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.RepositoryEvent](ctx, deliveryID, eventName, event,
+		g.onRepositoryEvent[RepositoryEventPrivatizedAction],
+		g.onRepositoryEvent[RepositoryEventAnyAction],
+	)
 }
 
 // OnRepositoryEventAny registers callbacks listening to any events of type github.RepositoryEvent
@@ -890,29 +682,7 @@ func (g *EventHandler) handleRepositoryEventAny(ctx context.Context, deliveryID
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onRepositoryEvent[RepositoryEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onRepositoryEvent[RepositoryEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.RepositoryEvent](ctx, deliveryID, eventName, event, g.onRepositoryEvent[RepositoryEventAnyAction])
 }
 
 // RepositoryEvent handles github.RepositoryEvent.
diff --git a/githubevents/events_repository_dispatch.go b/githubevents/events_repository_dispatch.go
index 18e9510d..0eba6fd6 100644
--- a/githubevents/events_repository_dispatch.go
+++ b/githubevents/events_repository_dispatch.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -80,29 +79,7 @@ func (g *EventHandler) handleRepositoryDispatchEventAny(ctx context.Context, del
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onRepositoryDispatchEvent[RepositoryDispatchEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onRepositoryDispatchEvent[RepositoryDispatchEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.RepositoryDispatchEvent](ctx, deliveryID, eventName, event, g.onRepositoryDispatchEvent[RepositoryDispatchEventAnyAction])
 }
 
 // RepositoryDispatchEvent handles github.RepositoryDispatchEvent.
diff --git a/githubevents/events_repository_ruleset.go b/githubevents/events_repository_ruleset.go
index 8b05b164..4c75f2cc 100644
--- a/githubevents/events_repository_ruleset.go
+++ b/githubevents/events_repository_ruleset.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -99,33 +98,10 @@ func (g *EventHandler) handleRepositoryRulesetEventCreated(ctx context.Context,
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		RepositoryRulesetEventCreatedAction,
-		RepositoryRulesetEventAnyAction,
-	} {
-		if _, ok := g.onRepositoryRulesetEvent[action]; ok {
-			for _, h := range g.onRepositoryRulesetEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.RepositoryRulesetEvent](ctx, deliveryID, eventName, event,
+		g.onRepositoryRulesetEvent[RepositoryRulesetEventCreatedAction],
+		g.onRepositoryRulesetEvent[RepositoryRulesetEventAnyAction],
+	)
 }
 
 // OnRepositoryRulesetEventDeleted registers callbacks listening to events of type github.RepositoryRulesetEvent and action 'deleted'.
@@ -185,33 +161,10 @@ func (g *EventHandler) handleRepositoryRulesetEventDeleted(ctx context.Context,
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		RepositoryRulesetEventDeletedAction,
-		RepositoryRulesetEventAnyAction,
-	} {
-		if _, ok := g.onRepositoryRulesetEvent[action]; ok {
-			for _, h := range g.onRepositoryRulesetEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.RepositoryRulesetEvent](ctx, deliveryID, eventName, event,
+		g.onRepositoryRulesetEvent[RepositoryRulesetEventDeletedAction],
+		g.onRepositoryRulesetEvent[RepositoryRulesetEventAnyAction],
+	)
 }
 
 // OnRepositoryRulesetEventEdited registers callbacks listening to events of type github.RepositoryRulesetEvent and action 'edited'.
@@ -271,33 +224,10 @@ func (g *EventHandler) handleRepositoryRulesetEventEdited(ctx context.Context, d
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		RepositoryRulesetEventEditedAction,
-		RepositoryRulesetEventAnyAction,
-	} {
-		if _, ok := g.onRepositoryRulesetEvent[action]; ok {
-			for _, h := range g.onRepositoryRulesetEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.RepositoryRulesetEvent](ctx, deliveryID, eventName, event,
+		g.onRepositoryRulesetEvent[RepositoryRulesetEventEditedAction],
+		g.onRepositoryRulesetEvent[RepositoryRulesetEventAnyAction],
+	)
 }
 
 // OnRepositoryRulesetEventAny registers callbacks listening to any events of type github.RepositoryRulesetEvent
@@ -350,29 +280,7 @@ func (g *EventHandler) handleRepositoryRulesetEventAny(ctx context.Context, deli
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onRepositoryRulesetEvent[RepositoryRulesetEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onRepositoryRulesetEvent[RepositoryRulesetEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.RepositoryRulesetEvent](ctx, deliveryID, eventName, event, g.onRepositoryRulesetEvent[RepositoryRulesetEventAnyAction])
 }
 
 // RepositoryRulesetEvent handles github.RepositoryRulesetEvent.
diff --git a/githubevents/events_repository_vulnerability_alert.go b/githubevents/events_repository_vulnerability_alert.go
index eb8510f0..0f7094a2 100644
--- a/githubevents/events_repository_vulnerability_alert.go
+++ b/githubevents/events_repository_vulnerability_alert.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -99,33 +98,10 @@ func (g *EventHandler) handleRepositoryVulnerabilityAlertEventCreate(ctx context
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		RepositoryVulnerabilityAlertEventCreateAction,
-		RepositoryVulnerabilityAlertEventAnyAction,
-	} {
-		if _, ok := g.onRepositoryVulnerabilityAlertEvent[action]; ok {
-			for _, h := range g.onRepositoryVulnerabilityAlertEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.RepositoryVulnerabilityAlertEvent](ctx, deliveryID, eventName, event,
+		g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventCreateAction],
+		g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventAnyAction],
+	)
 }
 
 // OnRepositoryVulnerabilityAlertEventDismiss registers callbacks listening to events of type github.RepositoryVulnerabilityAlertEvent and action 'dismiss'.
@@ -185,33 +161,10 @@ func (g *EventHandler) handleRepositoryVulnerabilityAlertEventDismiss(ctx contex
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		RepositoryVulnerabilityAlertEventDismissAction,
-		RepositoryVulnerabilityAlertEventAnyAction,
-	} {
-		if _, ok := g.onRepositoryVulnerabilityAlertEvent[action]; ok {
-			for _, h := range g.onRepositoryVulnerabilityAlertEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.RepositoryVulnerabilityAlertEvent](ctx, deliveryID, eventName, event,
+		g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventDismissAction],
+		g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventAnyAction],
+	)
 }
 
 // OnRepositoryVulnerabilityAlertEventResolve registers callbacks listening to events of type github.RepositoryVulnerabilityAlertEvent and action 'resolve'.
@@ -271,33 +224,10 @@ func (g *EventHandler) handleRepositoryVulnerabilityAlertEventResolve(ctx contex
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		RepositoryVulnerabilityAlertEventResolveAction,
-		RepositoryVulnerabilityAlertEventAnyAction,
-	} {
-		if _, ok := g.onRepositoryVulnerabilityAlertEvent[action]; ok {
-			for _, h := range g.onRepositoryVulnerabilityAlertEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.RepositoryVulnerabilityAlertEvent](ctx, deliveryID, eventName, event,
+		g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventResolveAction],
+		g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventAnyAction],
+	)
 }
 
 // OnRepositoryVulnerabilityAlertEventAny registers callbacks listening to any events of type github.RepositoryVulnerabilityAlertEvent
@@ -350,29 +280,7 @@ func (g *EventHandler) handleRepositoryVulnerabilityAlertEventAny(ctx context.Co
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.RepositoryVulnerabilityAlertEvent](ctx, deliveryID, eventName, event, g.onRepositoryVulnerabilityAlertEvent[RepositoryVulnerabilityAlertEventAnyAction])
 }
 
 // RepositoryVulnerabilityAlertEvent handles github.RepositoryVulnerabilityAlertEvent.
diff --git a/githubevents/events_star.go b/githubevents/events_star.go
index 940783e8..f987fa16 100644
--- a/githubevents/events_star.go
+++ b/githubevents/events_star.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -95,33 +94,10 @@ func (g *EventHandler) handleStarEventCreated(ctx context.Context, deliveryID st
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		StarEventCreatedAction,
-		StarEventAnyAction,
-	} {
-		if _, ok := g.onStarEvent[action]; ok {
-			for _, h := range g.onStarEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.StarEvent](ctx, deliveryID, eventName, event,
+		g.onStarEvent[StarEventCreatedAction],
+		g.onStarEvent[StarEventAnyAction],
+	)
 }
 
 // OnStarEventDeleted registers callbacks listening to events of type github.StarEvent and action 'deleted'.
@@ -181,33 +157,10 @@ func (g *EventHandler) handleStarEventDeleted(ctx context.Context, deliveryID st
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		StarEventDeletedAction,
-		StarEventAnyAction,
-	} {
-		if _, ok := g.onStarEvent[action]; ok {
-			for _, h := range g.onStarEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.StarEvent](ctx, deliveryID, eventName, event,
+		g.onStarEvent[StarEventDeletedAction],
+		g.onStarEvent[StarEventAnyAction],
+	)
 }
 
 // OnStarEventAny registers callbacks listening to any events of type github.StarEvent
@@ -260,29 +213,7 @@ func (g *EventHandler) handleStarEventAny(ctx context.Context, deliveryID string
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onStarEvent[StarEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onStarEvent[StarEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.StarEvent](ctx, deliveryID, eventName, event, g.onStarEvent[StarEventAnyAction])
 }
 
 // StarEvent handles github.StarEvent.
diff --git a/githubevents/events_status.go b/githubevents/events_status.go
index f2f03ae6..2398aa1f 100644
--- a/githubevents/events_status.go
+++ b/githubevents/events_status.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -80,29 +79,7 @@ func (g *EventHandler) handleStatusEventAny(ctx context.Context, deliveryID stri
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onStatusEvent[StatusEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onStatusEvent[StatusEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.StatusEvent](ctx, deliveryID, eventName, event, g.onStatusEvent[StatusEventAnyAction])
 }
 
 // StatusEvent handles github.StatusEvent.
diff --git a/githubevents/events_team.go b/githubevents/events_team.go
index c4684fae..d557eec0 100644
--- a/githubevents/events_team.go
+++ b/githubevents/events_team.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -107,33 +106,10 @@ func (g *EventHandler) handleTeamEventCreated(ctx context.Context, deliveryID st
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		TeamEventCreatedAction,
-		TeamEventAnyAction,
-	} {
-		if _, ok := g.onTeamEvent[action]; ok {
-			for _, h := range g.onTeamEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.TeamEvent](ctx, deliveryID, eventName, event,
+		g.onTeamEvent[TeamEventCreatedAction],
+		g.onTeamEvent[TeamEventAnyAction],
+	)
 }
 
 // OnTeamEventDeleted registers callbacks listening to events of type github.TeamEvent and action 'deleted'.
@@ -193,33 +169,10 @@ func (g *EventHandler) handleTeamEventDeleted(ctx context.Context, deliveryID st
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		TeamEventDeletedAction,
-		TeamEventAnyAction,
-	} {
-		if _, ok := g.onTeamEvent[action]; ok {
-			for _, h := range g.onTeamEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.TeamEvent](ctx, deliveryID, eventName, event,
+		g.onTeamEvent[TeamEventDeletedAction],
+		g.onTeamEvent[TeamEventAnyAction],
+	)
 }
 
 // OnTeamEventEdited registers callbacks listening to events of type github.TeamEvent and action 'edited'.
@@ -279,33 +232,10 @@ func (g *EventHandler) handleTeamEventEdited(ctx context.Context, deliveryID str
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		TeamEventEditedAction,
-		TeamEventAnyAction,
-	} {
-		if _, ok := g.onTeamEvent[action]; ok {
-			for _, h := range g.onTeamEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.TeamEvent](ctx, deliveryID, eventName, event,
+		g.onTeamEvent[TeamEventEditedAction],
+		g.onTeamEvent[TeamEventAnyAction],
+	)
 }
 
 // OnTeamEventAddedToRepository registers callbacks listening to events of type github.TeamEvent and action 'added_to_repository'.
@@ -365,33 +295,10 @@ func (g *EventHandler) handleTeamEventAddedToRepository(ctx context.Context, del
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		TeamEventAddedToRepositoryAction,
-		TeamEventAnyAction,
-	} {
-		if _, ok := g.onTeamEvent[action]; ok {
-			for _, h := range g.onTeamEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.TeamEvent](ctx, deliveryID, eventName, event,
+		g.onTeamEvent[TeamEventAddedToRepositoryAction],
+		g.onTeamEvent[TeamEventAnyAction],
+	)
 }
 
 // OnTeamEventRemovedFromRepository registers callbacks listening to events of type github.TeamEvent and action 'removed_from_repository'.
@@ -451,33 +358,10 @@ func (g *EventHandler) handleTeamEventRemovedFromRepository(ctx context.Context,
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		TeamEventRemovedFromRepositoryAction,
-		TeamEventAnyAction,
-	} {
-		if _, ok := g.onTeamEvent[action]; ok {
-			for _, h := range g.onTeamEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.TeamEvent](ctx, deliveryID, eventName, event,
+		g.onTeamEvent[TeamEventRemovedFromRepositoryAction],
+		g.onTeamEvent[TeamEventAnyAction],
+	)
 }
 
 // OnTeamEventAny registers callbacks listening to any events of type github.TeamEvent
@@ -530,29 +414,7 @@ func (g *EventHandler) handleTeamEventAny(ctx context.Context, deliveryID string
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onTeamEvent[TeamEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onTeamEvent[TeamEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.TeamEvent](ctx, deliveryID, eventName, event, g.onTeamEvent[TeamEventAnyAction])
 }
 
 // TeamEvent handles github.TeamEvent.
diff --git a/githubevents/events_team_add.go b/githubevents/events_team_add.go
index 8b83aeb1..e3e44c45 100644
--- a/githubevents/events_team_add.go
+++ b/githubevents/events_team_add.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -80,29 +79,7 @@ func (g *EventHandler) handleTeamAddEventAny(ctx context.Context, deliveryID str
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onTeamAddEvent[TeamAddEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onTeamAddEvent[TeamAddEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.TeamAddEvent](ctx, deliveryID, eventName, event, g.onTeamAddEvent[TeamAddEventAnyAction])
 }
 
 // TeamAddEvent handles github.TeamAddEvent.
diff --git a/githubevents/events_watch.go b/githubevents/events_watch.go
index e55cd37d..2db391f7 100644
--- a/githubevents/events_watch.go
+++ b/githubevents/events_watch.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -80,29 +79,7 @@ func (g *EventHandler) handleWatchEventAny(ctx context.Context, deliveryID strin
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onWatchEvent[WatchEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onWatchEvent[WatchEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.WatchEvent](ctx, deliveryID, eventName, event, g.onWatchEvent[WatchEventAnyAction])
 }
 
 // WatchEvent handles github.WatchEvent.
diff --git a/githubevents/events_workflow_dispatch.go b/githubevents/events_workflow_dispatch.go
index 7d04729d..0a779eda 100644
--- a/githubevents/events_workflow_dispatch.go
+++ b/githubevents/events_workflow_dispatch.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -80,29 +79,7 @@ func (g *EventHandler) handleWorkflowDispatchEventAny(ctx context.Context, deliv
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onWorkflowDispatchEvent[WorkflowDispatchEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onWorkflowDispatchEvent[WorkflowDispatchEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.WorkflowDispatchEvent](ctx, deliveryID, eventName, event, g.onWorkflowDispatchEvent[WorkflowDispatchEventAnyAction])
 }
 
 // WorkflowDispatchEvent handles github.WorkflowDispatchEvent.
diff --git a/githubevents/events_workflow_job.go b/githubevents/events_workflow_job.go
index 0141c602..23d94b27 100644
--- a/githubevents/events_workflow_job.go
+++ b/githubevents/events_workflow_job.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -99,33 +98,10 @@ func (g *EventHandler) handleWorkflowJobEventQueued(ctx context.Context, deliver
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		WorkflowJobEventQueuedAction,
-		WorkflowJobEventAnyAction,
-	} {
-		if _, ok := g.onWorkflowJobEvent[action]; ok {
-			for _, h := range g.onWorkflowJobEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.WorkflowJobEvent](ctx, deliveryID, eventName, event,
+		g.onWorkflowJobEvent[WorkflowJobEventQueuedAction],
+		g.onWorkflowJobEvent[WorkflowJobEventAnyAction],
+	)
 }
 
 // OnWorkflowJobEventInProgress registers callbacks listening to events of type github.WorkflowJobEvent and action 'in_progress'.
@@ -185,33 +161,10 @@ func (g *EventHandler) handleWorkflowJobEventInProgress(ctx context.Context, del
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		WorkflowJobEventInProgressAction,
-		WorkflowJobEventAnyAction,
-	} {
-		if _, ok := g.onWorkflowJobEvent[action]; ok {
-			for _, h := range g.onWorkflowJobEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.WorkflowJobEvent](ctx, deliveryID, eventName, event,
+		g.onWorkflowJobEvent[WorkflowJobEventInProgressAction],
+		g.onWorkflowJobEvent[WorkflowJobEventAnyAction],
+	)
 }
 
 // OnWorkflowJobEventCompleted registers callbacks listening to events of type github.WorkflowJobEvent and action 'completed'.
@@ -271,33 +224,10 @@ func (g *EventHandler) handleWorkflowJobEventCompleted(ctx context.Context, deli
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		WorkflowJobEventCompletedAction,
-		WorkflowJobEventAnyAction,
-	} {
-		if _, ok := g.onWorkflowJobEvent[action]; ok {
-			for _, h := range g.onWorkflowJobEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.WorkflowJobEvent](ctx, deliveryID, eventName, event,
+		g.onWorkflowJobEvent[WorkflowJobEventCompletedAction],
+		g.onWorkflowJobEvent[WorkflowJobEventAnyAction],
+	)
 }
 
 // OnWorkflowJobEventAny registers callbacks listening to any events of type github.WorkflowJobEvent
@@ -350,29 +280,7 @@ func (g *EventHandler) handleWorkflowJobEventAny(ctx context.Context, deliveryID
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onWorkflowJobEvent[WorkflowJobEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onWorkflowJobEvent[WorkflowJobEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.WorkflowJobEvent](ctx, deliveryID, eventName, event, g.onWorkflowJobEvent[WorkflowJobEventAnyAction])
 }
 
 // WorkflowJobEvent handles github.WorkflowJobEvent.
diff --git a/githubevents/events_workflow_run.go b/githubevents/events_workflow_run.go
index 2610edbb..982ed669 100644
--- a/githubevents/events_workflow_run.go
+++ b/githubevents/events_workflow_run.go
@@ -11,7 +11,6 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/go-github/v89/github"
-	"golang.org/x/sync/errgroup"
 )
 
 // Actions are used to identify registered callbacks.
@@ -95,33 +94,10 @@ func (g *EventHandler) handleWorkflowRunEventRequested(ctx context.Context, deli
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		WorkflowRunEventRequestedAction,
-		WorkflowRunEventAnyAction,
-	} {
-		if _, ok := g.onWorkflowRunEvent[action]; ok {
-			for _, h := range g.onWorkflowRunEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.WorkflowRunEvent](ctx, deliveryID, eventName, event,
+		g.onWorkflowRunEvent[WorkflowRunEventRequestedAction],
+		g.onWorkflowRunEvent[WorkflowRunEventAnyAction],
+	)
 }
 
 // OnWorkflowRunEventCompleted registers callbacks listening to events of type github.WorkflowRunEvent and action 'completed'.
@@ -181,33 +157,10 @@ func (g *EventHandler) handleWorkflowRunEventCompleted(ctx context.Context, deli
 			*event.Action,
 		)
 	}
-	eg := new(errgroup.Group)
-	for _, action := range []string{
-		WorkflowRunEventCompletedAction,
-		WorkflowRunEventAnyAction,
-	} {
-		if _, ok := g.onWorkflowRunEvent[action]; ok {
-			for _, h := range g.onWorkflowRunEvent[action] {
-				handle := h
-				eg.Go(func() (err error) {
-					defer func() {
-						if r := recover(); r != nil {
-							err = fmt.Errorf("recovered from panic: %v", r)
-						}
-					}()
-					err = handle(ctx, deliveryID, eventName, event)
-					if err != nil {
-						return err
-					}
-					return nil
-				})
-			}
-		}
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.WorkflowRunEvent](ctx, deliveryID, eventName, event,
+		g.onWorkflowRunEvent[WorkflowRunEventCompletedAction],
+		g.onWorkflowRunEvent[WorkflowRunEventAnyAction],
+	)
 }
 
 // OnWorkflowRunEventAny registers callbacks listening to any events of type github.WorkflowRunEvent
@@ -260,29 +213,7 @@ func (g *EventHandler) handleWorkflowRunEventAny(ctx context.Context, deliveryID
 	if event == nil {
 		return fmt.Errorf("event was empty or nil")
 	}
-	if _, ok := g.onWorkflowRunEvent[WorkflowRunEventAnyAction]; !ok {
-		return nil
-	}
-	eg := new(errgroup.Group)
-	for _, h := range g.onWorkflowRunEvent[WorkflowRunEventAnyAction] {
-		handle := h
-		eg.Go(func() (err error) {
-			defer func() {
-				if r := recover(); r != nil {
-					err = fmt.Errorf("recovered from panic: %v", r)
-				}
-			}()
-			err = handle(ctx, deliveryID, eventName, event)
-			if err != nil {
-				return err
-			}
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return err
-	}
-	return nil
+	return dispatch[*github.WorkflowRunEvent](ctx, deliveryID, eventName, event, g.onWorkflowRunEvent[WorkflowRunEventAnyAction])
 }
 
 // WorkflowRunEvent handles github.WorkflowRunEvent.