@opengeni/contracts 5.5.0 → 5.5.2-canary.40656248492001

package/dist/chunk-PI5VIKJY.js

@@ -0,0 +1,660 @@
+import {
+  defineSchema
+} from "./chunk-56SNIMDO.js";
+
+// src/event-triggers.ts
+import { z } from "zod";
+var EVENT_SOURCE_KINDS = [
+  "webhook",
+  "github",
+  "slack",
+  "gmail",
+  "mcp",
+  "workspace"
+];
+var EventSourceKind = /* @__PURE__ */ defineSchema(() => z.enum(EVENT_SOURCE_KINDS));
+var WEBHOOK_EVENT_ADAPTERS = ["standard", "linear", "sentry", "custom"];
+var WebhookEventAdapter = /* @__PURE__ */ defineSchema(
+  () => z.enum(WEBHOOK_EVENT_ADAPTERS)
+);
+var WebhookHeaderName = /* @__PURE__ */ defineSchema(
+  () => z.string().regex(/^[!#$%&'*+.^_`|~0-9A-Za-z-]{1,100}$/u, "A header name such as X-Signature")
+);
+var WebhookJsonPath = /* @__PURE__ */ defineSchema(
+  () => z.string().max(200).regex(/^[^.\s]+(?:\.[^.\s]+)*$/u, "A dot-separated path such as data.object.id")
+);
+var WebhookValueSource = /* @__PURE__ */ defineSchema(
+  () => z.union([
+    z.object({ path: WebhookJsonPath }).strict(),
+    z.object({ header: WebhookHeaderName }).strict()
+  ])
+);
+var WebhookSignatureFormat = /* @__PURE__ */ defineSchema(
+  () => z.discriminatedUnion("scheme", [
+    z.object({ scheme: z.literal("standard_webhooks") }).strict(),
+    z.object({
+      scheme: z.literal("hmac_sha256"),
+      header: WebhookHeaderName,
+      encoding: z.enum(["hex", "base64"]).default("hex"),
+      prefix: z.string().max(32).default("")
+    }).strict(),
+    z.object({
+      scheme: z.literal("timestamped_hmac_sha256"),
+      header: WebhookHeaderName,
+      toleranceSeconds: z.number().int().min(60).max(3600).default(300)
+    }).strict(),
+    z.object({
+      scheme: z.literal("token"),
+      header: WebhookHeaderName,
+      prefix: z.string().max(32).default("")
+    }).strict()
+  ])
+);
+var EventSourceStatus = /* @__PURE__ */ defineSchema(
+  () => z.enum(["active", "disabled", "blocked"])
+);
+var EVENT_STATUS_REASON_CODES = [
+  "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"
+];
+function isEventStatusReasonCode(code) {
+  return typeof code === "string" && EVENT_STATUS_REASON_CODES.includes(code);
+}
+var EventSourceVisibility = /* @__PURE__ */ defineSchema(
+  () => z.enum(["private", "workspace"])
+);
+var EVENT_SOURCE_NAME_MAX_LENGTH = 120;
+var EVENT_TYPE_MAX_LENGTH = 200;
+var EVENT_SUMMARY_MAX_LENGTH = 500;
+var EVENT_SUBJECT_MAX_LENGTH = 300;
+var EVENT_DATA_MAX_BYTES = 64 * 1024;
+var EVENT_DELIVERY_BODY_MAX_BYTES = 1024 * 1024;
+var EVENT_TRIGGERS_PER_AUTOMATION_MAX = 16;
+var EVENT_TRIGGER_TYPES_MAX = 32;
+var EVENT_TRIGGER_CONDITIONS_MAX = 16;
+var DEFAULT_EVENT_RUNS_PER_HOUR = 30;
+var MAX_EVENT_RUNS_PER_HOUR = 1e3;
+var EVENT_DELIVERY_BODY_RETENTION_DAYS = 7;
+var EVENT_RETENTION_DAYS = 30;
+var Uuid = /* @__PURE__ */ defineSchema(() => z.string().uuid());
+var Timestamp = /* @__PURE__ */ defineSchema(() => z.string());
+var EventSourceName = /* @__PURE__ */ defineSchema(
+  () => z.string().trim().min(1).max(EVENT_SOURCE_NAME_MAX_LENGTH)
+);
+var EventTypeName = /* @__PURE__ */ defineSchema(
+  () => z.string().min(1).max(EVENT_TYPE_MAX_LENGTH).regex(/^[\x21-\x7e]+$/u, "Event types are printable ASCII without spaces")
+);
+var WebhookFormat = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    /** The preset that filled this in, such as `tailscale`: names the app and its documented event types. */
+    preset: z.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/u).optional(),
+    signature: WebhookSignatureFormat,
+    /**
+     * Present when one delivery holds several events: the body is a JSON
+     * list of them, or holds one at `path`. Absent: the body is one event.
+     */
+    batch: z.object({ path: WebhookJsonPath.optional() }).strict().optional(),
+    /** The event type: a path or header, or one `value` for every delivery. */
+    type: z.union([
+      z.object({ path: WebhookJsonPath }).strict(),
+      z.object({ header: WebhookHeaderName }).strict(),
+      z.object({ value: EventTypeName }).strict()
+    ]),
+    /** The delivery's id, so a retried delivery is kept once; else the body's hash. */
+    deliveryId: WebhookValueSource.optional(),
+    /** Each event's own id, so an event delivered twice runs automations once. */
+    eventId: WebhookJsonPath.optional(),
+    /** When it happened: an ISO time or Unix seconds or milliseconds. */
+    occurredAt: WebhookJsonPath.optional(),
+    /** A one-line description; the event type when absent. */
+    summary: WebhookJsonPath.optional(),
+    /** What it is about, such as a device or order name. */
+    subject: WebhookJsonPath.optional(),
+    /** A link to it in the app. */
+    url: WebhookJsonPath.optional(),
+    /** Who did it. */
+    actor: WebhookJsonPath.optional()
+  }).strict()
+);
+var WEBHOOK_FORMAT_PRESETS = {
+  /** Tailscale: a JSON list of events, signed `t=…,v1=…` over `<t>.<body>`. */
+  tailscale: {
+    preset: "tailscale",
+    signature: { scheme: "timestamped_hmac_sha256", header: "Tailscale-Webhook-Signature" },
+    batch: {},
+    type: { path: "type" },
+    occurredAt: "timestamp",
+    summary: "message",
+    subject: "data.deviceName",
+    url: "data.url",
+    actor: "data.actor"
+  }
+};
+var EventSourceMcpBinding = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    /** The MCP server id as configured for the workspace. */
+    serverId: z.string().min(1).max(256),
+    /** The owner's connection used for every events/* request. */
+    connectionId: Uuid.nullable()
+  }).strict()
+);
+var EventSource = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    id: Uuid,
+    workspaceId: Uuid,
+    kind: EventSourceKind,
+    /** Webhook sources only. */
+    adapter: WebhookEventAdapter.nullable(),
+    /** How a `custom` webhook source reads its app's deliveries; null otherwise. */
+    format: WebhookFormat.nullable().default(null),
+    name: z.string(),
+    /** The person the source belongs to; null for workspace app sources. */
+    ownerSubjectId: z.string().nullable(),
+    visibility: EventSourceVisibility,
+    status: EventSourceStatus,
+    /** Why the source is blocked or disabled, in plain language. */
+    statusReason: z.string().nullable(),
+    /**
+     * The same reason as a code (`EVENT_STATUS_REASON_CODES`) a client words
+     * in its own language; null when active or from an older server.
+     */
+    statusReasonCode: z.string().nullable().default(null),
+    /** What the app or server said about it, verbatim, when it said something. */
+    statusReasonDetail: z.string().nullable().default(null),
+    /** The URL to paste into the sending app. Webhook sources only. */
+    webhookUrl: z.string().nullable(),
+    /**
+     * A Linear, Sentry or custom webhook whose secret is not pasted yet: it
+     * refuses deliveries until the secret is set with an update.
+     */
+    awaitingSigningSecret: z.boolean().default(false),
+    /** MCP sources only. */
+    mcp: EventSourceMcpBinding.nullable(),
+    lastDeliveryAt: Timestamp.nullable(),
+    createdAt: Timestamp,
+    updatedAt: Timestamp,
+    /**
+     * What the reading person can do with the source: `manage` (its owner or
+     * a workspace admin: edit, rotate, test, replay, delete) or `use` (point
+     * triggers at it and read its log). Set on REST reads.
+     */
+    viewerAccess: z.enum(["manage", "use"]).optional()
+  })
+);
+var EventSourceSigningSecretInput = /* @__PURE__ */ defineSchema(
+  () => z.string().min(8).max(512)
+);
+var CreateEventSourceRequest = /* @__PURE__ */ defineSchema(
+  () => z.discriminatedUnion("kind", [
+    z.object({
+      kind: z.literal("webhook"),
+      adapter: WebhookEventAdapter,
+      name: EventSourceName,
+      visibility: EventSourceVisibility.default("private"),
+      signingSecret: EventSourceSigningSecretInput.optional(),
+      /** Required for, and only for, the `custom` adapter. */
+      format: WebhookFormat.optional()
+    }).strict(),
+    z.object({
+      kind: z.enum(["github", "slack"]),
+      name: EventSourceName.optional()
+    }).strict(),
+    z.object({
+      kind: z.literal("gmail"),
+      /** The mailbox connection; defaults to the caller's only Gmail connection. */
+      connectionId: Uuid.optional(),
+      name: EventSourceName.optional()
+    }).strict(),
+    z.object({
+      kind: z.literal("mcp"),
+      serverId: z.string().min(1).max(256),
+      connectionId: Uuid.optional(),
+      name: EventSourceName.optional()
+    }).strict(),
+    z.object({
+      /**
+       * The caller's own "This workspace" source. There is one per person,
+       * so creating it again returns the existing one.
+       */
+      kind: z.literal("workspace"),
+      name: EventSourceName.optional()
+    }).strict()
+  ]).superRefine((value, context) => {
+    if (value.kind === "webhook" && value.adapter === "standard" && value.signingSecret !== void 0) {
+      context.addIssue({
+        code: "custom",
+        path: ["signingSecret"],
+        message: "Opengeni generates the signing secret for standard webhooks"
+      });
+    }
+    if (value.kind === "webhook" && value.adapter === "custom" !== (value.format !== void 0)) {
+      context.addIssue({
+        code: "custom",
+        path: ["format"],
+        message: value.adapter === "custom" ? "A custom webhook needs a format" : "Only a custom webhook takes a format"
+      });
+    }
+  })
+);
+var CreateEventSourceResponse = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    source: EventSource,
+    /** Standard webhook sources only; shown once. */
+    signingSecret: z.string().optional()
+  }).strict()
+);
+var UpdateEventSourceRequest = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    name: EventSourceName.optional(),
+    visibility: EventSourceVisibility.optional(),
+    status: z.enum(["active", "disabled"]).optional(),
+    /** Replace a pasted Linear, Sentry or custom webhook secret. */
+    signingSecret: EventSourceSigningSecretInput.optional(),
+    /** Replace a custom webhook's format. */
+    format: WebhookFormat.optional()
+  }).strict().refine((value) => Object.keys(value).length > 0, "Supply at least one field")
+);
+var RotateEventSourceSecretResponse = /* @__PURE__ */ defineSchema(
+  () => z.object({ signingSecret: z.string() }).strict()
+);
+var ListEventSourcesResponse = /* @__PURE__ */ defineSchema(
+  () => z.object({ sources: z.array(EventSource) }).strict()
+);
+var READY_EVENT_SOURCE_KINDS = ["mcp", "gmail", "workspace"];
+var MCP_SERVER_KEY_PREFIX = "mcp-server:";
+var GMAIL_KEY_PREFIX = "gmail:";
+var WORKSPACE_KEY = "workspace";
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
+var SERVER_ID_MAX_LENGTH = 256;
+function readyEventSourceKey(request) {
+  if (request.kind === "mcp") return `${MCP_SERVER_KEY_PREFIX}${request.serverId}`;
+  if (request.kind === "gmail") return `${GMAIL_KEY_PREFIX}${request.connectionId}`;
+  return WORKSPACE_KEY;
+}
+function readyEventSourceRequest(key) {
+  if (key === WORKSPACE_KEY) return { kind: "workspace" };
+  if (key.startsWith(MCP_SERVER_KEY_PREFIX)) {
+    const serverId = key.slice(MCP_SERVER_KEY_PREFIX.length);
+    return serverId.length > 0 && serverId.length <= SERVER_ID_MAX_LENGTH ? { kind: "mcp", serverId } : null;
+  }
+  if (key.startsWith(GMAIL_KEY_PREFIX)) {
+    const connectionId = key.slice(GMAIL_KEY_PREFIX.length);
+    return UUID_PATTERN.test(connectionId) ? { kind: "gmail", connectionId } : null;
+  }
+  return null;
+}
+var ReadyEventSource = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    /** Use it wherever a trigger names a source; see `readyEventSourceRequest`. */
+    key: z.string(),
+    kind: z.enum(READY_EVENT_SOURCE_KINDS),
+    name: z.string()
+  }).strict()
+);
+var ListReadyEventSourcesResponse = /* @__PURE__ */ defineSchema(
+  () => z.object({ sources: z.array(ReadyEventSource) }).strict()
+);
+var EventSourceRef = /* @__PURE__ */ defineSchema(
+  () => z.string().min(1).max(MCP_SERVER_KEY_PREFIX.length + SERVER_ID_MAX_LENGTH).refine(
+    (ref) => UUID_PATTERN.test(ref) || readyEventSourceRequest(ref) !== null,
+    "Use an event source's id or a ready source's key"
+  )
+);
+function isReadyEventSourceKey(ref) {
+  return !UUID_PATTERN.test(ref) && readyEventSourceRequest(ref) !== null;
+}
+var EventActorKind = /* @__PURE__ */ defineSchema(
+  () => z.enum(["person", "bot", "opengeni", "unknown"])
+);
+var EventActor = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    kind: EventActorKind,
+    name: z.string().max(200).nullable()
+  }).strict()
+);
+var InboundEvent = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    id: Uuid,
+    sourceId: Uuid,
+    sourceKind: EventSourceKind,
+    type: z.string(),
+    occurredAt: Timestamp,
+    receivedAt: Timestamp,
+    /** What the event is about, such as `acme/api#42`. */
+    subject: z.string().nullable(),
+    /** One line a person or agent can read. */
+    summary: z.string(),
+    /** A link to the thing in its app, when known. */
+    url: z.string().nullable(),
+    actor: EventActor,
+    data: z.record(z.string(), z.unknown()),
+    /** The source's data was larger than the stored budget and was cut. */
+    dataTruncated: z.boolean(),
+    /** Events from this source may have been missed just before this one. */
+    gapBefore: z.boolean()
+  })
+);
+var InboundEventSummary = /* @__PURE__ */ defineSchema(
+  () => InboundEvent.pick({
+    id: true,
+    sourceId: true,
+    sourceKind: true,
+    type: true,
+    occurredAt: true,
+    subject: true,
+    summary: true,
+    url: true,
+    actor: true
+  })
+);
+var ListInboundEventsResponse = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    events: z.array(InboundEvent),
+    nextCursor: z.string().nullable()
+  }).strict()
+);
+var EventDeliveryStatus = /* @__PURE__ */ defineSchema(
+  () => z.enum(["accepted", "ignored", "rejected", "failed"])
+);
+var EventDelivery = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    id: Uuid,
+    sourceId: Uuid,
+    receivedAt: Timestamp,
+    status: EventDeliveryStatus,
+    /** Why a delivery was ignored, rejected or failed, in plain language. */
+    reason: z.string().nullable(),
+    eventIds: z.array(Uuid),
+    /** The types of the events it became, each once, in order. */
+    eventTypes: z.array(z.string()),
+    bodyBytes: z.number().int().nonnegative(),
+    /** The raw body is kept for a few days so a delivery can be replayed. */
+    bodyRetained: z.boolean(),
+    /** How many times the sender delivered this same delivery again. */
+    duplicateCount: z.number().int().nonnegative(),
+    replayOfDeliveryId: Uuid.nullable()
+  })
+);
+var ListEventDeliveriesResponse = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    deliveries: z.array(EventDelivery),
+    nextCursor: z.string().nullable()
+  }).strict()
+);
+var ReplayEventDeliveryResponse = /* @__PURE__ */ defineSchema(
+  () => z.object({ delivery: EventDelivery }).strict()
+);
+var SendTestEventRequest = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    type: EventTypeName.default("opengeni.test"),
+    data: z.record(z.string(), z.unknown()).default({})
+  }).strict()
+);
+var SendTestEventResponse = /* @__PURE__ */ defineSchema(
+  () => z.object({ event: InboundEvent, matchedAutomationIds: z.array(Uuid) }).strict()
+);
+var EVENT_CONDITION_FIELD_PATTERN = /^(?:type|subject|summary|url|actor\.kind|actor\.name|data(?:\.[A-Za-z0-9_@$-]{1,64}){1,8})$/u;
+var EventConditionOperator = /* @__PURE__ */ defineSchema(
+  () => z.enum(["equals", "not_equals", "in", "not_in", "contains", "exists", "not_exists"])
+);
+var EventConditionScalar = /* @__PURE__ */ defineSchema(
+  () => z.union([z.string().max(500), z.number().finite(), z.boolean(), z.null()])
+);
+var EventCondition = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    /** `type`, `subject`, `summary`, `url`, `actor.kind`, `actor.name`, or `data.<path>`. */
+    field: z.string().regex(EVENT_CONDITION_FIELD_PATTERN, "Unsupported event field"),
+    op: EventConditionOperator,
+    value: z.union([EventConditionScalar, z.array(EventConditionScalar).max(50)]).optional()
+  }).strict().superRefine((condition, context) => {
+    const presence = condition.op === "exists" || condition.op === "not_exists";
+    const list = condition.op === "in" || condition.op === "not_in";
+    if (presence && condition.value !== void 0) {
+      context.addIssue({
+        code: "custom",
+        path: ["value"],
+        message: `${condition.op} takes no value`
+      });
+    }
+    if (!presence && condition.value === void 0) {
+      context.addIssue({
+        code: "custom",
+        path: ["value"],
+        message: `${condition.op} needs a value`
+      });
+    }
+    if (list && !Array.isArray(condition.value)) {
+      context.addIssue({
+        code: "custom",
+        path: ["value"],
+        message: `${condition.op} needs a list`
+      });
+    }
+    if (!list && Array.isArray(condition.value)) {
+      context.addIssue({
+        code: "custom",
+        path: ["value"],
+        message: `${condition.op} needs one value`
+      });
+    }
+  })
+);
+var EventTriggerInput = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    /** The source's id, or a ready source's key: the owner's source is added on first use. */
+    sourceId: EventSourceRef,
+    /** Event types that fire the trigger. An MCP trigger names exactly one. */
+    eventTypes: z.array(EventTypeName).min(1).max(EVENT_TRIGGER_TYPES_MAX),
+    /** All conditions must hold. */
+    conditions: z.array(EventCondition).max(EVENT_TRIGGER_CONDITIONS_MAX).default([]),
+    /** Also fire on events made by Opengeni's own bots. */
+    includeOwnEvents: z.boolean().default(false),
+    /** MCP subscription arguments, validated against the event type's inputSchema. */
+    arguments: z.record(z.string(), z.unknown()).optional()
+  }).strict()
+);
+var EventTriggerStatus = /* @__PURE__ */ defineSchema(
+  () => z.enum(["active", "blocked", "disabled"])
+);
+var EventTrigger = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    id: Uuid,
+    sourceId: Uuid,
+    sourceKind: EventSourceKind,
+    eventTypes: z.array(z.string()),
+    conditions: z.array(EventCondition),
+    includeOwnEvents: z.boolean(),
+    arguments: z.record(z.string(), z.unknown()).nullable(),
+    status: EventTriggerStatus,
+    statusReason: z.string().nullable(),
+    /** The reason as a code a client words itself; see `EVENT_STATUS_REASON_CODES`. */
+    statusReasonCode: z.string().nullable().default(null),
+    /** What the source's server said about it, verbatim, when it said something. */
+    statusReasonDetail: z.string().nullable().default(null),
+    createdAt: Timestamp,
+    updatedAt: Timestamp
+  })
+);
+var SessionAutomationWaitSummary = /* @__PURE__ */ defineSchema(() => {
+  const waitEvent = z.object({
+    source: z.object({ kind: EventSourceKind, name: z.string() }).strict().nullable(),
+    eventTypes: z.array(z.string())
+  }).strict();
+  return z.object({
+    /** The soonest scheduled run into the chat, or null when none is ahead. */
+    nextRunAt: z.string().datetime({ offset: true }).nullable(),
+    /**
+     * The first active event trigger that can start a run: its event types
+     * and its source, null when the reader can't see the source. Null when
+     * no event can start a run. `events` names them all.
+     */
+    event: waitEvent.nullable(),
+    /**
+     * Every event that can start a run, one entry per source in the order
+     * the automations were made: the event types its active triggers wait
+     * for (just `*` when one takes every event). Sources the reader can't
+     * see share one entry with a null source. Empty when no event can start
+     * a run; absent from servers that only send `event`.
+     */
+    events: z.array(waitEvent).optional(),
+    /** How many automations can still start a run in the chat, this one included. */
+    automations: z.number().int().positive()
+  }).strict();
+});
+var ScheduledTaskEventsInput = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    triggers: z.array(EventTriggerInput).max(EVENT_TRIGGERS_PER_AUTOMATION_MAX),
+    /** Storm guard: at most this many event runs in a rolling hour. */
+    maxRunsPerHour: z.number().int().min(1).max(MAX_EVENT_RUNS_PER_HOUR).optional(),
+    /** Finish the automation after its first run, whichever trigger fires first. */
+    once: z.boolean().optional()
+  }).strict()
+);
+var ScheduledTaskEvents = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    triggers: z.array(EventTrigger),
+    maxRunsPerHour: z.number().int(),
+    once: z.boolean(),
+    /** When a once-automation finished. */
+    completedAt: Timestamp.nullable(),
+    /** When the storm guard last held events back; null when it is not holding any. */
+    throttledSince: Timestamp.nullable()
+  })
+);
+var ScheduledTaskRunEventOccurrence = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    triggerIds: z.array(Uuid),
+    eventCount: z.number().int().nonnegative(),
+    events: z.array(InboundEventSummary)
+  })
+);
+var SCHEDULED_OCCURRENCE_EVENTS_MAX_BYTES = 12 * 1024;
+var SCHEDULED_OCCURRENCE_EVENT_DATA_MAX_BYTES = 2 * 1024;
+var ScheduledOccurrenceEvent = /* @__PURE__ */ defineSchema(
+  () => InboundEventSummary.extend({
+    data: z.record(z.string(), z.unknown()),
+    /** The data was cut to fit; the stored event has more. */
+    dataTruncated: z.boolean()
+  })
+);
+var ScheduledOccurrenceEvents = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    occurrenceId: Uuid,
+    eventCount: z.number().int().nonnegative(),
+    events: z.array(ScheduledOccurrenceEvent),
+    /** The source may have missed events just before these. */
+    gapBefore: z.boolean()
+  })
+);
+var EventTypeDescriptor = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    type: z.string(),
+    description: z.string(),
+    /** Fields worth matching in conditions, such as `data.repository`. */
+    fields: z.array(z.object({ field: z.string(), description: z.string() })),
+    /** MCP sources: the subscription arguments the server accepts. */
+    argumentsSchema: z.record(z.string(), z.unknown()).nullable(),
+    /** False when Opengeni cannot receive this type from this source. */
+    available: z.boolean(),
+    unavailableReason: z.string().nullable(),
+    /** The reason as a code a client words itself; see `EVENT_STATUS_REASON_CODES`. */
+    unavailableReasonCode: z.string().nullable().default(null),
+    /** What the reason names, such as the GitHub App event to subscribe to. */
+    unavailableReasonDetail: z.string().nullable().default(null)
+  })
+);
+var ListEventTypesResponse = /* @__PURE__ */ defineSchema(
+  () => z.object({ sourceId: Uuid, eventTypes: z.array(EventTypeDescriptor) }).strict()
+);
+
+export {
+  EVENT_SOURCE_KINDS,
+  EventSourceKind,
+  WEBHOOK_EVENT_ADAPTERS,
+  WebhookEventAdapter,
+  WebhookHeaderName,
+  WebhookJsonPath,
+  WebhookValueSource,
+  WebhookSignatureFormat,
+  EventSourceStatus,
+  EVENT_STATUS_REASON_CODES,
+  isEventStatusReasonCode,
+  EventSourceVisibility,
+  EVENT_SOURCE_NAME_MAX_LENGTH,
+  EVENT_TYPE_MAX_LENGTH,
+  EVENT_SUMMARY_MAX_LENGTH,
+  EVENT_SUBJECT_MAX_LENGTH,
+  EVENT_DATA_MAX_BYTES,
+  EVENT_DELIVERY_BODY_MAX_BYTES,
+  EVENT_TRIGGERS_PER_AUTOMATION_MAX,
+  EVENT_TRIGGER_TYPES_MAX,
+  EVENT_TRIGGER_CONDITIONS_MAX,
+  DEFAULT_EVENT_RUNS_PER_HOUR,
+  MAX_EVENT_RUNS_PER_HOUR,
+  EVENT_DELIVERY_BODY_RETENTION_DAYS,
+  EVENT_RETENTION_DAYS,
+  EventSourceName,
+  EventTypeName,
+  WebhookFormat,
+  WEBHOOK_FORMAT_PRESETS,
+  EventSourceMcpBinding,
+  EventSource,
+  EventSourceSigningSecretInput,
+  CreateEventSourceRequest,
+  CreateEventSourceResponse,
+  UpdateEventSourceRequest,
+  RotateEventSourceSecretResponse,
+  ListEventSourcesResponse,
+  READY_EVENT_SOURCE_KINDS,
+  readyEventSourceKey,
+  readyEventSourceRequest,
+  ReadyEventSource,
+  ListReadyEventSourcesResponse,
+  EventSourceRef,
+  isReadyEventSourceKey,
+  EventActorKind,
+  EventActor,
+  InboundEvent,
+  InboundEventSummary,
+  ListInboundEventsResponse,
+  EventDeliveryStatus,
+  EventDelivery,
+  ListEventDeliveriesResponse,
+  ReplayEventDeliveryResponse,
+  SendTestEventRequest,
+  SendTestEventResponse,
+  EVENT_CONDITION_FIELD_PATTERN,
+  EventConditionOperator,
+  EventCondition,
+  EventTriggerInput,
+  EventTriggerStatus,
+  EventTrigger,
+  SessionAutomationWaitSummary,
+  ScheduledTaskEventsInput,
+  ScheduledTaskEvents,
+  ScheduledTaskRunEventOccurrence,
+  SCHEDULED_OCCURRENCE_EVENTS_MAX_BYTES,
+  SCHEDULED_OCCURRENCE_EVENT_DATA_MAX_BYTES,
+  ScheduledOccurrenceEvent,
+  ScheduledOccurrenceEvents,
+  EventTypeDescriptor,
+  ListEventTypesResponse
+};
+//# sourceMappingURL=chunk-PI5VIKJY.js.map