@opengeni/contracts 5.5.0 → 5.5.2-canary.40656248492001

package/dist/event-triggers.d.ts

@@ -0,0 +1,1253 @@
+import { z } from "zod";
+/**
+ * Event sources, normalized events and event triggers.
+ *
+ * An event source delivers events into a workspace: a webhook endpoint a person
+ * pastes into another app, an app Opengeni receives events from directly, or an
+ * MCP connection whose server offers the MCP Events extension. Every source
+ * produces the same normalized event. An automation (a scheduled task) runs
+ * when one of its event triggers matches an event.
+ *
+ * This module must not import `./index`: the scheduled-task schemas there
+ * embed these schemas.
+ */
+/**
+ * `workspace` is "This workspace": things that happen in Opengeni itself, such
+ * as a meeting's transcript becoming ready, as one person may see them.
+ */
+export declare const EVENT_SOURCE_KINDS: readonly ["webhook", "github", "slack", "gmail", "mcp", "workspace"];
+export declare const EventSourceKind: z.ZodEnum<{
+    github: "github";
+    gmail: "gmail";
+    mcp: "mcp";
+    slack: "slack";
+    webhook: "webhook";
+    workspace: "workspace";
+}>;
+export type EventSourceKind = z.infer<typeof EventSourceKind>;
+/**
+ * How a webhook endpoint verifies and reads deliveries: `standard` is
+ * Opengeni's own format (Standard Webhooks with an Opengeni secret), `linear`
+ * and `sentry` are those apps' webhooks, and `custom` reads any other app's
+ * webhooks as the source's `format` describes.
+ */
+export declare const WEBHOOK_EVENT_ADAPTERS: readonly ["standard", "linear", "sentry", "custom"];
+export declare const WebhookEventAdapter: z.ZodEnum<{
+    custom: "custom";
+    linear: "linear";
+    sentry: "sentry";
+    standard: "standard";
+}>;
+export type WebhookEventAdapter = z.infer<typeof WebhookEventAdapter>;
+/** An HTTP header name, matched without regard to case. */
+export declare const WebhookHeaderName: z.ZodString;
+/** A dot-separated path into a JSON object, such as `data.object.id`. */
+export declare const WebhookJsonPath: z.ZodString;
+/** Where a value comes from: a JSON path in the event, or a request header. */
+export declare const WebhookValueSource: z.ZodUnion<readonly [z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    header: z.ZodString;
+}, z.core.$strict>]>;
+export type WebhookValueSource = z.infer<typeof WebhookValueSource>;
+/**
+ * How a custom webhook proves it came from the app, always over the exact raw
+ * body and with the source's secret:
+ * - `standard_webhooks`: Standard Webhooks (`webhook-id`, `webhook-timestamp`,
+ *   `webhook-signature`) with a `whsec_` secret, as Svix-based apps send.
+ * - `hmac_sha256`: the HMAC-SHA256 of the body in `header`, hex or base64,
+ *   after an optional `prefix` such as `sha256=`.
+ * - `timestamped_hmac_sha256`: a `t=<unix seconds>,v1=<hex>` header whose
+ *   signature is the HMAC-SHA256 of `<t>.<body>`, as Stripe and Tailscale
+ *   send; deliveries signed more than `toleranceSeconds` away are refused.
+ * - `token`: the secret itself in `header`, after an optional `prefix` such
+ *   as `Bearer ` (a shared token, as GitLab sends).
+ */
+export declare const WebhookSignatureFormat: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    scheme: z.ZodLiteral<"standard_webhooks">;
+}, z.core.$strict>, z.ZodObject<{
+    scheme: z.ZodLiteral<"hmac_sha256">;
+    header: z.ZodString;
+    encoding: z.ZodDefault<z.ZodEnum<{
+        base64: "base64";
+        hex: "hex";
+    }>>;
+    prefix: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    scheme: z.ZodLiteral<"timestamped_hmac_sha256">;
+    header: z.ZodString;
+    toleranceSeconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    scheme: z.ZodLiteral<"token">;
+    header: z.ZodString;
+    prefix: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>], "scheme">;
+export type WebhookSignatureFormat = z.infer<typeof WebhookSignatureFormat>;
+export declare const EventSourceStatus: z.ZodEnum<{
+    active: "active";
+    blocked: "blocked";
+    disabled: "disabled";
+}>;
+export type EventSourceStatus = z.infer<typeof EventSourceStatus>;
+/**
+ * Why an event source or trigger is not active, or why a source can't send
+ * an event type, as a code clients word in their own language. Each comes
+ * with the same reason as an English sentence (`statusReason`,
+ * `unavailableReason`) and, for some, what the app or server said
+ * (`…Detail`). The wire carries a plain string: a client reads a code it
+ * doesn't know, or none, as "show the sentence".
+ *
+ * - `turned_off`: someone turned it off.
+ * - `awaiting_secret`: a pasted Linear, Sentry or custom webhook waits for its signing secret.
+ * - `reconnect`: the owner's connection to the app has to be signed in again.
+ * - `missing_permission`: the connection no longer allows reading what the events need.
+ * - `app_not_enabled`: the app isn't turned on for the connected account.
+ * - `account_changed`: the connection now signs in as another account (the detail names it).
+ * - `connector_removed`: the app or connector is no longer added to the workspace.
+ * - `host_sign_in`: the server signs in through the app that embeds Opengeni, which automations can't use.
+ * - `events_unsupported`: the server doesn't offer events.
+ * - `event_type_gone`: the server no longer offers this event type.
+ * - `forbidden`: the server won't let the owner's account receive these events with these settings.
+ * - `invalid_arguments`: the server rejected the trigger's subscription arguments.
+ * - `needs_public_address`: the server sends this type only to a public https address, which the deployment lacks.
+ * - `push_only`: the server sends this type only over a held-open connection, which isn't supported yet.
+ * - `delivery_mode_unsupported`: the server won't send this type in a way the deployment can receive.
+ * - `callback_unreachable`: the server can't reach the deployment's webhook address.
+ * - `not_answering`: the app or server hasn't answered for over an hour.
+ * - `github_event_not_subscribed`: the GitHub App isn't subscribed to the event (the detail names it).
+ * - `unavailable`: the source can't receive events for another reason.
+ */
+export declare const EVENT_STATUS_REASON_CODES: readonly ["turned_off", "awaiting_secret", "reconnect", "missing_permission", "app_not_enabled", "account_changed", "connector_removed", "host_sign_in", "events_unsupported", "event_type_gone", "forbidden", "invalid_arguments", "needs_public_address", "push_only", "delivery_mode_unsupported", "callback_unreachable", "not_answering", "github_event_not_subscribed", "unavailable"];
+export type EventStatusReasonCode = (typeof EVENT_STATUS_REASON_CODES)[number];
+/** Whether `code` is one this version of the contract knows. */
+export declare function isEventStatusReasonCode(code: unknown): code is EventStatusReasonCode;
+/** Who can use a source and see its events: only its owner, or the workspace. */
+export declare const EventSourceVisibility: z.ZodEnum<{
+    private: "private";
+    workspace: "workspace";
+}>;
+export type EventSourceVisibility = z.infer<typeof EventSourceVisibility>;
+export declare const EVENT_SOURCE_NAME_MAX_LENGTH = 120;
+export declare const EVENT_TYPE_MAX_LENGTH = 200;
+export declare const EVENT_SUMMARY_MAX_LENGTH = 500;
+export declare const EVENT_SUBJECT_MAX_LENGTH = 300;
+/** Serialized UTF-8 bytes of an event's stored `data`; larger data is cut. */
+export declare const EVENT_DATA_MAX_BYTES: number;
+/** Raw request bodies above this size are refused before verification. */
+export declare const EVENT_DELIVERY_BODY_MAX_BYTES: number;
+export declare const EVENT_TRIGGERS_PER_AUTOMATION_MAX = 16;
+export declare const EVENT_TRIGGER_TYPES_MAX = 32;
+export declare const EVENT_TRIGGER_CONDITIONS_MAX = 16;
+export declare const DEFAULT_EVENT_RUNS_PER_HOUR = 30;
+export declare const MAX_EVENT_RUNS_PER_HOUR = 1000;
+/** Raw delivery bodies are deleted after this many days; delivery rows stay. */
+export declare const EVENT_DELIVERY_BODY_RETENTION_DAYS = 7;
+/** Normalized events and delivery rows are deleted after this many days. */
+export declare const EVENT_RETENTION_DAYS = 30;
+export declare const EventSourceName: z.ZodString;
+export declare const EventTypeName: z.ZodString;
+/**
+ * How a custom webhook source reads another app's deliveries. Paths are read
+ * in each event: the body, or each item of the list `batch` names.
+ */
+export declare const WebhookFormat: z.ZodObject<{
+    preset: z.ZodOptional<z.ZodString>;
+    signature: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        scheme: z.ZodLiteral<"standard_webhooks">;
+    }, z.core.$strict>, z.ZodObject<{
+        scheme: z.ZodLiteral<"hmac_sha256">;
+        header: z.ZodString;
+        encoding: z.ZodDefault<z.ZodEnum<{
+            base64: "base64";
+            hex: "hex";
+        }>>;
+        prefix: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        scheme: z.ZodLiteral<"timestamped_hmac_sha256">;
+        header: z.ZodString;
+        toleranceSeconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        scheme: z.ZodLiteral<"token">;
+        header: z.ZodString;
+        prefix: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>], "scheme">;
+    batch: z.ZodOptional<z.ZodObject<{
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    type: z.ZodUnion<readonly [z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        header: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        value: z.ZodString;
+    }, z.core.$strict>]>;
+    deliveryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        header: z.ZodString;
+    }, z.core.$strict>]>>;
+    eventId: z.ZodOptional<z.ZodString>;
+    occurredAt: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodString>;
+    subject: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    actor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type WebhookFormat = z.infer<typeof WebhookFormat>;
+export type WebhookFormatInput = z.input<typeof WebhookFormat>;
+/**
+ * Formats for apps whose webhooks are well known, keyed by their `preset`.
+ * A custom source made with one is the same as one that spells it out.
+ */
+export declare const WEBHOOK_FORMAT_PRESETS: {
+    /** Tailscale: a JSON list of events, signed `t=…,v1=…` over `<t>.<body>`. */
+    readonly tailscale: {
+        readonly preset: "tailscale";
+        readonly signature: {
+            readonly scheme: "timestamped_hmac_sha256";
+            readonly header: "Tailscale-Webhook-Signature";
+        };
+        readonly batch: {};
+        readonly type: {
+            readonly path: "type";
+        };
+        readonly occurredAt: "timestamp";
+        readonly summary: "message";
+        readonly subject: "data.deviceName";
+        readonly url: "data.url";
+        readonly actor: "data.actor";
+    };
+};
+export type WebhookFormatPreset = keyof typeof WEBHOOK_FORMAT_PRESETS;
+export declare const EventSourceMcpBinding: z.ZodObject<{
+    serverId: z.ZodString;
+    connectionId: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type EventSourceMcpBinding = z.infer<typeof EventSourceMcpBinding>;
+export declare const EventSource: z.ZodObject<{
+    id: z.ZodString;
+    workspaceId: z.ZodString;
+    kind: z.ZodEnum<{
+        github: "github";
+        gmail: "gmail";
+        mcp: "mcp";
+        slack: "slack";
+        webhook: "webhook";
+        workspace: "workspace";
+    }>;
+    adapter: z.ZodNullable<z.ZodEnum<{
+        custom: "custom";
+        linear: "linear";
+        sentry: "sentry";
+        standard: "standard";
+    }>>;
+    format: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        preset: z.ZodOptional<z.ZodString>;
+        signature: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            scheme: z.ZodLiteral<"standard_webhooks">;
+        }, z.core.$strict>, z.ZodObject<{
+            scheme: z.ZodLiteral<"hmac_sha256">;
+            header: z.ZodString;
+            encoding: z.ZodDefault<z.ZodEnum<{
+                base64: "base64";
+                hex: "hex";
+            }>>;
+            prefix: z.ZodDefault<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            scheme: z.ZodLiteral<"timestamped_hmac_sha256">;
+            header: z.ZodString;
+            toleranceSeconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            scheme: z.ZodLiteral<"token">;
+            header: z.ZodString;
+            prefix: z.ZodDefault<z.ZodString>;
+        }, z.core.$strict>], "scheme">;
+        batch: z.ZodOptional<z.ZodObject<{
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        type: z.ZodUnion<readonly [z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            header: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            value: z.ZodString;
+        }, z.core.$strict>]>;
+        deliveryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            header: z.ZodString;
+        }, z.core.$strict>]>>;
+        eventId: z.ZodOptional<z.ZodString>;
+        occurredAt: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        actor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    name: z.ZodString;
+    ownerSubjectId: z.ZodNullable<z.ZodString>;
+    visibility: z.ZodEnum<{
+        private: "private";
+        workspace: "workspace";
+    }>;
+    status: z.ZodEnum<{
+        active: "active";
+        blocked: "blocked";
+        disabled: "disabled";
+    }>;
+    statusReason: z.ZodNullable<z.ZodString>;
+    statusReasonCode: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    statusReasonDetail: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    webhookUrl: z.ZodNullable<z.ZodString>;
+    awaitingSigningSecret: z.ZodDefault<z.ZodBoolean>;
+    mcp: z.ZodNullable<z.ZodObject<{
+        serverId: z.ZodString;
+        connectionId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    lastDeliveryAt: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    viewerAccess: z.ZodOptional<z.ZodEnum<{
+        manage: "manage";
+        use: "use";
+    }>>;
+}, z.core.$strip>;
+export type EventSource = z.infer<typeof EventSource>;
+/**
+ * Linear and Sentry generate the secret once they have the webhook URL, so it
+ * is pasted on create or afterwards; a custom webhook takes the secret its app
+ * shows or the one a person chose there. Standard sources get one from
+ * Opengeni.
+ */
+export declare const EventSourceSigningSecretInput: z.ZodString;
+export declare const CreateEventSourceRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"webhook">;
+    adapter: z.ZodEnum<{
+        custom: "custom";
+        linear: "linear";
+        sentry: "sentry";
+        standard: "standard";
+    }>;
+    name: z.ZodString;
+    visibility: z.ZodDefault<z.ZodEnum<{
+        private: "private";
+        workspace: "workspace";
+    }>>;
+    signingSecret: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodObject<{
+        preset: z.ZodOptional<z.ZodString>;
+        signature: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            scheme: z.ZodLiteral<"standard_webhooks">;
+        }, z.core.$strict>, z.ZodObject<{
+            scheme: z.ZodLiteral<"hmac_sha256">;
+            header: z.ZodString;
+            encoding: z.ZodDefault<z.ZodEnum<{
+                base64: "base64";
+                hex: "hex";
+            }>>;
+            prefix: z.ZodDefault<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            scheme: z.ZodLiteral<"timestamped_hmac_sha256">;
+            header: z.ZodString;
+            toleranceSeconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            scheme: z.ZodLiteral<"token">;
+            header: z.ZodString;
+            prefix: z.ZodDefault<z.ZodString>;
+        }, z.core.$strict>], "scheme">;
+        batch: z.ZodOptional<z.ZodObject<{
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        type: z.ZodUnion<readonly [z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            header: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            value: z.ZodString;
+        }, z.core.$strict>]>;
+        deliveryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            header: z.ZodString;
+        }, z.core.$strict>]>>;
+        eventId: z.ZodOptional<z.ZodString>;
+        occurredAt: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        actor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodEnum<{
+        github: "github";
+        slack: "slack";
+    }>;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"gmail">;
+    connectionId: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"mcp">;
+    serverId: z.ZodString;
+    connectionId: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"workspace">;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "kind">;
+/** What a caller sends; a webhook source's `visibility` defaults to `private`. */
+export type CreateEventSourceRequest = z.input<typeof CreateEventSourceRequest>;
+export type ParsedCreateEventSourceRequest = z.output<typeof CreateEventSourceRequest>;
+export declare const CreateEventSourceResponse: z.ZodObject<{
+    source: z.ZodObject<{
+        id: z.ZodString;
+        workspaceId: z.ZodString;
+        kind: z.ZodEnum<{
+            github: "github";
+            gmail: "gmail";
+            mcp: "mcp";
+            slack: "slack";
+            webhook: "webhook";
+            workspace: "workspace";
+        }>;
+        adapter: z.ZodNullable<z.ZodEnum<{
+            custom: "custom";
+            linear: "linear";
+            sentry: "sentry";
+            standard: "standard";
+        }>>;
+        format: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            preset: z.ZodOptional<z.ZodString>;
+            signature: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                scheme: z.ZodLiteral<"standard_webhooks">;
+            }, z.core.$strict>, z.ZodObject<{
+                scheme: z.ZodLiteral<"hmac_sha256">;
+                header: z.ZodString;
+                encoding: z.ZodDefault<z.ZodEnum<{
+                    base64: "base64";
+                    hex: "hex";
+                }>>;
+                prefix: z.ZodDefault<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                scheme: z.ZodLiteral<"timestamped_hmac_sha256">;
+                header: z.ZodString;
+                toleranceSeconds: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>, z.ZodObject<{
+                scheme: z.ZodLiteral<"token">;
+                header: z.ZodString;
+                prefix: z.ZodDefault<z.ZodString>;
+            }, z.core.$strict>], "scheme">;
+            batch: z.ZodOptional<z.ZodObject<{
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            type: z.ZodUnion<readonly [z.ZodObject<{
+                path: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                header: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                value: z.ZodString;
+            }, z.core.$strict>]>;
+            deliveryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                path: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                header: z.ZodString;
+            }, z.core.$strict>]>>;
+            eventId: z.ZodOptional<z.ZodString>;
+            occurredAt: z.ZodOptional<z.ZodString>;
+            summary: z.ZodOptional<z.ZodString>;
+            subject: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+            actor: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        name: z.ZodString;
+        ownerSubjectId: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            private: "private";
+            workspace: "workspace";
+        }>;
+        status: z.ZodEnum<{
+            active: "active";
+            blocked: "blocked";
+            disabled: "disabled";
+        }>;
+        statusReason: z.ZodNullable<z.ZodString>;
+        statusReasonCode: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        statusReasonDetail: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        webhookUrl: z.ZodNullable<z.ZodString>;
+        awaitingSigningSecret: z.ZodDefault<z.ZodBoolean>;
+        mcp: z.ZodNullable<z.ZodObject<{
+            serverId: z.ZodString;
+            connectionId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        lastDeliveryAt: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        viewerAccess: z.ZodOptional<z.ZodEnum<{
+            manage: "manage";
+            use: "use";
+        }>>;
+    }, z.core.$strip>;
+    signingSecret: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CreateEventSourceResponse = z.infer<typeof CreateEventSourceResponse>;
+export declare const UpdateEventSourceRequest: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        private: "private";
+        workspace: "workspace";
+    }>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        disabled: "disabled";
+    }>>;
+    signingSecret: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodObject<{
+        preset: z.ZodOptional<z.ZodString>;
+        signature: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            scheme: z.ZodLiteral<"standard_webhooks">;
+        }, z.core.$strict>, z.ZodObject<{
+            scheme: z.ZodLiteral<"hmac_sha256">;
+            header: z.ZodString;
+            encoding: z.ZodDefault<z.ZodEnum<{
+                base64: "base64";
+                hex: "hex";
+            }>>;
+            prefix: z.ZodDefault<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            scheme: z.ZodLiteral<"timestamped_hmac_sha256">;
+            header: z.ZodString;
+            toleranceSeconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            scheme: z.ZodLiteral<"token">;
+            header: z.ZodString;
+            prefix: z.ZodDefault<z.ZodString>;
+        }, z.core.$strict>], "scheme">;
+        batch: z.ZodOptional<z.ZodObject<{
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        type: z.ZodUnion<readonly [z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            header: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            value: z.ZodString;
+        }, z.core.$strict>]>;
+        deliveryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            header: z.ZodString;
+        }, z.core.$strict>]>>;
+        eventId: z.ZodOptional<z.ZodString>;
+        occurredAt: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        actor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type UpdateEventSourceRequest = z.infer<typeof UpdateEventSourceRequest>;
+export declare const RotateEventSourceSecretResponse: z.ZodObject<{
+    signingSecret: z.ZodString;
+}, z.core.$strict>;
+export type RotateEventSourceSecretResponse = z.infer<typeof RotateEventSourceSecretResponse>;
+export declare const ListEventSourcesResponse: z.ZodObject<{
+    sources: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        workspaceId: z.ZodString;
+        kind: z.ZodEnum<{
+            github: "github";
+            gmail: "gmail";
+            mcp: "mcp";
+            slack: "slack";
+            webhook: "webhook";
+            workspace: "workspace";
+        }>;
+        adapter: z.ZodNullable<z.ZodEnum<{
+            custom: "custom";
+            linear: "linear";
+            sentry: "sentry";
+            standard: "standard";
+        }>>;
+        format: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            preset: z.ZodOptional<z.ZodString>;
+            signature: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                scheme: z.ZodLiteral<"standard_webhooks">;
+            }, z.core.$strict>, z.ZodObject<{
+                scheme: z.ZodLiteral<"hmac_sha256">;
+                header: z.ZodString;
+                encoding: z.ZodDefault<z.ZodEnum<{
+                    base64: "base64";
+                    hex: "hex";
+                }>>;
+                prefix: z.ZodDefault<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                scheme: z.ZodLiteral<"timestamped_hmac_sha256">;
+                header: z.ZodString;
+                toleranceSeconds: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strict>, z.ZodObject<{
+                scheme: z.ZodLiteral<"token">;
+                header: z.ZodString;
+                prefix: z.ZodDefault<z.ZodString>;
+            }, z.core.$strict>], "scheme">;
+            batch: z.ZodOptional<z.ZodObject<{
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            type: z.ZodUnion<readonly [z.ZodObject<{
+                path: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                header: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                value: z.ZodString;
+            }, z.core.$strict>]>;
+            deliveryId: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                path: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                header: z.ZodString;
+            }, z.core.$strict>]>>;
+            eventId: z.ZodOptional<z.ZodString>;
+            occurredAt: z.ZodOptional<z.ZodString>;
+            summary: z.ZodOptional<z.ZodString>;
+            subject: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+            actor: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        name: z.ZodString;
+        ownerSubjectId: z.ZodNullable<z.ZodString>;
+        visibility: z.ZodEnum<{
+            private: "private";
+            workspace: "workspace";
+        }>;
+        status: z.ZodEnum<{
+            active: "active";
+            blocked: "blocked";
+            disabled: "disabled";
+        }>;
+        statusReason: z.ZodNullable<z.ZodString>;
+        statusReasonCode: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        statusReasonDetail: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        webhookUrl: z.ZodNullable<z.ZodString>;
+        awaitingSigningSecret: z.ZodDefault<z.ZodBoolean>;
+        mcp: z.ZodNullable<z.ZodObject<{
+            serverId: z.ZodString;
+            connectionId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        lastDeliveryAt: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        viewerAccess: z.ZodOptional<z.ZodEnum<{
+            manage: "manage";
+            use: "use";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export type ListEventSourcesResponse = z.infer<typeof ListEventSourcesResponse>;
+/**
+ * Sources that need no setting up, named by a key until they are used: an
+ * MCP server the person is signed in to that offers events
+ * (`mcp-server:<serverId>`), a Gmail account they connected
+ * (`gmail:<connectionId>`), and "This workspace" (`workspace`). A trigger may
+ * name one by its key: the person's own source is added the first time it is
+ * used, and using the key again finds that same source.
+ */
+export declare const READY_EVENT_SOURCE_KINDS: readonly ["mcp", "gmail", "workspace"];
+export type ReadyEventSourceKind = (typeof READY_EVENT_SOURCE_KINDS)[number];
+/** What adds a ready source: the matching create request. */
+export type ReadyEventSourceRequest = {
+    kind: "mcp";
+    serverId: string;
+} | {
+    kind: "gmail";
+    connectionId: string;
+} | {
+    kind: "workspace";
+};
+export declare function readyEventSourceKey(request: ReadyEventSourceRequest): string;
+/** The source a key names, or null when it is not a ready source's key. */
+export declare function readyEventSourceRequest(key: string): ReadyEventSourceRequest | null;
+export declare const ReadyEventSource: z.ZodObject<{
+    key: z.ZodString;
+    kind: z.ZodEnum<{
+        gmail: "gmail";
+        mcp: "mcp";
+        workspace: "workspace";
+    }>;
+    name: z.ZodString;
+}, z.core.$strict>;
+export type ReadyEventSource = z.infer<typeof ReadyEventSource>;
+export declare const ListReadyEventSourcesResponse: z.ZodObject<{
+    sources: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        kind: z.ZodEnum<{
+            gmail: "gmail";
+            mcp: "mcp";
+            workspace: "workspace";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ListReadyEventSourcesResponse = z.infer<typeof ListReadyEventSourcesResponse>;
+/** A source's id, or a ready source's key. */
+export declare const EventSourceRef: z.ZodString;
+/** Whether a trigger's source names a ready source by its key rather than an id. */
+export declare function isReadyEventSourceKey(ref: string): boolean;
+/**
+ * Who caused an event. `opengeni` marks Opengeni's own identities (its GitHub
+ * App bot, its Slack bot); triggers ignore those events unless they opt in.
+ */
+export declare const EventActorKind: z.ZodEnum<{
+    bot: "bot";
+    opengeni: "opengeni";
+    person: "person";
+    unknown: "unknown";
+}>;
+export type EventActorKind = z.infer<typeof EventActorKind>;
+export declare const EventActor: z.ZodObject<{
+    kind: z.ZodEnum<{
+        bot: "bot";
+        opengeni: "opengeni";
+        person: "person";
+        unknown: "unknown";
+    }>;
+    name: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type EventActor = z.infer<typeof EventActor>;
+export declare const InboundEvent: z.ZodObject<{
+    id: z.ZodString;
+    sourceId: z.ZodString;
+    sourceKind: z.ZodEnum<{
+        github: "github";
+        gmail: "gmail";
+        mcp: "mcp";
+        slack: "slack";
+        webhook: "webhook";
+        workspace: "workspace";
+    }>;
+    type: z.ZodString;
+    occurredAt: z.ZodString;
+    receivedAt: z.ZodString;
+    subject: z.ZodNullable<z.ZodString>;
+    summary: z.ZodString;
+    url: z.ZodNullable<z.ZodString>;
+    actor: z.ZodObject<{
+        kind: z.ZodEnum<{
+            bot: "bot";
+            opengeni: "opengeni";
+            person: "person";
+            unknown: "unknown";
+        }>;
+        name: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    dataTruncated: z.ZodBoolean;
+    gapBefore: z.ZodBoolean;
+}, z.core.$strip>;
+export type InboundEvent = z.infer<typeof InboundEvent>;
+export declare const InboundEventSummary: z.ZodObject<{
+    id: z.ZodString;
+    sourceId: z.ZodString;
+    sourceKind: z.ZodEnum<{
+        github: "github";
+        gmail: "gmail";
+        mcp: "mcp";
+        slack: "slack";
+        webhook: "webhook";
+        workspace: "workspace";
+    }>;
+    type: z.ZodString;
+    occurredAt: z.ZodString;
+    subject: z.ZodNullable<z.ZodString>;
+    summary: z.ZodString;
+    url: z.ZodNullable<z.ZodString>;
+    actor: z.ZodObject<{
+        kind: z.ZodEnum<{
+            bot: "bot";
+            opengeni: "opengeni";
+            person: "person";
+            unknown: "unknown";
+        }>;
+        name: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+export type InboundEventSummary = z.infer<typeof InboundEventSummary>;
+export declare const ListInboundEventsResponse: z.ZodObject<{
+    events: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sourceId: z.ZodString;
+        sourceKind: z.ZodEnum<{
+            github: "github";
+            gmail: "gmail";
+            mcp: "mcp";
+            slack: "slack";
+            webhook: "webhook";
+            workspace: "workspace";
+        }>;
+        type: z.ZodString;
+        occurredAt: z.ZodString;
+        receivedAt: z.ZodString;
+        subject: z.ZodNullable<z.ZodString>;
+        summary: z.ZodString;
+        url: z.ZodNullable<z.ZodString>;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                bot: "bot";
+                opengeni: "opengeni";
+                person: "person";
+                unknown: "unknown";
+            }>;
+            name: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        dataTruncated: z.ZodBoolean;
+        gapBefore: z.ZodBoolean;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type ListInboundEventsResponse = z.infer<typeof ListInboundEventsResponse>;
+export declare const EventDeliveryStatus: z.ZodEnum<{
+    accepted: "accepted";
+    failed: "failed";
+    ignored: "ignored";
+    rejected: "rejected";
+}>;
+export type EventDeliveryStatus = z.infer<typeof EventDeliveryStatus>;
+export declare const EventDelivery: z.ZodObject<{
+    id: z.ZodString;
+    sourceId: z.ZodString;
+    receivedAt: z.ZodString;
+    status: z.ZodEnum<{
+        accepted: "accepted";
+        failed: "failed";
+        ignored: "ignored";
+        rejected: "rejected";
+    }>;
+    reason: z.ZodNullable<z.ZodString>;
+    eventIds: z.ZodArray<z.ZodString>;
+    eventTypes: z.ZodArray<z.ZodString>;
+    bodyBytes: z.ZodNumber;
+    bodyRetained: z.ZodBoolean;
+    duplicateCount: z.ZodNumber;
+    replayOfDeliveryId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type EventDelivery = z.infer<typeof EventDelivery>;
+export declare const ListEventDeliveriesResponse: z.ZodObject<{
+    deliveries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sourceId: z.ZodString;
+        receivedAt: z.ZodString;
+        status: z.ZodEnum<{
+            accepted: "accepted";
+            failed: "failed";
+            ignored: "ignored";
+            rejected: "rejected";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+        eventIds: z.ZodArray<z.ZodString>;
+        eventTypes: z.ZodArray<z.ZodString>;
+        bodyBytes: z.ZodNumber;
+        bodyRetained: z.ZodBoolean;
+        duplicateCount: z.ZodNumber;
+        replayOfDeliveryId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type ListEventDeliveriesResponse = z.infer<typeof ListEventDeliveriesResponse>;
+export declare const ReplayEventDeliveryResponse: z.ZodObject<{
+    delivery: z.ZodObject<{
+        id: z.ZodString;
+        sourceId: z.ZodString;
+        receivedAt: z.ZodString;
+        status: z.ZodEnum<{
+            accepted: "accepted";
+            failed: "failed";
+            ignored: "ignored";
+            rejected: "rejected";
+        }>;
+        reason: z.ZodNullable<z.ZodString>;
+        eventIds: z.ZodArray<z.ZodString>;
+        eventTypes: z.ZodArray<z.ZodString>;
+        bodyBytes: z.ZodNumber;
+        bodyRetained: z.ZodBoolean;
+        duplicateCount: z.ZodNumber;
+        replayOfDeliveryId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+export type ReplayEventDeliveryResponse = z.infer<typeof ReplayEventDeliveryResponse>;
+export declare const SendTestEventRequest: z.ZodObject<{
+    type: z.ZodDefault<z.ZodString>;
+    data: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+/** What a caller sends; `type` defaults to `opengeni.test` and `data` to `{}`. */
+export type SendTestEventRequest = z.input<typeof SendTestEventRequest>;
+export type ParsedSendTestEventRequest = z.output<typeof SendTestEventRequest>;
+export declare const SendTestEventResponse: z.ZodObject<{
+    event: z.ZodObject<{
+        id: z.ZodString;
+        sourceId: z.ZodString;
+        sourceKind: z.ZodEnum<{
+            github: "github";
+            gmail: "gmail";
+            mcp: "mcp";
+            slack: "slack";
+            webhook: "webhook";
+            workspace: "workspace";
+        }>;
+        type: z.ZodString;
+        occurredAt: z.ZodString;
+        receivedAt: z.ZodString;
+        subject: z.ZodNullable<z.ZodString>;
+        summary: z.ZodString;
+        url: z.ZodNullable<z.ZodString>;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                bot: "bot";
+                opengeni: "opengeni";
+                person: "person";
+                unknown: "unknown";
+            }>;
+            name: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        dataTruncated: z.ZodBoolean;
+        gapBefore: z.ZodBoolean;
+    }, z.core.$strip>;
+    matchedAutomationIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type SendTestEventResponse = z.infer<typeof SendTestEventResponse>;
+/** A field an event condition can read. */
+export declare const EVENT_CONDITION_FIELD_PATTERN: RegExp;
+export declare const EventConditionOperator: z.ZodEnum<{
+    contains: "contains";
+    equals: "equals";
+    exists: "exists";
+    in: "in";
+    not_equals: "not_equals";
+    not_exists: "not_exists";
+    not_in: "not_in";
+}>;
+export type EventConditionOperator = z.infer<typeof EventConditionOperator>;
+export declare const EventCondition: z.ZodObject<{
+    field: z.ZodString;
+    op: z.ZodEnum<{
+        contains: "contains";
+        equals: "equals";
+        exists: "exists";
+        in: "in";
+        not_equals: "not_equals";
+        not_exists: "not_exists";
+        not_in: "not_in";
+    }>;
+    value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>;
+}, z.core.$strict>;
+export type EventCondition = z.infer<typeof EventCondition>;
+export declare const EventTriggerInput: z.ZodObject<{
+    sourceId: z.ZodString;
+    eventTypes: z.ZodArray<z.ZodString>;
+    conditions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        op: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            exists: "exists";
+            in: "in";
+            not_equals: "not_equals";
+            not_exists: "not_exists";
+            not_in: "not_in";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>;
+    }, z.core.$strict>>>;
+    includeOwnEvents: z.ZodDefault<z.ZodBoolean>;
+    arguments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type EventTriggerInput = z.input<typeof EventTriggerInput>;
+export type ParsedEventTriggerInput = z.output<typeof EventTriggerInput>;
+export declare const EventTriggerStatus: z.ZodEnum<{
+    active: "active";
+    blocked: "blocked";
+    disabled: "disabled";
+}>;
+export type EventTriggerStatus = z.infer<typeof EventTriggerStatus>;
+export declare const EventTrigger: z.ZodObject<{
+    id: z.ZodString;
+    sourceId: z.ZodString;
+    sourceKind: z.ZodEnum<{
+        github: "github";
+        gmail: "gmail";
+        mcp: "mcp";
+        slack: "slack";
+        webhook: "webhook";
+        workspace: "workspace";
+    }>;
+    eventTypes: z.ZodArray<z.ZodString>;
+    conditions: z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        op: z.ZodEnum<{
+            contains: "contains";
+            equals: "equals";
+            exists: "exists";
+            in: "in";
+            not_equals: "not_equals";
+            not_exists: "not_exists";
+            not_in: "not_in";
+        }>;
+        value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>;
+    }, z.core.$strict>>;
+    includeOwnEvents: z.ZodBoolean;
+    arguments: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    status: z.ZodEnum<{
+        active: "active";
+        blocked: "blocked";
+        disabled: "disabled";
+    }>;
+    statusReason: z.ZodNullable<z.ZodString>;
+    statusReasonCode: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    statusReasonDetail: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type EventTrigger = z.infer<typeof EventTrigger>;
+/**
+ * What the automations that continue a chat are waiting for, as the chat list
+ * and header show it: the soonest scheduled run and the events that can start
+ * a run. Only automations the reader can see contribute; a chat that waits
+ * only on someone else's private automation has none.
+ */
+export declare const SessionAutomationWaitSummary: z.ZodObject<{
+    nextRunAt: z.ZodNullable<z.ZodString>;
+    event: z.ZodNullable<z.ZodObject<{
+        source: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                github: "github";
+                gmail: "gmail";
+                mcp: "mcp";
+                slack: "slack";
+                webhook: "webhook";
+                workspace: "workspace";
+            }>;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        eventTypes: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    events: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        source: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                github: "github";
+                gmail: "gmail";
+                mcp: "mcp";
+                slack: "slack";
+                webhook: "webhook";
+                workspace: "workspace";
+            }>;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        eventTypes: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>>;
+    automations: z.ZodNumber;
+}, z.core.$strict>;
+export type SessionAutomationWaitSummary = z.infer<typeof SessionAutomationWaitSummary>;
+/** Event triggers and the event run policy of an automation. */
+export declare const ScheduledTaskEventsInput: z.ZodObject<{
+    triggers: z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodString;
+        eventTypes: z.ZodArray<z.ZodString>;
+        conditions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                equals: "equals";
+                exists: "exists";
+                in: "in";
+                not_equals: "not_equals";
+                not_exists: "not_exists";
+                not_in: "not_in";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>;
+        }, z.core.$strict>>>;
+        includeOwnEvents: z.ZodDefault<z.ZodBoolean>;
+        arguments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+    maxRunsPerHour: z.ZodOptional<z.ZodNumber>;
+    once: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type ScheduledTaskEventsInput = z.input<typeof ScheduledTaskEventsInput>;
+export type ParsedScheduledTaskEventsInput = z.output<typeof ScheduledTaskEventsInput>;
+export declare const ScheduledTaskEvents: z.ZodObject<{
+    triggers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sourceId: z.ZodString;
+        sourceKind: z.ZodEnum<{
+            github: "github";
+            gmail: "gmail";
+            mcp: "mcp";
+            slack: "slack";
+            webhook: "webhook";
+            workspace: "workspace";
+        }>;
+        eventTypes: z.ZodArray<z.ZodString>;
+        conditions: z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                contains: "contains";
+                equals: "equals";
+                exists: "exists";
+                in: "in";
+                not_equals: "not_equals";
+                not_exists: "not_exists";
+                not_in: "not_in";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>;
+        }, z.core.$strict>>;
+        includeOwnEvents: z.ZodBoolean;
+        arguments: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        status: z.ZodEnum<{
+            active: "active";
+            blocked: "blocked";
+            disabled: "disabled";
+        }>;
+        statusReason: z.ZodNullable<z.ZodString>;
+        statusReasonCode: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        statusReasonDetail: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    maxRunsPerHour: z.ZodNumber;
+    once: z.ZodBoolean;
+    completedAt: z.ZodNullable<z.ZodString>;
+    throttledSince: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ScheduledTaskEvents = z.infer<typeof ScheduledTaskEvents>;
+/** The events an event run carried. */
+export declare const ScheduledTaskRunEventOccurrence: z.ZodObject<{
+    triggerIds: z.ZodArray<z.ZodString>;
+    eventCount: z.ZodNumber;
+    events: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sourceId: z.ZodString;
+        sourceKind: z.ZodEnum<{
+            github: "github";
+            gmail: "gmail";
+            mcp: "mcp";
+            slack: "slack";
+            webhook: "webhook";
+            workspace: "workspace";
+        }>;
+        type: z.ZodString;
+        occurredAt: z.ZodString;
+        subject: z.ZodNullable<z.ZodString>;
+        summary: z.ZodString;
+        url: z.ZodNullable<z.ZodString>;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                bot: "bot";
+                opengeni: "opengeni";
+                person: "person";
+                unknown: "unknown";
+            }>;
+            name: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ScheduledTaskRunEventOccurrence = z.infer<typeof ScheduledTaskRunEventOccurrence>;
+/** Bytes of a run's chat update spent on its events at most. */
+export declare const SCHEDULED_OCCURRENCE_EVENTS_MAX_BYTES: number;
+/** Bytes of one carried event's `data` at most; the full event stays fetchable by id. */
+export declare const SCHEDULED_OCCURRENCE_EVENT_DATA_MAX_BYTES: number;
+export declare const ScheduledOccurrenceEvent: z.ZodObject<{
+    id: z.ZodString;
+    sourceId: z.ZodString;
+    sourceKind: z.ZodEnum<{
+        github: "github";
+        gmail: "gmail";
+        mcp: "mcp";
+        slack: "slack";
+        webhook: "webhook";
+        workspace: "workspace";
+    }>;
+    type: z.ZodString;
+    occurredAt: z.ZodString;
+    subject: z.ZodNullable<z.ZodString>;
+    summary: z.ZodString;
+    url: z.ZodNullable<z.ZodString>;
+    actor: z.ZodObject<{
+        kind: z.ZodEnum<{
+            bot: "bot";
+            opengeni: "opengeni";
+            person: "person";
+            unknown: "unknown";
+        }>;
+        name: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    dataTruncated: z.ZodBoolean;
+}, z.core.$strip>;
+export type ScheduledOccurrenceEvent = z.infer<typeof ScheduledOccurrenceEvent>;
+/**
+ * The events an event run delivers into its chat, bounded to fit the chat
+ * update. `events` holds the oldest that fit; `eventCount` counts them all.
+ */
+export declare const ScheduledOccurrenceEvents: z.ZodObject<{
+    occurrenceId: z.ZodString;
+    eventCount: z.ZodNumber;
+    events: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sourceId: z.ZodString;
+        sourceKind: z.ZodEnum<{
+            github: "github";
+            gmail: "gmail";
+            mcp: "mcp";
+            slack: "slack";
+            webhook: "webhook";
+            workspace: "workspace";
+        }>;
+        type: z.ZodString;
+        occurredAt: z.ZodString;
+        subject: z.ZodNullable<z.ZodString>;
+        summary: z.ZodString;
+        url: z.ZodNullable<z.ZodString>;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                bot: "bot";
+                opengeni: "opengeni";
+                person: "person";
+                unknown: "unknown";
+            }>;
+            name: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        dataTruncated: z.ZodBoolean;
+    }, z.core.$strip>>;
+    gapBefore: z.ZodBoolean;
+}, z.core.$strip>;
+export type ScheduledOccurrenceEvents = z.infer<typeof ScheduledOccurrenceEvents>;
+/** An event type a source offers, for trigger pickers and agents. */
+export declare const EventTypeDescriptor: z.ZodObject<{
+    type: z.ZodString;
+    description: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+    argumentsSchema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    available: z.ZodBoolean;
+    unavailableReason: z.ZodNullable<z.ZodString>;
+    unavailableReasonCode: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    unavailableReasonDetail: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type EventTypeDescriptor = z.infer<typeof EventTypeDescriptor>;
+export declare const ListEventTypesResponse: z.ZodObject<{
+    sourceId: z.ZodString;
+    eventTypes: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        description: z.ZodString;
+        fields: z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strip>>;
+        argumentsSchema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        available: z.ZodBoolean;
+        unavailableReason: z.ZodNullable<z.ZodString>;
+        unavailableReasonCode: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        unavailableReasonDetail: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export type ListEventTypesResponse = z.infer<typeof ListEventTypesResponse>;