@relayflows/surface 2.0.16 → 2.0.18

package/src/triggers/README.md

@@ -9,8 +9,25 @@ export default flow('triage')
   .on(github.pull_request('opened'), async (f, event) => { f.done('success'); });
 ```
 
+Every provider a relayfile adapter can deliver has a namespace — 47 today,
+570 events; see [PROVIDERS.md](PROVIDERS.md) (generated) for the full table.
+Hyphenated providers become identifiers: `azure-blob` → `azure_blob`,
+`google-drive` → `google_drive`; the inbox name and event type keep the
+upstream spelling, so `azure_blob.file_created()` lowers to
+`{ provider: 'azure-blob', type: 'file.created' }`. Namespaces come from two
+sources: an adapter's `webhooks:` mapping block, which carries payload shape
+(`github.pull_request(action?)` takes an action because the mapping extracts
+one), and the trigger catalog (`@relayfile/adapter-core/triggers`, every adapter's
+`supportedEvents()`), which is the full set an adapter delivers and yields the
+plain `(filter?)` signature. The two are unioned per provider: a mapping
+covers payload shape for some events, never the whole set (gitlab maps 8 of
+53). Where two upstream names share an identifier (`reaction.added` and
+`reaction_added`), the mapping-declared one owns the method and the other
+stays subscribable via `webhook(provider, { provider, type })`; PROVIDERS.md
+lists them.
+
 Provider namespaces also export from `@relayflows/surface/triggers` and
-`@relayflows/surface/triggers/slack` (or `/github`). Declarations are immutable
+`@relayflows/surface/triggers/slack` (or `/github`, `/notion`, …). Declarations are immutable
 webhook sources: their executor/inbox name is the provider, and their filter
 matches the provider, event type, and requested payload fields. Register those
 provider names in `flows.json`'s `executors` array for preflight.
@@ -32,9 +49,21 @@ filter names that same provider, and the filter pins an event type.
 `slack.reaction(emoji)` subscribes to `reaction_added`. Arguments match provider
 values exactly: use the channel ID and reaction name from the incoming event.
 `github.pull_request(action)` filters `payload.action`; omitting the action
-accepts every pull request event. Upstream mappings do not declare action enums,
-so the action parameter is a string. Other generated methods accept an optional
-recursive payload filter, for example `github.push({ ref: 'refs/heads/main' })`.
+accepts every pull request event. GitHub (and some other providers) appear in
+two spellings because two ingresses deliver them: the aggregate event with the
+action in the payload (`pull_request` + `payload.action`) is what a raw GitHub
+delivery and this package's `POST /providers/github` receiver carry, while the
+action-qualified name (`pull_request.opened`) is what relayfile's Cloud
+ingress normalizes to and what the adapter catalog lists. Subscribe in the
+spelling of the ingress that will deliver to you; action-qualified methods
+take only a payload filter, never a second action. Upstream mappings do not declare action enums,
+so the action parameter is a string. `github.check_run(action)` (a CI check
+finished: `completed`, with `check_run.conclusion` in the payload) and
+`github.issue_comment(action)` (a comment on an issue or pull-request
+conversation: `created`, `edited`, `deleted`) take an action the same way — the
+two events a PR reviewer needs for merge-on-green and comment-driven directives.
+Other generated methods accept an optional recursive payload filter, for
+example `github.push({ ref: 'refs/heads/main' })`.
 
 The receiver accepts `POST /providers/slack` with this JSON:
 
@@ -72,9 +101,55 @@ Each provider inbox still binds one RunSpec. This extends E's declaration and
 inbox contract; deploying TypeScript handler bodies remains the separate #301
 binding step.
 
+## Schedules
+
+`schedule` is hand-written, not generated: a schedule is not a provider event.
+
+```ts
+import { flow, schedule } from '@relayflows/surface';
+
+export default flow('nightly')
+  .on(schedule.cron('0 9 * * 1-5', { tz: 'Europe/Oslo' }), async (f) => { f.done('success'); })
+  .on(schedule.every('5m'), async (f) => { f.done('success'); });
+```
+
+`schedule.cron` validates a standard five-field expression (values, ranges,
+lists, `/step`, month and weekday names) and an IANA `tz`; `schedule.every`
+takes `<n><s|m|h|d>`, at least one second. Both are inert data. The SDK lowers
+a declaration to the `flows.tick` subscription `testdata/tick-heartbeat.flow.yaml`
+writes by hand — event type `flows.tick`, pattern `schedule_id`, the tick
+dedupe key, and a three-slot silence budget — with a deterministic
+`schedule_id` from the flow name and the declaration (`scheduleIdFor`).
+`flows check` prints each one:
+
+```
+SCHEDULE handler 0 every 300000ms -> flows.tick schedule_id nightly-every-300000ms-33a704f768702f7d [local: flows tick start --schedule-id nightly-every-300000ms-33a704f768702f7d --interval-ms 300000 --epoch-ms 0]
+SCHEDULE handler 1 cron "0 9 * * 1-5" tz Europe/Oslo -> flows.tick schedule_id nightly-cron-0-9-1-5-europe-oslo-41f5a267fd758564 [Cloud only: ...]
+```
+
+The id is a readable slug plus a hash of the exact declaration, so `1-5` and
+`1,5`, two zones, or two long names never share a tick stream (the kernel
+dispatches an event to its first matching subscription only).
+
+Locally the tick runner fires at `epoch + k·interval`, so it drives a cron
+only when that grid reproduces it **exactly**: `every(...)`; `*/N * * * *`
+with `N` dividing 60; `M */N * * *` with `N` dividing 24 (phase `M`
+minutes); `M H * * *` daily (phase `H:M`) — all in UTC. `*/7 * * * *` is not
+a grid (cron restarts the count each hour, a grid drifts), nor is anything
+with day, month or weekday constraints, lists, ranges, or a non-UTC zone.
+Those are reported as Cloud-only rather than approximated; `flows schedule`
+registers them on Cloud's cron-aware runner. Every schedule declares its own
+silence budget — three intervals for a grid, three times the cron's longest
+quiet period otherwise (`cronMaxGapMs`) — so a weekday-morning cron is not
+journaled stale on Monday at 09:05 by the kernel's five-minute default.
+Schedules need no `flows.json` executor entry: the tick source ships with
+the CLI.
+
 Generation requires the SDK's development dependencies. The default input is
-the mapping YAML shipped in the pinned `@relayfile/adapter-core` dependency
-(currently Slack and GitHub). A checkout supplies additional providers:
+the pinned `@relayfile/adapter-core` dependency: its `mappings/` fallbacks,
+its `mappings/adapters/` bundle (every adapter's own mapping, adapter-core
+≥ 0.5.26), and its trigger catalog. A checkout supplies the same three from
+source:
 
 ```sh
 node scripts/generate-triggers.mjs
@@ -83,6 +158,7 @@ node scripts/generate-triggers.mjs --adapters-dir /path/to/relayfile-adapters
 ```
 
 The generator reads `packages/core/mappings/*.mapping.yaml`, then each adapter's
-`packages/<adapter>/*.mapping.yaml`; adapter-local mappings take precedence.
-Only adapters with a nonempty `webhooks:` section produce modules. It never
+`packages/<adapter>/*.mapping.yaml` (adapter-local mappings take precedence),
+then `packages/core/src/triggers/catalog.generated.json` for providers with no
+`webhooks:` block. Only providers with at least one event produce modules. It never
 imports or executes adapter code. Rebuild the surface and SDK after regeneration.

package/src/triggers/airtable.ts

@@ -0,0 +1,34 @@
+// GENERATED by scripts/generate-triggers.mjs — do not edit.
+
+import { providerTrigger } from "../provider-trigger.js";
+import type { WebhookFilter } from "../triggers.js";
+
+export const airtable = Object.freeze({
+  base_create(filter?: WebhookFilter) {
+    return providerTrigger("airtable", "base.create", filter);
+  },
+  base_delete(filter?: WebhookFilter) {
+    return providerTrigger("airtable", "base.delete", filter);
+  },
+  base_update(filter?: WebhookFilter) {
+    return providerTrigger("airtable", "base.update", filter);
+  },
+  record_create(filter?: WebhookFilter) {
+    return providerTrigger("airtable", "record.create", filter);
+  },
+  record_delete(filter?: WebhookFilter) {
+    return providerTrigger("airtable", "record.delete", filter);
+  },
+  record_update(filter?: WebhookFilter) {
+    return providerTrigger("airtable", "record.update", filter);
+  },
+  table_create(filter?: WebhookFilter) {
+    return providerTrigger("airtable", "table.create", filter);
+  },
+  table_delete(filter?: WebhookFilter) {
+    return providerTrigger("airtable", "table.delete", filter);
+  },
+  table_update(filter?: WebhookFilter) {
+    return providerTrigger("airtable", "table.update", filter);
+  },
+});

package/src/triggers/asana.ts

@@ -0,0 +1,58 @@
+// GENERATED by scripts/generate-triggers.mjs — do not edit.
+
+import { providerTrigger } from "../provider-trigger.js";
+import type { WebhookFilter } from "../triggers.js";
+
+export const asana = Object.freeze({
+  project_added(filter?: WebhookFilter) {
+    return providerTrigger("asana", "project.added", filter);
+  },
+  project_changed(filter?: WebhookFilter) {
+    return providerTrigger("asana", "project.changed", filter);
+  },
+  project_deleted(filter?: WebhookFilter) {
+    return providerTrigger("asana", "project.deleted", filter);
+  },
+  project_removed(filter?: WebhookFilter) {
+    return providerTrigger("asana", "project.removed", filter);
+  },
+  section_added(filter?: WebhookFilter) {
+    return providerTrigger("asana", "section.added", filter);
+  },
+  section_changed(filter?: WebhookFilter) {
+    return providerTrigger("asana", "section.changed", filter);
+  },
+  section_deleted(filter?: WebhookFilter) {
+    return providerTrigger("asana", "section.deleted", filter);
+  },
+  section_removed(filter?: WebhookFilter) {
+    return providerTrigger("asana", "section.removed", filter);
+  },
+  task_added(filter?: WebhookFilter) {
+    return providerTrigger("asana", "task.added", filter);
+  },
+  task_changed(filter?: WebhookFilter) {
+    return providerTrigger("asana", "task.changed", filter);
+  },
+  task_completed(filter?: WebhookFilter) {
+    return providerTrigger("asana", "task.completed", filter);
+  },
+  task_deleted(filter?: WebhookFilter) {
+    return providerTrigger("asana", "task.deleted", filter);
+  },
+  task_removed(filter?: WebhookFilter) {
+    return providerTrigger("asana", "task.removed", filter);
+  },
+  workspace_added(filter?: WebhookFilter) {
+    return providerTrigger("asana", "workspace.added", filter);
+  },
+  workspace_changed(filter?: WebhookFilter) {
+    return providerTrigger("asana", "workspace.changed", filter);
+  },
+  workspace_deleted(filter?: WebhookFilter) {
+    return providerTrigger("asana", "workspace.deleted", filter);
+  },
+  workspace_removed(filter?: WebhookFilter) {
+    return providerTrigger("asana", "workspace.removed", filter);
+  },
+});

package/src/triggers/azure-blob.ts

@@ -0,0 +1,16 @@
+// GENERATED by scripts/generate-triggers.mjs — do not edit.
+
+import { providerTrigger } from "../provider-trigger.js";
+import type { WebhookFilter } from "../triggers.js";
+
+export const azure_blob = Object.freeze({
+  file_created(filter?: WebhookFilter) {
+    return providerTrigger("azure-blob", "file.created", filter);
+  },
+  file_deleted(filter?: WebhookFilter) {
+    return providerTrigger("azure-blob", "file.deleted", filter);
+  },
+  file_updated(filter?: WebhookFilter) {
+    return providerTrigger("azure-blob", "file.updated", filter);
+  },
+});

package/src/triggers/box.ts

@@ -0,0 +1,16 @@
+// GENERATED by scripts/generate-triggers.mjs — do not edit.
+
+import { providerTrigger } from "../provider-trigger.js";
+import type { WebhookFilter } from "../triggers.js";
+
+export const box = Object.freeze({
+  file_created(filter?: WebhookFilter) {
+    return providerTrigger("box", "file.created", filter);
+  },
+  file_deleted(filter?: WebhookFilter) {
+    return providerTrigger("box", "file.deleted", filter);
+  },
+  file_updated(filter?: WebhookFilter) {
+    return providerTrigger("box", "file.updated", filter);
+  },
+});

package/src/triggers/calendly.ts

@@ -0,0 +1,43 @@
+// GENERATED by scripts/generate-triggers.mjs — do not edit.
+
+import { providerTrigger } from "../provider-trigger.js";
+import type { WebhookFilter } from "../triggers.js";
+
+export const calendly = Object.freeze({
+  event_type_canceled(filter?: WebhookFilter) {
+    return providerTrigger("calendly", "event_type.canceled", filter);
+  },
+  event_type_created(filter?: WebhookFilter) {
+    return providerTrigger("calendly", "event_type.created", filter);
+  },
+  event_type_deleted(filter?: WebhookFilter) {
+    return providerTrigger("calendly", "event_type.deleted", filter);
+  },
+  event_type_updated(filter?: WebhookFilter) {
+    return providerTrigger("calendly", "event_type.updated", filter);
+  },
+  invitee_canceled(filter?: WebhookFilter) {
+    return providerTrigger("calendly", "invitee.canceled", filter);
+  },
+  invitee_created(filter?: WebhookFilter) {
+    return providerTrigger("calendly", "invitee.created", filter);
+  },
+  invitee_deleted(filter?: WebhookFilter) {
+    return providerTrigger("calendly", "invitee.deleted", filter);
+  },
+  invitee_updated(filter?: WebhookFilter) {
+    return providerTrigger("calendly", "invitee.updated", filter);
+  },
+  scheduled_event_canceled(filter?: WebhookFilter) {
+    return providerTrigger("calendly", "scheduled_event.canceled", filter);
+  },
+  scheduled_event_created(filter?: WebhookFilter) {
+    return providerTrigger("calendly", "scheduled_event.created", filter);
+  },
+  scheduled_event_deleted(filter?: WebhookFilter) {
+    return providerTrigger("calendly", "scheduled_event.deleted", filter);
+  },
+  scheduled_event_updated(filter?: WebhookFilter) {
+    return providerTrigger("calendly", "scheduled_event.updated", filter);
+  },
+});

package/src/triggers/clickup.ts

@@ -0,0 +1,43 @@
+// GENERATED by scripts/generate-triggers.mjs — do not edit.
+
+import { providerTrigger } from "../provider-trigger.js";
+import type { WebhookFilter } from "../triggers.js";
+
+export const clickup = Object.freeze({
+  folder_created(filter?: WebhookFilter) {
+    return providerTrigger("clickup", "folder.created", filter);
+  },
+  folder_deleted(filter?: WebhookFilter) {
+    return providerTrigger("clickup", "folder.deleted", filter);
+  },
+  folder_updated(filter?: WebhookFilter) {
+    return providerTrigger("clickup", "folder.updated", filter);
+  },
+  list_created(filter?: WebhookFilter) {
+    return providerTrigger("clickup", "list.created", filter);
+  },
+  list_deleted(filter?: WebhookFilter) {
+    return providerTrigger("clickup", "list.deleted", filter);
+  },
+  list_updated(filter?: WebhookFilter) {
+    return providerTrigger("clickup", "list.updated", filter);
+  },
+  space_created(filter?: WebhookFilter) {
+    return providerTrigger("clickup", "space.created", filter);
+  },
+  space_deleted(filter?: WebhookFilter) {
+    return providerTrigger("clickup", "space.deleted", filter);
+  },
+  space_updated(filter?: WebhookFilter) {
+    return providerTrigger("clickup", "space.updated", filter);
+  },
+  task_created(filter?: WebhookFilter) {
+    return providerTrigger("clickup", "task.created", filter);
+  },
+  task_deleted(filter?: WebhookFilter) {
+    return providerTrigger("clickup", "task.deleted", filter);
+  },
+  task_updated(filter?: WebhookFilter) {
+    return providerTrigger("clickup", "task.updated", filter);
+  },
+});

package/src/triggers/cloudflare.ts

@@ -0,0 +1,31 @@
+// GENERATED by scripts/generate-triggers.mjs — do not edit.
+
+import { providerTrigger } from "../provider-trigger.js";
+import type { WebhookFilter } from "../triggers.js";
+
+export const cloudflare = Object.freeze({
+  access_custom_certificate_expiration_type(filter?: WebhookFilter) {
+    return providerTrigger("cloudflare", "access_custom_certificate_expiration_type", filter);
+  },
+  advanced_http_alert_error(filter?: WebhookFilter) {
+    return providerTrigger("cloudflare", "advanced_http_alert_error", filter);
+  },
+  billing_usage_alert(filter?: WebhookFilter) {
+    return providerTrigger("cloudflare", "billing_usage_alert", filter);
+  },
+  dedicated_ssl_certificate_event_type(filter?: WebhookFilter) {
+    return providerTrigger("cloudflare", "dedicated_ssl_certificate_event_type", filter);
+  },
+  health_check_status_notification(filter?: WebhookFilter) {
+    return providerTrigger("cloudflare", "health_check_status_notification", filter);
+  },
+  http_alert_origin_error(filter?: WebhookFilter) {
+    return providerTrigger("cloudflare", "http_alert_origin_error", filter);
+  },
+  workers_alert(filter?: WebhookFilter) {
+    return providerTrigger("cloudflare", "workers_alert", filter);
+  },
+  workers_observability_alert(filter?: WebhookFilter) {
+    return providerTrigger("cloudflare", "workers_observability_alert", filter);
+  },
+});

package/src/triggers/confluence.ts

@@ -0,0 +1,25 @@
+// GENERATED by scripts/generate-triggers.mjs — do not edit.
+
+import { providerTrigger } from "../provider-trigger.js";
+import type { WebhookFilter } from "../triggers.js";
+
+export const confluence = Object.freeze({
+  page_created(filter?: WebhookFilter) {
+    return providerTrigger("confluence", "page.created", filter);
+  },
+  page_deleted(filter?: WebhookFilter) {
+    return providerTrigger("confluence", "page.deleted", filter);
+  },
+  page_updated(filter?: WebhookFilter) {
+    return providerTrigger("confluence", "page.updated", filter);
+  },
+  space_created(filter?: WebhookFilter) {
+    return providerTrigger("confluence", "space.created", filter);
+  },
+  space_deleted(filter?: WebhookFilter) {
+    return providerTrigger("confluence", "space.deleted", filter);
+  },
+  space_updated(filter?: WebhookFilter) {
+    return providerTrigger("confluence", "space.updated", filter);
+  },
+});

package/src/triggers/daytona.ts

@@ -0,0 +1,28 @@
+// GENERATED by scripts/generate-triggers.mjs — do not edit.
+
+import { providerTrigger } from "../provider-trigger.js";
+import type { WebhookFilter } from "../triggers.js";
+
+export const daytona = Object.freeze({
+  sandbox_created(filter?: WebhookFilter) {
+    return providerTrigger("daytona", "sandbox.created", filter);
+  },
+  sandbox_state_updated(filter?: WebhookFilter) {
+    return providerTrigger("daytona", "sandbox.state.updated", filter);
+  },
+  snapshot_created(filter?: WebhookFilter) {
+    return providerTrigger("daytona", "snapshot.created", filter);
+  },
+  snapshot_removed(filter?: WebhookFilter) {
+    return providerTrigger("daytona", "snapshot.removed", filter);
+  },
+  snapshot_state_updated(filter?: WebhookFilter) {
+    return providerTrigger("daytona", "snapshot.state.updated", filter);
+  },
+  volume_created(filter?: WebhookFilter) {
+    return providerTrigger("daytona", "volume.created", filter);
+  },
+  volume_state_updated(filter?: WebhookFilter) {
+    return providerTrigger("daytona", "volume.state.updated", filter);
+  },
+});

package/src/triggers/docker-hub.ts

@@ -0,0 +1,10 @@
+// GENERATED by scripts/generate-triggers.mjs — do not edit.
+
+import { providerTrigger } from "../provider-trigger.js";
+import type { WebhookFilter } from "../triggers.js";
+
+export const docker_hub = Object.freeze({
+  push(filter?: WebhookFilter) {
+    return providerTrigger("docker-hub", "push", filter);
+  },
+});

package/src/triggers/dropbox.ts

@@ -0,0 +1,10 @@
+// GENERATED by scripts/generate-triggers.mjs — do not edit.
+
+import { providerTrigger } from "../provider-trigger.js";
+import type { WebhookFilter } from "../triggers.js";
+
+export const dropbox = Object.freeze({
+  file_changed(filter?: WebhookFilter) {
+    return providerTrigger("dropbox", "file.changed", filter);
+  },
+});

package/src/triggers/fathom.ts

@@ -0,0 +1,10 @@
+// GENERATED by scripts/generate-triggers.mjs — do not edit.
+
+import { providerTrigger } from "../provider-trigger.js";
+import type { WebhookFilter } from "../triggers.js";
+
+export const fathom = Object.freeze({
+  new_meeting_content_ready(filter?: WebhookFilter) {
+    return providerTrigger("fathom", "new-meeting-content-ready", filter);
+  },
+});

package/src/triggers/gcp.ts

@@ -0,0 +1,34 @@
+// GENERATED by scripts/generate-triggers.mjs — do not edit.
+
+import { providerTrigger } from "../provider-trigger.js";
+import type { WebhookFilter } from "../triggers.js";
+
+export const gcp = Object.freeze({
+  billing_budget_alert(filter?: WebhookFilter) {
+    return providerTrigger("gcp", "billing.budget.alert", filter);
+  },
+  cloud_run_service_created(filter?: WebhookFilter) {
+    return providerTrigger("gcp", "cloud-run.service.created", filter);
+  },
+  cloud_run_service_deleted(filter?: WebhookFilter) {
+    return providerTrigger("gcp", "cloud-run.service.deleted", filter);
+  },
+  cloud_run_service_updated(filter?: WebhookFilter) {
+    return providerTrigger("gcp", "cloud-run.service.updated", filter);
+  },
+  error_reporting_event_logged(filter?: WebhookFilter) {
+    return providerTrigger("gcp", "error-reporting.event.logged", filter);
+  },
+  error_reporting_group_opened(filter?: WebhookFilter) {
+    return providerTrigger("gcp", "error-reporting.group.opened", filter);
+  },
+  error_reporting_group_reopened(filter?: WebhookFilter) {
+    return providerTrigger("gcp", "error-reporting.group.reopened", filter);
+  },
+  monitoring_incident_closed(filter?: WebhookFilter) {
+    return providerTrigger("gcp", "monitoring.incident.closed", filter);
+  },
+  monitoring_incident_open(filter?: WebhookFilter) {
+    return providerTrigger("gcp", "monitoring.incident.open", filter);
+  },
+});

package/src/triggers/gcs.ts

@@ -0,0 +1,16 @@
+// GENERATED by scripts/generate-triggers.mjs — do not edit.
+
+import { providerTrigger } from "../provider-trigger.js";
+import type { WebhookFilter } from "../triggers.js";
+
+export const gcs = Object.freeze({
+  file_created(filter?: WebhookFilter) {
+    return providerTrigger("gcs", "file.created", filter);
+  },
+  file_deleted(filter?: WebhookFilter) {
+    return providerTrigger("gcs", "file.deleted", filter);
+  },
+  file_updated(filter?: WebhookFilter) {
+    return providerTrigger("gcs", "file.updated", filter);
+  },
+});

package/src/triggers/github.ts

@@ -4,16 +4,82 @@ import { providerTrigger, triggerArgument } from "../provider-trigger.js";
 import type { WebhookFilter } from "../triggers.js";
 
 export const github = Object.freeze({
+  check_run(action?: string) {
+    return providerTrigger("github", "check_run", action === undefined ? undefined : { action: triggerArgument(action, "action") });
+  },
+  check_run_completed(filter?: WebhookFilter) {
+    return providerTrigger("github", "check_run.completed", filter);
+  },
+  deployment_status_created(filter?: WebhookFilter) {
+    return providerTrigger("github", "deployment_status.created", filter);
+  },
+  issue_comment(action?: string) {
+    return providerTrigger("github", "issue_comment", action === undefined ? undefined : { action: triggerArgument(action, "action") });
+  },
+  issue_comment_created(filter?: WebhookFilter) {
+    return providerTrigger("github", "issue_comment.created", filter);
+  },
   issues(filter?: WebhookFilter) {
     return providerTrigger("github", "issues", filter);
   },
+  issues_edited(filter?: WebhookFilter) {
+    return providerTrigger("github", "issues.edited", filter);
+  },
+  issues_labeled(filter?: WebhookFilter) {
+    return providerTrigger("github", "issues.labeled", filter);
+  },
+  issues_reopened(filter?: WebhookFilter) {
+    return providerTrigger("github", "issues.reopened", filter);
+  },
+  issues_unlabeled(filter?: WebhookFilter) {
+    return providerTrigger("github", "issues.unlabeled", filter);
+  },
   pull_request(action?: string) {
     return providerTrigger("github", "pull_request", action === undefined ? undefined : { action: triggerArgument(action, "action") });
   },
   pull_request_review(filter?: WebhookFilter) {
     return providerTrigger("github", "pull_request_review", filter);
   },
+  pull_request_review_comment_created(filter?: WebhookFilter) {
+    return providerTrigger("github", "pull_request_review_comment.created", filter);
+  },
+  pull_request_review_thread_resolved(filter?: WebhookFilter) {
+    return providerTrigger("github", "pull_request_review_thread.resolved", filter);
+  },
+  pull_request_review_dismissed(filter?: WebhookFilter) {
+    return providerTrigger("github", "pull_request_review.dismissed", filter);
+  },
+  pull_request_review_edited(filter?: WebhookFilter) {
+    return providerTrigger("github", "pull_request_review.edited", filter);
+  },
+  pull_request_review_submitted(filter?: WebhookFilter) {
+    return providerTrigger("github", "pull_request_review.submitted", filter);
+  },
+  pull_request_edited(filter?: WebhookFilter) {
+    return providerTrigger("github", "pull_request.edited", filter);
+  },
+  pull_request_reopened(filter?: WebhookFilter) {
+    return providerTrigger("github", "pull_request.reopened", filter);
+  },
   push(filter?: WebhookFilter) {
     return providerTrigger("github", "push", filter);
   },
+  status(filter?: WebhookFilter) {
+    return providerTrigger("github", "status", filter);
+  },
+  issues_closed(filter?: WebhookFilter) {
+    return providerTrigger("github", "issues.closed", filter);
+  },
+  issues_opened(filter?: WebhookFilter) {
+    return providerTrigger("github", "issues.opened", filter);
+  },
+  pull_request_closed(filter?: WebhookFilter) {
+    return providerTrigger("github", "pull_request.closed", filter);
+  },
+  pull_request_opened(filter?: WebhookFilter) {
+    return providerTrigger("github", "pull_request.opened", filter);
+  },
+  pull_request_synchronize(filter?: WebhookFilter) {
+    return providerTrigger("github", "pull_request.synchronize", filter);
+  },
 });