/**
 * 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