@oneuptime/common 11.6.0 → 11.6.2

package/Types/Dashboard/DashboardTemplates.ts

@@ -27,6 +27,7 @@ export enum DashboardTemplateType {
   Incident = "Incident",
   Alert = "Alert",
   Kubernetes = "Kubernetes",
+  KubernetesCost = "KubernetesCost",
   Host = "Host",
   Proxmox = "Proxmox",
   Ceph = "Ceph",
@@ -110,6 +111,14 @@ export const DashboardTemplates: Array<DashboardTemplate> = [
     icon: IconProp.Kubernetes,
     category: DashboardTemplateCategory.Infrastructure,
   },
+  {
+    type: DashboardTemplateType.KubernetesCost,
+    name: "Kubernetes Cost Dashboard",
+    description:
+      "Node hourly cost trends, CPU/RAM unit costs, persistent volume and load balancer spend from your in-cluster cost engine (OpenCost / Kubecost).",
+    icon: IconProp.Billing,
+    category: DashboardTemplateCategory.Infrastructure,
+  },
   {
     type: DashboardTemplateType.Host,
     name: "Hosts Dashboard",
@@ -1639,6 +1648,209 @@ function createKubernetesDashboardConfig(): DashboardViewConfig {
   };
 }
 
+function createKubernetesCostDashboardConfig(): DashboardViewConfig {
+  /*
+   * Built on the cost metrics the kubernetes-agent chart scrapes from an
+   * in-cluster cost engine (OpenCost / Kubecost cost-model) when
+   * `cost.metrics` is enabled — node_total_hourly_cost,
+   * node_cpu_hourly_cost, node_ram_hourly_cost, pv_hourly_cost,
+   * kubecost_load_balancer_cost. Per-workload allocation (namespace /
+   * controller spend, idle, efficiency) is NOT charted here — those come
+   * from the Allocation API poller and live on the cluster's Costs page.
+   *
+   * Layout notes:
+   *
+   * - Every cost metric here is a per-resource gauge (one series per
+   *   node / volume / load balancer) re-emitted on every scrape, so a
+   *   `Sum` aggregation would multiply by the scrape count over the
+   *   window — the same trap the Kubernetes template documents for
+   *   k8s.pod.phase. All widgets therefore use `Avg`, and the charts fan
+   *   out per resource via groupByAttributeKeys so a stacked area still
+   *   reads as the cluster total per bucket.
+   *
+   * - The engine's metric labels are plain Prometheus labels ("node",
+   *   "persistentvolume", "service_name"), not OTel resource attributes,
+   *   so group keys have no `resource.` prefix.
+   */
+  const components: Array<DashboardBaseComponent> = [
+    // Row 0: Title
+    createTextComponent({
+      text: "Kubernetes Cost Dashboard",
+      top: 0,
+      left: 0,
+      width: 12,
+      height: 1,
+      isBold: true,
+    }),
+
+    // Row 1: Unit-cost stat tiles. Rising cost is "worse" for all four.
+    createValueComponent({
+      title: "Node Cost $/hr (avg per node)",
+      top: 1,
+      left: 0,
+      width: 3,
+      metricConfig: {
+        metricName: "node_total_hourly_cost",
+        aggregationType: MetricsAggregationType.Avg,
+      },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
+    }),
+    createValueComponent({
+      title: "CPU Cost $/core-hr (avg)",
+      top: 1,
+      left: 3,
+      width: 3,
+      metricConfig: {
+        metricName: "node_cpu_hourly_cost",
+        aggregationType: MetricsAggregationType.Avg,
+      },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
+    }),
+    createValueComponent({
+      title: "RAM Cost $/GiB-hr (avg)",
+      top: 1,
+      left: 6,
+      width: 3,
+      metricConfig: {
+        metricName: "node_ram_hourly_cost",
+        aggregationType: MetricsAggregationType.Avg,
+      },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
+    }),
+    createValueComponent({
+      title: "PV Cost $/hr (avg per volume)",
+      top: 1,
+      left: 9,
+      width: 3,
+      metricConfig: {
+        metricName: "pv_hourly_cost",
+        aggregationType: MetricsAggregationType.Avg,
+      },
+      trendDirection: DashboardValueTrendDirection.HigherIsWorse,
+    }),
+
+    /*
+     * Row 2-5: Hourly cost per node, stacked — the stack height is the
+     * cluster's total node $/hr per bucket.
+     */
+    createChartComponent({
+      title: "Node Hourly Cost ($/hr, stacked by node)",
+      chartType: DashboardChartType.StackedArea,
+      top: 2,
+      left: 0,
+      width: 12,
+      height: 3,
+      metricConfig: {
+        metricName: "node_total_hourly_cost",
+        aggregationType: MetricsAggregationType.Avg,
+        legend: "Node",
+        legendUnit: "$/hr",
+        groupByAttributeKeys: ["node"],
+      },
+    }),
+
+    // Row 5-8: Unit-cost trends per node — catches spot/instance-type churn.
+    createChartComponent({
+      title: "CPU Cost per Core Hour by Node",
+      chartType: DashboardChartType.Line,
+      top: 5,
+      left: 0,
+      width: 6,
+      height: 3,
+      metricConfig: {
+        metricName: "node_cpu_hourly_cost",
+        aggregationType: MetricsAggregationType.Avg,
+        legend: "Node",
+        legendUnit: "$/core-hr",
+        groupByAttributeKeys: ["node"],
+      },
+    }),
+    createChartComponent({
+      title: "RAM Cost per GiB Hour by Node",
+      chartType: DashboardChartType.Line,
+      top: 5,
+      left: 6,
+      width: 6,
+      height: 3,
+      metricConfig: {
+        metricName: "node_ram_hourly_cost",
+        aggregationType: MetricsAggregationType.Avg,
+        legend: "Node",
+        legendUnit: "$/GiB-hr",
+        groupByAttributeKeys: ["node"],
+      },
+    }),
+
+    // Row 8-11: Storage and load balancer spend.
+    createChartComponent({
+      title: "Persistent Volume Hourly Cost (stacked by volume)",
+      chartType: DashboardChartType.StackedArea,
+      top: 8,
+      left: 0,
+      width: 6,
+      height: 3,
+      metricConfig: {
+        metricName: "pv_hourly_cost",
+        aggregationType: MetricsAggregationType.Avg,
+        legend: "Volume",
+        legendUnit: "$/hr",
+        groupByAttributeKeys: ["persistentvolume"],
+      },
+    }),
+    createChartComponent({
+      title: "Load Balancer Hourly Cost (stacked by service)",
+      chartType: DashboardChartType.StackedArea,
+      top: 8,
+      left: 6,
+      width: 6,
+      height: 3,
+      metricConfig: {
+        metricName: "kubecost_load_balancer_cost",
+        aggregationType: MetricsAggregationType.Avg,
+        legend: "Service",
+        legendUnit: "$/hr",
+        groupByAttributeKeys: ["service_name"],
+      },
+    }),
+
+    // Row 11-14: Per-node cost table for quick ranking.
+    createTableComponent({
+      title: "Cost by Node ($/hr)",
+      top: 11,
+      left: 0,
+      width: 12,
+      height: 3,
+      maxRows: 20,
+      metricConfig: {
+        metricName: "node_total_hourly_cost",
+        aggregationType: MetricsAggregationType.Avg,
+        groupByAttributeKeys: ["node"],
+      },
+    }),
+  ];
+
+  /*
+   * Cluster picker so multi-cluster projects can scope every widget from
+   * the toolbar. The deployment collector stamps k8s.cluster.name on the
+   * scraped cost metrics, so the binding key matches the other
+   * Kubernetes dashboards.
+   */
+  const variables: Array<DashboardVariable> = [
+    createTelemetryAttributeVariable({
+      name: "cluster",
+      label: "Cluster",
+      attributeKey: "resource.k8s.cluster.name",
+    }),
+  ];
+
+  return {
+    _type: ObjectType.DashboardViewConfig,
+    components,
+    variables,
+    heightInDashboardUnits: Math.max(DashboardSize.heightInDashboardUnits, 14),
+  };
+}
+
 function createMetricsDashboardConfig(): DashboardViewConfig {
   /*
    * Layout notes:
@@ -2697,6 +2909,8 @@ export function getTemplateConfig(
       return createAlertDashboardConfig();
     case DashboardTemplateType.Kubernetes:
       return createKubernetesDashboardConfig();
+    case DashboardTemplateType.KubernetesCost:
+      return createKubernetesCostDashboardConfig();
     case DashboardTemplateType.Host:
       return createHostDashboardConfig();
     case DashboardTemplateType.Proxmox:

package/Types/Email/EmailTemplateType.ts

@@ -32,6 +32,8 @@ enum EmailTemplateType {
   MonitorProbesStatus = "MonitorProbesStatus.hbs",
   MonitorOwnerStatusChanged = "MonitorOwnerStatusChanged.hbs",
 
+  SloOwnerStatusChanged = "SloOwnerStatusChanged.hbs",
+
   IncidentOwnerAdded = "IncidentOwnerAdded.hbs",
   IncidentOwnerStateChanged = "IncidentOwnerStateChanged.hbs",
   IncidentOwnerNotePosted = "IncidentOwnerNotePosted.hbs",

package/Types/Kubernetes/KubernetesCostIngest.ts

@@ -0,0 +1,79 @@
+/*
+ * Wire contract for POST /kubernetes-cost/ingest — the payload the
+ * Kubernetes agent's cost poller ships after querying an in-cluster cost
+ * engine's Allocation API (OpenCost `/allocation/compute`, Kubecost
+ * `/model/allocation`). One request carries one cluster's allocation rows
+ * for one or more closed time windows.
+ *
+ * The route is mounted under both "/telemetry" and "/" (TELEMETRY_PREFIXES).
+ * The agent posts to the "/telemetry" prefix — see the note in
+ * KubernetesCostAgent/Shipper.ts for why.
+ *
+ * The agent projects are standalone (no dependency on Common), so the
+ * poller carries its own mirror of these interfaces
+ * (KubernetesCostAgent/Types.ts) — keep the two in sync.
+ */
+
+export interface KubernetesCostAllocationIngestRow {
+  /** ISO-8601 start of the allocation window. Required. */
+  windowStart: string;
+  /** ISO-8601 end of the allocation window. Required. */
+  windowEnd: string;
+
+  /*
+   * Workload identity. All optional — idle / unallocated rows carry the
+   * engine's sentinel in `namespace` ("__idle__" / "__unallocated__") and
+   * nothing else.
+   */
+  namespace?: string | undefined;
+  controllerKind?: string | undefined;
+  controllerName?: string | undefined;
+  podName?: string | undefined;
+  containerName?: string | undefined;
+  nodeName?: string | undefined;
+  providerId?: string | undefined;
+  labels?: Record<string, string> | undefined;
+
+  // Usage / request measures.
+  cpuCoreHours?: number | undefined;
+  cpuCoreRequestAverage?: number | undefined;
+  cpuCoreUsageAverage?: number | undefined;
+  gpuHours?: number | undefined;
+  ramByteHours?: number | undefined;
+  ramBytesRequestAverage?: number | undefined;
+  ramBytesUsageAverage?: number | undefined;
+  pvByteHours?: number | undefined;
+
+  // Pre-priced cost components (in `currency` of the payload).
+  cpuCost?: number | undefined;
+  gpuCost?: number | undefined;
+  ramCost?: number | undefined;
+  pvCost?: number | undefined;
+  networkCost?: number | undefined;
+  loadBalancerCost?: number | undefined;
+  sharedCost?: number | undefined;
+  externalCost?: number | undefined;
+  totalCost?: number | undefined;
+
+  // Efficiency ratios (usage / request, 0..1+).
+  cpuEfficiency?: number | undefined;
+  ramEfficiency?: number | undefined;
+  totalEfficiency?: number | undefined;
+}
+
+export interface KubernetesCostIngestPayload {
+  /**
+   * Cluster identifier — must match the k8s.cluster.name the agent stamps
+   * on metrics so cost rows land on the same KubernetesCluster resource.
+   */
+  clusterName: string;
+  /** Currency code of all cost figures (e.g. "USD"). Optional. */
+  currency?: string | undefined;
+  allocations: Array<KubernetesCostAllocationIngestRow>;
+}
+
+/**
+ * Upper bound on `allocations.length` per request. The poller chunks its
+ * output to stay under this; the ingest endpoint rejects anything larger.
+ */
+export const MAX_KUBERNETES_COST_ALLOCATIONS_PER_REQUEST: number = 5000;

package/Types/Monitor/CriteriaFilter.ts

@@ -119,6 +119,14 @@ export interface ServerMonitorOptions {
 
 export interface SnmpMonitorOptions {
   oid?: string | undefined;
+  /*
+   * Optional interface scope for the interface CheckOns (down /
+   * utilization / errors). When set, only interfaces whose name or alias
+   * equals this value (case-insensitive) are evaluated — so "uplink Gi0/1
+   * above 80%" does not fire because an access port got busy. Empty =
+   * every monitored interface, the historical behavior.
+   */
+  interfaceName?: string | undefined;
 }
 
 export enum EvaluateOverTimeType {
@@ -429,6 +437,7 @@ export const CriteriaFilterSchema: ZodSchema = Zod.object({
   }).optional(),
   snmpMonitorOptions: Zod.object({
     oid: Zod.string().optional(),
+    interfaceName: Zod.string().optional(),
   }).optional(),
   filterType: Zod.string().optional(),
   value: Zod.union([Zod.string(), Zod.number()]).optional(),

package/Types/Monitor/MonitorStep.ts

@@ -734,18 +734,15 @@ export default class MonitorStep extends DatabaseProperty {
       return "Port is required";
     }
 
+    /*
+     * A Network Device monitor only needs to know WHICH device to alert
+     * on. What gets collected (interface walks, endpoint discovery, health
+     * OIDs) is configured on the NetworkDevice resource itself, not here.
+     */
     if (monitorType === MonitorType.NetworkDevice) {
       if (!value.data.networkDeviceMonitor?.networkDeviceId) {
         return "Network Device is required";
       }
-
-      if (
-        !value.data.networkDeviceMonitor.monitorInterfaces &&
-        (!value.data.networkDeviceMonitor.oids ||
-          value.data.networkDeviceMonitor.oids.length === 0)
-      ) {
-        return "Enable interface monitoring or configure at least one OID";
-      }
     }
 
     if (monitorType === MonitorType.DNS) {

package/Types/Monitor/MonitorStepNetworkDeviceMonitor.ts

@@ -2,15 +2,29 @@ import { JSONObject } from "../JSON";
 import SnmpOid from "./SnmpMonitor/SnmpOid";
 
 /*
- * Step configuration for Network Device monitors. Unlike the retired SNMP
- * monitor type, the step carries no connection details — it references a
- * NetworkDevice resource which owns the hostname, credentials, and
- * interface inventory. The server hydrates the device's SNMP config into
- * the step (as `snmpMonitor`) when handing work to probes.
+ * Step configuration for Network Device monitors. The step is purely a
+ * device reference: the NetworkDevice resource owns the hostname,
+ * credentials, polling schedule, interface walks, endpoint discovery, and
+ * health OIDs. The monitor is the alerting layer — it is evaluated
+ * server-side against the device's walk results and traps.
  */
 export default interface MonitorStepNetworkDeviceMonitor {
   networkDeviceId: string | undefined;
+  /*
+   * DEPRECATED: interface walking is now configured on the NetworkDevice
+   * (walkInterfaces). Retained so steps saved before the move still parse;
+   * never written by the dashboard anymore.
+   */
   monitorInterfaces: boolean;
+  /*
+   * DEPRECATED: endpoint collection is now configured on the NetworkDevice
+   * (collectEndpoints). Retained for parsing legacy steps only.
+   */
+  collectEndpoints?: boolean | undefined;
+  /*
+   * DEPRECATED: health OIDs are now configured on the NetworkDevice
+   * (snmpOids). Retained for parsing legacy steps only.
+   */
   oids: Array<SnmpOid>;
 }
 
@@ -19,6 +33,8 @@ export class MonitorStepNetworkDeviceMonitorUtil {
     return {
       networkDeviceId: undefined,
       monitorInterfaces: true,
+      // Off by default; the form renders it as an explicit opt-in switch.
+      collectEndpoints: false,
       oids: [],
     };
   }
@@ -27,6 +43,11 @@ export class MonitorStepNetworkDeviceMonitorUtil {
     return {
       networkDeviceId: (json["networkDeviceId"] as string) || undefined,
       monitorInterfaces: json["monitorInterfaces"] !== false,
+      /*
+       * Unlike monitorInterfaces, this is default-FALSE: only an explicit
+       * true opts in, so steps saved before the flag existed stay off.
+       */
+      collectEndpoints: json["collectEndpoints"] === true,
       oids: ((json["oids"] as Array<JSONObject>) || []).map(
         (oid: JSONObject) => {
           return {
@@ -43,6 +64,7 @@ export class MonitorStepNetworkDeviceMonitorUtil {
     return {
       networkDeviceId: monitor.networkDeviceId,
       monitorInterfaces: monitor.monitorInterfaces,
+      collectEndpoints: monitor.collectEndpoints,
       oids: monitor.oids.map((oid: SnmpOid) => {
         return {
           oid: oid.oid,

package/Types/Monitor/MonitorType.ts

@@ -37,9 +37,11 @@ enum MonitorType {
 
   /*
    * Network device monitoring (SNMP-based). Replaced the retired SNMP
-   * monitor type: instead of inline SNMP config, the monitor references a
-   * NetworkDevice resource that owns the credentials and interface
-   * inventory.
+   * monitor type. The referenced NetworkDevice resource owns everything
+   * about data collection — credentials, polling schedule, interface
+   * walks, endpoint discovery, and health OIDs. The monitor is purely the
+   * alerting layer: it picks a device and evaluates criteria against the
+   * device's walk results and traps, server-side.
    */
   NetworkDevice = "Network Device",
 
@@ -354,7 +356,7 @@ export class MonitorTypeHelper {
         monitorType: MonitorType.NetworkDevice,
         title: "Network Device",
         description:
-          "This monitor type lets you monitor a registered Network Device (switch, router, firewall, or access point) via SNMP — availability, interface status, bandwidth, and traps.",
+          "This monitor type alerts on a registered Network Device (switch, router, firewall, or access point) — availability, interface status, bandwidth, health OIDs, and traps. The device itself is polled by its assigned probe; the monitor chooses what to alert on.",
         icon: IconProp.Signal,
       },
       {
@@ -420,6 +422,15 @@ export class MonitorTypeHelper {
     return monitorTypeProps[0].title;
   }
 
+  /*
+   * Monitor types the probe executes on a schedule via MonitorProbe rows.
+   *
+   * NetworkDevice is deliberately NOT probeable: the NetworkDevice resource
+   * owns its own polling (the device's assigned probe walks it on the
+   * device's schedule), and Network Device monitors are evaluated
+   * server-side against each walk result and incoming trap — like
+   * IncomingRequest monitors, they never appear in a probe's work list.
+   */
   public static isProbableMonitor(monitorType: MonitorType): boolean {
     const isProbeableMonitor: boolean =
       monitorType === MonitorType.API ||
@@ -430,7 +441,6 @@ export class MonitorTypeHelper {
       monitorType === MonitorType.SSLCertificate ||
       monitorType === MonitorType.SyntheticMonitor ||
       monitorType === MonitorType.CustomJavaScriptCode ||
-      monitorType === MonitorType.NetworkDevice ||
       monitorType === MonitorType.DNS ||
       monitorType === MonitorType.DNSSEC ||
       monitorType === MonitorType.Domain ||

package/Types/Monitor/SnmpMonitor/ArpEntry.ts

@@ -0,0 +1,14 @@
+/*
+ * One entry from a device's ARP / IP-to-media table (IP-MIB
+ * ipNetToMediaTable). Captured by the probe alongside the interface walk
+ * when endpoint collection is enabled; the server joins these against FDB
+ * entries by MAC address to give discovered endpoints an IP address on the
+ * topology graph.
+ */
+export default interface ArpEntry {
+  ipAddress: string;
+  macAddress: string;
+  interfaceIndex: number;
+  // ipNetToMediaType, decoded: e.g. "dynamic", "static", "invalid".
+  entryType?: string | undefined;
+}

package/Types/Monitor/SnmpMonitor/FdbEntry.ts

@@ -0,0 +1,18 @@
+/*
+ * One entry from a switch's forwarding database (BRIDGE-MIB dot1dTpFdbTable
+ * or Q-BRIDGE-MIB dot1qTpFdbTable). Each row says "this MAC address was
+ * learned on this bridge port" — the raw material for endpoint discovery.
+ * The probe resolves bridgePort to an ifIndex via dot1dBasePortIfIndex when
+ * the device implements it; the server turns MACs learned on leaf ports
+ * into endpoint nodes on the topology graph.
+ */
+export default interface FdbEntry {
+  macAddress: string;
+  bridgePort: number;
+  // ifIndex the bridge port maps to, when dot1dBasePortIfIndex resolved it.
+  interfaceIndex?: number | undefined;
+  // From Q-BRIDGE-MIB walks; undefined when only dot1d data was available.
+  vlanId?: number | undefined;
+  // dot1dTpFdbStatus, decoded: e.g. "learned", "self", "mgmt".
+  status?: string | undefined;
+}

package/Types/Monitor/SnmpMonitor/NetworkDeviceAlertPack.ts

@@ -88,8 +88,9 @@ export default class NetworkDeviceAlertPackUtil {
 
   /*
    * Builds ready-to-append MonitorCriteriaInstances from the pack. Each is
-   * enabled and set to change monitor status; severities and on-call
-   * policies are left for the user to fill in.
+   * enabled; incident-creating items also change the monitor status to the
+   * context's down status. Severities and on-call policies are left for the
+   * user to fill in.
    */
   public static buildCriteriaInstances(
     context?: NetworkDeviceAlertPackContext,
@@ -105,7 +106,13 @@ export default class NetworkDeviceAlertPackUtil {
         alerts: [],
         createAlerts: item.createAlerts,
         createIncidents: item.createIncidents,
-        changeMonitorStatus: item.createIncidents,
+        /*
+         * Never claim to change monitor status without a status to change
+         * to — a caller that passes no context would otherwise produce
+         * criteria that "change" the monitor to an undefined status.
+         */
+        changeMonitorStatus:
+          item.createIncidents && Boolean(context?.downMonitorStatusId),
         isEnabled: true,
         name: item.name,
         description: item.description,

package/Types/Monitor/SnmpMonitor/NetworkTopology.ts

@@ -1,16 +1,30 @@
 /*
  * A derived view of the network topology for one project, built server-side
- * from the LLDP and CDP neighbor data each device reports. Nodes are devices;
- * unmanaged neighbors (discovery-protocol peers with no matching
- * NetworkDevice) appear as lightweight nodes so the graph doesn't dead-end.
+ * from the LLDP and CDP neighbor data each device reports (and, when
+ * endpoint collection is enabled, the ARP/FDB endpoint data). Nodes are
+ * devices; unmanaged neighbors (discovery-protocol peers with no matching
+ * NetworkDevice) appear as lightweight nodes so the graph doesn't dead-end,
+ * and discovered endpoints appear as "endpoint" nodes attached via "fdb"
+ * links.
  * Edges are physical links — one per device pair even when both ends (or
  * both protocols) report it — annotated with the operational state of the
  * interface at each end when the neighbor entry identifies it.
  */
 export type NetworkTopologyNodeStatus = "up" | "down" | "unknown";
 
-// Which discovery protocol(s) reported a link.
-export type NetworkTopologyLinkProtocol = "lldp" | "cdp";
+/*
+ * Which source(s) reported a link — a discovery protocol, or the bridge
+ * forwarding database (endpoint attachment).
+ */
+export type NetworkTopologyLinkProtocol = "lldp" | "cdp" | "fdb";
+
+/*
+ * What a node represents. Older payloads carry no kind — readers should
+ * derive it from isManaged ("device" when true, "unmanaged" otherwise).
+ * "endpoint" nodes are non-network hosts (POS terminals, cameras, kiosks)
+ * discovered from ARP/FDB data.
+ */
+export type NetworkTopologyNodeKind = "device" | "unmanaged" | "endpoint";
 
 export interface NetworkTopologyNode {
   // Device id for managed nodes; a synthetic "unmanaged:<key>" id otherwise.
@@ -18,6 +32,8 @@ export interface NetworkTopologyNode {
   name: string;
   isManaged: boolean;
   status: NetworkTopologyNodeStatus;
+  // Missing on older payloads — derive from isManaged.
+  kind?: NetworkTopologyNodeKind | undefined;
   interfacesUp?: number | undefined;
   interfacesDown?: number | undefined;
   // Extra device identity for search and the detail panel (managed nodes).
@@ -25,6 +41,16 @@ export interface NetworkTopologyNode {
   vendor?: string | undefined;
   // For unmanaged CDP peers this carries the reported platform string.
   deviceModel?: string | undefined;
+  /*
+   * Endpoint identity (endpoint nodes only), all best-effort: MAC from the
+   * FDB, IP from the ARP join, classification from OUI/heuristics (e.g.
+   * "pos-terminal", "camera", "printer"), VLAN from the FDB entry that
+   * learned the MAC. Optional so older payloads stay valid.
+   */
+  macAddress?: string | undefined;
+  ipAddress?: string | undefined;
+  classification?: string | undefined;
+  vlanId?: number | undefined;
 }
 
 /*

package/Types/Monitor/SnmpMonitor/SnmpMonitorResponse.ts

@@ -3,6 +3,8 @@ import SnmpDataType from "./SnmpDataType";
 import SnmpInterface from "./SnmpInterface";
 import LldpNeighbor from "./LldpNeighbor";
 import CdpNeighbor from "./CdpNeighbor";
+import ArpEntry from "./ArpEntry";
+import FdbEntry from "./FdbEntry";
 import SnmpSystemInfo from "./SnmpSystemInfo";
 import SnmpEntityInfo from "./SnmpEntityInfo";
 
@@ -49,4 +51,14 @@ export default interface SnmpMonitorResponse {
    * Undefined on older probes and non-CDP devices.
    */
   cdpNeighbors?: Array<CdpNeighbor> | undefined;
+  /*
+   * ARP / IP-to-media entries, walked when endpoint collection is enabled
+   * on the monitor step. Undefined on older probes.
+   */
+  arpEntries?: Array<ArpEntry> | undefined;
+  /*
+   * Bridge forwarding-database entries — MAC addresses learned per bridge
+   * port. Undefined on older probes and non-bridge devices.
+   */
+  fdbEntries?: Array<FdbEntry> | undefined;
 }