@shipfox/client-triggers 4.0.0 → 6.0.1

package/src/core/trigger-event.ts

@@ -0,0 +1,126 @@
+export type TriggerEventOrigin = 'integration' | 'manual' | 'cron';
+
+export type TriggerEventOutcome = 'received' | 'routed' | 'discarded' | 'failed' | 'errored';
+
+export const triggerEventOutcomes = [
+  'received',
+  'routed',
+  'discarded',
+  'failed',
+  'errored',
+] as const satisfies readonly TriggerEventOutcome[];
+
+export type TriggerEventDecisionOutcome = 'triggered' | 'filter-error' | 'dispatch-error';
+
+export interface TriggerEventSource {
+  provider: string | null;
+  source: string;
+}
+
+export interface TriggerEventSummary extends TriggerEventSource {
+  id: string;
+  eventRef: string;
+  origin: TriggerEventOrigin;
+  workspaceId: string;
+  event: string;
+  deliveryId: string | null;
+  connectionId: string | null;
+  outcome: TriggerEventOutcome;
+  matchedCount: number;
+  receivedAt: string;
+  processedAt: string | null;
+  createdAt: string;
+}
+
+export interface TriggerEventMatchedWorkflowResult {
+  id: string;
+  subscriptionName: string;
+  decision: TriggerEventDecisionOutcome;
+  projectId: string | null;
+  runId: string | null;
+  runName: string | null;
+  reason: string | null;
+}
+
+export interface TriggerEventDetail extends TriggerEventSummary {
+  connectionName: string | null;
+  payload: Record<string, unknown> | null;
+  decisions: TriggerEventMatchedWorkflowResult[];
+}
+
+export interface TriggerEventFacetItem {
+  value: string;
+  count: number;
+}
+
+export interface TriggerEventFacets {
+  sources: TriggerEventFacetItem[];
+  events: TriggerEventFacetItem[];
+}
+
+export interface TriggerEventListPage {
+  events: TriggerEventSummary[];
+  nextCursor: string | null;
+}
+
+export interface TriggerEventFilters {
+  source?: string[] | undefined;
+  event?: string[] | undefined;
+  outcome?: TriggerEventOutcome[] | undefined;
+  from?: string | undefined;
+  to?: string | undefined;
+}
+
+export function normalizeTriggerEventFilterValues(
+  values: readonly string[] | undefined,
+): string[] | null {
+  return values && values.length > 0 ? [...new Set(values)].sort() : null;
+}
+
+export function normalizeTriggerEventFilters(filters: TriggerEventFilters) {
+  return {
+    source: normalizeTriggerEventFilterValues(filters.source),
+    event: normalizeTriggerEventFilterValues(filters.event),
+    outcome: normalizeTriggerEventFilterValues(filters.outcome),
+    from: filters.from ?? null,
+    to: filters.to ?? null,
+  };
+}
+
+export function hasTriggerEventFilters(filters: TriggerEventFilters): boolean {
+  const normalized = normalizeTriggerEventFilters(filters);
+  return Boolean(
+    normalized.source || normalized.event || normalized.outcome || normalized.from || normalized.to,
+  );
+}
+
+export type TriggerEventResultKind = 'triggered' | 'no-match' | 'failed' | 'evaluating';
+
+export interface TriggerEventResult {
+  kind: TriggerEventResultKind;
+  matchedWorkflowCount: number;
+  isFailure: boolean;
+}
+
+export function getTriggerEventResult(
+  event: Pick<TriggerEventSummary, 'outcome' | 'matchedCount'>,
+): TriggerEventResult {
+  switch (event.outcome) {
+    case 'routed':
+      return {kind: 'triggered', matchedWorkflowCount: event.matchedCount, isFailure: false};
+    case 'discarded':
+      return {kind: 'no-match', matchedWorkflowCount: 0, isFailure: false};
+    case 'failed':
+    case 'errored':
+      return {kind: 'failed', matchedWorkflowCount: event.matchedCount, isFailure: true};
+    case 'received':
+      return {kind: 'evaluating', matchedWorkflowCount: 0, isFailure: false};
+  }
+}
+
+export const triggerEventResultFilterOutcomes = {
+  triggered: ['routed'],
+  'no-match': ['discarded'],
+  failed: ['failed', 'errored'],
+  evaluating: ['received'],
+} as const satisfies Record<TriggerEventResultKind, readonly TriggerEventOutcome[]>;

package/src/feature.ts

@@ -0,0 +1,17 @@
+import {defineClientFeature, type SettingsSectionEntry} from '@shipfox/client-shell';
+
+export const triggersSettingsSections = [
+  {id: 'settings.events', pathSegment: 'events', label: 'Events', icon: 'pulseLine', order: 800},
+] as const satisfies readonly SettingsSectionEntry[];
+
+export const triggersFeature = defineClientFeature({
+  id: 'shipfox.triggers',
+  routes: [
+    {
+      path: '/workspaces/$wid/settings/events',
+      parent: 'workspaceSettings',
+      impl: '@shipfox/client-triggers/routes/events-settings',
+    },
+  ],
+  settingsSections: triggersSettingsSections,
+});

package/src/hooks/api/trigger-event-mapper.test.ts

@@ -0,0 +1,88 @@
+import type {
+  TriggerEventDetailResponseDto,
+  TriggerEventListItemDto,
+} from '@shipfox/api-triggers-dto';
+import {toTriggerEventDetail, toTriggerEventListPage} from './trigger-event-mapper.js';
+
+const EVENT_ID = '22222222-2222-4222-8222-222222222222';
+const WORKSPACE_ID = '11111111-1111-4111-8111-111111111111';
+
+function triggerEventDto(
+  overrides: Partial<TriggerEventListItemDto> = {},
+): TriggerEventListItemDto {
+  return {
+    id: EVENT_ID,
+    event_ref: 'github:delivery-1:push',
+    origin: 'integration' as const,
+    workspace_id: WORKSPACE_ID,
+    provider: 'github',
+    source: 'github',
+    event: 'push',
+    delivery_id: 'delivery-1',
+    connection_id: '33333333-3333-4333-8333-333333333333',
+    outcome: 'routed' as const,
+    matched_count: 1,
+    received_at: '2026-06-01T00:00:00.000Z',
+    processed_at: '2026-06-01T00:00:01.000Z',
+    created_at: '2026-06-01T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+describe('trigger event mapper', () => {
+  test('maps a transport list page before it enters the cache', () => {
+    const page = toTriggerEventListPage({trigger_events: [triggerEventDto()], next_cursor: 'next'});
+
+    expect(page).toEqual({
+      events: [
+        expect.objectContaining({
+          eventRef: 'github:delivery-1:push',
+          workspaceId: WORKSPACE_ID,
+          matchedCount: 1,
+          receivedAt: '2026-06-01T00:00:00.000Z',
+        }),
+      ],
+      nextCursor: 'next',
+    });
+  });
+
+  test('maps matched workflow results into their domain contract', () => {
+    const detail = toTriggerEventDetail({
+      ...triggerEventDto(),
+      connection_name: 'Shipfox',
+      payload: {ref: 'main'},
+      decisions: [
+        {
+          id: '44444444-4444-4444-8444-444444444444',
+          received_event_id: EVENT_ID,
+          subscription_kind: 'trigger',
+          subscription_id: '55555555-5555-4555-8555-555555555555',
+          subscription_name: 'Deploy',
+          workflow_definition_id: '66666666-6666-4666-8666-666666666666',
+          project_id: '77777777-7777-4777-8777-777777777777',
+          workflow_run_id: null,
+          job_id: null,
+          matcher_kind: null,
+          matcher_ordinal: null,
+          decision: 'triggered',
+          run_id: '88888888-8888-4888-8888-888888888888',
+          run_name: 'deploy #1',
+          reason: null,
+          created_at: '2026-06-01T00:00:01.000Z',
+        },
+      ],
+    } satisfies TriggerEventDetailResponseDto);
+
+    expect(detail.decisions).toEqual([
+      {
+        id: '44444444-4444-4444-8444-444444444444',
+        subscriptionName: 'Deploy',
+        decision: 'triggered',
+        projectId: '77777777-7777-4777-8777-777777777777',
+        runId: '88888888-8888-4888-8888-888888888888',
+        runName: 'deploy #1',
+        reason: null,
+      },
+    ]);
+  });
+});

package/src/hooks/api/trigger-event-mapper.ts

@@ -0,0 +1,76 @@
+import type {
+  TriggerDecisionDto,
+  TriggerEventDetailResponseDto,
+  TriggerEventFacetItemDto,
+  TriggerEventFacetsResponseDto,
+  TriggerEventListItemDto,
+  TriggerEventListResponseDto,
+} from '@shipfox/api-triggers-dto';
+import type {
+  TriggerEventDetail,
+  TriggerEventFacetItem,
+  TriggerEventFacets,
+  TriggerEventListPage,
+  TriggerEventMatchedWorkflowResult,
+  TriggerEventSummary,
+} from '#core/trigger-event.js';
+
+export function toTriggerEventSummary(event: TriggerEventListItemDto): TriggerEventSummary {
+  return {
+    id: event.id,
+    eventRef: event.event_ref,
+    origin: event.origin,
+    workspaceId: event.workspace_id,
+    provider: event.provider,
+    source: event.source,
+    event: event.event,
+    deliveryId: event.delivery_id,
+    connectionId: event.connection_id,
+    outcome: event.outcome,
+    matchedCount: event.matched_count,
+    receivedAt: event.received_at,
+    processedAt: event.processed_at,
+    createdAt: event.created_at,
+  };
+}
+
+export function toTriggerEventListPage(
+  response: TriggerEventListResponseDto,
+): TriggerEventListPage {
+  return {
+    events: response.trigger_events.map(toTriggerEventSummary),
+    nextCursor: response.next_cursor,
+  };
+}
+
+function toMatchedWorkflowResult(decision: TriggerDecisionDto): TriggerEventMatchedWorkflowResult {
+  return {
+    id: decision.id,
+    subscriptionName: decision.subscription_name,
+    decision: decision.decision,
+    projectId: decision.project_id,
+    runId: decision.run_id,
+    runName: decision.run_name,
+    reason: decision.reason,
+  };
+}
+
+export function toTriggerEventDetail(response: TriggerEventDetailResponseDto): TriggerEventDetail {
+  return {
+    ...toTriggerEventSummary(response),
+    connectionName: response.connection_name,
+    payload: response.payload,
+    decisions: response.decisions.map(toMatchedWorkflowResult),
+  };
+}
+
+function toTriggerEventFacetItem(item: TriggerEventFacetItemDto): TriggerEventFacetItem {
+  return {value: item.value, count: item.count};
+}
+
+export function toTriggerEventFacets(response: TriggerEventFacetsResponseDto): TriggerEventFacets {
+  return {
+    sources: response.sources.map(toTriggerEventFacetItem),
+    events: response.events.map(toTriggerEventFacetItem),
+  };
+}

package/src/hooks/api/trigger-events.test.ts

@@ -18,9 +18,32 @@ function requestFrom(fetchImpl: ReturnType<typeof vi.fn>): Request {
   return fetchImpl.mock.calls[0]?.[0] as Request;
 }
 
+const EVENT_ID = '22222222-2222-4222-8222-222222222222';
+const WORKSPACE_ID = '11111111-1111-4111-8111-111111111111';
+
+function triggerEventDto(overrides: Record<string, unknown> = {}) {
+  return {
+    id: EVENT_ID,
+    event_ref: 'github:delivery-1:push',
+    origin: 'integration',
+    workspace_id: WORKSPACE_ID,
+    provider: 'github',
+    source: 'github',
+    event: 'push',
+    delivery_id: 'delivery-1',
+    connection_id: '33333333-3333-4333-8333-333333333333',
+    outcome: 'routed',
+    matched_count: 1,
+    received_at: '2026-06-01T00:00:00.000Z',
+    processed_at: '2026-06-01T00:00:01.000Z',
+    created_at: '2026-06-01T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
 describe('triggerEventsQueryKeys', () => {
   test('list key nests under the workspace lists key', () => {
-    const workspaceId = '11111111-1111-4111-8111-111111111111';
+    const workspaceId = WORKSPACE_ID;
 
     const key = triggerEventsQueryKeys.list(workspaceId, {});
 
@@ -35,7 +58,7 @@ describe('triggerEventsQueryKeys', () => {
   });
 
   test('keeps distinct page limits on distinct keys', () => {
-    const workspaceId = '11111111-1111-4111-8111-111111111111';
+    const workspaceId = WORKSPACE_ID;
 
     const defaultLimit = triggerEventsQueryKeys.list(workspaceId, {});
     const compactLimit = triggerEventsQueryKeys.list(workspaceId, {}, 25);
@@ -46,7 +69,7 @@ describe('triggerEventsQueryKeys', () => {
   });
 
   test('normalizes absent filter fields to null so empty variants share a key', () => {
-    const workspaceId = '11111111-1111-4111-8111-111111111111';
+    const workspaceId = WORKSPACE_ID;
 
     const empty = triggerEventsQueryKeys.list(workspaceId, {});
     const allUndefined = triggerEventsQueryKeys.list(workspaceId, {
@@ -61,7 +84,7 @@ describe('triggerEventsQueryKeys', () => {
   });
 
   test('treats an empty outcome array as no outcome filter', () => {
-    const workspaceId = '11111111-1111-4111-8111-111111111111';
+    const workspaceId = WORKSPACE_ID;
 
     const key = triggerEventsQueryKeys.list(workspaceId, {outcome: []});
 
@@ -69,7 +92,7 @@ describe('triggerEventsQueryKeys', () => {
   });
 
   test('treats empty source and event arrays as no filter', () => {
-    const workspaceId = '11111111-1111-4111-8111-111111111111';
+    const workspaceId = WORKSPACE_ID;
 
     const key = triggerEventsQueryKeys.list(workspaceId, {source: [], event: []});
 
@@ -77,7 +100,7 @@ describe('triggerEventsQueryKeys', () => {
   });
 
   test('sorts and de-duplicates outcome so filter order does not split the cache', () => {
-    const workspaceId = '11111111-1111-4111-8111-111111111111';
+    const workspaceId = WORKSPACE_ID;
 
     const a = triggerEventsQueryKeys.list(workspaceId, {outcome: ['routed', 'failed']});
     const b = triggerEventsQueryKeys.list(workspaceId, {outcome: ['failed', 'routed', 'failed']});
@@ -87,7 +110,7 @@ describe('triggerEventsQueryKeys', () => {
   });
 
   test('sorts and de-duplicates source and event filters so order does not split the cache', () => {
-    const workspaceId = '11111111-1111-4111-8111-111111111111';
+    const workspaceId = WORKSPACE_ID;
 
     const a = triggerEventsQueryKeys.list(workspaceId, {
       source: ['github', 'gitea'],
@@ -203,14 +226,23 @@ describe('listTriggerEvents', () => {
 
   test('returns the parsed list response', async () => {
     const page = {
-      trigger_events: [],
+      trigger_events: [triggerEventDto()],
       next_cursor: 'next-page',
     };
     configureApiClient({fetchImpl: vi.fn(async () => jsonResponse(page))});
 
     const result = await listTriggerEvents({workspaceId});
 
-    expect(result).toEqual(page);
+    expect(result).toEqual({
+      events: [
+        expect.objectContaining({
+          id: EVENT_ID,
+          eventRef: 'github:delivery-1:push',
+          matchedCount: 1,
+        }),
+      ],
+      nextCursor: 'next-page',
+    });
   });
 });
 
@@ -220,8 +252,13 @@ describe('getTriggerEvent', () => {
   });
 
   test('requests the event detail by id', async () => {
-    const id = '22222222-2222-4222-8222-222222222222';
-    const fetchImpl = vi.fn(async () => jsonResponse({id, decisions: []}));
+    const id = EVENT_ID;
+    const fetchImpl = vi.fn(async () =>
+      jsonResponse({
+        ...triggerEventDto({id, connection_name: null, payload: null}),
+        decisions: [],
+      }),
+    );
     configureApiClient({fetchImpl});
 
     await getTriggerEvent({id});
@@ -238,7 +275,7 @@ describe('getTriggerEventFacets', () => {
   });
 
   test('requests the workspace facets', async () => {
-    const workspaceId = '11111111-1111-4111-8111-111111111111';
+    const workspaceId = WORKSPACE_ID;
     const fetchImpl = vi.fn(async () => jsonResponse({sources: [], events: []}));
     configureApiClient({fetchImpl});
 

package/src/hooks/api/trigger-events.ts

@@ -1,40 +1,60 @@
-import type {
-  TriggerEventDetailResponseDto,
-  TriggerEventFacetsResponseDto,
-  TriggerEventListResponseDto,
-  TriggerEventOutcomeDto,
+import {
+  triggerEventDetailResponseSchema,
+  triggerEventFacetsResponseSchema,
+  triggerEventListResponseSchema,
 } from '@shipfox/api-triggers-dto';
-import {apiRequest} from '@shipfox/client-api';
-import {keepPreviousData, useInfiniteQuery, useQuery} from '@tanstack/react-query';
-
-export interface TriggerEventFilters {
-  source?: string[] | undefined;
-  event?: string[] | undefined;
-  outcome?: TriggerEventOutcomeDto[] | undefined;
-  from?: string | undefined;
-  to?: string | undefined;
-}
+import {checkedApiRequest} from '@shipfox/client-api';
+import {
+  type FetchQueryOptions,
+  type InfiniteData,
+  infiniteQueryOptions,
+  keepPreviousData,
+  queryOptions,
+  type UseInfiniteQueryOptions,
+  useInfiniteQuery,
+  useQuery,
+} from '@tanstack/react-query';
+import {
+  normalizeTriggerEventFilters,
+  normalizeTriggerEventFilterValues,
+  type TriggerEventFilters,
+} from '#core/trigger-event.js';
+import {
+  toTriggerEventDetail,
+  toTriggerEventFacets,
+  toTriggerEventListPage,
+} from './trigger-event-mapper.js';
 
-function normalizeStringFilter(values: readonly string[] | undefined) {
-  return values && values.length > 0 ? [...new Set(values)].sort() : null;
-}
+export type {TriggerEventFilters} from '#core/trigger-event.js';
 
-function normalizeTriggerEventFiltersForQueryKey(filters: TriggerEventFilters) {
-  return {
-    source: normalizeStringFilter(filters.source),
-    event: normalizeStringFilter(filters.event),
-    outcome: normalizeStringFilter(filters.outcome),
-    from: filters.from ?? null,
-    to: filters.to ?? null,
-  };
-}
+type TriggerEventsInfiniteQueryOptions = UseInfiniteQueryOptions<
+  import('#core/trigger-event.js').TriggerEventListPage,
+  Error,
+  InfiniteData<import('#core/trigger-event.js').TriggerEventListPage, string | undefined>,
+  ReturnType<typeof triggerEventsQueryKeys.list>,
+  string | undefined
+>;
+
+type TriggerEventQueryOptions = FetchQueryOptions<
+  import('#core/trigger-event.js').TriggerEventDetail,
+  Error,
+  import('#core/trigger-event.js').TriggerEventDetail,
+  ReturnType<typeof triggerEventsQueryKeys.detail>
+>;
+
+type TriggerEventFacetsQueryOptions = FetchQueryOptions<
+  import('#core/trigger-event.js').TriggerEventFacets,
+  Error,
+  import('#core/trigger-event.js').TriggerEventFacets,
+  ReturnType<typeof triggerEventsQueryKeys.facets>
+>;
 
 function setListParam(
   params: URLSearchParams,
   name: string,
   values: readonly string[] | undefined,
 ) {
-  const normalized = normalizeStringFilter(values);
+  const normalized = normalizeTriggerEventFilterValues(values);
   if (normalized) params.set(name, normalized.join(','));
 }
 
@@ -45,7 +65,7 @@ export const triggerEventsQueryKeys = {
     [
       ...triggerEventsQueryKeys.lists(workspaceId),
       limit,
-      normalizeTriggerEventFiltersForQueryKey(filters),
+      normalizeTriggerEventFilters(filters),
     ] as const,
   detail: (id: string) => [...triggerEventsQueryKeys.all, 'detail', id] as const,
   facets: (workspaceId: string) => [...triggerEventsQueryKeys.all, 'facets', workspaceId] as const,
@@ -72,16 +92,36 @@ export async function listTriggerEvents({
   if (filters.to) params.set('to', filters.to);
   setListParam(params, 'outcome', filters.outcome);
 
-  return await apiRequest<TriggerEventListResponseDto>(`/trigger-events?${params.toString()}`, {
-    signal,
-  });
+  const response = await checkedApiRequest(
+    triggerEventListResponseSchema,
+    `/trigger-events?${params.toString()}`,
+    {signal},
+  );
+  return toTriggerEventListPage(response);
 }
 
 export async function getTriggerEvent({id, signal}: {id: string; signal?: AbortSignal}) {
-  return await apiRequest<TriggerEventDetailResponseDto>(
+  const response = await checkedApiRequest(
+    triggerEventDetailResponseSchema,
     `/trigger-events/${encodeURIComponent(id)}`,
     {signal},
   );
+  return toTriggerEventDetail(response);
+}
+
+export function triggerEventsInfiniteQueryOptions(
+  workspaceId: string,
+  filters: TriggerEventFilters = {},
+  limit = 50,
+): TriggerEventsInfiniteQueryOptions {
+  return infiniteQueryOptions({
+    queryKey: triggerEventsQueryKeys.list(workspaceId, filters, limit),
+    initialPageParam: undefined as string | undefined,
+    queryFn: ({pageParam, signal}) =>
+      listTriggerEvents({workspaceId, filters, limit, cursor: pageParam, signal}),
+    getNextPageParam: (lastPage) => lastPage.nextCursor ?? undefined,
+    placeholderData: keepPreviousData,
+  });
 }
 
 export function useTriggerEventsInfiniteQuery(
@@ -90,29 +130,22 @@ export function useTriggerEventsInfiniteQuery(
   limit = 50,
 ) {
   return useInfiniteQuery({
-    queryKey: workspaceId
-      ? triggerEventsQueryKeys.list(workspaceId, filters, limit)
-      : [...triggerEventsQueryKeys.all, 'list'],
+    ...triggerEventsInfiniteQueryOptions(workspaceId ?? '', filters, limit),
     enabled: Boolean(workspaceId),
-    initialPageParam: undefined as string | undefined,
-    queryFn: ({pageParam, signal}) =>
-      listTriggerEvents({
-        workspaceId: workspaceId ?? '',
-        filters,
-        limit,
-        cursor: pageParam,
-        signal,
-      }),
-    getNextPageParam: (lastPage) => lastPage.next_cursor ?? undefined,
-    placeholderData: keepPreviousData,
+  });
+}
+
+export function triggerEventQueryOptions(id: string): TriggerEventQueryOptions {
+  return queryOptions({
+    queryKey: triggerEventsQueryKeys.detail(id),
+    queryFn: ({signal}) => getTriggerEvent({id, signal}),
   });
 }
 
 export function useTriggerEventQuery(id: string | undefined) {
   return useQuery({
-    queryKey: id ? triggerEventsQueryKeys.detail(id) : [...triggerEventsQueryKeys.all, 'detail'],
+    ...triggerEventQueryOptions(id ?? ''),
     enabled: Boolean(id),
-    queryFn: ({signal}) => getTriggerEvent({id: id ?? '', signal}),
   });
 }
 
@@ -124,20 +157,27 @@ export async function getTriggerEventFacets({
   signal?: AbortSignal;
 }) {
   const params = new URLSearchParams({workspace_id: workspaceId});
-  return await apiRequest<TriggerEventFacetsResponseDto>(
+  const response = await checkedApiRequest(
+    triggerEventFacetsResponseSchema,
     `/trigger-events/facets?${params.toString()}`,
     {signal},
   );
+  return toTriggerEventFacets(response);
+}
+
+export function triggerEventFacetsQueryOptions(
+  workspaceId: string,
+): TriggerEventFacetsQueryOptions {
+  return queryOptions({
+    queryKey: triggerEventsQueryKeys.facets(workspaceId),
+    queryFn: ({signal}) => getTriggerEventFacets({workspaceId, signal}),
+    staleTime: 5 * 60 * 1000,
+  });
 }
 
 export function useTriggerEventFacetsQuery(workspaceId: string | undefined) {
   return useQuery({
-    queryKey: workspaceId
-      ? triggerEventsQueryKeys.facets(workspaceId)
-      : [...triggerEventsQueryKeys.all, 'facets'],
+    ...triggerEventFacetsQueryOptions(workspaceId ?? ''),
     enabled: Boolean(workspaceId),
-    queryFn: ({signal}) => getTriggerEventFacets({workspaceId: workspaceId ?? '', signal}),
-    // Distinct values change slowly; avoid refetching on every page mount.
-    staleTime: 5 * 60 * 1000,
   });
 }

package/src/index.ts

@@ -1,3 +1,4 @@
+export * from '#core/trigger-event.js';
 export * from './components/trigger-source-icon.js';
 export * from './hooks/api/trigger-events.js';
 export * from './pages/events-page.js';