@shipeasy/openapi 1.4.0 → 1.6.0

package/dist/resources/index.d.ts

@@ -1,7 +1,17 @@
-import { Transport } from '../transport.js';
-import '../schemas/pagination.js';
 import * as zod_v4_core from 'zod/v4/core';
 import * as zod from 'zod';
+import { AttributesClient } from './attributes.js';
+export { attributesClient } from './attributes.js';
+import { I18nClient } from './i18n.js';
+export { i18nClient } from './i18n.js';
+import { ProjectsClient } from './projects.js';
+export { projectsClient } from './projects.js';
+import { OpsClient } from './ops.js';
+export { opsClient } from './ops.js';
+import { EventsClient } from './events.js';
+export { eventsClient } from './events.js';
+import { MetricsClient } from './metrics.js';
+export { metricsClient } from './metrics.js';
 import { AlertRulesClient } from './alert-rules.js';
 export { alertRulesClient } from './alert-rules.js';
 import { KillswitchesClient } from './killswitches.js';
@@ -14,12 +24,14 @@ import { ExperimentsClient } from './experiments.js';
 export { experimentsClient, experimentsResource } from './experiments.js';
 import { GatesClient } from './gates.js';
 export { gatesClient, gatesResource } from './gates.js';
-import '../schemas/gates.js';
-import '../schemas/universes.js';
+import { Transport } from '../transport.js';
 import '../schemas/alert-rules.js';
 import '../schemas/killswitches.js';
+import '../schemas/pagination.js';
+import '../schemas/universes.js';
 import '../schemas/configs.js';
 import '../schemas/experiments.js';
+import '../schemas/gates.js';
 
 /**
  * Aggregate admin client. Each resource lives in its own file under
@@ -36,6 +48,12 @@ declare function createAdminClient(transport: Transport): {
     universes: UniversesClient;
     killswitches: KillswitchesClient;
     alertRules: AlertRulesClient;
+    metrics: MetricsClient;
+    events: EventsClient;
+    ops: OpsClient;
+    projects: ProjectsClient;
+    i18n: I18nClient;
+    attributes: AttributesClient;
 };
 type AdminClient = ReturnType<typeof createAdminClient>;
 /**

package/dist/resources/index.js

@@ -2296,6 +2296,13 @@ var killswitchesResource = {
 import { z as z13 } from "zod";
 var ALERT_COMPARATORS = ["gt", "gte", "lt", "lte"];
 var ALERT_SEVERITIES = ["danger", "warn", "info"];
+var notificationTargetSchema = z13.object({
+  slackChannel: z13.object({
+    id: z13.string().min(1).describe("Slack channel id (e.g. C0123ABCD)."),
+    name: z13.string().min(1).describe("Slack channel name (without the leading #).")
+  }).nullish().describe("Slack channel to post this rule's alert to. Requires a Slack connector."),
+  email: z13.string().email().nullish().describe("Email address to notify for this rule (overrides the default recipient).")
+}).strict();
 var alertRuleCreateSchema = z13.object({
   name: z13.string().min(1).max(120).describe("Human label for the rule, shown on the alert and the rules list."),
   metricId: z13.string().min(1).describe("Id of the metric to evaluate."),
@@ -2303,7 +2310,8 @@ var alertRuleCreateSchema = z13.object({
   threshold: z13.number().finite().describe("Threshold the metric value is compared against."),
   windowHours: z13.number().int().min(1).max(720).default(24).describe("Lookback window (hours) the metric is aggregated over. 1\u2013720."),
   severity: z13.enum(ALERT_SEVERITIES).default("warn").describe("Severity of the raised alert."),
-  enabled: z13.boolean().default(true).describe("Whether the rule is evaluated by the cron.")
+  enabled: z13.boolean().default(true).describe("Whether the rule is evaluated by the cron."),
+  notify: notificationTargetSchema.nullish().describe("Where to deliver this rule's alert (Slack channel and/or email target).")
 }).strict();
 var alertRuleUpdateSchema = z13.object({
   name: z13.string().min(1).max(120),
@@ -2311,7 +2319,8 @@ var alertRuleUpdateSchema = z13.object({
   threshold: z13.number().finite(),
   windowHours: z13.number().int().min(1).max(720),
   severity: z13.enum(ALERT_SEVERITIES),
-  enabled: z13.boolean()
+  enabled: z13.boolean(),
+  notify: notificationTargetSchema.nullish()
 }).partial().strict();
 
 // src/resources/alert-rules.ts
@@ -2346,6 +2355,166 @@ function alertRulesClient(t) {
   };
 }
 
+// src/resources/metrics.ts
+var BASE7 = "/api/admin/metrics";
+function metricsClient(t) {
+  async function list() {
+    return t.request("GET", BASE7);
+  }
+  async function resolve(idOrName) {
+    const all = await list();
+    const byId = all.find((m) => m.id === idOrName);
+    if (byId) return byId;
+    const byPrefix = all.filter((m) => m.id.startsWith(idOrName));
+    if (byPrefix.length === 1) return byPrefix[0];
+    if (byPrefix.length > 1) throw new ApiError(`Metric id prefix '${idOrName}' is ambiguous`, 400);
+    const byName = all.filter((m) => m.name === idOrName);
+    if (byName.length === 1) return byName[0];
+    if (byName.length > 1)
+      throw new ApiError(`Metric name '${idOrName}' is ambiguous \u2014 pass an id`, 400);
+    throw new ApiError(`Metric '${idOrName}' not found`, 404);
+  }
+  return {
+    list,
+    resolve,
+    get: (id) => t.request("GET", `${BASE7}/${id}`),
+    create: (input) => t.request("POST", BASE7, input),
+    delete: (id) => t.request("DELETE", `${BASE7}/${id}`)
+  };
+}
+
+// src/resources/events.ts
+var BASE8 = "/api/admin/events";
+function eventsClient(t) {
+  async function list() {
+    return t.request("GET", BASE8);
+  }
+  async function resolve(idOrName) {
+    const all = await list();
+    const byId = all.find((e) => e.id === idOrName);
+    if (byId) return byId;
+    const byPrefix = all.filter((e) => e.id.startsWith(idOrName));
+    if (byPrefix.length === 1) return byPrefix[0];
+    if (byPrefix.length > 1) throw new ApiError(`Event id prefix '${idOrName}' is ambiguous`, 400);
+    const byName = all.filter((e) => e.name === idOrName);
+    if (byName.length === 1) return byName[0];
+    if (byName.length > 1)
+      throw new ApiError(`Event name '${idOrName}' is ambiguous \u2014 pass an id`, 400);
+    throw new ApiError(`Event '${idOrName}' not found`, 404);
+  }
+  return {
+    list,
+    resolve,
+    get: (id) => t.request("GET", `${BASE8}/${id}`),
+    create: (input) => t.request("POST", BASE8, input),
+    update: (id, input) => t.request("PATCH", `${BASE8}/${id}`, input),
+    approve: (id, input = {}) => t.request("POST", `${BASE8}/${id}/approve`, input),
+    delete: (id) => t.request("DELETE", `${BASE8}/${id}`)
+  };
+}
+
+// src/resources/ops.ts
+var FEEDBACK = "/api/admin/feedback";
+var NOTIFY = "/api/admin/notifications";
+var CREATE_PATH = {
+  bug: "/api/admin/bugs",
+  feature_request: "/api/admin/feature-requests"
+};
+function itemPath(handle) {
+  return `${FEEDBACK}/${encodeURIComponent(handle)}`;
+}
+function opsClient(t) {
+  return {
+    list: (query = {}) => {
+      const q = {};
+      if (query.type) q.type = query.type;
+      if (query.status) q.status = query.status;
+      if (query.limit !== void 0) q.limit = String(query.limit);
+      return t.request("GET", FEEDBACK, void 0, q);
+    },
+    get: (handle) => t.request("GET", itemPath(handle)),
+    create: ({ type, ...body }) => t.request("POST", CREATE_PATH[type], body),
+    update: (handle, input) => t.request("PATCH", itemPath(handle), input),
+    linkPr: (handle, input) => t.request("POST", `${itemPath(handle)}/link-pr`, input),
+    notify: (input) => t.request("POST", NOTIFY, {
+      title: input.title,
+      summary: input.summary,
+      steps: input.steps ?? [],
+      ...input.href ? { href: input.href } : {},
+      ...input.dedupeKey ? { dedupeKey: input.dedupeKey } : {}
+    }),
+    channels: () => t.request("GET", "/api/admin/slack/channels")
+  };
+}
+
+// src/resources/projects.ts
+var BASE9 = "/api/admin/projects";
+function projectsClient(t) {
+  return {
+    upsert: (input) => t.request("POST", `${BASE9}/upsert`, {
+      domain: input.domain,
+      ...input.name ? { name: input.name } : {}
+    }),
+    current: () => t.request("GET", `${BASE9}/current`)
+  };
+}
+
+// src/resources/i18n.ts
+var PROFILES = "/api/admin/i18n/profiles";
+var KEYS = "/api/admin/i18n/keys";
+var DRAFTS = "/api/admin/i18n/drafts";
+function i18nClient(t) {
+  async function listProfiles() {
+    return t.request("GET", PROFILES);
+  }
+  async function resolveProfile(name) {
+    const all = await listProfiles();
+    const found = all.find((p) => p.name === name);
+    if (!found)
+      throw new ApiError(
+        `Profile '${name}' not found. Existing: ${all.map((p) => p.name).join(", ") || "(none)"}`,
+        404
+      );
+    return found;
+  }
+  async function listKeys(query = {}) {
+    const q = {};
+    if (query.profile_id) q.profile_id = query.profile_id;
+    if (query.prefix) q.prefix = query.prefix;
+    if (query.limit !== void 0) q.limit = String(query.limit);
+    const res = await t.request("GET", KEYS, void 0, q);
+    return Array.isArray(res) ? res : res.keys;
+  }
+  function updateKey(id, input) {
+    return t.request("PUT", `${KEYS}/${id}`, input);
+  }
+  return {
+    listProfiles,
+    resolveProfile,
+    listKeys,
+    updateKey,
+    createProfile: (input) => t.request("POST", PROFILES, input),
+    pushKeys: (input) => t.request("POST", KEYS, input),
+    updateKeyByName: async (profileId, key, input) => {
+      const rows = await listKeys({ profile_id: profileId, prefix: key, limit: 500 });
+      const match = rows.find((k) => k.key === key);
+      if (!match)
+        throw new ApiError(`Key '${key}' not found in profile. Add it first with i18n push.`, 404);
+      return updateKey(match.id, input);
+    },
+    listDrafts: () => t.request("GET", DRAFTS),
+    publish: (profileId, input) => t.request("POST", `${PROFILES}/${profileId}/publish`, { chunk: input.chunk ?? "default" })
+  };
+}
+
+// src/resources/attributes.ts
+var BASE10 = "/api/admin/attributes";
+function attributesClient(t) {
+  return {
+    list: () => t.request("GET", BASE10)
+  };
+}
+
 // src/resources/index.ts
 function createAdminClient(transport) {
   return {
@@ -2355,7 +2524,13 @@ function createAdminClient(transport) {
     configs: configsClient(transport),
     universes: universesClient(transport),
     killswitches: killswitchesClient(transport),
-    alertRules: alertRulesClient(transport)
+    alertRules: alertRulesClient(transport),
+    metrics: metricsClient(transport),
+    events: eventsClient(transport),
+    ops: opsClient(transport),
+    projects: projectsClient(transport),
+    i18n: i18nClient(transport),
+    attributes: attributesClient(transport)
   };
 }
 var RESOURCE_REGISTRY = [
@@ -2368,15 +2543,21 @@ var RESOURCE_REGISTRY = [
 export {
   RESOURCE_REGISTRY,
   alertRulesClient,
+  attributesClient,
   configsClient,
   configsResource,
   createAdminClient,
+  eventsClient,
   experimentsClient,
   experimentsResource,
   gatesClient,
   gatesResource,
+  i18nClient,
   killswitchesClient,
   killswitchesResource,
+  metricsClient,
+  opsClient,
+  projectsClient,
   universesClient,
   universesResource
 };

package/dist/resources/metrics.d.ts

@@ -0,0 +1,54 @@
+import { Transport } from '../transport.js';
+
+/**
+ * Metric definitions — the event-backed queries that power tracking dashboards
+ * and experiment success/guardrail metrics. A metric pins one event, one
+ * aggregation, and (for sum/avg) a value path, expressed as the metric query
+ * DSL or its typed IR form.
+ *
+ * The admin endpoint accepts either `query` (the DSL string) or `query_ir`
+ * (the typed IR). The CLI's vendored DSL parser turns `--query` into IR
+ * client-side for an early error; the server validates either form, so the
+ * registry op can pass `query` straight through and stay worker-safe (no
+ * parser bundled into the shared registry).
+ */
+interface Metric {
+    id: string;
+    name: string;
+    folder: string | null;
+    eventName: string;
+    aggregation: string;
+    valuePath: string | null;
+    queryIr?: unknown;
+    [key: string]: unknown;
+}
+interface MetricCreateInput {
+    name: string;
+    event_name: string;
+    folder?: string | null;
+    winsorize_pct?: number;
+    min_detectable_effect?: number | null;
+    /** Metric query DSL string, e.g. `sum(purchase, amount)`. */
+    query?: string;
+    /** Typed IR form (alternative to `query`). */
+    query_ir?: unknown;
+}
+interface MetricsClient {
+    /** Every metric in the project (the list endpoint is not paginated). */
+    list(): Promise<Metric[]>;
+    /** Fetch one metric by its full id. */
+    get(id: string): Promise<Metric>;
+    /** Resolve by exact id, unique id-prefix, or exact (unique) name. */
+    resolve(idOrName: string): Promise<Metric>;
+    create(input: MetricCreateInput): Promise<{
+        id: string;
+        name: string;
+    }>;
+    /** Soft-delete (the user-facing verb is `archive`). */
+    delete(id: string): Promise<{
+        ok: true;
+    }>;
+}
+declare function metricsClient(t: Transport): MetricsClient;
+
+export { type Metric, type MetricCreateInput, type MetricsClient, metricsClient };

package/dist/resources/metrics.js

@@ -0,0 +1,40 @@
+// src/transport.ts
+var ApiError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "ApiError";
+  }
+  status;
+};
+
+// src/resources/metrics.ts
+var BASE = "/api/admin/metrics";
+function metricsClient(t) {
+  async function list() {
+    return t.request("GET", BASE);
+  }
+  async function resolve(idOrName) {
+    const all = await list();
+    const byId = all.find((m) => m.id === idOrName);
+    if (byId) return byId;
+    const byPrefix = all.filter((m) => m.id.startsWith(idOrName));
+    if (byPrefix.length === 1) return byPrefix[0];
+    if (byPrefix.length > 1) throw new ApiError(`Metric id prefix '${idOrName}' is ambiguous`, 400);
+    const byName = all.filter((m) => m.name === idOrName);
+    if (byName.length === 1) return byName[0];
+    if (byName.length > 1)
+      throw new ApiError(`Metric name '${idOrName}' is ambiguous \u2014 pass an id`, 400);
+    throw new ApiError(`Metric '${idOrName}' not found`, 404);
+  }
+  return {
+    list,
+    resolve,
+    get: (id) => t.request("GET", `${BASE}/${id}`),
+    create: (input) => t.request("POST", BASE, input),
+    delete: (id) => t.request("DELETE", `${BASE}/${id}`)
+  };
+}
+export {
+  metricsClient
+};

package/dist/resources/ops.d.ts

@@ -0,0 +1,88 @@
+import { Transport } from '../transport.js';
+
+/**
+ * Operational queue — the unified feedback table of bug reports, feature
+ * requests, and auto-filed error/alert tickets, over `/api/admin/feedback`.
+ * One resource covers list/get/create/update/link-pr plus the `notify`
+ * escalation bell (`/api/admin/notifications`) and the Slack channel reader
+ * (`/api/admin/slack/channels`) used to resolve alert-rule targets.
+ *
+ * Item handles are either the per-project number (`7`) or the full id; the
+ * admin API resolves either, so callers pass the handle straight through.
+ */
+type OpsType = "bug" | "feature_request" | "error" | "alert";
+type OpsStatus = "open" | "triaged" | "in_progress" | "ready_for_qa" | "resolved" | "wont_fix";
+type OpsPriority = "nice_to_have" | "medium" | "high" | "critical";
+interface OpsItem {
+    id: string;
+    number: number | null;
+    type: string;
+    title: string;
+    status: string;
+    priority: string | null;
+    sourceRef?: string | null;
+    createdAt: string;
+    [key: string]: unknown;
+}
+interface OpsListQuery {
+    type?: OpsType | "all";
+    status?: OpsStatus | "all";
+    limit?: number;
+}
+interface OpsCreateInput {
+    /** Only `bug` / `feature_request` are user-fileable; error/alert are auto-filed. */
+    type: "bug" | "feature_request";
+    title: string;
+    body?: string;
+    priority?: OpsPriority;
+    stepsToReproduce?: string;
+    pageUrl?: string;
+}
+interface OpsUpdateInput {
+    status?: OpsStatus;
+    priority?: OpsPriority;
+}
+interface OpsNotifyInput {
+    title: string;
+    summary: string;
+    steps?: string[];
+    href?: string;
+    dedupeKey?: string;
+}
+interface SlackChannel {
+    id: string;
+    name: string;
+    isPrivate?: boolean;
+}
+interface SlackChannelsResponse {
+    connected: boolean;
+    channels: SlackChannel[];
+}
+interface OpsClient {
+    list(query?: OpsListQuery): Promise<OpsItem[]>;
+    get(handle: string): Promise<OpsItem>;
+    /** File a bug or feature request. Fires project connectors (GitHub/Slack). */
+    create(input: OpsCreateInput): Promise<{
+        id: string;
+        number?: number | null;
+    }>;
+    update(handle: string, input: OpsUpdateInput): Promise<{
+        id: string;
+    }>;
+    linkPr(handle: string, input: {
+        prNumber: number | null;
+        prUrl?: string;
+    }): Promise<{
+        id: string;
+    }>;
+    /** Raise a 'needs your attention' bell notification (create-only, idempotent on dedupeKey). */
+    notify(input: OpsNotifyInput): Promise<{
+        dedupeKey: string;
+        dispatched: boolean;
+    }>;
+    /** The project's Slack channels — used to resolve alert-rule `--slack-channel`. */
+    channels(): Promise<SlackChannelsResponse>;
+}
+declare function opsClient(t: Transport): OpsClient;
+
+export { type OpsClient, type OpsCreateInput, type OpsItem, type OpsListQuery, type OpsNotifyInput, type OpsPriority, type OpsStatus, type OpsType, type OpsUpdateInput, type SlackChannel, type SlackChannelsResponse, opsClient };

package/dist/resources/ops.js

@@ -0,0 +1,36 @@
+// src/resources/ops.ts
+var FEEDBACK = "/api/admin/feedback";
+var NOTIFY = "/api/admin/notifications";
+var CREATE_PATH = {
+  bug: "/api/admin/bugs",
+  feature_request: "/api/admin/feature-requests"
+};
+function itemPath(handle) {
+  return `${FEEDBACK}/${encodeURIComponent(handle)}`;
+}
+function opsClient(t) {
+  return {
+    list: (query = {}) => {
+      const q = {};
+      if (query.type) q.type = query.type;
+      if (query.status) q.status = query.status;
+      if (query.limit !== void 0) q.limit = String(query.limit);
+      return t.request("GET", FEEDBACK, void 0, q);
+    },
+    get: (handle) => t.request("GET", itemPath(handle)),
+    create: ({ type, ...body }) => t.request("POST", CREATE_PATH[type], body),
+    update: (handle, input) => t.request("PATCH", itemPath(handle), input),
+    linkPr: (handle, input) => t.request("POST", `${itemPath(handle)}/link-pr`, input),
+    notify: (input) => t.request("POST", NOTIFY, {
+      title: input.title,
+      summary: input.summary,
+      steps: input.steps ?? [],
+      ...input.href ? { href: input.href } : {},
+      ...input.dedupeKey ? { dedupeKey: input.dedupeKey } : {}
+    }),
+    channels: () => t.request("GET", "/api/admin/slack/channels")
+  };
+}
+export {
+  opsClient
+};

package/dist/resources/projects.d.ts

@@ -0,0 +1,54 @@
+import { Transport } from '../transport.js';
+
+/**
+ * Projects — find-or-create by domain (`upsert`) and the auth-resolved current
+ * project (`current`). The `.shipeasy` write that `bind`/`upsert --bind`
+ * performs is a CONSUMER side-effect layered on top of these calls (it touches
+ * the filesystem); it never lives in the resource, so this stays worker-safe.
+ */
+interface UpsertResult {
+    id: string;
+    name: string;
+    domain: string | null;
+    owner_email: string;
+    created: boolean;
+}
+/**
+ * The project the caller's auth header resolves to. The server reads the
+ * project from the credential — there is no id parameter — so `current` works
+ * with nothing but the session, which is what makes a registry-driven `whoami`
+ * possible.
+ */
+interface CurrentProject {
+    id: string;
+    name: string;
+    domain: string | null;
+    ownerEmail: string;
+    plan: "free" | "paid";
+    status: "active" | "inactive";
+    subscriptionStatus: string;
+    billingInterval: "monthly" | "annual";
+    currentPeriodEnd: string | null;
+    trialEndsAt: string | null;
+    cancelAtPeriodEnd: number;
+    moduleTranslations: boolean | number;
+    moduleConfigs: boolean | number;
+    moduleGates: boolean | number;
+    moduleExperiments: boolean | number;
+    moduleFeedback: boolean | number;
+    createdAt: string;
+    updatedAt: string;
+    [key: string]: unknown;
+}
+interface ProjectsClient {
+    /** Find-or-create a project by domain (idempotent). */
+    upsert(input: {
+        domain: string;
+        name?: string;
+    }): Promise<UpsertResult>;
+    /** The project the auth header resolves to (no id needed). */
+    current(): Promise<CurrentProject>;
+}
+declare function projectsClient(t: Transport): ProjectsClient;
+
+export { type CurrentProject, type ProjectsClient, type UpsertResult, projectsClient };

package/dist/resources/projects.js

@@ -0,0 +1,14 @@
+// src/resources/projects.ts
+var BASE = "/api/admin/projects";
+function projectsClient(t) {
+  return {
+    upsert: (input) => t.request("POST", `${BASE}/upsert`, {
+      domain: input.domain,
+      ...input.name ? { name: input.name } : {}
+    }),
+    current: () => t.request("GET", `${BASE}/current`)
+  };
+}
+export {
+  projectsClient
+};

package/dist/schemas/alert-rules.d.ts

@@ -2,6 +2,14 @@ import { z } from 'zod';
 
 declare const ALERT_COMPARATORS: readonly ["gt", "gte", "lt", "lte"];
 declare const ALERT_SEVERITIES: readonly ["danger", "warn", "info"];
+declare const notificationTargetSchema: z.ZodObject<{
+    slackChannel: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>>;
+    email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+type NotificationTarget = z.infer<typeof notificationTargetSchema>;
 declare const alertRuleCreateSchema: z.ZodObject<{
     name: z.ZodString;
     metricId: z.ZodString;
@@ -19,6 +27,13 @@ declare const alertRuleCreateSchema: z.ZodObject<{
         info: "info";
     }>>;
     enabled: z.ZodDefault<z.ZodBoolean>;
+    notify: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        slackChannel: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>;
+        email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>>;
 }, z.core.$strict>;
 declare const alertRuleUpdateSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
@@ -36,8 +51,15 @@ declare const alertRuleUpdateSchema: z.ZodObject<{
         info: "info";
     }>>;
     enabled: z.ZodOptional<z.ZodBoolean>;
+    notify: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        slackChannel: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>>;
+        email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>>>;
 }, z.core.$strict>;
 type AlertRuleCreate = z.infer<typeof alertRuleCreateSchema>;
 type AlertRuleUpdate = z.infer<typeof alertRuleUpdateSchema>;
 
-export { ALERT_COMPARATORS, ALERT_SEVERITIES, type AlertRuleCreate, type AlertRuleUpdate, alertRuleCreateSchema, alertRuleUpdateSchema };
+export { ALERT_COMPARATORS, ALERT_SEVERITIES, type AlertRuleCreate, type AlertRuleUpdate, type NotificationTarget, alertRuleCreateSchema, alertRuleUpdateSchema, notificationTargetSchema };

package/dist/schemas/alert-rules.js

@@ -2,6 +2,13 @@
 import { z } from "zod";
 var ALERT_COMPARATORS = ["gt", "gte", "lt", "lte"];
 var ALERT_SEVERITIES = ["danger", "warn", "info"];
+var notificationTargetSchema = z.object({
+  slackChannel: z.object({
+    id: z.string().min(1).describe("Slack channel id (e.g. C0123ABCD)."),
+    name: z.string().min(1).describe("Slack channel name (without the leading #).")
+  }).nullish().describe("Slack channel to post this rule's alert to. Requires a Slack connector."),
+  email: z.string().email().nullish().describe("Email address to notify for this rule (overrides the default recipient).")
+}).strict();
 var alertRuleCreateSchema = z.object({
   name: z.string().min(1).max(120).describe("Human label for the rule, shown on the alert and the rules list."),
   metricId: z.string().min(1).describe("Id of the metric to evaluate."),
@@ -9,7 +16,8 @@ var alertRuleCreateSchema = z.object({
   threshold: z.number().finite().describe("Threshold the metric value is compared against."),
   windowHours: z.number().int().min(1).max(720).default(24).describe("Lookback window (hours) the metric is aggregated over. 1\u2013720."),
   severity: z.enum(ALERT_SEVERITIES).default("warn").describe("Severity of the raised alert."),
-  enabled: z.boolean().default(true).describe("Whether the rule is evaluated by the cron.")
+  enabled: z.boolean().default(true).describe("Whether the rule is evaluated by the cron."),
+  notify: notificationTargetSchema.nullish().describe("Where to deliver this rule's alert (Slack channel and/or email target).")
 }).strict();
 var alertRuleUpdateSchema = z.object({
   name: z.string().min(1).max(120),
@@ -17,11 +25,13 @@ var alertRuleUpdateSchema = z.object({
   threshold: z.number().finite(),
   windowHours: z.number().int().min(1).max(720),
   severity: z.enum(ALERT_SEVERITIES),
-  enabled: z.boolean()
+  enabled: z.boolean(),
+  notify: notificationTargetSchema.nullish()
 }).partial().strict();
 export {
   ALERT_COMPARATORS,
   ALERT_SEVERITIES,
   alertRuleCreateSchema,
-  alertRuleUpdateSchema
+  alertRuleUpdateSchema,
+  notificationTargetSchema
 };

package/dist/schemas/index.d.ts

@@ -7,5 +7,5 @@ export { GateCreateInput, GateUpdateInput, StackedGateEntryInput, gateCreateResp
 export { KillswitchCreateInput, KillswitchSwitchSetInput, KillswitchSwitchUnsetInput, KillswitchUpdateInput, KillswitchValue, KillswitchValueSetInput, SWITCH_KEY_RE, killswitchCreateResponseSchema, killswitchCreateSchema, killswitchDeleteResponseSchema, killswitchResponseSchema, killswitchSwitchSetResponseSchema, killswitchSwitchSetSchema, killswitchSwitchUnsetResponseSchema, killswitchSwitchUnsetSchema, killswitchUpdateResponseSchema, killswitchUpdateSchema, killswitchValueSchema, killswitchValueSetSchema, switchKeySchema } from './killswitches.js';
 export { UniverseCreateInput, UniverseUpdateInput, holdoutRangeSchema, universeCreateResponseSchema, universeCreateSchema, universeDeleteResponseSchema, universeNameSchema, universeResponseSchema, universeUpdateResponseSchema, universeUpdateSchema } from './universes.js';
 export { ExperimentCreateInput, ExperimentInlineMetric, ExperimentUpdateInput, bucketBySchema, experimentCreateResponseSchema, experimentCreateSchema, experimentDeleteResponseSchema, experimentGroupSchema, experimentInlineMetricSchema, experimentMetricsResponseSchema, experimentMetricsUpdateSchema, experimentNameSchema, experimentReanalyzeResponseSchema, experimentResponseSchema, experimentResultsResponseSchema, experimentStatusResponseSchema, experimentStatusUpdateSchema, experimentTimeseriesResponseSchema, experimentUpdateResponseSchema, experimentUpdateSchema, paramSchemaSchema } from './experiments.js';
-export { ALERT_COMPARATORS, ALERT_SEVERITIES, AlertRuleCreate, AlertRuleUpdate, alertRuleCreateSchema, alertRuleUpdateSchema } from './alert-rules.js';
+export { ALERT_COMPARATORS, ALERT_SEVERITIES, AlertRuleCreate, AlertRuleUpdate, NotificationTarget, alertRuleCreateSchema, alertRuleUpdateSchema, notificationTargetSchema } from './alert-rules.js';
 import 'zod';