@flink-app/github-app-plugin 2.0.0-alpha.58 → 2.0.0-alpha.60

package/dist/autoRegisteredGitHubHandlers.d.ts

@@ -0,0 +1,6 @@
+import { GitHubEventHandlerFile } from "./types/GitHubEventHandler";
+/**
+ * Populated at compile time by the Flink compiler extension.
+ * Do not modify manually.
+ */
+export declare const autoRegisteredGitHubHandlers: GitHubEventHandlerFile[];

package/dist/autoRegisteredGitHubHandlers.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoRegisteredGitHubHandlers = void 0;
+/**
+ * Populated at compile time by the Flink compiler extension.
+ * Do not modify manually.
+ */
+exports.autoRegisteredGitHubHandlers = [];

package/dist/compiler.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Build-time compiler plugin descriptor for @flink-app/github-app-plugin.
+ *
+ * Import this from flink.config.js — it MUST NOT import from @flink-app/flink
+ * to avoid circular build-time dependencies.
+ *
+ * Usage in flink.config.js:
+ * ```js
+ * const { compilerPlugin } = require("@flink-app/github-app-plugin/compiler");
+ * module.exports = {
+ *   compilerPlugins: [compilerPlugin()],
+ * };
+ * ```
+ */
+interface FlinkCompilerPlugin {
+    package: string;
+    scanDir: string;
+    generatedFile: string;
+    registrationVar: string;
+    detectBy?: (fileContent: string, filePath: string) => boolean;
+}
+export declare function compilerPlugin(opts?: {
+    scanDir?: string;
+}): FlinkCompilerPlugin;
+export {};

package/dist/compiler.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Build-time compiler plugin descriptor for @flink-app/github-app-plugin.
+ *
+ * Import this from flink.config.js — it MUST NOT import from @flink-app/flink
+ * to avoid circular build-time dependencies.
+ *
+ * Usage in flink.config.js:
+ * ```js
+ * const { compilerPlugin } = require("@flink-app/github-app-plugin/compiler");
+ * module.exports = {
+ *   compilerPlugins: [compilerPlugin()],
+ * };
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compilerPlugin = compilerPlugin;
+function compilerPlugin(opts) {
+    return {
+        package: "@flink-app/github-app-plugin",
+        scanDir: opts?.scanDir ?? "src/github-events",
+        generatedFile: "generatedGitHubHandlers",
+        registrationVar: "autoRegisteredGitHubHandlers",
+        detectBy: (fileContent) => fileContent.includes("GitHubEventHandler"),
+    };
+}

package/dist/githubEventRouter.d.ts

@@ -0,0 +1,6 @@
+import { GitHubEventRouteProps } from "./types/GitHubEventHandler";
+/**
+ * Returns true if the webhook event matches the given route criteria.
+ * An empty/undefined Route always matches (catch-all).
+ */
+export declare function matchesRoute(event: string, action: string | undefined, payload: Record<string, any>, installationId: number, route: GitHubEventRouteProps): boolean;

package/dist/githubEventRouter.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesRoute = matchesRoute;
+/**
+ * Returns true if the webhook event matches the given route criteria.
+ * An empty/undefined Route always matches (catch-all).
+ */
+function matchesRoute(event, action, payload, installationId, route) {
+    if (route.event !== undefined) {
+        if (Array.isArray(route.event)) {
+            if (!route.event.includes(event))
+                return false;
+        }
+        else {
+            if (event !== route.event)
+                return false;
+        }
+    }
+    if (route.action !== undefined) {
+        if (action === undefined)
+            return false;
+        if (Array.isArray(route.action)) {
+            if (!route.action.includes(action))
+                return false;
+        }
+        else {
+            if (action !== route.action)
+                return false;
+        }
+    }
+    if (route.repository !== undefined) {
+        const repoFullName = payload.repository?.full_name;
+        if (!repoFullName)
+            return false;
+        if (typeof route.repository === "function") {
+            if (!route.repository(payload))
+                return false;
+        }
+        else if (route.repository instanceof RegExp) {
+            if (!route.repository.test(repoFullName))
+                return false;
+        }
+        else {
+            if (repoFullName !== route.repository)
+                return false;
+        }
+    }
+    if (route.installationId !== undefined) {
+        if (Array.isArray(route.installationId)) {
+            if (!route.installationId.includes(installationId))
+                return false;
+        }
+        else {
+            if (installationId !== route.installationId)
+                return false;
+        }
+    }
+    return true;
+}

package/dist/handlers/WebhookHandler.js

@@ -11,9 +11,35 @@
  *
  * Route: POST /github-app/webhook
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Route = void 0;
+const crypto = __importStar(require("crypto"));
 const flink_1 = require("@flink-app/flink");
+const autoRegisteredGitHubHandlers_1 = require("../autoRegisteredGitHubHandlers");
+const githubEventRouter_1 = require("../githubEventRouter");
 /**
  * Route configuration
  * Registered programmatically by the plugin if registerRoutes is enabled
@@ -136,6 +162,46 @@ const WebhookHandler = async ({ ctx, req }) => {
                 }
             }
         }
+        // Run auto-registered event handlers
+        if (installationId && autoRegisteredGitHubHandlers_1.autoRegisteredGitHubHandlers.length > 0) {
+            try {
+                const github = await ctx.plugins.githubApp.getClient(installationId);
+                for (const h of autoRegisteredGitHubHandlers_1.autoRegisteredGitHubHandlers) {
+                    if (!(0, githubEventRouter_1.matchesRoute)(event, action, payload, installationId, h.Route ?? {}))
+                        continue;
+                    try {
+                        await flink_1.requestContext.run({ reqId: crypto.randomUUID(), timestamp: Date.now() }, () => h.default({
+                            ctx,
+                            event,
+                            action,
+                            payload,
+                            installationId,
+                            deliveryId,
+                            github,
+                        }));
+                    }
+                    catch (error) {
+                        flink_1.log.error("Error in GitHub event handler", {
+                            event,
+                            action,
+                            installationId,
+                            deliveryId,
+                            file: h.__file,
+                            error: error.message,
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                flink_1.log.error("Failed to create GitHub API client for event handlers", {
+                    event,
+                    action,
+                    installationId,
+                    deliveryId,
+                    error: error.message,
+                });
+            }
+        }
         // Return 200 OK to GitHub to acknowledge receipt
         return {
             status: 200,

package/dist/index.d.ts

@@ -17,4 +17,7 @@ export type { default as WebhookPayload } from "./schemas/WebhookPayload";
 export { GitHubAPIClient, type Repository, type Content, type Issue, type CreateIssueParams } from "./services/GitHubAPIClient";
 export { GitHubAuthService } from "./services/GitHubAuthService";
 export { InstallationService, type CompleteInstallationResult } from "./services/InstallationService";
+export * from "./types/GitHubEventHandler";
+export * from "./autoRegisteredGitHubHandlers";
+export * from "./githubEventRouter";
 export { GitHubAppErrorCodes } from "./utils/error-utils";

package/dist/index.js

@@ -8,6 +8,20 @@
  * - Webhook handling with signature validation
  * - API client wrapper
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitHubAppErrorCodes = exports.InstallationService = exports.GitHubAuthService = exports.GitHubAPIClient = exports.githubAppPlugin = void 0;
 // Plugin factory
@@ -20,6 +34,10 @@ var GitHubAuthService_1 = require("./services/GitHubAuthService");
 Object.defineProperty(exports, "GitHubAuthService", { enumerable: true, get: function () { return GitHubAuthService_1.GitHubAuthService; } });
 var InstallationService_1 = require("./services/InstallationService");
 Object.defineProperty(exports, "InstallationService", { enumerable: true, get: function () { return InstallationService_1.InstallationService; } });
+// Event handler types and auto-registration
+__exportStar(require("./types/GitHubEventHandler"), exports);
+__exportStar(require("./autoRegisteredGitHubHandlers"), exports);
+__exportStar(require("./githubEventRouter"), exports);
 // Error utilities
 var error_utils_1 = require("./utils/error-utils");
 Object.defineProperty(exports, "GitHubAppErrorCodes", { enumerable: true, get: function () { return error_utils_1.GitHubAppErrorCodes; } });

package/dist/types/GitHubEventHandler.d.ts

@@ -0,0 +1,28 @@
+import { GitHubAPIClient } from "../services/GitHubAPIClient";
+/** Route matching criteria for a GitHubEventHandler */
+export interface GitHubEventRouteProps {
+    /** Match by event type (e.g. "push", "pull_request") */
+    event?: string | string[];
+    /** Match by action (e.g. "opened", "closed") */
+    action?: string | string[];
+    /** Match by repository full name (e.g. "owner/repo") */
+    repository?: string | RegExp | ((payload: Record<string, any>) => boolean);
+    /** Match by installation ID */
+    installationId?: number | number[];
+}
+/** Handler function type */
+export type GitHubEventHandler<TCtx = any> = (args: {
+    ctx: TCtx;
+    event: string;
+    action?: string;
+    payload: Record<string, any>;
+    installationId: number;
+    deliveryId: string;
+    github: GitHubAPIClient;
+}) => Promise<void>;
+/** Handler file shape (populated by compiler) */
+export interface GitHubEventHandlerFile<TCtx = any> {
+    Route?: GitHubEventRouteProps;
+    default: GitHubEventHandler<TCtx>;
+    __file?: string;
+}

package/dist/types/GitHubEventHandler.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,17 +1,27 @@
 {
   "name": "@flink-app/github-app-plugin",
-  "version": "2.0.0-alpha.58",
+  "version": "2.0.0-alpha.60",
   "description": "Flink plugin for GitHub App integration with installation management and webhook handling",
   "author": "joel@frost.se",
   "license": "MIT",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
+  "exports": {
+    ".": {
+      "default": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./compiler": {
+      "default": "./dist/compiler.js",
+      "types": "./dist/compiler.d.ts"
+    }
+  },
   "publishConfig": {
     "access": "public"
   },
   "peerDependencies": {
     "mongodb": "^6.15.0",
-    "@flink-app/flink": ">=2.0.0-alpha.58"
+    "@flink-app/flink": ">=2.0.0-alpha.60"
   },
   "dependencies": {
     "jsonwebtoken": "^9.0.2"
@@ -23,8 +33,8 @@
     "mongodb-memory-server": "^10.2.3",
     "ts-node": "^10.9.2",
     "tsc-watch": "^4.2.9",
-    "@flink-app/test-utils": "2.0.0-alpha.58",
-    "@flink-app/flink": "2.0.0-alpha.58"
+    "@flink-app/flink": "2.0.0-alpha.60",
+    "@flink-app/test-utils": "2.0.0-alpha.60"
   },
   "gitHead": "4243e3b3cd6d4e1ca001a61baa8436bf2bbe4113",
   "scripts": {

package/spec/githubEventRouter.spec.ts

@@ -0,0 +1,122 @@
+import { matchesRoute } from "../src/githubEventRouter";
+import { GitHubEventRouteProps } from "../src/types/GitHubEventHandler";
+
+describe("githubEventRouter", () => {
+    describe("matchesRoute", () => {
+        const basePayload = {
+            repository: { full_name: "owner/repo" },
+            sender: { login: "user1" },
+        };
+
+        it("should match everything with empty route", () => {
+            expect(matchesRoute("push", undefined, basePayload, 123, {})).toBe(true);
+        });
+
+        // Event matching
+        it("should match by event string", () => {
+            expect(matchesRoute("push", undefined, basePayload, 123, { event: "push" })).toBe(true);
+        });
+
+        it("should not match wrong event string", () => {
+            expect(matchesRoute("push", undefined, basePayload, 123, { event: "pull_request" })).toBe(false);
+        });
+
+        it("should match by event array", () => {
+            expect(matchesRoute("push", undefined, basePayload, 123, { event: ["push", "pull_request"] })).toBe(true);
+        });
+
+        it("should not match event not in array", () => {
+            expect(matchesRoute("issues", undefined, basePayload, 123, { event: ["push", "pull_request"] })).toBe(false);
+        });
+
+        // Action matching
+        it("should match by action string", () => {
+            expect(matchesRoute("pull_request", "opened", basePayload, 123, { action: "opened" })).toBe(true);
+        });
+
+        it("should not match wrong action string", () => {
+            expect(matchesRoute("pull_request", "closed", basePayload, 123, { action: "opened" })).toBe(false);
+        });
+
+        it("should not match when action is undefined but route requires action", () => {
+            expect(matchesRoute("push", undefined, basePayload, 123, { action: "opened" })).toBe(false);
+        });
+
+        it("should match by action array", () => {
+            expect(matchesRoute("pull_request", "closed", basePayload, 123, { action: ["opened", "closed"] })).toBe(true);
+        });
+
+        it("should not match action not in array", () => {
+            expect(matchesRoute("pull_request", "reopened", basePayload, 123, { action: ["opened", "closed"] })).toBe(false);
+        });
+
+        // Repository matching
+        it("should match by repository string", () => {
+            expect(matchesRoute("push", undefined, basePayload, 123, { repository: "owner/repo" })).toBe(true);
+        });
+
+        it("should not match wrong repository string", () => {
+            expect(matchesRoute("push", undefined, basePayload, 123, { repository: "other/repo" })).toBe(false);
+        });
+
+        it("should match by repository regex", () => {
+            expect(matchesRoute("push", undefined, basePayload, 123, { repository: /^owner\// })).toBe(true);
+        });
+
+        it("should not match repository regex that doesn't match", () => {
+            expect(matchesRoute("push", undefined, basePayload, 123, { repository: /^other\// })).toBe(false);
+        });
+
+        it("should match by repository function", () => {
+            const fn = (payload: Record<string, any>) => payload.repository.full_name.startsWith("owner");
+            expect(matchesRoute("push", undefined, basePayload, 123, { repository: fn })).toBe(true);
+        });
+
+        it("should not match repository function returning false", () => {
+            const fn = () => false;
+            expect(matchesRoute("push", undefined, basePayload, 123, { repository: fn })).toBe(false);
+        });
+
+        it("should not match when payload has no repository", () => {
+            expect(matchesRoute("push", undefined, {}, 123, { repository: "owner/repo" })).toBe(false);
+        });
+
+        // InstallationId matching
+        it("should match by installationId number", () => {
+            expect(matchesRoute("push", undefined, basePayload, 123, { installationId: 123 })).toBe(true);
+        });
+
+        it("should not match wrong installationId number", () => {
+            expect(matchesRoute("push", undefined, basePayload, 123, { installationId: 456 })).toBe(false);
+        });
+
+        it("should match by installationId array", () => {
+            expect(matchesRoute("push", undefined, basePayload, 123, { installationId: [123, 456] })).toBe(true);
+        });
+
+        it("should not match installationId not in array", () => {
+            expect(matchesRoute("push", undefined, basePayload, 123, { installationId: [456, 789] })).toBe(false);
+        });
+
+        // Combined criteria (AND logic)
+        it("should match when all criteria match", () => {
+            const route: GitHubEventRouteProps = {
+                event: "pull_request",
+                action: "opened",
+                repository: "owner/repo",
+                installationId: 123,
+            };
+            expect(matchesRoute("pull_request", "opened", basePayload, 123, route)).toBe(true);
+        });
+
+        it("should not match when one criterion fails", () => {
+            const route: GitHubEventRouteProps = {
+                event: "pull_request",
+                action: "opened",
+                repository: "owner/repo",
+                installationId: 456, // wrong
+            };
+            expect(matchesRoute("pull_request", "opened", basePayload, 123, route)).toBe(false);
+        });
+    });
+});

package/src/autoRegisteredGitHubHandlers.ts

@@ -0,0 +1,7 @@
+import { GitHubEventHandlerFile } from "./types/GitHubEventHandler";
+
+/**
+ * Populated at compile time by the Flink compiler extension.
+ * Do not modify manually.
+ */
+export const autoRegisteredGitHubHandlers: GitHubEventHandlerFile[] = [];

package/src/compiler.ts

@@ -0,0 +1,32 @@
+/**
+ * Build-time compiler plugin descriptor for @flink-app/github-app-plugin.
+ *
+ * Import this from flink.config.js — it MUST NOT import from @flink-app/flink
+ * to avoid circular build-time dependencies.
+ *
+ * Usage in flink.config.js:
+ * ```js
+ * const { compilerPlugin } = require("@flink-app/github-app-plugin/compiler");
+ * module.exports = {
+ *   compilerPlugins: [compilerPlugin()],
+ * };
+ * ```
+ */
+
+interface FlinkCompilerPlugin {
+    package: string;
+    scanDir: string;
+    generatedFile: string;
+    registrationVar: string;
+    detectBy?: (fileContent: string, filePath: string) => boolean;
+}
+
+export function compilerPlugin(opts?: { scanDir?: string }): FlinkCompilerPlugin {
+    return {
+        package: "@flink-app/github-app-plugin",
+        scanDir: opts?.scanDir ?? "src/github-events",
+        generatedFile: "generatedGitHubHandlers",
+        registrationVar: "autoRegisteredGitHubHandlers",
+        detectBy: (fileContent) => fileContent.includes("GitHubEventHandler"),
+    };
+}

package/src/githubEventRouter.ts

@@ -0,0 +1,53 @@
+import { GitHubEventRouteProps } from "./types/GitHubEventHandler";
+
+/**
+ * Returns true if the webhook event matches the given route criteria.
+ * An empty/undefined Route always matches (catch-all).
+ */
+export function matchesRoute(
+    event: string,
+    action: string | undefined,
+    payload: Record<string, any>,
+    installationId: number,
+    route: GitHubEventRouteProps
+): boolean {
+    if (route.event !== undefined) {
+        if (Array.isArray(route.event)) {
+            if (!route.event.includes(event)) return false;
+        } else {
+            if (event !== route.event) return false;
+        }
+    }
+
+    if (route.action !== undefined) {
+        if (action === undefined) return false;
+        if (Array.isArray(route.action)) {
+            if (!route.action.includes(action)) return false;
+        } else {
+            if (action !== route.action) return false;
+        }
+    }
+
+    if (route.repository !== undefined) {
+        const repoFullName = payload.repository?.full_name;
+        if (!repoFullName) return false;
+
+        if (typeof route.repository === "function") {
+            if (!route.repository(payload)) return false;
+        } else if (route.repository instanceof RegExp) {
+            if (!route.repository.test(repoFullName)) return false;
+        } else {
+            if (repoFullName !== route.repository) return false;
+        }
+    }
+
+    if (route.installationId !== undefined) {
+        if (Array.isArray(route.installationId)) {
+            if (!route.installationId.includes(installationId)) return false;
+        } else {
+            if (installationId !== route.installationId) return false;
+        }
+    }
+
+    return true;
+}

package/src/handlers/WebhookHandler.ts

@@ -11,8 +11,11 @@
  * Route: POST /github-app/webhook
  */
 
-import { HttpMethod, RouteProps, log } from "@flink-app/flink";
+import * as crypto from "crypto";
+import { HttpMethod, RouteProps, log, requestContext } from "@flink-app/flink";
 import { GitHubAppInternalContext } from "../GitHubAppInternalContext";
+import { autoRegisteredGitHubHandlers } from "../autoRegisteredGitHubHandlers";
+import { matchesRoute } from "../githubEventRouter";
 
 /**
  * Route configuration
@@ -149,6 +152,50 @@ const WebhookHandler = async ({ ctx, req }: { ctx: GitHubAppInternalContext; req
             }
         }
 
+        // Run auto-registered event handlers
+        if (installationId && autoRegisteredGitHubHandlers.length > 0) {
+            try {
+                const github = await ctx.plugins.githubApp.getClient(installationId);
+
+                for (const h of autoRegisteredGitHubHandlers) {
+                    if (!matchesRoute(event, action, payload, installationId, h.Route ?? {})) continue;
+
+                    try {
+                        await requestContext.run(
+                            { reqId: crypto.randomUUID(), timestamp: Date.now() },
+                            () =>
+                                h.default({
+                                    ctx,
+                                    event,
+                                    action,
+                                    payload,
+                                    installationId,
+                                    deliveryId,
+                                    github,
+                                })
+                        );
+                    } catch (error: any) {
+                        log.error("Error in GitHub event handler", {
+                            event,
+                            action,
+                            installationId,
+                            deliveryId,
+                            file: h.__file,
+                            error: error.message,
+                        });
+                    }
+                }
+            } catch (error: any) {
+                log.error("Failed to create GitHub API client for event handlers", {
+                    event,
+                    action,
+                    installationId,
+                    deliveryId,
+                    error: error.message,
+                });
+            }
+        }
+
         // Return 200 OK to GitHub to acknowledge receipt
         return {
             status: 200,

package/src/index.ts

@@ -29,5 +29,10 @@ export { GitHubAPIClient, type Repository, type Content, type Issue, type Create
 export { GitHubAuthService } from "./services/GitHubAuthService";
 export { InstallationService, type CompleteInstallationResult } from "./services/InstallationService";
 
+// Event handler types and auto-registration
+export * from "./types/GitHubEventHandler";
+export * from "./autoRegisteredGitHubHandlers";
+export * from "./githubEventRouter";
+
 // Error utilities
 export { GitHubAppErrorCodes } from "./utils/error-utils";

package/src/types/GitHubEventHandler.ts

@@ -0,0 +1,31 @@
+import { GitHubAPIClient } from "../services/GitHubAPIClient";
+
+/** Route matching criteria for a GitHubEventHandler */
+export interface GitHubEventRouteProps {
+    /** Match by event type (e.g. "push", "pull_request") */
+    event?: string | string[];
+    /** Match by action (e.g. "opened", "closed") */
+    action?: string | string[];
+    /** Match by repository full name (e.g. "owner/repo") */
+    repository?: string | RegExp | ((payload: Record<string, any>) => boolean);
+    /** Match by installation ID */
+    installationId?: number | number[];
+}
+
+/** Handler function type */
+export type GitHubEventHandler<TCtx = any> = (args: {
+    ctx: TCtx;
+    event: string;
+    action?: string;
+    payload: Record<string, any>;
+    installationId: number;
+    deliveryId: string;
+    github: GitHubAPIClient;
+}) => Promise<void>;
+
+/** Handler file shape (populated by compiler) */
+export interface GitHubEventHandlerFile<TCtx = any> {
+    Route?: GitHubEventRouteProps;
+    default: GitHubEventHandler<TCtx>;
+    __file?: string;
+}