@oneuptime/common 13.0.5 → 13.0.7

package/Tests/Utils/Slo/SloWidgetFormat.test.ts

@@ -258,6 +258,53 @@ describe("SloWidgetFormat", () => {
       ).toBe("Error Budget Remaining");
     });
 
+    /*
+     * A widget that follows a toolbar variable shows whichever SLO the reader
+     * picked, so the objective is DATA: its name leads even the author's own
+     * title. A pinned widget's author title keeps standing alone.
+     */
+    it("leads a followed widget's author title with the picked SLO's name", () => {
+      expect(
+        getSloWidgetTitle({
+          widgetTitle: "SLI History",
+          sloName: "API Availability",
+          sloMetric: SloWidgetMetric.Sli,
+          followsSelection: true,
+        }),
+      ).toBe("API Availability · SLI History");
+
+      expect(
+        getSloWidgetTitle({
+          widgetTitle: "SLI History",
+          sloName: "API Availability",
+          sloMetric: SloWidgetMetric.Sli,
+          followsSelection: false,
+        }),
+      ).toBe("SLI History");
+    });
+
+    it("keeps a followed widget's title alone until the SLO has loaded", () => {
+      for (const sloName of [undefined, null, "", "   "]) {
+        expect(
+          getSloWidgetTitle({
+            widgetTitle: "  Burn Rate  ",
+            sloName: sloName,
+            followsSelection: true,
+          }),
+        ).toBe("Burn Rate");
+      }
+    });
+
+    it("uses the ordinary fallback for a followed widget without a title", () => {
+      expect(
+        getSloWidgetTitle({
+          sloName: "API Availability",
+          sloMetric: SloWidgetMetric.BurnRate,
+          followsSelection: true,
+        }),
+      ).toBe("API Availability · Burn Rate");
+    });
+
     it("falls back to the SLI label when neither title, name, nor metric are set", () => {
       expect(getSloWidgetTitle({})).toBe("SLI");
     });

package/Tests/Utils/Telemetry/HostIpAddresses.test.ts

@@ -1,6 +1,8 @@
 import {
   MAX_HOST_IP_ADDRESSES_LENGTH,
   MAX_HOST_IP_ADDRESS_COUNT,
+  MAX_INVENTORY_HOST_IP_ADDRESSES_LENGTH,
+  MAX_INVENTORY_HOST_IP_ADDRESS_COUNT,
   normalizeHostIpAddresses,
 } from "../../../Utils/Telemetry/HostIpAddresses";
 import { describe, expect, test } from "@jest/globals";
@@ -288,4 +290,107 @@ describe("normalizeHostIpAddresses", () => {
       expect(twice).toBe(once);
     });
   });
+
+  /*
+   * Issue #3866 gave the Inventory item's `host.ip` attribute its own, much
+   * smaller caps. The Host column stays the lossless record; the inventory
+   * value is a CMDB summary that has to fit one row of a definition list.
+   */
+  describe("inventory caps (issue #3866)", () => {
+    const INVENTORY: { maxCount: number; maxLength: number } = {
+      maxCount: MAX_INVENTORY_HOST_IP_ADDRESS_COUNT,
+      maxLength: MAX_INVENTORY_HOST_IP_ADDRESSES_LENGTH,
+    };
+
+    test("omitting options reproduces the Host column behaviour exactly", () => {
+      const addresses: Array<string> = issueReporterAddresses();
+      expect(normalizeHostIpAddresses(addresses, {})).toBe(
+        normalizeHostIpAddresses(addresses),
+      );
+      expect(
+        normalizeHostIpAddresses(addresses, {
+          maxCount: undefined,
+          maxLength: undefined,
+        }),
+      ).toBe(normalizeHostIpAddresses(addresses));
+    });
+
+    test("the inventory caps are far below the Host column's", () => {
+      expect(MAX_INVENTORY_HOST_IP_ADDRESS_COUNT).toBeLessThan(
+        MAX_HOST_IP_ADDRESS_COUNT,
+      );
+      expect(MAX_INVENTORY_HOST_IP_ADDRESSES_LENGTH).toBeLessThan(
+        MAX_HOST_IP_ADDRESSES_LENGTH,
+      );
+    });
+
+    /*
+     * The property that matters: for every host small enough to fit, the
+     * Network card and a CMDB export read the same string. Truncation is
+     * the only thing the two surfaces are allowed to disagree about.
+     */
+    test("a host below both cap sets serializes identically either way", () => {
+      const addresses: Array<string> = [
+        "192.168.1.42",
+        "10.0.0.7",
+        "fe80::42:acff:fe11:1",
+      ];
+      expect(normalizeHostIpAddresses(addresses, INVENTORY)).toBe(
+        normalizeHostIpAddresses(addresses),
+      );
+    });
+
+    test("the issue-#3006 payload truncates to a prefix of the full result", () => {
+      const addresses: Array<string> = issueReporterAddresses();
+      const full: string = normalizeHostIpAddresses(addresses) as string;
+      const capped: string = normalizeHostIpAddresses(
+        addresses,
+        INVENTORY,
+      ) as string;
+
+      expect(capped.length).toBeLessThan(full.length);
+      expect(full.startsWith(capped)).toBe(true);
+    });
+
+    test("truncation drops whole addresses, never a fragment", () => {
+      const addresses: Array<string> = issueReporterAddresses();
+      const capped: string = normalizeHostIpAddresses(
+        addresses,
+        INVENTORY,
+      ) as string;
+
+      expect(capped.length).toBeLessThanOrEqual(
+        MAX_INVENTORY_HOST_IP_ADDRESSES_LENGTH,
+      );
+      for (const address of capped.split(", ")) {
+        expect(addresses).toContain(address);
+      }
+    });
+
+    test("the count cap bites before the length cap on short addresses", () => {
+      const addresses: Array<string> = [];
+      for (let i: number = 0; i < 100; i++) {
+        addresses.push(`10.0.${i}.1`);
+      }
+      const capped: string = normalizeHostIpAddresses(
+        addresses,
+        INVENTORY,
+      ) as string;
+      expect(capped.split(", ")).toHaveLength(
+        MAX_INVENTORY_HOST_IP_ADDRESS_COUNT,
+      );
+    });
+
+    test.each([
+      ["an empty list", []],
+      ["whitespace only", ["  ", "\t"]],
+    ])(
+      "%s is null under the inventory caps too",
+      (_l: string, input: unknown) => {
+        expect(
+          normalizeHostIpAddresses(input as Array<string>, INVENTORY),
+        ).toBeNull();
+      },
+    );
+  });
 });

package/Tests/Utils/Telemetry/LockedFilterSearch.test.ts

@@ -7,7 +7,6 @@ import {
 import {
   TELEMETRY_EXPLORER_LABELS,
   TelemetrySignal,
-  buildSearchTextForFilters,
   buildSearchTokenForFilter,
   buildSearchTokenForOperatorValue,
   isSearchTokenSafeKey,
@@ -33,7 +32,7 @@ import Wildcard from "../../../Types/BaseDatabase/Wildcard";
 import { JSONObject } from "../../../Types/JSON";
 
 /*
- * A locked chip's "Copy filter" text must reproduce the chip on the explorer
+ * A locked chip's search syntax must reproduce the chip on the explorer
  * for the same signal when pasted into its search bar — nothing more (a token
  * the explorer reads as something else) and nothing less (a filter silently
  * left out of the copy). These pin which columns have a token per signal and
@@ -261,84 +260,6 @@ describe("buildSearchTokenForFilter — column chips", () => {
   });
 });
 
-describe("buildSearchTextForFilters", () => {
-  test("joins the tokens of every chip with single spaces, in order", () => {
-    expect(
-      buildSearchTextForFilters("logs", [
-        { facetKey: "attributes.resource.host.name", value: "web-01" },
-        { facetKey: "attributes.resource.container.runtime", value: "docker" },
-      ]),
-    ).toBe("@resource.host.name:web-01 @resource.container.runtime:docker");
-  });
-
-  test("skips chips without a token instead of inventing one", () => {
-    expect(
-      buildSearchTextForFilters("metrics", [
-        { facetKey: "primaryEntityId", value: "651a000000000000000000aa" },
-        { facetKey: "attributes.resource.faas.name", value: "fn" },
-      ]),
-    ).toBe("@resource.faas.name:fn");
-  });
-
-  test("drops duplicate tokens", () => {
-    expect(
-      buildSearchTextForFilters("logs", [
-        { facetKey: "attributes.k", value: "v" },
-        { facetKey: "attributes.k", value: "v" },
-      ]),
-    ).toBe("@k:v");
-  });
-
-  test("returns an empty string when nothing can be expressed", () => {
-    expect(
-      buildSearchTextForFilters("logs", [
-        { facetKey: "sessionId", value: "s" },
-      ]),
-    ).toBe("");
-    expect(buildSearchTextForFilters("logs", [])).toBe("");
-  });
-
-  test("a chip carrying a lockedDetail is trusted on its own searchToken", () => {
-    expect(
-      buildSearchTextForFilters("logs", [
-        {
-          facetKey: "attributes.k",
-          value: "contains web",
-          lockedDetail: {
-            source: "Pinned by this page",
-            summary: "s",
-            predicates: [],
-            searchToken: "@k:~web",
-          },
-        },
-      ]),
-    ).toBe("@k:~web");
-  });
-
-  test("a lockedDetail WITHOUT a searchToken is skipped — never re-derived from display text", () => {
-    /*
-     * An operator filter ("is any of web, api") has no search syntax; the
-     * chip's value is its display text, and a token built from it would
-     * filter on the literal string "is any of web, api".
-     */
-    expect(
-      buildSearchTextForFilters("logs", [
-        {
-          facetKey: "attributes.k",
-          value: "is any of web, api",
-          lockedDetail: {
-            source: "Pinned by this page",
-            summary: "s",
-            predicates: [],
-            searchTokenUnavailableReason: "Operator filters have no syntax.",
-          },
-        },
-        { facetKey: "attributes.other", value: "x" },
-      ]),
-    ).toBe("@other:x");
-  });
-});
-
 describe("TELEMETRY_EXPLORER_LABELS", () => {
   test("names every explorer", () => {
     expect(TELEMETRY_EXPLORER_LABELS).toEqual({

package/Types/AI/AIChatPageContext.ts

@@ -1,12 +1,19 @@
 import { JSONObject } from "../JSON";
+import {
+  AIResourceSubresource,
+  AIResourceType,
+  isAIResourceSubresourceKind,
+  isAIResourceType,
+} from "./AIResourceContext";
 
 /*
  * "Page context" makes Ask AI aware of what the user is looking at in the
  * dashboard. The client detects the current page (an incident, a monitor, a
  * trace waterfall, the logs explorer, …) and attaches this small descriptor to
  * each message it sends; the server folds it into the system prompt so "this
- * incident" resolves to the entity on screen. It is a per-turn hint, never
- * persisted — the user can detach it in the composer at any time.
+ * incident" resolves to the entity on screen. The latest context is kept as
+ * the conversation's subject. Sending null explicitly detaches and clears
+ * that subject; omitting context lets a full-page conversation keep it.
  */
 enum AIChatPageContextType {
   // Entity pages — carry the entity's id (and usually a display title).
@@ -15,6 +22,8 @@ enum AIChatPageContextType {
   Monitor = "Monitor",
   ScheduledMaintenanceEvent = "ScheduledMaintenanceEvent",
   TelemetryService = "TelemetryService",
+  RumApplication = "RumApplication",
+  Resource = "Resource",
   Trace = "Trace",
   Exception = "Exception",
 
@@ -27,6 +36,9 @@ enum AIChatPageContextType {
   TracesExplorer = "TracesExplorer",
   MetricsExplorer = "MetricsExplorer",
   ExceptionsList = "ExceptionsList",
+  RumApplications = "RumApplications",
+  TelemetryServicesList = "TelemetryServicesList",
+  ResourcesList = "ResourcesList",
 }
 
 export default AIChatPageContextType;
@@ -37,6 +49,8 @@ export interface AIChatPageContext {
   entityId?: string | undefined;
   // Display title of the entity (incident title, monitor name, …). Optional.
   entityTitle?: string | undefined;
+  resourceType?: AIResourceType | undefined;
+  subresource?: AIResourceSubresource | undefined;
 }
 
 /*
@@ -58,11 +72,28 @@ const ENTITY_TYPES: Array<AIChatPageContextType> = [
   AIChatPageContextType.Monitor,
   AIChatPageContextType.ScheduledMaintenanceEvent,
   AIChatPageContextType.TelemetryService,
+  AIChatPageContextType.RumApplication,
+  AIChatPageContextType.Resource,
   AIChatPageContextType.Trace,
   AIChatPageContextType.Exception,
 ];
 
 export class AIChatPageContextHelper {
+  /*
+   * Titles are presentation hints; only the resource and child identity decide
+   * whether navigation has selected a different conversation subject.
+   */
+  public static getIdentity(context: AIChatPageContext): string {
+    return JSON.stringify([
+      context.type,
+      context.entityId || null,
+      context.resourceType || null,
+      context.subresource?.kind || null,
+      context.subresource?.key || null,
+      context.subresource?.namespace || null,
+    ]);
+  }
+
   public static isValidType(
     value: string | undefined,
   ): value is AIChatPageContextType {
@@ -97,6 +128,16 @@ export class AIChatPageContextHelper {
 
     const context: AIChatPageContext = { type: type };
 
+    if (
+      type === AIChatPageContextType.Resource ||
+      type === AIChatPageContextType.ResourcesList
+    ) {
+      if (!isAIResourceType(json["resourceType"])) {
+        return undefined;
+      }
+      context.resourceType = json["resourceType"];
+    }
+
     if (this.isEntityType(type)) {
       const entityId: string =
         typeof json["entityId"] === "string"
@@ -113,6 +154,50 @@ export class AIChatPageContextHelper {
 
       context.entityId = entityId;
 
+      if (
+        type === AIChatPageContextType.Resource &&
+        json["subresource"] !== undefined
+      ) {
+        const raw: unknown = json["subresource"];
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+          return undefined;
+        }
+        const child: JSONObject = raw as JSONObject;
+        if (
+          !context.resourceType ||
+          !isAIResourceSubresourceKind(context.resourceType, child["kind"])
+        ) {
+          return undefined;
+        }
+        const subresource: AIResourceSubresource = { kind: child["kind"] };
+        if (child["key"] !== undefined) {
+          // eslint-disable-next-line no-control-regex
+          const controlCharacters: RegExp = /[\u0000-\u001F\u007F]/;
+          if (
+            typeof child["key"] !== "string" ||
+            !child["key"].trim() ||
+            child["key"].length > 512 ||
+            controlCharacters.test(child["key"])
+          ) {
+            return undefined;
+          }
+          subresource.key = child["key"].trim();
+        }
+        if (child["namespace"] !== undefined) {
+          const namespacePattern: RegExp = /^[a-z0-9](?:[-a-z0-9]*[a-z0-9])?$/;
+          if (
+            context.resourceType !== AIResourceType.KubernetesCluster ||
+            typeof child["namespace"] !== "string" ||
+            child["namespace"].length > 63 ||
+            !namespacePattern.test(child["namespace"])
+          ) {
+            return undefined;
+          }
+          subresource.namespace = child["namespace"];
+        }
+        context.subresource = subresource;
+      }
+
       if (typeof json["entityTitle"] === "string") {
         /*
          * The title is echoed into the system prompt: collapse whitespace and

package/Types/AI/AIChatTypes.ts

@@ -37,6 +37,10 @@ export enum AIChatCitationTargetType {
   Probes = "Probes",
   Teams = "Teams",
   SecurityEvents = "SecurityEvents",
+  RumApplications = "RumApplications",
+  RumApplicationView = "RumApplicationView",
+  TelemetryResources = "TelemetryResources",
+  TelemetryResourceView = "TelemetryResourceView",
 }
 
 export interface AIChatCitationTarget {

package/Types/AI/AIResourceContext.ts

@@ -0,0 +1,198 @@
+import IconProp from "../Icon/IconProp";
+import {
+  RESOURCE_FACET_CATALOG,
+  ResourceFacetDefinition,
+} from "../Telemetry/ResourceFacetCatalog";
+import ServiceType from "../Telemetry/ServiceType";
+
+export enum AIResourceType {
+  Host = "Host",
+  DockerHost = "DockerHost",
+  PodmanHost = "PodmanHost",
+  KubernetesCluster = "KubernetesCluster",
+  DockerSwarmCluster = "DockerSwarmCluster",
+  ProxmoxCluster = "ProxmoxCluster",
+  VMwareVCenter = "VMwareVCenter",
+  CephCluster = "CephCluster",
+  ServerlessFunction = "ServerlessFunction",
+  CloudResource = "CloudResource",
+  IoTFleet = "IoTFleet",
+  NetworkDevice = "NetworkDevice",
+}
+
+export enum AIResourceSubresourceKind {
+  Namespace = "Namespace",
+  Pod = "Pod",
+  Deployment = "Deployment",
+  StatefulSet = "StatefulSet",
+  DaemonSet = "DaemonSet",
+  Job = "Job",
+  CronJob = "CronJob",
+  Node = "Node",
+  Container = "Container",
+  PersistentVolumeClaim = "PersistentVolumeClaim",
+  PersistentVolume = "PersistentVolume",
+  HorizontalPodAutoscaler = "HorizontalPodAutoscaler",
+  VerticalPodAutoscaler = "VerticalPodAutoscaler",
+  Service = "Service",
+  Task = "Task",
+  Stack = "Stack",
+  Network = "Network",
+  Volume = "Volume",
+  Secret = "Secret",
+  Config = "Config",
+  Guest = "Guest",
+  Storage = "Storage",
+  Host = "Host",
+  VirtualMachine = "VirtualMachine",
+  Datastore = "Datastore",
+  Cluster = "Cluster",
+  Osd = "Osd",
+  Pool = "Pool",
+  Device = "Device",
+  Process = "Process",
+  WindowsService = "WindowsService",
+  SystemdUnit = "SystemdUnit",
+  Instance = "Instance",
+  Interface = "Interface",
+}
+
+export interface AIResourceSubresource {
+  kind: AIResourceSubresourceKind;
+  // Child names and external IDs are not OneUptime resource UUIDs.
+  key?: string | undefined;
+  namespace?: string | undefined;
+}
+
+export interface AIResourceDefinition extends ResourceFacetDefinition {
+  type: AIResourceType;
+}
+
+const RESOURCE_FACET_KEYS: Record<AIResourceType, string> = {
+  [AIResourceType.Host]: "hostId",
+  [AIResourceType.DockerHost]: "dockerHostId",
+  [AIResourceType.PodmanHost]: "podmanHostId",
+  [AIResourceType.KubernetesCluster]: "kubernetesClusterId",
+  [AIResourceType.DockerSwarmCluster]: "dockerSwarmClusterId",
+  [AIResourceType.ProxmoxCluster]: "proxmoxClusterId",
+  [AIResourceType.VMwareVCenter]: "vmwareVCenterId",
+  [AIResourceType.CephCluster]: "cephClusterId",
+  [AIResourceType.ServerlessFunction]: "serverlessFunctionId",
+  [AIResourceType.CloudResource]: "cloudResourceId",
+  [AIResourceType.IoTFleet]: "iotFleetId",
+  [AIResourceType.NetworkDevice]: "networkDeviceId",
+};
+
+/*
+ * Reuse the telemetry catalog's labels and type discriminators, including
+ * IoTFleet's historical IoTDevice discriminator. Network devices have no facet.
+ */
+export const AI_RESOURCE_DEFINITIONS: ReadonlyArray<AIResourceDefinition> =
+  Object.values(AIResourceType).map(
+    (type: AIResourceType): AIResourceDefinition => {
+      const facetKey: string = RESOURCE_FACET_KEYS[type];
+      if (type === AIResourceType.NetworkDevice) {
+        return {
+          type,
+          facetKey,
+          serviceType: ServiceType.NetworkDevice,
+          label: "Network Device",
+          pluralLabel: "Network Devices",
+          icon: IconProp.Server,
+        };
+      }
+
+      const definition: ResourceFacetDefinition | undefined =
+        RESOURCE_FACET_CATALOG.find(
+          (item: ResourceFacetDefinition): boolean => {
+            return item.facetKey === facetKey;
+          },
+        );
+      if (!definition) {
+        throw new Error(`Missing resource facet definition: ${type}`);
+      }
+      return { ...definition, type };
+    },
+  );
+
+export function getAIResourceDefinition(
+  type: AIResourceType,
+): AIResourceDefinition {
+  const definition: AIResourceDefinition | undefined =
+    AI_RESOURCE_DEFINITIONS.find((item: AIResourceDefinition): boolean => {
+      return item.type === type;
+    });
+  if (!definition) {
+    throw new Error(`Unknown AI resource type: ${type}`);
+  }
+  return definition;
+}
+
+export function isAIResourceType(value: unknown): value is AIResourceType {
+  return Object.values(AIResourceType).includes(value as AIResourceType);
+}
+
+export const AI_RESOURCE_SUBRESOURCE_KINDS: Readonly<
+  Record<AIResourceType, ReadonlyArray<AIResourceSubresourceKind>>
+> = {
+  [AIResourceType.Host]: [
+    AIResourceSubresourceKind.Process,
+    AIResourceSubresourceKind.WindowsService,
+    AIResourceSubresourceKind.SystemdUnit,
+  ],
+  [AIResourceType.DockerHost]: [AIResourceSubresourceKind.Container],
+  [AIResourceType.PodmanHost]: [AIResourceSubresourceKind.Container],
+  [AIResourceType.KubernetesCluster]: [
+    AIResourceSubresourceKind.Namespace,
+    AIResourceSubresourceKind.Pod,
+    AIResourceSubresourceKind.Deployment,
+    AIResourceSubresourceKind.StatefulSet,
+    AIResourceSubresourceKind.DaemonSet,
+    AIResourceSubresourceKind.Job,
+    AIResourceSubresourceKind.CronJob,
+    AIResourceSubresourceKind.Node,
+    AIResourceSubresourceKind.Container,
+    AIResourceSubresourceKind.PersistentVolumeClaim,
+    AIResourceSubresourceKind.PersistentVolume,
+    AIResourceSubresourceKind.HorizontalPodAutoscaler,
+    AIResourceSubresourceKind.VerticalPodAutoscaler,
+  ],
+  [AIResourceType.DockerSwarmCluster]: [
+    AIResourceSubresourceKind.Node,
+    AIResourceSubresourceKind.Service,
+    AIResourceSubresourceKind.Task,
+    AIResourceSubresourceKind.Stack,
+    AIResourceSubresourceKind.Network,
+    AIResourceSubresourceKind.Volume,
+    AIResourceSubresourceKind.Secret,
+    AIResourceSubresourceKind.Config,
+  ],
+  [AIResourceType.ProxmoxCluster]: [
+    AIResourceSubresourceKind.Node,
+    AIResourceSubresourceKind.Guest,
+    AIResourceSubresourceKind.Storage,
+  ],
+  [AIResourceType.VMwareVCenter]: [
+    AIResourceSubresourceKind.Host,
+    AIResourceSubresourceKind.VirtualMachine,
+    AIResourceSubresourceKind.Datastore,
+    AIResourceSubresourceKind.Cluster,
+  ],
+  [AIResourceType.CephCluster]: [
+    AIResourceSubresourceKind.Osd,
+    AIResourceSubresourceKind.Pool,
+  ],
+  [AIResourceType.IoTFleet]: [AIResourceSubresourceKind.Device],
+  [AIResourceType.ServerlessFunction]: [AIResourceSubresourceKind.Instance],
+  [AIResourceType.CloudResource]: [AIResourceSubresourceKind.Instance],
+  [AIResourceType.NetworkDevice]: [AIResourceSubresourceKind.Interface],
+};
+
+export function isAIResourceSubresourceKind(
+  type: AIResourceType,
+  value: unknown,
+): value is AIResourceSubresourceKind {
+  return AI_RESOURCE_SUBRESOURCE_KINDS[type].includes(
+    value as AIResourceSubresourceKind,
+  );
+}

package/Types/AI/InvestigationNotStartedReason.ts

@@ -0,0 +1,30 @@
+export type InvestigationNotStartedCode =
+  | "ai_disabled"
+  | "automatic_investigation_disabled"
+  | "provider_missing"
+  | "severity_below_threshold"
+  | "monitor_cooldown"
+  | "daily_budget_exhausted"
+  | "budget_check_failed"
+  | "enqueue_failed"
+  | "eligibility_check_failed"
+  | "no_run_recorded";
+
+/**
+ * A recorded decision is evidence from the creation hook. Current settings
+ * explain eligibility now, and must never be presented as a historical fact.
+ */
+export default interface InvestigationNotStartedReason {
+  code: InvestigationNotStartedCode;
+  title: string;
+  description: string;
+  nextStep: string;
+  source: "recorded" | "current_configuration" | "unknown";
+  evaluatedAt: string;
+}
+
+export interface InvestigationGateDetails {
+  severityName?: string | undefined;
+  minimumSeverityName?: string | undefined;
+  cooldownWindowMinutes?: number | undefined;
+}