github-webhook-schemas 0.2.4 → 1.1.0

package/dist/registry.d.ts

@@ -0,0 +1,763 @@
+/**
+ * Auto-generated webhook event schema registry
+ * DO NOT MODIFY - regenerate with: bun run scripts/generate-registry.ts
+ */
+import type { WebhookEvent, WebhookEventMap, WebhookEventName, WebhookEvents } from '@octokit/webhooks-types';
+import { z } from 'zod';
+export type { WebhookEvent, WebhookEventMap, WebhookEventName, WebhookEvents };
+interface WebhookRouteKeyEventMap {
+    branchProtectionConfiguration: WebhookEventMap['branch_protection_configuration'];
+    branchProtectionConfigurationDisabled: Extract<WebhookEventMap['branch_protection_configuration'], {
+        action: 'disabled';
+    }>;
+    branchProtectionConfigurationEnabled: Extract<WebhookEventMap['branch_protection_configuration'], {
+        action: 'enabled';
+    }>;
+    branchProtectionRule: WebhookEventMap['branch_protection_rule'];
+    branchProtectionRuleCreated: Extract<WebhookEventMap['branch_protection_rule'], {
+        action: 'created';
+    }>;
+    branchProtectionRuleDeleted: Extract<WebhookEventMap['branch_protection_rule'], {
+        action: 'deleted';
+    }>;
+    branchProtectionRuleEdited: Extract<WebhookEventMap['branch_protection_rule'], {
+        action: 'edited';
+    }>;
+    checkRun: WebhookEventMap['check_run'];
+    checkRunCompleted: Extract<WebhookEventMap['check_run'], {
+        action: 'completed';
+    }>;
+    checkRunCreated: Extract<WebhookEventMap['check_run'], {
+        action: 'created';
+    }>;
+    checkRunRequestedAction: Extract<WebhookEventMap['check_run'], {
+        action: 'requested_action';
+    }>;
+    checkRunRerequested: Extract<WebhookEventMap['check_run'], {
+        action: 'rerequested';
+    }>;
+    checkSuite: WebhookEventMap['check_suite'];
+    checkSuiteCompleted: Extract<WebhookEventMap['check_suite'], {
+        action: 'completed';
+    }>;
+    checkSuiteRequested: Extract<WebhookEventMap['check_suite'], {
+        action: 'requested';
+    }>;
+    checkSuiteRerequested: Extract<WebhookEventMap['check_suite'], {
+        action: 'rerequested';
+    }>;
+    codeScanningAlert: WebhookEventMap['code_scanning_alert'];
+    codeScanningAlertAppearedInBranch: Extract<WebhookEventMap['code_scanning_alert'], {
+        action: 'appeared_in_branch';
+    }>;
+    codeScanningAlertClosedByUser: Extract<WebhookEventMap['code_scanning_alert'], {
+        action: 'closed_by_user';
+    }>;
+    codeScanningAlertCreated: Extract<WebhookEventMap['code_scanning_alert'], {
+        action: 'created';
+    }>;
+    codeScanningAlertFixed: Extract<WebhookEventMap['code_scanning_alert'], {
+        action: 'fixed';
+    }>;
+    codeScanningAlertReopened: Extract<WebhookEventMap['code_scanning_alert'], {
+        action: 'reopened';
+    }>;
+    codeScanningAlertReopenedByUser: Extract<WebhookEventMap['code_scanning_alert'], {
+        action: 'reopened_by_user';
+    }>;
+    commitComment: WebhookEventMap['commit_comment'];
+    commitCommentCreated: Extract<WebhookEventMap['commit_comment'], {
+        action: 'created';
+    }>;
+    create: WebhookEventMap['create'];
+    customProperty: WebhookEventMap['custom_property'];
+    customPropertyCreated: Extract<WebhookEventMap['custom_property'], {
+        action: 'created';
+    }>;
+    customPropertyDeleted: Extract<WebhookEventMap['custom_property'], {
+        action: 'deleted';
+    }>;
+    customPropertyPromoteToEnterprise: Extract<WebhookEventMap['custom_property'], {
+        action: 'promote_to_enterprise';
+    }>;
+    customPropertyUpdated: Extract<WebhookEventMap['custom_property'], {
+        action: 'updated';
+    }>;
+    customPropertyValues: WebhookEventMap['custom_property_values'];
+    customPropertyValuesUpdated: Extract<WebhookEventMap['custom_property_values'], {
+        action: 'updated';
+    }>;
+    delete: WebhookEventMap['delete'];
+    dependabotAlert: WebhookEventMap['dependabot_alert'];
+    dependabotAlertAutoDismissed: Extract<WebhookEventMap['dependabot_alert'], {
+        action: 'auto_dismissed';
+    }>;
+    dependabotAlertAutoReopened: Extract<WebhookEventMap['dependabot_alert'], {
+        action: 'auto_reopened';
+    }>;
+    dependabotAlertCreated: Extract<WebhookEventMap['dependabot_alert'], {
+        action: 'created';
+    }>;
+    dependabotAlertDismissed: Extract<WebhookEventMap['dependabot_alert'], {
+        action: 'dismissed';
+    }>;
+    dependabotAlertFixed: Extract<WebhookEventMap['dependabot_alert'], {
+        action: 'fixed';
+    }>;
+    dependabotAlertReintroduced: Extract<WebhookEventMap['dependabot_alert'], {
+        action: 'reintroduced';
+    }>;
+    dependabotAlertReopened: Extract<WebhookEventMap['dependabot_alert'], {
+        action: 'reopened';
+    }>;
+    deployKey: WebhookEventMap['deploy_key'];
+    deployKeyCreated: Extract<WebhookEventMap['deploy_key'], {
+        action: 'created';
+    }>;
+    deployKeyDeleted: Extract<WebhookEventMap['deploy_key'], {
+        action: 'deleted';
+    }>;
+    deployment: WebhookEventMap['deployment'];
+    deploymentCreated: Extract<WebhookEventMap['deployment'], {
+        action: 'created';
+    }>;
+    deploymentProtectionRule: WebhookEventMap['deployment_protection_rule'];
+    deploymentProtectionRuleRequested: Extract<WebhookEventMap['deployment_protection_rule'], {
+        action: 'requested';
+    }>;
+    deploymentReview: WebhookEventMap['deployment_review'];
+    deploymentReviewApproved: Extract<WebhookEventMap['deployment_review'], {
+        action: 'approved';
+    }>;
+    deploymentReviewRejected: Extract<WebhookEventMap['deployment_review'], {
+        action: 'rejected';
+    }>;
+    deploymentReviewRequested: Extract<WebhookEventMap['deployment_review'], {
+        action: 'requested';
+    }>;
+    deploymentStatus: WebhookEventMap['deployment_status'];
+    deploymentStatusCreated: Extract<WebhookEventMap['deployment_status'], {
+        action: 'created';
+    }>;
+    discussion: WebhookEventMap['discussion'];
+    discussionAnswered: Extract<WebhookEventMap['discussion'], {
+        action: 'answered';
+    }>;
+    discussionCategoryChanged: Extract<WebhookEventMap['discussion'], {
+        action: 'category_changed';
+    }>;
+    discussionClosed: Extract<WebhookEventMap['discussion'], {
+        action: 'closed';
+    }>;
+    discussionCreated: Extract<WebhookEventMap['discussion'], {
+        action: 'created';
+    }>;
+    discussionDeleted: Extract<WebhookEventMap['discussion'], {
+        action: 'deleted';
+    }>;
+    discussionEdited: Extract<WebhookEventMap['discussion'], {
+        action: 'edited';
+    }>;
+    discussionLabeled: Extract<WebhookEventMap['discussion'], {
+        action: 'labeled';
+    }>;
+    discussionLocked: Extract<WebhookEventMap['discussion'], {
+        action: 'locked';
+    }>;
+    discussionPinned: Extract<WebhookEventMap['discussion'], {
+        action: 'pinned';
+    }>;
+    discussionReopened: Extract<WebhookEventMap['discussion'], {
+        action: 'reopened';
+    }>;
+    discussionTransferred: Extract<WebhookEventMap['discussion'], {
+        action: 'transferred';
+    }>;
+    discussionUnanswered: Extract<WebhookEventMap['discussion'], {
+        action: 'unanswered';
+    }>;
+    discussionUnlabeled: Extract<WebhookEventMap['discussion'], {
+        action: 'unlabeled';
+    }>;
+    discussionUnlocked: Extract<WebhookEventMap['discussion'], {
+        action: 'unlocked';
+    }>;
+    discussionUnpinned: Extract<WebhookEventMap['discussion'], {
+        action: 'unpinned';
+    }>;
+    discussionComment: WebhookEventMap['discussion_comment'];
+    discussionCommentCreated: Extract<WebhookEventMap['discussion_comment'], {
+        action: 'created';
+    }>;
+    discussionCommentDeleted: Extract<WebhookEventMap['discussion_comment'], {
+        action: 'deleted';
+    }>;
+    discussionCommentEdited: Extract<WebhookEventMap['discussion_comment'], {
+        action: 'edited';
+    }>;
+    fork: WebhookEventMap['fork'];
+    githubAppAuthorization: WebhookEventMap['github_app_authorization'];
+    githubAppAuthorizationRevoked: Extract<WebhookEventMap['github_app_authorization'], {
+        action: 'revoked';
+    }>;
+    gollum: WebhookEventMap['gollum'];
+    installation: WebhookEventMap['installation'];
+    installationCreated: Extract<WebhookEventMap['installation'], {
+        action: 'created';
+    }>;
+    installationDeleted: Extract<WebhookEventMap['installation'], {
+        action: 'deleted';
+    }>;
+    installationNewPermissionsAccepted: Extract<WebhookEventMap['installation'], {
+        action: 'new_permissions_accepted';
+    }>;
+    installationSuspend: Extract<WebhookEventMap['installation'], {
+        action: 'suspend';
+    }>;
+    installationUnsuspend: Extract<WebhookEventMap['installation'], {
+        action: 'unsuspend';
+    }>;
+    installationRepositories: WebhookEventMap['installation_repositories'];
+    installationRepositoriesAdded: Extract<WebhookEventMap['installation_repositories'], {
+        action: 'added';
+    }>;
+    installationRepositoriesRemoved: Extract<WebhookEventMap['installation_repositories'], {
+        action: 'removed';
+    }>;
+    installationTarget: WebhookEventMap['installation_target'];
+    installationTargetRenamed: Extract<WebhookEventMap['installation_target'], {
+        action: 'renamed';
+    }>;
+    issueComment: WebhookEventMap['issue_comment'];
+    issueCommentCreated: Extract<WebhookEventMap['issue_comment'], {
+        action: 'created';
+    }>;
+    issueCommentDeleted: Extract<WebhookEventMap['issue_comment'], {
+        action: 'deleted';
+    }>;
+    issueCommentEdited: Extract<WebhookEventMap['issue_comment'], {
+        action: 'edited';
+    }>;
+    issues: WebhookEventMap['issues'];
+    issuesAssigned: Extract<WebhookEventMap['issues'], {
+        action: 'assigned';
+    }>;
+    issuesClosed: Extract<WebhookEventMap['issues'], {
+        action: 'closed';
+    }>;
+    issuesDeleted: Extract<WebhookEventMap['issues'], {
+        action: 'deleted';
+    }>;
+    issuesDemilestoned: Extract<WebhookEventMap['issues'], {
+        action: 'demilestoned';
+    }>;
+    issuesEdited: Extract<WebhookEventMap['issues'], {
+        action: 'edited';
+    }>;
+    issuesLabeled: Extract<WebhookEventMap['issues'], {
+        action: 'labeled';
+    }>;
+    issuesLocked: Extract<WebhookEventMap['issues'], {
+        action: 'locked';
+    }>;
+    issuesMilestoned: Extract<WebhookEventMap['issues'], {
+        action: 'milestoned';
+    }>;
+    issuesOpened: Extract<WebhookEventMap['issues'], {
+        action: 'opened';
+    }>;
+    issuesPinned: Extract<WebhookEventMap['issues'], {
+        action: 'pinned';
+    }>;
+    issuesReopened: Extract<WebhookEventMap['issues'], {
+        action: 'reopened';
+    }>;
+    issuesTransferred: Extract<WebhookEventMap['issues'], {
+        action: 'transferred';
+    }>;
+    issuesTyped: Extract<WebhookEventMap['issues'], {
+        action: 'typed';
+    }>;
+    issuesUnassigned: Extract<WebhookEventMap['issues'], {
+        action: 'unassigned';
+    }>;
+    issuesUnlabeled: Extract<WebhookEventMap['issues'], {
+        action: 'unlabeled';
+    }>;
+    issuesUnlocked: Extract<WebhookEventMap['issues'], {
+        action: 'unlocked';
+    }>;
+    issuesUnpinned: Extract<WebhookEventMap['issues'], {
+        action: 'unpinned';
+    }>;
+    issuesUntyped: Extract<WebhookEventMap['issues'], {
+        action: 'untyped';
+    }>;
+    label: WebhookEventMap['label'];
+    labelCreated: Extract<WebhookEventMap['label'], {
+        action: 'created';
+    }>;
+    labelDeleted: Extract<WebhookEventMap['label'], {
+        action: 'deleted';
+    }>;
+    labelEdited: Extract<WebhookEventMap['label'], {
+        action: 'edited';
+    }>;
+    marketplacePurchase: WebhookEventMap['marketplace_purchase'];
+    marketplacePurchaseCancelled: Extract<WebhookEventMap['marketplace_purchase'], {
+        action: 'cancelled';
+    }>;
+    marketplacePurchaseChanged: Extract<WebhookEventMap['marketplace_purchase'], {
+        action: 'changed';
+    }>;
+    marketplacePurchasePendingChange: Extract<WebhookEventMap['marketplace_purchase'], {
+        action: 'pending_change';
+    }>;
+    marketplacePurchasePendingChangeCancelled: Extract<WebhookEventMap['marketplace_purchase'], {
+        action: 'pending_change_cancelled';
+    }>;
+    marketplacePurchasePurchased: Extract<WebhookEventMap['marketplace_purchase'], {
+        action: 'purchased';
+    }>;
+    member: WebhookEventMap['member'];
+    memberAdded: Extract<WebhookEventMap['member'], {
+        action: 'added';
+    }>;
+    memberEdited: Extract<WebhookEventMap['member'], {
+        action: 'edited';
+    }>;
+    memberRemoved: Extract<WebhookEventMap['member'], {
+        action: 'removed';
+    }>;
+    membership: WebhookEventMap['membership'];
+    membershipAdded: Extract<WebhookEventMap['membership'], {
+        action: 'added';
+    }>;
+    membershipRemoved: Extract<WebhookEventMap['membership'], {
+        action: 'removed';
+    }>;
+    mergeGroup: WebhookEventMap['merge_group'];
+    mergeGroupChecksRequested: Extract<WebhookEventMap['merge_group'], {
+        action: 'checks_requested';
+    }>;
+    mergeGroupDestroyed: Extract<WebhookEventMap['merge_group'], {
+        action: 'destroyed';
+    }>;
+    meta: WebhookEventMap['meta'];
+    metaDeleted: Extract<WebhookEventMap['meta'], {
+        action: 'deleted';
+    }>;
+    milestone: WebhookEventMap['milestone'];
+    milestoneClosed: Extract<WebhookEventMap['milestone'], {
+        action: 'closed';
+    }>;
+    milestoneCreated: Extract<WebhookEventMap['milestone'], {
+        action: 'created';
+    }>;
+    milestoneDeleted: Extract<WebhookEventMap['milestone'], {
+        action: 'deleted';
+    }>;
+    milestoneEdited: Extract<WebhookEventMap['milestone'], {
+        action: 'edited';
+    }>;
+    milestoneOpened: Extract<WebhookEventMap['milestone'], {
+        action: 'opened';
+    }>;
+    orgBlock: WebhookEventMap['org_block'];
+    orgBlockBlocked: Extract<WebhookEventMap['org_block'], {
+        action: 'blocked';
+    }>;
+    orgBlockUnblocked: Extract<WebhookEventMap['org_block'], {
+        action: 'unblocked';
+    }>;
+    organization: WebhookEventMap['organization'];
+    organizationDeleted: Extract<WebhookEventMap['organization'], {
+        action: 'deleted';
+    }>;
+    organizationMemberAdded: Extract<WebhookEventMap['organization'], {
+        action: 'member_added';
+    }>;
+    organizationMemberInvited: Extract<WebhookEventMap['organization'], {
+        action: 'member_invited';
+    }>;
+    organizationMemberRemoved: Extract<WebhookEventMap['organization'], {
+        action: 'member_removed';
+    }>;
+    organizationRenamed: Extract<WebhookEventMap['organization'], {
+        action: 'renamed';
+    }>;
+    package: WebhookEventMap['package'];
+    packagePublished: Extract<WebhookEventMap['package'], {
+        action: 'published';
+    }>;
+    packageUpdated: Extract<WebhookEventMap['package'], {
+        action: 'updated';
+    }>;
+    pageBuild: WebhookEventMap['page_build'];
+    ping: WebhookEventMap['ping'];
+    project: WebhookEventMap['project'];
+    projectClosed: Extract<WebhookEventMap['project'], {
+        action: 'closed';
+    }>;
+    projectCreated: Extract<WebhookEventMap['project'], {
+        action: 'created';
+    }>;
+    projectDeleted: Extract<WebhookEventMap['project'], {
+        action: 'deleted';
+    }>;
+    projectEdited: Extract<WebhookEventMap['project'], {
+        action: 'edited';
+    }>;
+    projectReopened: Extract<WebhookEventMap['project'], {
+        action: 'reopened';
+    }>;
+    projectCard: WebhookEventMap['project_card'];
+    projectCardConverted: Extract<WebhookEventMap['project_card'], {
+        action: 'converted';
+    }>;
+    projectCardCreated: Extract<WebhookEventMap['project_card'], {
+        action: 'created';
+    }>;
+    projectCardDeleted: Extract<WebhookEventMap['project_card'], {
+        action: 'deleted';
+    }>;
+    projectCardEdited: Extract<WebhookEventMap['project_card'], {
+        action: 'edited';
+    }>;
+    projectCardMoved: Extract<WebhookEventMap['project_card'], {
+        action: 'moved';
+    }>;
+    projectColumn: WebhookEventMap['project_column'];
+    projectColumnCreated: Extract<WebhookEventMap['project_column'], {
+        action: 'created';
+    }>;
+    projectColumnDeleted: Extract<WebhookEventMap['project_column'], {
+        action: 'deleted';
+    }>;
+    projectColumnEdited: Extract<WebhookEventMap['project_column'], {
+        action: 'edited';
+    }>;
+    projectColumnMoved: Extract<WebhookEventMap['project_column'], {
+        action: 'moved';
+    }>;
+    projectsV2Item: WebhookEventMap['projects_v2_item'];
+    projectsV2ItemArchived: Extract<WebhookEventMap['projects_v2_item'], {
+        action: 'archived';
+    }>;
+    projectsV2ItemConverted: Extract<WebhookEventMap['projects_v2_item'], {
+        action: 'converted';
+    }>;
+    projectsV2ItemCreated: Extract<WebhookEventMap['projects_v2_item'], {
+        action: 'created';
+    }>;
+    projectsV2ItemDeleted: Extract<WebhookEventMap['projects_v2_item'], {
+        action: 'deleted';
+    }>;
+    projectsV2ItemEdited: Extract<WebhookEventMap['projects_v2_item'], {
+        action: 'edited';
+    }>;
+    projectsV2ItemReordered: Extract<WebhookEventMap['projects_v2_item'], {
+        action: 'reordered';
+    }>;
+    projectsV2ItemRestored: Extract<WebhookEventMap['projects_v2_item'], {
+        action: 'restored';
+    }>;
+    public: WebhookEventMap['public'];
+    pullRequest: WebhookEventMap['pull_request'];
+    pullRequestAssigned: Extract<WebhookEventMap['pull_request'], {
+        action: 'assigned';
+    }>;
+    pullRequestAutoMergeDisabled: Extract<WebhookEventMap['pull_request'], {
+        action: 'auto_merge_disabled';
+    }>;
+    pullRequestAutoMergeEnabled: Extract<WebhookEventMap['pull_request'], {
+        action: 'auto_merge_enabled';
+    }>;
+    pullRequestClosed: Extract<WebhookEventMap['pull_request'], {
+        action: 'closed';
+    }>;
+    pullRequestConvertedToDraft: Extract<WebhookEventMap['pull_request'], {
+        action: 'converted_to_draft';
+    }>;
+    pullRequestDemilestoned: Extract<WebhookEventMap['pull_request'], {
+        action: 'demilestoned';
+    }>;
+    pullRequestDequeued: Extract<WebhookEventMap['pull_request'], {
+        action: 'dequeued';
+    }>;
+    pullRequestEdited: Extract<WebhookEventMap['pull_request'], {
+        action: 'edited';
+    }>;
+    pullRequestEnqueued: Extract<WebhookEventMap['pull_request'], {
+        action: 'enqueued';
+    }>;
+    pullRequestLabeled: Extract<WebhookEventMap['pull_request'], {
+        action: 'labeled';
+    }>;
+    pullRequestLocked: Extract<WebhookEventMap['pull_request'], {
+        action: 'locked';
+    }>;
+    pullRequestMilestoned: Extract<WebhookEventMap['pull_request'], {
+        action: 'milestoned';
+    }>;
+    pullRequestOpened: Extract<WebhookEventMap['pull_request'], {
+        action: 'opened';
+    }>;
+    pullRequestReadyForReview: Extract<WebhookEventMap['pull_request'], {
+        action: 'ready_for_review';
+    }>;
+    pullRequestReopened: Extract<WebhookEventMap['pull_request'], {
+        action: 'reopened';
+    }>;
+    pullRequestReviewRequestRemoved: Extract<WebhookEventMap['pull_request'], {
+        action: 'review_request_removed';
+    }>;
+    pullRequestReviewRequested: Extract<WebhookEventMap['pull_request'], {
+        action: 'review_requested';
+    }>;
+    pullRequestSynchronize: Extract<WebhookEventMap['pull_request'], {
+        action: 'synchronize';
+    }>;
+    pullRequestUnassigned: Extract<WebhookEventMap['pull_request'], {
+        action: 'unassigned';
+    }>;
+    pullRequestUnlabeled: Extract<WebhookEventMap['pull_request'], {
+        action: 'unlabeled';
+    }>;
+    pullRequestUnlocked: Extract<WebhookEventMap['pull_request'], {
+        action: 'unlocked';
+    }>;
+    pullRequestReview: WebhookEventMap['pull_request_review'];
+    pullRequestReviewDismissed: Extract<WebhookEventMap['pull_request_review'], {
+        action: 'dismissed';
+    }>;
+    pullRequestReviewEdited: Extract<WebhookEventMap['pull_request_review'], {
+        action: 'edited';
+    }>;
+    pullRequestReviewSubmitted: Extract<WebhookEventMap['pull_request_review'], {
+        action: 'submitted';
+    }>;
+    pullRequestReviewComment: WebhookEventMap['pull_request_review_comment'];
+    pullRequestReviewCommentCreated: Extract<WebhookEventMap['pull_request_review_comment'], {
+        action: 'created';
+    }>;
+    pullRequestReviewCommentDeleted: Extract<WebhookEventMap['pull_request_review_comment'], {
+        action: 'deleted';
+    }>;
+    pullRequestReviewCommentEdited: Extract<WebhookEventMap['pull_request_review_comment'], {
+        action: 'edited';
+    }>;
+    pullRequestReviewThread: WebhookEventMap['pull_request_review_thread'];
+    pullRequestReviewThreadResolved: Extract<WebhookEventMap['pull_request_review_thread'], {
+        action: 'resolved';
+    }>;
+    pullRequestReviewThreadUnresolved: Extract<WebhookEventMap['pull_request_review_thread'], {
+        action: 'unresolved';
+    }>;
+    push: WebhookEventMap['push'];
+    registryPackage: WebhookEventMap['registry_package'];
+    registryPackagePublished: Extract<WebhookEventMap['registry_package'], {
+        action: 'published';
+    }>;
+    registryPackageUpdated: Extract<WebhookEventMap['registry_package'], {
+        action: 'updated';
+    }>;
+    release: WebhookEventMap['release'];
+    releaseCreated: Extract<WebhookEventMap['release'], {
+        action: 'created';
+    }>;
+    releaseDeleted: Extract<WebhookEventMap['release'], {
+        action: 'deleted';
+    }>;
+    releaseEdited: Extract<WebhookEventMap['release'], {
+        action: 'edited';
+    }>;
+    releasePrereleased: Extract<WebhookEventMap['release'], {
+        action: 'prereleased';
+    }>;
+    releasePublished: Extract<WebhookEventMap['release'], {
+        action: 'published';
+    }>;
+    releaseReleased: Extract<WebhookEventMap['release'], {
+        action: 'released';
+    }>;
+    releaseUnpublished: Extract<WebhookEventMap['release'], {
+        action: 'unpublished';
+    }>;
+    repository: WebhookEventMap['repository'];
+    repositoryArchived: Extract<WebhookEventMap['repository'], {
+        action: 'archived';
+    }>;
+    repositoryCreated: Extract<WebhookEventMap['repository'], {
+        action: 'created';
+    }>;
+    repositoryDeleted: Extract<WebhookEventMap['repository'], {
+        action: 'deleted';
+    }>;
+    repositoryEdited: Extract<WebhookEventMap['repository'], {
+        action: 'edited';
+    }>;
+    repositoryPrivatized: Extract<WebhookEventMap['repository'], {
+        action: 'privatized';
+    }>;
+    repositoryPublicized: Extract<WebhookEventMap['repository'], {
+        action: 'publicized';
+    }>;
+    repositoryRenamed: Extract<WebhookEventMap['repository'], {
+        action: 'renamed';
+    }>;
+    repositoryTransferred: Extract<WebhookEventMap['repository'], {
+        action: 'transferred';
+    }>;
+    repositoryUnarchived: Extract<WebhookEventMap['repository'], {
+        action: 'unarchived';
+    }>;
+    repositoryDispatch: WebhookEventMap['repository_dispatch'];
+    repositoryDispatchSampleCollected: Extract<WebhookEventMap['repository_dispatch'], {
+        action: 'sample.collected';
+    }>;
+    repositoryImport: WebhookEventMap['repository_import'];
+    repositoryVulnerabilityAlert: WebhookEventMap['repository_vulnerability_alert'];
+    repositoryVulnerabilityAlertCreate: Extract<WebhookEventMap['repository_vulnerability_alert'], {
+        action: 'create';
+    }>;
+    repositoryVulnerabilityAlertDismiss: Extract<WebhookEventMap['repository_vulnerability_alert'], {
+        action: 'dismiss';
+    }>;
+    repositoryVulnerabilityAlertReopen: Extract<WebhookEventMap['repository_vulnerability_alert'], {
+        action: 'reopen';
+    }>;
+    repositoryVulnerabilityAlertResolve: Extract<WebhookEventMap['repository_vulnerability_alert'], {
+        action: 'resolve';
+    }>;
+    secretScanningAlert: WebhookEventMap['secret_scanning_alert'];
+    secretScanningAlertAssigned: Extract<WebhookEventMap['secret_scanning_alert'], {
+        action: 'assigned';
+    }>;
+    secretScanningAlertCreated: Extract<WebhookEventMap['secret_scanning_alert'], {
+        action: 'created';
+    }>;
+    secretScanningAlertPubliclyLeaked: Extract<WebhookEventMap['secret_scanning_alert'], {
+        action: 'publicly_leaked';
+    }>;
+    secretScanningAlertReopened: Extract<WebhookEventMap['secret_scanning_alert'], {
+        action: 'reopened';
+    }>;
+    secretScanningAlertResolved: Extract<WebhookEventMap['secret_scanning_alert'], {
+        action: 'resolved';
+    }>;
+    secretScanningAlertUnassigned: Extract<WebhookEventMap['secret_scanning_alert'], {
+        action: 'unassigned';
+    }>;
+    secretScanningAlertValidated: Extract<WebhookEventMap['secret_scanning_alert'], {
+        action: 'validated';
+    }>;
+    secretScanningAlertLocation: WebhookEventMap['secret_scanning_alert_location'];
+    secretScanningAlertLocationCreated: Extract<WebhookEventMap['secret_scanning_alert_location'], {
+        action: 'created';
+    }>;
+    securityAdvisory: WebhookEventMap['security_advisory'];
+    securityAdvisoryPublished: Extract<WebhookEventMap['security_advisory'], {
+        action: 'published';
+    }>;
+    securityAdvisoryUpdated: Extract<WebhookEventMap['security_advisory'], {
+        action: 'updated';
+    }>;
+    securityAdvisoryWithdrawn: Extract<WebhookEventMap['security_advisory'], {
+        action: 'withdrawn';
+    }>;
+    sponsorship: WebhookEventMap['sponsorship'];
+    sponsorshipCancelled: Extract<WebhookEventMap['sponsorship'], {
+        action: 'cancelled';
+    }>;
+    sponsorshipCreated: Extract<WebhookEventMap['sponsorship'], {
+        action: 'created';
+    }>;
+    sponsorshipEdited: Extract<WebhookEventMap['sponsorship'], {
+        action: 'edited';
+    }>;
+    sponsorshipPendingCancellation: Extract<WebhookEventMap['sponsorship'], {
+        action: 'pending_cancellation';
+    }>;
+    sponsorshipPendingTierChange: Extract<WebhookEventMap['sponsorship'], {
+        action: 'pending_tier_change';
+    }>;
+    sponsorshipTierChanged: Extract<WebhookEventMap['sponsorship'], {
+        action: 'tier_changed';
+    }>;
+    star: WebhookEventMap['star'];
+    starCreated: Extract<WebhookEventMap['star'], {
+        action: 'created';
+    }>;
+    starDeleted: Extract<WebhookEventMap['star'], {
+        action: 'deleted';
+    }>;
+    status: WebhookEventMap['status'];
+    team: WebhookEventMap['team'];
+    teamAddedToRepository: Extract<WebhookEventMap['team'], {
+        action: 'added_to_repository';
+    }>;
+    teamCreated: Extract<WebhookEventMap['team'], {
+        action: 'created';
+    }>;
+    teamDeleted: Extract<WebhookEventMap['team'], {
+        action: 'deleted';
+    }>;
+    teamEdited: Extract<WebhookEventMap['team'], {
+        action: 'edited';
+    }>;
+    teamRemovedFromRepository: Extract<WebhookEventMap['team'], {
+        action: 'removed_from_repository';
+    }>;
+    teamAdd: WebhookEventMap['team_add'];
+    watch: WebhookEventMap['watch'];
+    watchStarted: Extract<WebhookEventMap['watch'], {
+        action: 'started';
+    }>;
+    workflowDispatch: WebhookEventMap['workflow_dispatch'];
+    workflowJob: WebhookEventMap['workflow_job'];
+    workflowJobCompleted: Extract<WebhookEventMap['workflow_job'], {
+        action: 'completed';
+    }>;
+    workflowJobInProgress: Extract<WebhookEventMap['workflow_job'], {
+        action: 'in_progress';
+    }>;
+    workflowJobQueued: Extract<WebhookEventMap['workflow_job'], {
+        action: 'queued';
+    }>;
+    workflowJobWaiting: Extract<WebhookEventMap['workflow_job'], {
+        action: 'waiting';
+    }>;
+    workflowRun: WebhookEventMap['workflow_run'];
+    workflowRunCompleted: Extract<WebhookEventMap['workflow_run'], {
+        action: 'completed';
+    }>;
+    workflowRunInProgress: Extract<WebhookEventMap['workflow_run'], {
+        action: 'in_progress';
+    }>;
+    workflowRunRequested: Extract<WebhookEventMap['workflow_run'], {
+        action: 'requested';
+    }>;
+}
+export type WebhookRouteKey = keyof WebhookRouteKeyEventMap;
+export type WebhookRouteEvent<K extends WebhookRouteKey> = WebhookRouteKeyEventMap[K];
+export type WebhookHandler<K extends WebhookRouteKey> = (event: WebhookRouteEvent<K>) => void | Promise<void>;
+export type WebhookErrorHandler = (error: unknown) => void;
+export interface WebhookRouter {
+    (payload: unknown): void;
+    on<K extends WebhookRouteKey>(event: K, handler: WebhookHandler<K>): WebhookRouter;
+    on(event: 'error', handler: WebhookErrorHandler): WebhookRouter;
+    off<K extends WebhookRouteKey>(event: K, handler: WebhookHandler<K>): WebhookRouter;
+    off(event: 'error', handler: WebhookErrorHandler): WebhookRouter;
+    removeAllListeners(event?: string): WebhookRouter;
+}
+export declare const schemas: {
+    get<EventType extends WebhookEventName>(eventType: EventType): z.ZodType<WebhookEventMap[EventType]>;
+};
+export declare function isWebhookEventName(value: unknown): value is WebhookEventName;
+export declare function isWebhookEvent(value: unknown): value is WebhookEvent;
+export type WebhookRouteHandlers = Partial<{
+    [RouteKey in WebhookRouteKey]: (event: WebhookRouteEvent<RouteKey>) => void | Promise<void>;
+}>;
+export declare function createGithubWebhookRouter(handlers?: WebhookRouteHandlers): WebhookRouter;
+//# sourceMappingURL=registry.d.ts.map