import type { IntegrationAccountRequirement, TriggerDefinition } from "../types"

const GITHUB_ISSUES_ACCOUNT = {
  connectionOptions: [
    {
      requiredScopes: ["issues:read"],
    },
  ],
  serviceId: "github",
} as const satisfies IntegrationAccountRequirement

const GITHUB_PULL_REQUESTS_ACCOUNT = {
  connectionOptions: [
    {
      requiredScopes: ["pull_requests:read"],
    },
  ],
  serviceId: "github",
} as const satisfies IntegrationAccountRequirement

const GITHUB_CONTENTS_ACCOUNT = {
  connectionOptions: [
    {
      requiredScopes: ["contents:read"],
    },
  ],
  serviceId: "github",
} as const satisfies IntegrationAccountRequirement

const GITHUB_ACTIONS_ACCOUNT = {
  connectionOptions: [
    {
      requiredScopes: ["actions:read"],
    },
  ],
  serviceId: "github",
} as const satisfies IntegrationAccountRequirement

const GITHUB_DEPLOYMENTS_ACCOUNT = {
  connectionOptions: [
    {
      requiredScopes: ["deployments:read"],
    },
  ],
  serviceId: "github",
} as const satisfies IntegrationAccountRequirement

const GITHUB_COMMIT_STATUSES_ACCOUNT = {
  connectionOptions: [
    {
      requiredScopes: ["statuses:read"],
    },
  ],
  serviceId: "github",
} as const satisfies IntegrationAccountRequirement

const GITHUB_CHECKS_ACCOUNT = {
  connectionOptions: [
    {
      requiredScopes: ["checks:read"],
    },
  ],
  serviceId: "github",
} as const satisfies IntegrationAccountRequirement

const GITHUB_CHECKS_WRITE_ACCOUNT = {
  connectionOptions: [
    {
      requiredScopes: ["checks:write"],
    },
  ],
  serviceId: "github",
} as const satisfies IntegrationAccountRequirement

const GITHUB_MERGE_QUEUES_ACCOUNT = {
  connectionOptions: [
    {
      requiredScopes: ["merge_queues:read"],
    },
  ],
  serviceId: "github",
} as const satisfies IntegrationAccountRequirement

const GITHUB_METADATA_ACCOUNT = {
  connectionOptions: [
    {
      requiredScopes: ["metadata:read"],
    },
  ],
  serviceId: "github",
} as const satisfies IntegrationAccountRequirement

export const githubTriggerDefinitions = {
  githubCommitCommentCreated: {
    account: GITHUB_CONTENTS_ACCOUNT,
    type: "github.commit-comment.created",
  },
  githubCommitCommentEvent: {
    account: GITHUB_CONTENTS_ACCOUNT,
    type: "github.commit-comment.event",
  },
  githubDeploymentProtectionRuleEvent: {
    account: GITHUB_DEPLOYMENTS_ACCOUNT,
    type: "github.deployment-protection-rule.event",
  },
  githubDeploymentProtectionRuleRequested: {
    account: GITHUB_DEPLOYMENTS_ACCOUNT,
    type: "github.deployment-protection-rule.requested",
  },
  githubDeploymentReviewApproved: {
    account: GITHUB_DEPLOYMENTS_ACCOUNT,
    type: "github.deployment-review.approved",
  },
  githubDeploymentReviewEvent: {
    account: GITHUB_DEPLOYMENTS_ACCOUNT,
    type: "github.deployment-review.event",
  },
  githubDeploymentReviewRejected: {
    account: GITHUB_DEPLOYMENTS_ACCOUNT,
    type: "github.deployment-review.rejected",
  },
  githubDeploymentReviewRequested: {
    account: GITHUB_DEPLOYMENTS_ACCOUNT,
    type: "github.deployment-review.requested",
  },
  githubIssueDependencyBlockedByAdded: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue-dependencies.blocked-by-added",
  },
  githubIssueDependencyBlockedByRemoved: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue-dependencies.blocked-by-removed",
  },
  githubIssueDependencyBlockingAdded: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue-dependencies.blocking-added",
  },
  githubIssueDependencyBlockingRemoved: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue-dependencies.blocking-removed",
  },
  githubIssueDependenciesEvent: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue-dependencies.event",
  },
  githubMergeGroupChecksRequested: {
    account: GITHUB_MERGE_QUEUES_ACCOUNT,
    type: "github.merge-group.checks-requested",
  },
  githubMergeGroupDestroyed: {
    account: GITHUB_MERGE_QUEUES_ACCOUNT,
    type: "github.merge-group.destroyed",
  },
  githubMergeGroupEvent: {
    account: GITHUB_MERGE_QUEUES_ACCOUNT,
    type: "github.merge-group.event",
  },
  githubParentIssueAdded: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.parent-issue.added",
  },
  githubParentIssueRemoved: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.parent-issue.removed",
  },
  githubPullRequestReviewThreadEvent: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request-review-thread.event",
  },
  githubPullRequestReviewThreadResolved: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request-review-thread.resolved",
  },
  githubPullRequestReviewThreadUnresolved: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request-review-thread.unresolved",
  },
  githubRepositoryArchived: {
    account: GITHUB_METADATA_ACCOUNT,
    type: "github.repository.archived",
  },
  githubRepositoryCreated: {
    account: GITHUB_METADATA_ACCOUNT,
    type: "github.repository.created",
  },
  githubRepositoryDeleted: {
    account: GITHUB_METADATA_ACCOUNT,
    type: "github.repository.deleted",
  },
  githubRepositoryEdited: {
    account: GITHUB_METADATA_ACCOUNT,
    type: "github.repository.edited",
  },
  githubRepositoryEvent: {
    account: GITHUB_METADATA_ACCOUNT,
    type: "github.repository.event",
  },
  githubRepositoryPrivatized: {
    account: GITHUB_METADATA_ACCOUNT,
    type: "github.repository.privatized",
  },
  githubRepositoryPublicized: {
    account: GITHUB_METADATA_ACCOUNT,
    type: "github.repository.publicized",
  },
  githubRepositoryRenamed: {
    account: GITHUB_METADATA_ACCOUNT,
    type: "github.repository.renamed",
  },
  githubRepositoryTransferred: {
    account: GITHUB_METADATA_ACCOUNT,
    type: "github.repository.transferred",
  },
  githubRepositoryUnarchived: {
    account: GITHUB_METADATA_ACCOUNT,
    type: "github.repository.unarchived",
  },
  githubSubIssueAdded: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.sub-issue.added",
  },
  githubSubIssueRemoved: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.sub-issue.removed",
  },
  githubSubIssuesEvent: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.sub-issues.event",
  },
  githubBranchCreated: {
    account: GITHUB_CONTENTS_ACCOUNT,
    type: "github.branch.created",
  },
  githubBranchDeleted: {
    account: GITHUB_CONTENTS_ACCOUNT,
    type: "github.branch.deleted",
  },
  githubCheckRunActionRequired: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-run.action-required",
  },
  githubCheckRunCancelled: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-run.cancelled",
  },
  githubCheckRunCompleted: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-run.completed",
  },
  githubCheckRunCreated: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-run.created",
  },
  githubCheckRunEvent: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-run.event",
  },
  githubCheckRunFailed: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-run.failed",
  },
  githubCheckRunNeutral: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-run.neutral",
  },
  githubCheckRunPending: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-run.pending",
  },
  githubCheckRunRerequested: {
    account: GITHUB_CHECKS_WRITE_ACCOUNT,
    type: "github.check-run.rerequested",
  },
  githubCheckRunRequestedAction: {
    account: GITHUB_CHECKS_WRITE_ACCOUNT,
    type: "github.check-run.requested-action",
  },
  githubCheckRunSkipped: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-run.skipped",
  },
  githubCheckRunStale: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-run.stale",
  },
  githubCheckRunSucceeded: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-run.succeeded",
  },
  githubCheckRunStartupFailed: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-run.startup-failed",
  },
  githubCheckRunTimedOut: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-run.timed-out",
  },
  githubCheckRunWaiting: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-run.waiting",
  },
  githubCheckSuiteActionRequired: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-suite.action-required",
  },
  githubCheckSuiteCancelled: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-suite.cancelled",
  },
  githubCheckSuiteCompleted: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-suite.completed",
  },
  githubCheckSuiteEvent: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-suite.event",
  },
  githubCheckSuiteFailed: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-suite.failed",
  },
  githubCheckSuiteNeutral: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-suite.neutral",
  },
  githubCheckSuiteRerequested: {
    account: GITHUB_CHECKS_WRITE_ACCOUNT,
    type: "github.check-suite.rerequested",
  },
  githubCheckSuiteRequested: {
    account: GITHUB_CHECKS_WRITE_ACCOUNT,
    type: "github.check-suite.requested",
  },
  githubCheckSuiteSkipped: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-suite.skipped",
  },
  githubCheckSuiteStale: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-suite.stale",
  },
  githubCheckSuiteSucceeded: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-suite.succeeded",
  },
  githubCheckSuiteStartupFailed: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-suite.startup-failed",
  },
  githubCheckSuiteTimedOut: {
    account: GITHUB_CHECKS_ACCOUNT,
    type: "github.check-suite.timed-out",
  },
  githubDeploymentCreated: {
    account: GITHUB_DEPLOYMENTS_ACCOUNT,
    type: "github.deployment.created",
  },
  githubDeploymentStatusErrored: {
    account: GITHUB_DEPLOYMENTS_ACCOUNT,
    type: "github.deployment-status.errored",
  },
  githubDeploymentStatusEvent: {
    account: GITHUB_DEPLOYMENTS_ACCOUNT,
    type: "github.deployment-status.event",
  },
  githubDeploymentStatusFailed: {
    account: GITHUB_DEPLOYMENTS_ACCOUNT,
    type: "github.deployment-status.failed",
  },
  githubDeploymentStatusPending: {
    account: GITHUB_DEPLOYMENTS_ACCOUNT,
    type: "github.deployment-status.pending",
  },
  githubDeploymentStatusQueued: {
    account: GITHUB_DEPLOYMENTS_ACCOUNT,
    type: "github.deployment-status.queued",
  },
  githubDeploymentStatusStarted: {
    account: GITHUB_DEPLOYMENTS_ACCOUNT,
    type: "github.deployment-status.started",
  },
  githubDeploymentStatusSucceeded: {
    account: GITHUB_DEPLOYMENTS_ACCOUNT,
    type: "github.deployment-status.succeeded",
  },
  githubIssueCommentCreated: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue-comment.created",
  },
  githubIssueCommentDeleted: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue-comment.deleted",
  },
  githubIssueCommentEdited: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue-comment.edited",
  },
  githubIssueCommentEvent: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue-comment.event",
  },
  githubIssueCommentPinned: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue-comment.pinned",
  },
  githubIssueCommentUnpinned: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue-comment.unpinned",
  },
  githubIssueAssigned: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.assigned",
  },
  githubIssueClosed: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.closed",
  },
  githubIssueDeleted: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.deleted",
  },
  githubIssueDemilestoned: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.demilestoned",
  },
  githubIssueEdited: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.edited",
  },
  githubIssueEvent: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.event",
  },
  githubIssueFieldAdded: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.field-added",
  },
  githubIssueFieldRemoved: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.field-removed",
  },
  githubIssueLabeled: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.labeled",
  },
  githubIssueLocked: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.locked",
  },
  githubIssueMilestoned: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.milestoned",
  },
  githubIssueOpened: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.opened",
  },
  githubIssuePinned: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.pinned",
  },
  githubIssueReopened: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.reopened",
  },
  githubIssueTransferred: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.transferred",
  },
  githubIssueTyped: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.typed",
  },
  githubIssueUnassigned: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.unassigned",
  },
  githubIssueUnlabeled: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.unlabeled",
  },
  githubIssueUnlocked: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.unlocked",
  },
  githubIssueUnpinned: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.unpinned",
  },
  githubIssueUntyped: {
    account: GITHUB_ISSUES_ACCOUNT,
    type: "github.issue.untyped",
  },
  githubPullRequestAssigned: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.assigned",
  },
  githubPullRequestAutoMergeDisabled: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.auto-merge-disabled",
  },
  githubPullRequestAutoMergeEnabled: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.auto-merge-enabled",
  },
  githubPullRequestClosed: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.closed",
  },
  githubPullRequestConvertedToDraft: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.converted-to-draft",
  },
  githubPullRequestDemilestoned: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.demilestoned",
  },
  githubPullRequestDequeued: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.dequeued",
  },
  githubPullRequestEdited: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.edited",
  },
  githubPullRequestEnqueued: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.enqueued",
  },
  githubPullRequestEvent: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.event",
  },
  githubPullRequestMerged: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.merged",
  },
  githubPullRequestLabeled: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.labeled",
  },
  githubPullRequestLocked: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.locked",
  },
  githubPullRequestMilestoned: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.milestoned",
  },
  githubPullRequestOpened: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.opened",
  },
  githubPullRequestReadyForReview: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.ready-for-review",
  },
  githubPullRequestReopened: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.reopened",
  },
  githubPullRequestReviewRequestRemoved: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.review-request-removed",
  },
  githubPullRequestReviewRequested: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.review-requested",
  },
  githubPullRequestStacked: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.stacked",
  },
  githubPullRequestReviewApproved: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request-review.approved",
  },
  githubPullRequestReviewChangesRequested: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    name: "GitHub pull request changes requested",
    type: "github.pull-request-review.changes-requested",
  },
  githubPullRequestReviewDismissed: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request-review.dismissed",
  },
  githubPullRequestReviewEdited: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request-review.edited",
  },
  githubPullRequestReviewEvent: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request-review.event",
  },
  githubPullRequestReviewSubmitted: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request-review.submitted",
  },
  githubPullRequestReviewCommentCreated: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request-review-comment.created",
  },
  githubPullRequestReviewCommentDeleted: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request-review-comment.deleted",
  },
  githubPullRequestReviewCommentEdited: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request-review-comment.edited",
  },
  githubPullRequestReviewCommentEvent: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request-review-comment.event",
  },
  githubPullRequestSynchronized: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.synchronized",
  },
  githubPullRequestUnassigned: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.unassigned",
  },
  githubPullRequestUnlabeled: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.unlabeled",
  },
  githubPullRequestUnlocked: {
    account: GITHUB_PULL_REQUESTS_ACCOUNT,
    type: "github.pull-request.unlocked",
  },
  githubPush: {
    account: GITHUB_CONTENTS_ACCOUNT,
    type: "github.push",
  },
  githubReleaseCreated: {
    account: GITHUB_CONTENTS_ACCOUNT,
    type: "github.release.created",
  },
  githubReleaseDeleted: {
    account: GITHUB_CONTENTS_ACCOUNT,
    type: "github.release.deleted",
  },
  githubReleaseEdited: {
    account: GITHUB_CONTENTS_ACCOUNT,
    type: "github.release.edited",
  },
  githubReleaseEvent: {
    account: GITHUB_CONTENTS_ACCOUNT,
    type: "github.release.event",
  },
  githubReleasePrereleased: {
    account: GITHUB_CONTENTS_ACCOUNT,
    type: "github.release.prereleased",
  },
  githubReleasePublished: {
    account: GITHUB_CONTENTS_ACCOUNT,
    type: "github.release.published",
  },
  githubReleaseReleased: {
    account: GITHUB_CONTENTS_ACCOUNT,
    type: "github.release.released",
  },
  githubReleaseUnpublished: {
    account: GITHUB_CONTENTS_ACCOUNT,
    type: "github.release.unpublished",
  },
  githubRefCreated: {
    account: GITHUB_CONTENTS_ACCOUNT,
    type: "github.ref.created",
  },
  githubRefDeleted: {
    account: GITHUB_CONTENTS_ACCOUNT,
    type: "github.ref.deleted",
  },
  githubRepositoryDispatch: {
    account: GITHUB_CONTENTS_ACCOUNT,
    type: "github.repository-dispatch",
  },
  githubStatusErrored: {
    account: GITHUB_COMMIT_STATUSES_ACCOUNT,
    type: "github.status.errored",
  },
  githubStatusEvent: {
    account: GITHUB_COMMIT_STATUSES_ACCOUNT,
    type: "github.status.event",
  },
  githubStatusFailed: {
    account: GITHUB_COMMIT_STATUSES_ACCOUNT,
    type: "github.status.failed",
  },
  githubStatusPending: {
    account: GITHUB_COMMIT_STATUSES_ACCOUNT,
    type: "github.status.pending",
  },
  githubStatusSucceeded: {
    account: GITHUB_COMMIT_STATUSES_ACCOUNT,
    type: "github.status.succeeded",
  },
  githubTagCreated: {
    account: GITHUB_CONTENTS_ACCOUNT,
    type: "github.tag.created",
  },
  githubTagDeleted: {
    account: GITHUB_CONTENTS_ACCOUNT,
    type: "github.tag.deleted",
  },
  githubWorkflowDispatch: {
    account: GITHUB_CONTENTS_ACCOUNT,
    type: "github.workflow-dispatch",
  },
  githubWorkflowJobActionRequired: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-job.action-required",
  },
  githubWorkflowJobCancelled: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-job.cancelled",
  },
  githubWorkflowJobCompleted: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-job.completed",
  },
  githubWorkflowJobEvent: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-job.event",
  },
  githubWorkflowJobFailed: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-job.failed",
  },
  githubWorkflowJobNeutral: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-job.neutral",
  },
  githubWorkflowJobQueued: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-job.queued",
  },
  githubWorkflowJobSkipped: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-job.skipped",
  },
  githubWorkflowJobStarted: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-job.started",
  },
  githubWorkflowJobSucceeded: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-job.succeeded",
  },
  githubWorkflowJobTimedOut: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-job.timed-out",
  },
  githubWorkflowJobWaiting: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-job.waiting",
  },
  githubWorkflowRunActionRequired: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-run.action-required",
  },
  githubWorkflowRunCancelled: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-run.cancelled",
  },
  githubWorkflowRunCompleted: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-run.completed",
  },
  githubWorkflowRunEvent: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-run.event",
  },
  githubWorkflowRunFailed: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-run.failed",
  },
  githubWorkflowRunNeutral: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-run.neutral",
  },
  githubWorkflowRunRequested: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-run.requested",
  },
  githubWorkflowRunSkipped: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-run.skipped",
  },
  githubWorkflowRunStale: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-run.stale",
  },
  githubWorkflowRunStarted: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-run.started",
  },
  githubWorkflowRunStartupFailed: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-run.startup-failed",
  },
  githubWorkflowRunSucceeded: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-run.succeeded",
  },
  githubWorkflowRunTimedOut: {
    account: GITHUB_ACTIONS_ACCOUNT,
    type: "github.workflow-run.timed-out",
  },
} as const satisfies Record<string, TriggerDefinition>