@oneuptime/common 12.0.32 → 12.0.34

package/Types/NetworkDevice/NetworkDeviceMonitoringMethod.ts

@@ -1,39 +1,54 @@
 /*
  * How a NetworkDevice's health is established.
  *
- * The network product was built around SNMP: a device is a thing an assigned
- * probe walks on a schedule, and everything downstream — the status pill, the
- * site rollup, the topology map — reads freshness off `lastSeenAt`, which only
- * a successful walk ever stamps.
+ * A device is the unit; reachability is a built-in capability of every device
+ * a probe polls, and SNMP is an enrichment layered on top when credentials
+ * exist. That is what `Probe` means: the assigned probe pings the device on
+ * its own schedule, and walks it over SNMP as well whenever it has usable
+ * credentials (its own, or through a credential profile). A device with no
+ * credentials is simply pinged — it still has a status from its first poll,
+ * still belongs to a site, still appears on the map.
  *
- * Plenty of real gear cannot be walked. Consumer APs, PDUs, cameras, anything
- * with SNMP disabled by policy: an operator tracks those with an ordinary Ping
- * or IP monitor. They are as real a part of the network as the switch they
- * hang off, and before this existed they could not be recorded as devices at
- * all — so they were absent from the site hierarchy and from the topology map,
- * which is what issue #3023 is about.
+ * `Monitor` is the override for gear a probe cannot reach at all, or whose
+ * health is better judged by an HTTP or port check: no polling; the bound
+ * Monitor's status IS the device's status, stamped through the same bridge
+ * that stamps every other device.
  *
- * `Monitor` is that second answer: no probe, no credentials, no polling; the
- * bound Monitor's status IS the device's status, stamped through the same
- * bridge that already stamps SNMP devices watched by a Network Device monitor.
+ * HISTORY. The product started SNMP-first: the first value was "SNMP", and
+ * everything that could not be walked had to be `Monitor`-backed, which meant
+ * a Ping monitor per phone and per camera (issue #3023, #3447). Rows written
+ * in that era hold "SNMP" or NULL, and both read as `Probe` — they were
+ * probe-polled devices all along, the probe just did not ping them yet.
  *
  * Stored as free text on the column (the SnmpVersion precedent), so parse it
  * through `NetworkDeviceMonitoringMethodUtil.parse` rather than comparing the
- * raw column: rows written before this existed hold NULL and must read as
- * `Snmp`, which is what they are.
+ * raw column: NULL, "", "SNMP" and anything unrecognised must read as
+ * `Probe`, and defaulting a device into "monitor-backed" would silently stop
+ * it being polled.
  */
 export enum NetworkDeviceMonitoringMethod {
-  // An assigned probe walks the device over SNMP on its own schedule.
-  Snmp = "SNMP",
-  // No polling; a bound Monitor (Ping, IP, Port, ...) reports its health.
+  /*
+   * The assigned probe pings the device on its schedule, and walks it over
+   * SNMP as well whenever it has usable credentials.
+   */
+  Probe = "Probe",
+  // No polling; a bound Monitor (Ping, IP, Port, HTTP, ...) reports its health.
   Monitor = "Monitor",
 }
 
+/*
+ * The value every device written before ping-first polling carries. Kept as
+ * a named constant for the parser, the normalising data migration and tests;
+ * it is not a value the product writes any more.
+ */
+export const LEGACY_SNMP_MONITORING_METHOD: string = "SNMP";
+
 export class NetworkDeviceMonitoringMethodUtil {
   /*
-   * NULL, empty and anything unrecognised read as Snmp — that is what every
-   * device created before this column existed is, and defaulting a device
-   * into "monitor-backed" would silently stop it being polled.
+   * NULL, empty, the legacy "SNMP" and anything unrecognised read as Probe —
+   * that is what every device created before this column (or before
+   * ping-first polling) is, and defaulting a device into "monitor-backed"
+   * would silently stop it being polled.
    */
   public static parse(
     value: string | undefined | null,
@@ -41,7 +56,7 @@ export class NetworkDeviceMonitoringMethodUtil {
     if ((value || "").trim().toLowerCase() === "monitor") {
       return NetworkDeviceMonitoringMethod.Monitor;
     }
-    return NetworkDeviceMonitoringMethod.Snmp;
+    return NetworkDeviceMonitoringMethod.Probe;
   }
 
   public static isMonitorBacked(value: string | undefined | null): boolean {
@@ -50,6 +65,11 @@ export class NetworkDeviceMonitoringMethodUtil {
       NetworkDeviceMonitoringMethod.Monitor
     );
   }
+
+  /** The complement of isMonitorBacked: the assigned probe polls the device. */
+  public static isProbePolled(value: string | undefined | null): boolean {
+    return !NetworkDeviceMonitoringMethodUtil.isMonitorBacked(value);
+  }
 }
 
 export default NetworkDeviceMonitoringMethod;

package/Types/NetworkSite/DefaultNetworkSiteTypeHierarchy.ts

@@ -0,0 +1,30 @@
+import DefaultNetworkSiteType from "./DefaultNetworkSiteType";
+
+/*
+ * One shared hierarchy policy for new-project seeding and the idempotent data
+ * migration that repairs projects created before parent site types existed.
+ * Keep parents before children in creation order so every FK can be resolved
+ * from a row that has already been found or created.
+ */
+export const DefaultNetworkSiteTypeParent: Readonly<
+  Record<DefaultNetworkSiteType, DefaultNetworkSiteType | null>
+> = Object.freeze({
+  [DefaultNetworkSiteType.AccountType]: null,
+  [DefaultNetworkSiteType.Region]: DefaultNetworkSiteType.AccountType,
+  [DefaultNetworkSiteType.Franchisee]: DefaultNetworkSiteType.Region,
+  [DefaultNetworkSiteType.Market]: DefaultNetworkSiteType.Franchisee,
+  [DefaultNetworkSiteType.Unit]: DefaultNetworkSiteType.Market,
+  [DefaultNetworkSiteType.DataCenter]: null,
+  [DefaultNetworkSiteType.Other]: null,
+});
+
+export const DefaultNetworkSiteTypeCreationOrder: ReadonlyArray<DefaultNetworkSiteType> =
+  Object.freeze([
+    DefaultNetworkSiteType.AccountType,
+    DefaultNetworkSiteType.Region,
+    DefaultNetworkSiteType.Franchisee,
+    DefaultNetworkSiteType.Market,
+    DefaultNetworkSiteType.Unit,
+    DefaultNetworkSiteType.DataCenter,
+    DefaultNetworkSiteType.Other,
+  ]);

package/Types/NotificationSetting/NotificationEmailRollupCategory.ts

@@ -0,0 +1,255 @@
+import NotificationSettingEventType from "./NotificationSettingEventType";
+
+/*
+ * Why this file exists: the burst counter that decides whether an owner email
+ * is sent now or coalesced into a rollup has to be scoped to something
+ * narrower than "this recipient". Scoped per recipient alone, a probe
+ * connection storm - the noisiest event the product produces, and the one
+ * event seeded on by default with no cooldown - would push the first incident
+ * email of a real outage over the threshold and delay it. The category is that
+ * scope. It is also the heading the rollup email groups its rows under, so one
+ * classification serves both the throttle and the reader.
+ *
+ * The VALUES below are stable machine codes, never display strings, because
+ * they are persisted in UserNotificationEmailRollupItem.rollupCategory.
+ * Changing a value orphans every existing row that carries the old one: the
+ * burst count for that category silently restarts from zero, and any row still
+ * pending a flush can never be matched to its bucket again. This is precisely
+ * the hazard NotificationSettingEventType already lives with - its stored
+ * value IS the English prose sentence shown in the UI, so no member of it can
+ * ever be reworded - and there is no reason to repeat that mistake on purpose.
+ * Display text lives in ROLLUP_CATEGORY_LABEL below, where it is free to
+ * change on any afternoon.
+ */
+export enum RollupCategory {
+  Incidents = "incidents",
+  Alerts = "alerts",
+  IncidentEpisodes = "incident-episodes",
+  AlertEpisodes = "alert-episodes",
+  Monitors = "monitors",
+  ScheduledMaintenance = "scheduled-maintenance",
+  StatusPages = "status-pages",
+  Probes = "probes",
+  AIAgents = "ai-agents",
+  Slos = "slos",
+  OnCall = "on-call",
+  Other = "other",
+}
+
+/*
+ * The human-readable heading for each category. Separate from the enum value
+ * on purpose: this map is presentation, the enum value is storage, and only
+ * one of the two is safe to edit.
+ */
+export const ROLLUP_CATEGORY_LABEL: Record<RollupCategory, string> = {
+  [RollupCategory.Incidents]: "Incidents",
+  [RollupCategory.Alerts]: "Alerts",
+  [RollupCategory.IncidentEpisodes]: "Incident Episodes",
+  [RollupCategory.AlertEpisodes]: "Alert Episodes",
+  [RollupCategory.Monitors]: "Monitors",
+  [RollupCategory.ScheduledMaintenance]: "Scheduled Maintenance",
+  [RollupCategory.StatusPages]: "Status Pages",
+  [RollupCategory.Probes]: "Probes",
+  [RollupCategory.AIAgents]: "AI Agents",
+  [RollupCategory.Slos]: "SLOs",
+  [RollupCategory.OnCall]: "On Call",
+  [RollupCategory.Other]: "Other",
+};
+
+/*
+ * Every NotificationSettingEventType, classified. The grouping follows the
+ * comment groups the enum already declares about itself, so the two files say
+ * the same thing and a reader only has to learn one taxonomy.
+ *
+ * This is deliberately an exhaustive Record rather than a lookup with a
+ * default: because the key type is the enum itself, adding a 48th member to
+ * NotificationSettingEventType is a COMPILE ERROR here until somebody decides
+ * which bucket it belongs in. That is the same idiom the Dashboard's
+ * EVENT_LIBRARY uses, and it is the whole reason to spell out 47 lines instead
+ * of matching on a name prefix - a prefix match would quietly file a new
+ * resource type under the wrong heading, or under none, and nobody would
+ * notice until a customer read the email.
+ */
+export const ROLLUP_CATEGORY_BY_EVENT_TYPE: Record<
+  NotificationSettingEventType,
+  RollupCategory
+> = {
+  // Incident
+  [NotificationSettingEventType.SEND_INCIDENT_CREATED_OWNER_NOTIFICATION]:
+    RollupCategory.Incidents,
+  [NotificationSettingEventType.SEND_INCIDENT_NOTE_POSTED_OWNER_NOTIFICATION]:
+    RollupCategory.Incidents,
+  [NotificationSettingEventType.SEND_INCIDENT_STATE_CHANGED_OWNER_NOTIFICATION]:
+    RollupCategory.Incidents,
+  [NotificationSettingEventType.SEND_INCIDENT_OWNER_ADDED_NOTIFICATION]:
+    RollupCategory.Incidents,
+  [NotificationSettingEventType.SEND_INCIDENT_MEMBER_ADDED_NOTIFICATION]:
+    RollupCategory.Incidents,
+  [NotificationSettingEventType.SEND_INCIDENT_REMINDER_OWNER_NOTIFICATION]:
+    RollupCategory.Incidents,
+
+  // Alerts
+  [NotificationSettingEventType.SEND_ALERT_CREATED_OWNER_NOTIFICATION]:
+    RollupCategory.Alerts,
+  [NotificationSettingEventType.SEND_ALERT_NOTE_POSTED_OWNER_NOTIFICATION]:
+    RollupCategory.Alerts,
+  [NotificationSettingEventType.SEND_ALERT_STATE_CHANGED_OWNER_NOTIFICATION]:
+    RollupCategory.Alerts,
+  [NotificationSettingEventType.SEND_ALERT_OWNER_ADDED_NOTIFICATION]:
+    RollupCategory.Alerts,
+  [NotificationSettingEventType.SEND_ALERT_REMINDER_OWNER_NOTIFICATION]:
+    RollupCategory.Alerts,
+
+  // Alert Episodes
+  [NotificationSettingEventType.SEND_ALERT_EPISODE_CREATED_OWNER_NOTIFICATION]:
+    RollupCategory.AlertEpisodes,
+  [NotificationSettingEventType.SEND_ALERT_EPISODE_NOTE_POSTED_OWNER_NOTIFICATION]:
+    RollupCategory.AlertEpisodes,
+  [NotificationSettingEventType.SEND_ALERT_EPISODE_STATE_CHANGED_OWNER_NOTIFICATION]:
+    RollupCategory.AlertEpisodes,
+  [NotificationSettingEventType.SEND_ALERT_EPISODE_OWNER_ADDED_NOTIFICATION]:
+    RollupCategory.AlertEpisodes,
+  [NotificationSettingEventType.SEND_ALERT_ADDED_TO_EPISODE_OWNER_NOTIFICATION]:
+    RollupCategory.AlertEpisodes,
+
+  // Incident Episodes
+  [NotificationSettingEventType.SEND_INCIDENT_EPISODE_CREATED_OWNER_NOTIFICATION]:
+    RollupCategory.IncidentEpisodes,
+  [NotificationSettingEventType.SEND_INCIDENT_EPISODE_NOTE_POSTED_OWNER_NOTIFICATION]:
+    RollupCategory.IncidentEpisodes,
+  [NotificationSettingEventType.SEND_INCIDENT_EPISODE_STATE_CHANGED_OWNER_NOTIFICATION]:
+    RollupCategory.IncidentEpisodes,
+  [NotificationSettingEventType.SEND_INCIDENT_EPISODE_OWNER_ADDED_NOTIFICATION]:
+    RollupCategory.IncidentEpisodes,
+  [NotificationSettingEventType.SEND_INCIDENT_ADDED_TO_EPISODE_OWNER_NOTIFICATION]:
+    RollupCategory.IncidentEpisodes,
+
+  // Monitors
+  [NotificationSettingEventType.SEND_MONITOR_OWNER_ADDED_NOTIFICATION]:
+    RollupCategory.Monitors,
+  [NotificationSettingEventType.SEND_MONITOR_CREATED_OWNER_NOTIFICATION]:
+    RollupCategory.Monitors,
+  [NotificationSettingEventType.SEND_MONITOR_STATUS_CHANGED_OWNER_NOTIFICATION]:
+    RollupCategory.Monitors,
+  [NotificationSettingEventType.SEND_MONITOR_NOTIFICATION_WHEN_PORBE_STATUS_CHANGES]:
+    RollupCategory.Monitors,
+  [NotificationSettingEventType.SEND_MONITOR_NOTIFICATION_WHEN_NO_PROBES_ARE_MONITORING_THE_MONITOR]:
+    RollupCategory.Monitors,
+
+  // Scheduled Maintenance
+  [NotificationSettingEventType.SEND_SCHEDULED_MAINTENANCE_CREATED_OWNER_NOTIFICATION]:
+    RollupCategory.ScheduledMaintenance,
+  [NotificationSettingEventType.SEND_SCHEDULED_MAINTENANCE_NOTE_POSTED_OWNER_NOTIFICATION]:
+    RollupCategory.ScheduledMaintenance,
+  [NotificationSettingEventType.SEND_SCHEDULED_MAINTENANCE_OWNER_ADDED_NOTIFICATION]:
+    RollupCategory.ScheduledMaintenance,
+  [NotificationSettingEventType.SEND_SCHEDULED_MAINTENANCE_STATE_CHANGED_OWNER_NOTIFICATION]:
+    RollupCategory.ScheduledMaintenance,
+  [NotificationSettingEventType.SEND_SCHEDULED_MAINTENANCE_REMINDER_OWNER_NOTIFICATION]:
+    RollupCategory.ScheduledMaintenance,
+
+  // Status Page
+  [NotificationSettingEventType.SEND_STATUS_PAGE_ANNOUNCEMENT_CREATED_OWNER_NOTIFICATION]:
+    RollupCategory.StatusPages,
+  [NotificationSettingEventType.SEND_STATUS_PAGE_CREATED_OWNER_NOTIFICATION]:
+    RollupCategory.StatusPages,
+  [NotificationSettingEventType.SEND_STATUS_PAGE_OWNER_ADDED_NOTIFICATION]:
+    RollupCategory.StatusPages,
+
+  // Probe Status change Notification
+  [NotificationSettingEventType.SEND_PROBE_STATUS_CHANGED_OWNER_NOTIFICATION]:
+    RollupCategory.Probes,
+  [NotificationSettingEventType.SEND_PROBE_OWNER_ADDED_NOTIFICATION]:
+    RollupCategory.Probes,
+
+  // AI Agent Status change Notification
+  [NotificationSettingEventType.SEND_AI_AGENT_STATUS_CHANGED_OWNER_NOTIFICATION]:
+    RollupCategory.AIAgents,
+  [NotificationSettingEventType.SEND_AI_AGENT_OWNER_ADDED_NOTIFICATION]:
+    RollupCategory.AIAgents,
+
+  // SLO
+  [NotificationSettingEventType.SEND_SLO_OWNER_STATUS_CHANGE_NOTIFICATION]:
+    RollupCategory.Slos,
+  [NotificationSettingEventType.SEND_SLO_OWNER_ADDED_NOTIFICATION]:
+    RollupCategory.Slos,
+
+  /*
+   * On Call Notifications, including the two shift reminders. Five of these
+   * seven are never rolled up at all (see NotificationEmailRollupPolicy); they
+   * are classified anyway so the Record stays exhaustive, and so that the one
+   * row per notification the write path records for accounting has a heading
+   * whichever way the policy is later tuned.
+   */
+  [NotificationSettingEventType.SEND_WHEN_USER_IS_ON_CALL_ROSTER]:
+    RollupCategory.OnCall,
+  [NotificationSettingEventType.SEND_WHEN_USER_IS_NEXT_ON_CALL_ROSTER]:
+    RollupCategory.OnCall,
+  [NotificationSettingEventType.SEND_WHEN_USER_IS_ADDED_TO_ON_CALL_POLICY]:
+    RollupCategory.OnCall,
+  [NotificationSettingEventType.SEND_WHEN_USER_IS_REMOVED_FROM_ON_CALL_POLICY]:
+    RollupCategory.OnCall,
+  [NotificationSettingEventType.SEND_WHEN_USER_IS_NO_LONGER_ACTIVE_ON_ON_CALL_ROSTER]:
+    RollupCategory.OnCall,
+  [NotificationSettingEventType.SEND_BEFORE_USER_ON_CALL_SHIFT_STARTS]:
+    RollupCategory.OnCall,
+  [NotificationSettingEventType.SEND_WHEN_USER_ON_CALL_SHIFT_IS_REASSIGNED]:
+    RollupCategory.OnCall,
+};
+
+/*
+ * The order the rollup email lists its sections in, most urgent first.
+ *
+ * A rollup exists because something happened forty times in ten minutes, so
+ * the reader is scanning, not reading. Ordering sections by how much they can
+ * cost - an incident before the monitor that declared it, and both before the
+ * probe that noticed - means the first thing under the summary is the first
+ * thing worth clicking. Ordering by count instead would put a flapping probe
+ * above a production incident precisely when that is most wrong, and ordering
+ * by recency would move the sections around between two rollups five minutes
+ * apart, which is exactly the shape a reader learns to skim.
+ *
+ * Categories with no items in a given rollup are not rendered at all, so this
+ * being longer than any one email's section list is expected.
+ *
+ * Every RollupCategory MUST appear here exactly once - a category missing
+ * from this array would silently drop its section out of every rollup email.
+ * That is pinned by NotificationEmailRollupCategory.test.ts rather than by the
+ * type system, because an array cannot express "exhaustive" the way the
+ * Record above can.
+ */
+export const ROLLUP_CATEGORY_ORDER: ReadonlyArray<RollupCategory> = [
+  RollupCategory.Incidents,
+  RollupCategory.IncidentEpisodes,
+  RollupCategory.Alerts,
+  RollupCategory.AlertEpisodes,
+  RollupCategory.Slos,
+  RollupCategory.Monitors,
+  RollupCategory.ScheduledMaintenance,
+  RollupCategory.Probes,
+  RollupCategory.AIAgents,
+  RollupCategory.StatusPages,
+  RollupCategory.OnCall,
+  RollupCategory.Other,
+];
+
+export type GetRollupCategoryFunction = (
+  eventType: NotificationSettingEventType,
+) => RollupCategory;
+
+/*
+ * The `?? Other` is not defending against a hole in the Record above - the
+ * type system already guarantees there is none. It defends against a value
+ * that was never a member of the enum in the first place: an eventType read
+ * back out of Postgres and cast, or a row written by an older build whose
+ * member has since been renamed. Falling back to Other keeps that row in the
+ * rollup under a slightly vague heading instead of throwing on a send path
+ * whose whole point is to be no worse than sending the email directly.
+ */
+export const getRollupCategory: GetRollupCategoryFunction = (
+  eventType: NotificationSettingEventType,
+): RollupCategory => {
+  return ROLLUP_CATEGORY_BY_EVENT_TYPE[eventType] ?? RollupCategory.Other;
+};
+
+export default RollupCategory;

package/Types/NotificationSetting/NotificationEmailRollupPolicy.ts

@@ -0,0 +1,104 @@
+import NotificationSettingEventType from "./NotificationSettingEventType";
+
+/*
+ * Why this file exists: burst coalescing holds an owner email back for a few
+ * minutes so the fourth-and-later message of a flood can arrive as one. That
+ * trade is fine for "an incident you own changed state" and unacceptable for
+ * "you are on call now". This file is the single place that decides which is
+ * which, and it is pure - no imports beyond the enum - so the runtime write
+ * path and the ratchet test read exactly the same constants with no mocks
+ * between them.
+ */
+
+/*
+ * Time-critical on-call mail. Never held back, never counted, never written to
+ * the queue table at all.
+ *
+ * A five-minute coalescing window eats a thirty-minute shift lead time, which
+ * is the entire value of "your shift starts soon". And "you are on call now",
+ * delayed, is a missed page - the one failure mode an incident tool is not
+ * allowed to have. The saving from rolling these up would be nil anyway: they
+ * fire once per roster transition, not per resource, so they are not what
+ * floods anyone's inbox.
+ */
+export const NEVER_ROLLED_UP_EVENT_TYPES: ReadonlySet<NotificationSettingEventType> =
+  new Set<NotificationSettingEventType>([
+    NotificationSettingEventType.SEND_WHEN_USER_IS_ON_CALL_ROSTER,
+    NotificationSettingEventType.SEND_WHEN_USER_IS_NEXT_ON_CALL_ROSTER,
+    NotificationSettingEventType.SEND_WHEN_USER_IS_NO_LONGER_ACTIVE_ON_ON_CALL_ROSTER,
+    NotificationSettingEventType.SEND_BEFORE_USER_ON_CALL_SHIFT_STARTS,
+    NotificationSettingEventType.SEND_WHEN_USER_ON_CALL_SHIFT_IS_REASSIGNED,
+  ]);
+
+/*
+ * SHRINK-ONLY. These two carry ON_CALL in their member name and are still
+ * rollup-eligible, which is the one place in this feature where the obvious
+ * reading of "never delay on-call mail" is deliberately not followed. The
+ * reasoning, in full, because anyone auditing this file will stop here:
+ *
+ * They are configuration notices, not pages. "You were added to an on-call
+ * policy" carries no deadline; nothing about it is actionable in the next five
+ * minutes, and nobody is being asked to acknowledge anything. The escalation
+ * pages that ARE time-critical do not pass through here at all - they call
+ * MailService directly from UserNotificationRuleService and never consult
+ * UserNotificationSetting - so nothing about this decision can reach them.
+ *
+ * And they are high volume in exactly the shape burst coalescing exists to
+ * fix: they fan out per user per escalation rule, from six call sites
+ * (Common/Server/Services/OnCallDutyPolicyEscalationRuleUserService.ts:136 and
+ * :370, ...RuleTeamService.ts:117/:153/:318/:355, and
+ * ...RuleScheduleService.ts:270/:307/:495/:532). Adding a twenty-person team
+ * to a five-rule policy is one hundred emails out of one admin click.
+ * Excluding them would give away most of the real volume for no safety gain.
+ *
+ * Nothing may be ADDED to this list without a deliberate edit to
+ * Common/Tests/Types/NotificationSetting/NotificationEmailRollupPolicy.test.ts,
+ * which pins its exact membership. That is on purpose: the next member someone
+ * is tempted to add here is far more likely to be a page than these two are.
+ */
+export const ROLLUP_ELIGIBLE_ON_CALL_ADMIN_EVENT_TYPES: ReadonlySet<NotificationSettingEventType> =
+  new Set<NotificationSettingEventType>([
+    NotificationSettingEventType.SEND_WHEN_USER_IS_ADDED_TO_ON_CALL_POLICY,
+    NotificationSettingEventType.SEND_WHEN_USER_IS_REMOVED_FROM_ON_CALL_POLICY,
+  ]);
+
+/*
+ * Everything else - the other 42 members. Derived from the enum by exclusion
+ * rather than listed by hand, so the two sets are a partition by construction
+ * and cannot drift: there is no edit that adds a member to both, and no edit
+ * that drops one from both.
+ */
+export const ROLLUP_ELIGIBLE_EVENT_TYPES: ReadonlySet<NotificationSettingEventType> =
+  new Set<NotificationSettingEventType>(
+    Object.values(NotificationSettingEventType).filter(
+      (eventType: NotificationSettingEventType): boolean => {
+        return !NEVER_ROLLED_UP_EVENT_TYPES.has(eventType);
+      },
+    ),
+  );
+
+export type IsRollupEligibleFunction = (
+  eventType: NotificationSettingEventType,
+) => boolean;
+
+/*
+ * A POSITIVE allow-list, not `!NEVER_ROLLED_UP_EVENT_TYPES.has(...)`. The two
+ * are equivalent for every real enum member and deliberately different for a
+ * value that is not one - a string cast in from the database, or a member a
+ * newer build wrote and this one has never heard of. Under the allow-list such
+ * a value is sent immediately, which is exactly what the product does today
+ * and therefore the only safe answer. Under a deny-list it would be silently
+ * coalesced, which is a behaviour change nobody asked for arriving through the
+ * one path least likely to be noticed.
+ *
+ * The other half of the ratchet lives in NotificationEmailRollupCategory: a
+ * genuinely new enum member is picked up here by Object.values and is
+ * rollup-eligible by default, but it cannot compile until the exhaustive
+ * Record over there classifies it, so nobody adds one without reading this
+ * file.
+ */
+export const isRollupEligible: IsRollupEligibleFunction = (
+  eventType: NotificationSettingEventType,
+): boolean => {
+  return ROLLUP_ELIGIBLE_EVENT_TYPES.has(eventType);
+};

package/Types/NotificationSetting/RoutineEmailEvents.ts

@@ -0,0 +1,30 @@
+import NotificationSettingEventType from "./NotificationSettingEventType";
+
+/*
+ * Keep this an explicit allowlist: newly introduced events retain their existing
+ * email preference until someone deliberately classifies them as routine.
+ */
+export const ROUTINE_EMAIL_EVENT_TYPES: ReadonlyArray<NotificationSettingEventType> =
+  Object.freeze([
+    NotificationSettingEventType.SEND_INCIDENT_NOTE_POSTED_OWNER_NOTIFICATION,
+    NotificationSettingEventType.SEND_ALERT_NOTE_POSTED_OWNER_NOTIFICATION,
+    NotificationSettingEventType.SEND_INCIDENT_EPISODE_NOTE_POSTED_OWNER_NOTIFICATION,
+    NotificationSettingEventType.SEND_ALERT_EPISODE_NOTE_POSTED_OWNER_NOTIFICATION,
+    NotificationSettingEventType.SEND_SCHEDULED_MAINTENANCE_NOTE_POSTED_OWNER_NOTIFICATION,
+    NotificationSettingEventType.SEND_INCIDENT_OWNER_ADDED_NOTIFICATION,
+    NotificationSettingEventType.SEND_ALERT_OWNER_ADDED_NOTIFICATION,
+    NotificationSettingEventType.SEND_INCIDENT_EPISODE_OWNER_ADDED_NOTIFICATION,
+    NotificationSettingEventType.SEND_ALERT_EPISODE_OWNER_ADDED_NOTIFICATION,
+    NotificationSettingEventType.SEND_MONITOR_OWNER_ADDED_NOTIFICATION,
+    NotificationSettingEventType.SEND_SLO_OWNER_ADDED_NOTIFICATION,
+    NotificationSettingEventType.SEND_PROBE_OWNER_ADDED_NOTIFICATION,
+    NotificationSettingEventType.SEND_AI_AGENT_OWNER_ADDED_NOTIFICATION,
+    NotificationSettingEventType.SEND_STATUS_PAGE_OWNER_ADDED_NOTIFICATION,
+    NotificationSettingEventType.SEND_SCHEDULED_MAINTENANCE_OWNER_ADDED_NOTIFICATION,
+    NotificationSettingEventType.SEND_INCIDENT_ADDED_TO_EPISODE_OWNER_NOTIFICATION,
+    NotificationSettingEventType.SEND_ALERT_ADDED_TO_EPISODE_OWNER_NOTIFICATION,
+    NotificationSettingEventType.SEND_WHEN_USER_IS_ADDED_TO_ON_CALL_POLICY,
+    NotificationSettingEventType.SEND_WHEN_USER_IS_REMOVED_FROM_ON_CALL_POLICY,
+    NotificationSettingEventType.SEND_MONITOR_CREATED_OWNER_NOTIFICATION,
+    NotificationSettingEventType.SEND_STATUS_PAGE_CREATED_OWNER_NOTIFICATION,
+  ]);

package/Types/Permission.ts

@@ -1398,6 +1398,16 @@ enum Permission {
   EditNetworkDeviceRole = "EditNetworkDeviceRole",
   ReadNetworkDeviceRole = "ReadNetworkDeviceRole",
 
+  CreateNetworkAlertPolicy = "CreateNetworkAlertPolicy",
+  DeleteNetworkAlertPolicy = "DeleteNetworkAlertPolicy",
+  EditNetworkAlertPolicy = "EditNetworkAlertPolicy",
+  ReadNetworkAlertPolicy = "ReadNetworkAlertPolicy",
+
+  CreateNetworkSnmpCredentialProfile = "CreateNetworkSnmpCredentialProfile",
+  DeleteNetworkSnmpCredentialProfile = "DeleteNetworkSnmpCredentialProfile",
+  EditNetworkSnmpCredentialProfile = "EditNetworkSnmpCredentialProfile",
+  ReadNetworkSnmpCredentialProfile = "ReadNetworkSnmpCredentialProfile",
+
   CreateRecommendationDismissal = "CreateRecommendationDismissal",
   DeleteRecommendationDismissal = "DeleteRecommendationDismissal",
   EditRecommendationDismissal = "EditRecommendationDismissal",
@@ -8617,6 +8627,86 @@ export class PermissionHelper {
         isRolePermission: false,
         group: PermissionGroup.Monitor,
       },
+      {
+        permission: Permission.CreateNetworkSnmpCredentialProfile,
+        title: "Create SNMP Credential Profile",
+        description:
+          "This permission can create SNMP Credential Profile in this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.Monitor,
+      },
+      {
+        permission: Permission.DeleteNetworkSnmpCredentialProfile,
+        title: "Delete SNMP Credential Profile",
+        description:
+          "This permission can delete SNMP Credential Profile of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: true,
+        isRolePermission: false,
+        group: PermissionGroup.Monitor,
+      },
+      {
+        permission: Permission.EditNetworkSnmpCredentialProfile,
+        title: "Edit SNMP Credential Profile",
+        description:
+          "This permission can edit SNMP Credential Profile of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: true,
+        isRolePermission: false,
+        group: PermissionGroup.Monitor,
+      },
+      {
+        permission: Permission.ReadNetworkSnmpCredentialProfile,
+        title: "Read SNMP Credential Profile",
+        description:
+          "This permission can read SNMP Credential Profile of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: true,
+        isRolePermission: false,
+        group: PermissionGroup.Monitor,
+      },
+      {
+        permission: Permission.CreateNetworkAlertPolicy,
+        title: "Create Network Alert Policy",
+        description:
+          "This permission can create Network Alert Policy in this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.Monitor,
+      },
+      {
+        permission: Permission.DeleteNetworkAlertPolicy,
+        title: "Delete Network Alert Policy",
+        description:
+          "This permission can delete Network Alert Policy of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: true,
+        isRolePermission: false,
+        group: PermissionGroup.Monitor,
+      },
+      {
+        permission: Permission.EditNetworkAlertPolicy,
+        title: "Edit Network Alert Policy",
+        description:
+          "This permission can edit Network Alert Policy of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: true,
+        isRolePermission: false,
+        group: PermissionGroup.Monitor,
+      },
+      {
+        permission: Permission.ReadNetworkAlertPolicy,
+        title: "Read Network Alert Policy",
+        description:
+          "This permission can read Network Alert Policy of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: true,
+        isRolePermission: false,
+        group: PermissionGroup.Monitor,
+      },
       {
         permission: Permission.CreateRecommendationDismissal,
         title: "Create Recommendation Dismissal",

package/Types/Probe/ProbeMonitorResponse.ts

@@ -13,6 +13,7 @@ import PingMonitorResponse from "../Monitor/PingMonitor/PingMonitorResponse";
 import DomainMonitorResponse from "../Monitor/DomainMonitor/DomainMonitorResponse";
 import DnssecMonitorResponse from "../Monitor/DnssecMonitor/DnssecMonitorResponse";
 import SqlMonitorResponse from "../Monitor/SqlMonitor/SqlMonitorResponse";
+import DatabaseMonitorResponse from "../Monitor/DatabaseMonitor/DatabaseMonitorResponse";
 import ExternalStatusPageMonitorResponse from "../Monitor/ExternalStatusPageMonitor/ExternalStatusPageMonitorResponse";
 import HttpPhaseTimings from "../Monitor/HttpPhaseTimings";
 import MonitorEvaluationSummary from "../Monitor/MonitorEvaluationSummary";
@@ -40,6 +41,15 @@ export default interface ProbeMonitorResponse {
   sslResponse?: SslMonitorResponse | undefined;
   syntheticMonitorResponse?: Array<SyntheticMonitorResponse> | undefined;
   customCodeMonitorResponse?: CustomCodeMonitorResponse | undefined;
+  /*
+   * For Network Device monitors this is the REAL walk when one ran (success
+   * or failure) and undefined when the poll ran no walk - a device with no
+   * usable SNMP credentials is only pinged. It is never synthesized from the
+   * ping: walk-dependent criteria treat undefined as "not evaluated", and
+   * `isOnline` above carries device reachability (ping OR walk) on its own.
+   * `responseTimeInMs` is the walk's time only; ping RTT and packet loss
+   * travel in `pingResponse`.
+   */
   snmpResponse?: SnmpMonitorResponse | undefined;
   /*
    * Present ONLY on event-driven responses generated when a probe's trap
@@ -68,6 +78,12 @@ export default interface ProbeMonitorResponse {
   domainResponse?: DomainMonitorResponse | undefined;
   dnssecResponse?: DnssecMonitorResponse | undefined;
   sqlQueryMonitorResponse?: SqlMonitorResponse | undefined;
+  /*
+   * Database Health monitor payload: normalized metric values plus the
+   * groups that could not be collected. Partial collection is normal here -
+   * see DatabaseMonitorResponse for why it never implies an outage.
+   */
+  databaseMonitorResponse?: DatabaseMonitorResponse | undefined;
   externalStatusPageResponse?: ExternalStatusPageMonitorResponse | undefined;
   monitoredAt: Date;
   isTimeout?: boolean | undefined;