@newhomestar/sdk 0.6.7 → 0.6.9

package/dist/events.js

@@ -0,0 +1,503 @@
+// @newhomestar/sdk/events — Transactional outbox + HTTP event client
+// =====================================================================
+// Producer-side helpers for emitting platform events safely.
+//
+// The central problem: a service can write to its DB successfully and
+// then fail to call POST /events/queue, leaving state changed but the
+// event missing. The transactional outbox solves this by writing data
+// + outbox row in ONE atomic transaction — they succeed or fail together.
+//
+// ─── Usage ───────────────────────────────────────────────────────────
+//
+//  Producer service (e.g. HRIS):
+//
+//  import { withEventOutbox, startOutboxRelay } from '@newhomestar/sdk/events';
+//
+//  // In a route handler — atomically writes data + emits event:
+//  const employee = await withEventOutbox(db, async (tx) => {
+//    const row = await tx.hrisEmployee.update({ where: { id }, data });
+//    return {
+//      events: [{ entity_type: 'employee', action: 'updated', entity_id: id, ... }],
+//      result: row,
+//    };
+//  });
+//
+//  // In layout.tsx — starts the retry loop for any failed relays:
+//  startOutboxRelay(db);
+//
+// ─── Required env vars ───────────────────────────────────────────────
+//  NOVA_EVENTS_SERVICE_URL  — URL of the nova-events-service
+//  NOVA_SERVICE_TOKEN       — JWT with scope to POST /events/queue
+//  NOVA_SERVICE_SLUG        — Stamped as source_service on every event
+// =====================================================================
+import dotenv from 'dotenv';
+// Load .env.local in dev if NOVA_EVENTS_SERVICE_URL not already set
+if (!process.env.NOVA_EVENTS_SERVICE_URL) {
+    dotenv.config({ path: '.env.local', override: false });
+}
+// ── Internal helpers ───────────────────────────────────────────────────────────
+function _getEnvOrThrow(key, context) {
+    const val = process.env[key];
+    if (!val)
+        throw new Error(`[${context}] ${key} env var is required but not set`);
+    return val;
+}
+/**
+ * Relay a single outbox row to the events service and update the outbox.
+ * Used by both withEventOutbox (immediate relay) and startOutboxRelay (retry loop).
+ */
+async function _relayRow(db, row, eventsUrl, serviceToken) {
+    let lastError = null;
+    try {
+        const body = {
+            ...row.payload,
+            idempotency_key: row.idempotencyKey,
+        };
+        const res = await fetch(`${eventsUrl}/events/queue`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${serviceToken}`,
+                'Content-Type': 'application/json',
+                'Idempotency-Key': row.idempotencyKey,
+            },
+            body: JSON.stringify(body),
+        });
+        if (res.ok) {
+            await db.eventOutbox.update({
+                where: { id: row.id },
+                data: { delivered: true, deliveredAt: new Date() },
+            });
+            return;
+        }
+        // Non-2xx: treat as transient failure, update error fields
+        const text = await res.text().catch(() => `HTTP ${res.status}`);
+        lastError = `HTTP ${res.status}: ${text}`.slice(0, 500);
+    }
+    catch (err) {
+        lastError = String(err).slice(0, 500);
+    }
+    // Relay failed — record the attempt
+    await db.eventOutbox.update({
+        where: { id: row.id },
+        data: {
+            attempts: { increment: 1 },
+            lastAttemptAt: new Date(),
+            lastError,
+        },
+    }).catch((updateErr) => {
+        console.error('[nova/events] Failed to update outbox row after relay failure:', updateErr);
+    });
+}
+// ── isIntegrationSync ─────────────────────────────────────────────────────────
+/**
+ * Returns `true` when a request originated from an integration sync or worker,
+ * indicated by the `x-source: integration_sync` header.
+ *
+ * **Producer side** — pass `req` to `withServiceEventOutbox()` and this check is
+ * done for you automatically. Use this helper directly only when you need
+ * conditional logic beyond event emission (e.g. skipping a side-effect).
+ *
+ * **Consumer side** — integration workers MUST check this before writing back to
+ * the source system to avoid infinite sync loops:
+ *
+ * @example
+ * // In a worker handler — don't write back to BambooHR if BambooHR caused the event
+ * if (isIntegrationSync(event)) return { status: 'skipped' };
+ * await ctx.fetch(`https://api.bamboohr.com/...`, { method: 'PUT', ... });
+ *
+ * @example
+ * // In a Next.js route handler (producer side) — pass req instead of calling this
+ * const employee = await withServiceEventOutbox(db, req, async (tx, emit) => { ... });
+ */
+export function isIntegrationSync(reqOrEvent) {
+    // Next.js / fetch Request object
+    if (typeof reqOrEvent.headers?.get === 'function') {
+        return reqOrEvent.headers.get('x-source') === 'integration_sync';
+    }
+    // Plain event/message object (consumer side: check metadata stamped at emit time)
+    const meta = reqOrEvent?.metadata;
+    return meta?.source === 'integration_sync';
+}
+/**
+ * Run a Prisma transaction that atomically writes business data + outbox rows,
+ * then immediately relays events to the Nova Events Service.
+ *
+ * This is the **preferred** high-level API for emitting events from service
+ * route handlers. It is source-aware: if the incoming request carries
+ * `x-source: integration_sync` or `x-integration-id: <slug>`, those values are
+ * automatically stamped on every event's `metadata` field. This lets downstream
+ * consumers self-filter to prevent sync loops without suppressing events for
+ * other subscribers.
+ *
+ * Events **always fan out** to all subscriber queues — no events are silently
+ * dropped. An integration worker that receives an event it caused should check
+ * `isIntegrationSync(event)` and skip processing if true.
+ *
+ * @param db               - Prisma client instance (must have `eventOutbox` model)
+ * @param reqOrCallback    - Either the inbound `Request` (for source tagging) OR
+ *                           the callback directly (if source context is not needed)
+ * @param maybeCallback    - The callback when `req` is provided as the second arg
+ *
+ * @example
+ * // Route handler — source metadata auto-stamped from request headers
+ * export async function POST(req: Request) {
+ *   const employee = await withServiceEventOutbox(db, req, async (tx, emit) => {
+ *     const row = await tx.hrisEmployee.create({ data });
+ *     emit('employee.created', { id: row.id, firstName: row.firstName });
+ *     return row;
+ *   });
+ *   return NextResponse.json(employee);
+ * }
+ *
+ * @example
+ * // Without a request (background job, scheduled task)
+ * const result = await withServiceEventOutbox(db, async (tx, emit) => {
+ *   const row = await tx.hrisEmployee.update({ where: { id }, data });
+ *   emit('employee.updated', { id, ...changes });
+ *   return row;
+ * });
+ */
+export async function withServiceEventOutbox(db, reqOrCallback, maybeCallback) {
+    // ── Resolve overloads ────────────────────────────────────────────────────
+    const req = typeof reqOrCallback !== 'function' ? reqOrCallback : undefined;
+    const callback = (typeof reqOrCallback === 'function' ? reqOrCallback : maybeCallback);
+    const eventsUrl = process.env.NOVA_EVENTS_SERVICE_URL;
+    const serviceToken = process.env.NOVA_SERVICE_TOKEN;
+    const serviceSlug = process.env.NOVA_SERVICE_SLUG;
+    if (!eventsUrl || !serviceToken) {
+        throw new Error('[withServiceEventOutbox] NOVA_EVENTS_SERVICE_URL and NOVA_SERVICE_TOKEN must be set. ' +
+            'Add them to your .env.local or deployment environment.');
+    }
+    // ── Extract source metadata from request headers ─────────────────────────
+    // x-source:         set by integration sync handlers (value: "integration_sync")
+    // x-integration-id: set by integration workers to identify the source system
+    const xSource = req?.headers?.get('x-source') ?? 'user';
+    const integrationId = req?.headers?.get('x-integration-id') ?? undefined;
+    const stagedEmits = [];
+    const outboxRows = [];
+    // ── Atomic: callback + outbox INSERTs in one transaction ─────────────────
+    const result = await db.$transaction(async (tx) => {
+        // The emit fn is synchronous — events are staged and written after callback returns
+        const emit = (topic, payload, idempotencyKey) => {
+            stagedEmits.push({ topic, payload, idempotencyKey });
+        };
+        const callbackResult = await callback(tx, emit);
+        // Write one outbox row per staged emit
+        for (const staged of stagedEmits) {
+            // ── Derive entity_type + action from topic string ──────────────────
+            // Supports dot notation   ("employee.created"  → entity_type=employee, action=created)
+            //           dotted path   ("hris.employee.created" → entity_type=hris.employee, action=created)
+            //           UPPER_SNAKE   ("EMPLOYEE_CREATED"  → entity_type=employee, action=created)
+            //           bare string   ("employee"          → entity_type=employee, action=event)
+            let entity_type;
+            let action;
+            if (staged.topic.includes('.')) {
+                const lastDot = staged.topic.lastIndexOf('.');
+                entity_type = staged.topic.slice(0, lastDot);
+                action = staged.topic.slice(lastDot + 1);
+            }
+            else if (staged.topic.includes('_')) {
+                const firstUnderscore = staged.topic.indexOf('_');
+                entity_type = staged.topic.slice(0, firstUnderscore).toLowerCase();
+                action = staged.topic.slice(firstUnderscore + 1).toLowerCase().replace(/_/g, '.');
+            }
+            else {
+                entity_type = staged.topic.toLowerCase();
+                action = 'event';
+            }
+            const fullPayload = {
+                entity_type,
+                action,
+                source_service: serviceSlug ?? undefined,
+                attributes: staged.payload,
+                metadata: {
+                    source: xSource,
+                    ...(integrationId ? { integration_id: integrationId } : {}),
+                },
+            };
+            const row = await tx.eventOutbox.create({
+                data: {
+                    eventType: staged.topic,
+                    payload: fullPayload,
+                    ...(staged.idempotencyKey
+                        ? { idempotencyKey: staged.idempotencyKey }
+                        : {}),
+                },
+                select: { id: true, idempotencyKey: true },
+            });
+            outboxRows.push({
+                id: row.id,
+                idempotencyKey: row.idempotencyKey,
+                payload: fullPayload,
+            });
+        }
+        return callbackResult;
+    });
+    // ── Immediate relay: best-effort POST after commit ────────────────────────
+    await Promise.allSettled(outboxRows.map(row => _relayRow(db, row, eventsUrl, serviceToken)));
+    return result;
+}
+// ── withEventOutbox ────────────────────────────────────────────────────────────
+/**
+ * Run a Prisma transaction that atomically writes business data + an outbox row,
+ * then immediately relays the event to the Nova Events Service.
+ *
+ * If the relay fails (network error or non-2xx), the outbox row is preserved and
+ * startOutboxRelay() will retry it with exponential backoff.
+ *
+ * @param db       - Prisma client instance (must have `eventOutbox` model)
+ * @param callback - Receives the transaction `tx`; must return `{ events, result }`
+ *
+ * @example
+ * const employee = await withEventOutbox(db, async (tx) => {
+ *   const row = await tx.hrisEmployee.update({ where: { id }, data: updates });
+ *   return {
+ *     events: [{
+ *       entity_type: 'employee',
+ *       action:      'updated',
+ *       entity_id:   id,
+ *       diff:        { before: old, after: mapRow(row), changed_fields },
+ *     }],
+ *     result: row,
+ *   };
+ * });
+ */
+export async function withEventOutbox(db, callback) {
+    const eventsUrl = process.env.NOVA_EVENTS_SERVICE_URL;
+    const serviceToken = process.env.NOVA_SERVICE_TOKEN;
+    const serviceSlug = process.env.NOVA_SERVICE_SLUG;
+    if (!eventsUrl || !serviceToken) {
+        throw new Error('[withEventOutbox] NOVA_EVENTS_SERVICE_URL and NOVA_SERVICE_TOKEN must be set. ' +
+            'Add them to your .env.local or deployment environment.');
+    }
+    // Rows inserted in the transaction — relayed after commit
+    const outboxRows = [];
+    // ── Atomic: business write + outbox INSERT in one transaction ──────────────
+    const result = await db.$transaction(async (tx) => {
+        const { events, result: callbackResult } = await callback(tx);
+        for (const event of events) {
+            const fullPayload = {
+                ...event,
+                source_service: event.source_service ?? serviceSlug ?? undefined,
+            };
+            const row = await tx.eventOutbox.create({
+                data: {
+                    eventType: `${event.entity_type}.${event.action}`,
+                    payload: fullPayload,
+                },
+                select: { id: true, idempotencyKey: true },
+            });
+            outboxRows.push({
+                id: row.id,
+                idempotencyKey: row.idempotencyKey,
+                payload: fullPayload,
+            });
+        }
+        return callbackResult;
+    });
+    // ── Immediate relay: best-effort POST after commit ─────────────────────────
+    // Failures are recorded in the outbox and retried by startOutboxRelay().
+    // We fire all relays concurrently (most calls have a single event anyway).
+    await Promise.allSettled(outboxRows.map(row => _relayRow(db, row, eventsUrl, serviceToken)));
+    return result;
+}
+// ── logEvent ───────────────────────────────────────────────────────────────────
+/**
+ * POST /events — Record an event in the audit log WITHOUT queue fan-out.
+ *
+ * Use for:
+ *   • Inbound sync audits (metadata.source = "integration_sync")
+ *   • Read events ("employee.viewed")
+ *   • System events that don't need integration write-back
+ *
+ * For events that need downstream processing, use queueEvent() or withEventOutbox().
+ */
+export async function logEvent(payload) {
+    const eventsUrl = _getEnvOrThrow('NOVA_EVENTS_SERVICE_URL', 'logEvent');
+    const serviceToken = _getEnvOrThrow('NOVA_SERVICE_TOKEN', 'logEvent');
+    const serviceSlug = process.env.NOVA_SERVICE_SLUG;
+    const res = await fetch(`${eventsUrl}/events`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${serviceToken}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            ...payload,
+            source_service: payload.source_service ?? serviceSlug,
+        }),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`[logEvent] HTTP ${res.status}: ${text}`);
+    }
+    return res.json();
+}
+// ── queueEvent ─────────────────────────────────────────────────────────────────
+/**
+ * POST /events/queue — Log an event AND fan-out to all active subscriber queues.
+ *
+ * Use when there is NO database transaction context (e.g. a scheduled job,
+ * a webhook handler that doesn't update its own DB first).
+ *
+ * When you have a DB transaction, prefer withEventOutbox() for atomicity.
+ *
+ * @throws if the events service returns non-2xx (no retry logic)
+ */
+export async function queueEvent(payload) {
+    const eventsUrl = _getEnvOrThrow('NOVA_EVENTS_SERVICE_URL', 'queueEvent');
+    const serviceToken = _getEnvOrThrow('NOVA_SERVICE_TOKEN', 'queueEvent');
+    const serviceSlug = process.env.NOVA_SERVICE_SLUG;
+    const res = await fetch(`${eventsUrl}/events/queue`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${serviceToken}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            ...payload,
+            source_service: payload.source_service ?? serviceSlug,
+        }),
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(`[queueEvent] HTTP ${res.status}: ${text}`);
+    }
+    return res.json();
+}
+// ── startOutboxRelay ───────────────────────────────────────────────────────────
+/**
+ * Start a background interval that retries undelivered outbox rows.
+ *
+ * Call ONCE at service startup (e.g. in layout.tsx or the service entry point).
+ * Returns the interval handle so you can clear it in tests or graceful shutdown.
+ *
+ * Retry schedule (exponential backoff): 2^attempts * 5s
+ *   attempt 0 → 5s,  attempt 1 → 10s,  attempt 2 → 20s,
+ *   attempt 3 → 40s, attempt 4 → 80s
+ *
+ * Rows with attempts >= maxAttempts (default 5) are skipped and left for
+ * a manual reconciler — they won't be retried automatically.
+ *
+ * @param db      - Prisma client instance (must have `eventOutbox` model)
+ * @param options - Relay configuration
+ *
+ * @example
+ * // src/app/layout.tsx
+ * import { startOutboxRelay } from '@newhomestar/sdk/events';
+ * import { db } from '@/lib/db';
+ *
+ * startOutboxRelay(db);
+ */
+export function startOutboxRelay(db, options = {}) {
+    const { intervalMs = 60_000, maxAttempts = 5, eventsUrl = process.env.NOVA_EVENTS_SERVICE_URL, serviceToken = process.env.NOVA_SERVICE_TOKEN, } = options;
+    if (!eventsUrl || !serviceToken) {
+        console.warn('[nova/events] startOutboxRelay: NOVA_EVENTS_SERVICE_URL or NOVA_SERVICE_TOKEN not set — ' +
+            'outbox relay is DISABLED. Set these env vars to enable automatic retry.');
+        // Return a no-op interval that never fires
+        return setInterval(() => { }, 2_147_483_647);
+    }
+    console.log(`[nova/events] Outbox relay started (interval: ${intervalMs}ms, maxAttempts: ${maxAttempts})`);
+    const handle = setInterval(async () => {
+        try {
+            const now = new Date();
+            // Find undelivered rows where the backoff window has elapsed.
+            // The query fetches rows where last_attempt_at is old enough for the
+            // minimum backoff (5s for attempt 0). The per-row check below applies
+            // the precise 2^attempts * 5 calculation to skip rows still in cooldown.
+            const undelivered = await db.eventOutbox.findMany({
+                where: {
+                    delivered: false,
+                    attempts: { lt: maxAttempts },
+                    OR: [
+                        { lastAttemptAt: null },
+                        { lastAttemptAt: { lt: new Date(now.getTime() - 5_000) } },
+                    ],
+                },
+                orderBy: [{ attempts: 'asc' }, { createdAt: 'asc' }],
+                take: 50,
+            });
+            for (const row of undelivered) {
+                // Precise per-row backoff gate: skip if cooldown hasn't elapsed
+                if (row.lastAttemptAt != null) {
+                    const backoffMs = Math.pow(2, row.attempts) * 5_000;
+                    if (now.getTime() - row.lastAttemptAt.getTime() < backoffMs) {
+                        continue;
+                    }
+                }
+                await _relayRow(db, row, eventsUrl, serviceToken);
+            }
+            // Cleanup: delete delivered rows older than 7 days (keep audit trail brief)
+            await db.eventOutbox.deleteMany({
+                where: {
+                    delivered: true,
+                    deliveredAt: { lt: new Date(now.getTime() - 7 * 24 * 60 * 60 * 1_000) },
+                },
+            });
+        }
+        catch (err) {
+            console.error('[nova/events] Outbox relay cycle error:', err);
+        }
+    }, intervalMs);
+    return handle;
+}
+// ── NovaEventsClient ───────────────────────────────────────────────────────────
+/**
+ * Class-based client when you need more control than the top-level functions.
+ * Useful when you want to pass configuration explicitly rather than relying on env vars.
+ *
+ * @example
+ * const client = new NovaEventsClient({ serviceSlug: 'my-service' });
+ * await client.queueEvent({ entity_type: 'employee', action: 'updated', ... });
+ * client.startOutboxRelay(db);
+ */
+export class NovaEventsClient {
+    eventsUrl;
+    serviceToken;
+    serviceSlug;
+    constructor(options) {
+        this.eventsUrl = options?.eventsUrl ?? process.env.NOVA_EVENTS_SERVICE_URL ?? '';
+        this.serviceToken = options?.serviceToken ?? process.env.NOVA_SERVICE_TOKEN ?? '';
+        this.serviceSlug = options?.serviceSlug ?? process.env.NOVA_SERVICE_SLUG;
+    }
+    /** POST /events — audit log only */
+    async logEvent(payload) {
+        return logEvent({ ...payload, source_service: payload.source_service ?? this.serviceSlug });
+    }
+    /** POST /events/queue — log + fan-out to all subscriber queues */
+    async queueEvent(payload) {
+        return queueEvent({ ...payload, source_service: payload.source_service ?? this.serviceSlug });
+    }
+    /** Transactional outbox helper (use in services with a Prisma DB) */
+    async withOutbox(db, callback) {
+        // Temporarily override env for the helpers
+        const original = {
+            eventsUrl: process.env.NOVA_EVENTS_SERVICE_URL,
+            serviceToken: process.env.NOVA_SERVICE_TOKEN,
+            serviceSlug: process.env.NOVA_SERVICE_SLUG,
+        };
+        process.env.NOVA_EVENTS_SERVICE_URL = this.eventsUrl;
+        process.env.NOVA_SERVICE_TOKEN = this.serviceToken;
+        if (this.serviceSlug)
+            process.env.NOVA_SERVICE_SLUG = this.serviceSlug;
+        try {
+            return await withEventOutbox(db, callback);
+        }
+        finally {
+            if (original.eventsUrl !== undefined)
+                process.env.NOVA_EVENTS_SERVICE_URL = original.eventsUrl;
+            if (original.serviceToken !== undefined)
+                process.env.NOVA_SERVICE_TOKEN = original.serviceToken;
+            if (original.serviceSlug !== undefined)
+                process.env.NOVA_SERVICE_SLUG = original.serviceSlug;
+        }
+    }
+    /** Start the background outbox retry relay */
+    startOutboxRelay(db, options) {
+        return startOutboxRelay(db, {
+            ...options,
+            eventsUrl: this.eventsUrl,
+            serviceToken: this.serviceToken,
+        });
+    }
+}

package/dist/index.d.ts

@@ -75,6 +75,20 @@ export interface JWTPayload {
 export interface ActionCtx {
     jobId: string;
     progress: (percent: number, meta?: unknown) => void;
+    /**
+     * Number of times this message has been delivered/retried.
+     * Populated in SSE worker mode; undefined in HTTP server mode.
+     * Use for alerting when read_ct is high (approaching DLQ threshold).
+     */
+    read_ct?: number;
+    /**
+     * Extend the message visibility lease for long-running handlers.
+     * Call periodically to prevent the message from re-appearing in the queue
+     * before processing is complete. SSE worker mode only.
+     *
+     * @param extend_by - Seconds to extend the lease (default: 30)
+     */
+    heartbeat?: (extend_by?: number) => Promise<void>;
     /** Raw HTTP headers from the inbound request (HTTP mode only) */
     headers?: Record<string, string | string[] | undefined>;
     /** Bearer token extracted from the Authorization header (HTTP mode only) */
@@ -231,11 +245,13 @@ export declare function runHttpServer<T extends WorkerDef>(def: T, opts?: HttpSe
 export declare function runDualMode<T extends WorkerDef>(def: T, opts?: {
     port?: number;
 }): void;
+export { withServiceEventOutbox, withEventOutbox, isIntegrationSync, queueEvent, logEvent, startOutboxRelay, NovaEventsClient, } from './events.js';
+export type { QueueEventPayload, LogEventPayload, OutboxRelayOptions, ServiceEmitFn, } from './events.js';
 export type { ZodTypeAny as SchemaAny, ZodTypeAny };
 export { parseNovaSpec } from "./parseSpec.js";
 export type { NovaSpec } from "./parseSpec.js";
 export { defineIntegration, validateIntegration, integrationSchema, integrationEvent, integrationFunction, schema, event, IntegrationDefSchema, } from "./integration.js";
-export type { IntegrationDef, IntegrationSchemaDef, IntegrationEventDef, IntegrationFunctionDef, ValidationResult, SchemaType, ParamMeta, ParamIn, ParamUiType, } from "./integration.js";
+export type { IntegrationDef, IntegrationSchemaDef, IntegrationEventDef, IntegrationFunctionDef, ValidationResult, SchemaType, ParamMeta, ParamIn, ParamUiType, SyncMappingDef, SyncMappingFieldDef, } from "./integration.js";
 export { parseIntegrationSpec, IntegrationSpecSchema } from "./integrationSpec.js";
 export type { IntegrationSpec } from "./integrationSpec.js";
 export type WebhookCapability = {
@@ -268,5 +284,25 @@ export type StreamCapability = {
     consumerGroup?: string;
 };
 export type Capability = WebhookCapability | ScheduledCapability | QueueCapability | StreamCapability;
+/**
+ * Event trigger — subscribes the worker to one or more Nova event topics.
+ * Topics are matched against `message.topic` / `message.event_type` in SSE frames.
+ */
+export type EventTrigger = {
+    type: 'event';
+    /** Nova event topic strings (e.g. "hris.employee.created") */
+    events: string[];
+};
+/**
+ * Schedule trigger — runs the worker on a cron schedule.
+ */
+export type ScheduleTrigger = {
+    type: 'schedule';
+    cron: string;
+    timezone?: string;
+    description?: string;
+};
+/** Union of all trigger variants */
+export type Trigger = EventTrigger | ScheduleTrigger;
 export { createPlatformClient, resolveCredentials, resolveCredentialsViaHttp, detectCredentialStrategy, integrationFetch, emitPlatformEvent, IntegrationNotFoundError, IntegrationDisabledError, CredentialsNotConfiguredError, ConnectionNotFoundError, TokenExchangeError, } from "./credentials.js";
 export type { ResolvedCredentials, IntegrationConfig, AuthMode, } from "./credentials.js";