@oneuptime/common 11.3.4 → 11.3.6

package/Tests/UI/Components/Alert.test.tsx

@@ -8,7 +8,7 @@ describe("alert tests", () => {
   test("it should render all props passed", () => {
     const handleClick: undefined | (() => void) = jest.fn();
     const handleClose: (() => void) | undefined = jest.fn();
-    render(
+    const { container } = render(
       <Alert
         title="title"
         strongTitle="strong"
@@ -18,8 +18,8 @@ describe("alert tests", () => {
       />,
     );
 
-    const icon: HTMLElement = screen.getByRole("icon");
-    expect(icon).toBeInTheDocument();
+    // The alert icon renders an inline <svg> (no role="icon"; WCAG 4.1.2).
+    expect(container.querySelector("svg")).not.toBeNull();
 
     const alert: HTMLElement = screen.getByRole("alert");
     expect(alert).toBeInTheDocument();
@@ -34,30 +34,38 @@ describe("alert tests", () => {
     expect(handleClose).toBeCalled();
   });
   test("it should show icon when alert type is equal to success", () => {
-    render(<Alert dataTestId="test-id" type={AlertType.SUCCESS} />);
-    const icon: HTMLElement = screen.getByRole("icon");
-    expect(icon).toBeInTheDocument();
+    const { container } = render(
+      <Alert dataTestId="test-id" type={AlertType.SUCCESS} />,
+    );
+    // The alert icon renders an inline <svg> (no role="icon"; WCAG 4.1.2).
+    expect(container.querySelector("svg")).not.toBeNull();
     const testId: HTMLElement = screen.getByTestId("test-id");
     expect(testId).toHaveClass("rounded-md bg-gray-700 p-4");
   });
   test("it should show icon when alert type is equal to info", () => {
-    render(<Alert dataTestId="test-id" type={AlertType.INFO} />);
-    const icon: HTMLElement = screen.getByRole("icon");
-    expect(icon).toBeInTheDocument();
+    const { container } = render(
+      <Alert dataTestId="test-id" type={AlertType.INFO} />,
+    );
+    // The alert icon renders an inline <svg> (no role="icon"; WCAG 4.1.2).
+    expect(container.querySelector("svg")).not.toBeNull();
     const testId: HTMLElement = screen.getByTestId("test-id");
     expect(testId).toHaveClass("rounded-md bg-gray-700 p-4");
   });
   test("it should show icon when alert type is equal to warning", () => {
-    render(<Alert dataTestId="test-id" type={AlertType.WARNING} />);
-    const icon: HTMLElement = screen.getByRole("icon");
-    expect(icon).toBeInTheDocument();
+    const { container } = render(
+      <Alert dataTestId="test-id" type={AlertType.WARNING} />,
+    );
+    // The alert icon renders an inline <svg> (no role="icon"; WCAG 4.1.2).
+    expect(container.querySelector("svg")).not.toBeNull();
     const testId: HTMLElement = screen.getByTestId("test-id");
     expect(testId).toHaveClass("rounded-md bg-gray-700 p-4");
   });
   test("it should show icon when alert type is equal to danger", () => {
-    render(<Alert dataTestId="test-id" type={AlertType.DANGER} />);
-    const icon: HTMLElement = screen.getByRole("icon");
-    expect(icon).toBeInTheDocument();
+    const { container } = render(
+      <Alert dataTestId="test-id" type={AlertType.DANGER} />,
+    );
+    // The alert icon renders an inline <svg> (no role="icon"; WCAG 4.1.2).
+    expect(container.querySelector("svg")).not.toBeNull();
     const testId: HTMLElement = screen.getByTestId("test-id");
     expect(testId).toHaveClass("rounded-md bg-red-700 p-4");
   });

package/Tests/UI/Components/Breadcrumbs.test.tsx

@@ -63,20 +63,32 @@ describe("Breadcrumbs", () => {
       <Breadcrumbs links={links} />,
     );
     const testInstance: ReactTestInstance = testRenderer.root;
-    // Assert cursor style
+    /*
+     * The current page is not linked: it renders as a non-interactive <span>
+     * (cursor-default), not an <a> (WCAG 4.1.2). Only the other crumbs are
+     * rendered as anchors.
+     */
     const anchors: ReactTestInstance[] = testInstance.findAllByType("a");
+    expect(anchors).toHaveLength(1);
     expect(anchors[0]?.props["className"]).toContain("cursor-pointer");
-    expect(anchors[1]?.props["className"]).toContain("cursor-default");
+    // The current page ("Projects") renders as a cursor-default span.
+    const currentPageSpans: ReactTestInstance[] = testInstance.findAll(
+      (node: ReactTestInstance) => {
+        return (
+          node.type === "span" &&
+          typeof node.props["className"] === "string" &&
+          node.props["className"].includes("cursor-default")
+        );
+      },
+    );
+    expect(currentPageSpans.length).toBeGreaterThan(0);
     // Set up spy on navigation
     jest.spyOn(Navigation, "navigate");
     // Create a mock event with preventDefault
     const mockEvent: { preventDefault: ReturnType<typeof jest.fn> } = {
       preventDefault: jest.fn(),
     };
-    // Assert the second link does not navigate
-    anchors[1]?.props["onClick"](mockEvent);
-    expect(Navigation.navigate).not.toHaveBeenCalled();
-    // Assert the first link navigates
+    // The first (non-current) link navigates when clicked.
     anchors[0]?.props["onClick"](mockEvent);
     expect(Navigation.navigate).toHaveBeenCalledTimes(1);
   });

package/Tests/UI/Components/Button.test.tsx

@@ -12,7 +12,7 @@ import { describe, expect, jest } from "@jest/globals";
 
 describe("Button", () => {
   test("it should render correctly with title and icon", () => {
-    render(
+    const { container } = render(
       <Button
         dataTestId="test-id"
         title="sample title"
@@ -28,8 +28,8 @@ describe("Button", () => {
     expect(testId).toBeInTheDocument();
     expect(testId).toHaveAttribute("type", "button");
     expect(testId).toHaveAttribute("disabled");
-    const icon: HTMLElement = screen.getByRole("icon");
-    expect(icon).toBeInTheDocument();
+    // The icon renders an inline <svg> (no invalid role="icon"; WCAG 4.1.2).
+    expect(container.querySelector("svg")).not.toBeNull();
   });
 
   test("it should have shortcutKey Setting", () => {

package/Tests/UI/Components/DictionaryFilterOperator.test.ts

@@ -0,0 +1,174 @@
+import {
+  DictionaryEntryValue,
+  DictionaryFilterOperator,
+  buildDictionaryValue,
+  detectOperatorFromValue,
+} from "../../../UI/Components/Dictionary/DictionaryFilterOperator";
+import Includes from "../../../Types/BaseDatabase/Includes";
+import IncludesNone from "../../../Types/BaseDatabase/IncludesNone";
+import { ObjectType } from "../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
+
+describe("DictionaryFilterOperator - IsAnyOf (multi-value membership)", () => {
+  it("builds an Includes wrapper from a multi-value selection", () => {
+    const built: DictionaryEntryValue = buildDictionaryValue({
+      operator: DictionaryFilterOperator.IsAnyOf,
+      rawValue: "",
+      rawValues: ["system", "user"],
+    });
+
+    expect(built).toBeInstanceOf(Includes);
+    expect((built as Includes).values).toEqual(["system", "user"]);
+  });
+
+  it("drops empty-string entries so an empty pick becomes an empty Includes (treated as 'All' downstream)", () => {
+    const built: DictionaryEntryValue = buildDictionaryValue({
+      operator: DictionaryFilterOperator.IsAnyOf,
+      rawValue: "",
+      rawValues: ["system", "", "user"],
+    });
+
+    expect((built as Includes).values).toEqual(["system", "user"]);
+  });
+
+  it("builds an empty Includes when no values are supplied", () => {
+    const built: DictionaryEntryValue = buildDictionaryValue({
+      operator: DictionaryFilterOperator.IsAnyOf,
+      rawValue: "",
+    });
+
+    expect(built).toBeInstanceOf(Includes);
+    expect((built as Includes).values).toEqual([]);
+  });
+
+  it("detects a hydrated Includes instance as IsAnyOf with a joined display value and structured array", () => {
+    const detected: {
+      operator: DictionaryFilterOperator;
+      rawValue: string;
+      rawValues?: Array<string> | undefined;
+    } = detectOperatorFromValue(new Includes(["system", "user"]));
+
+    expect(detected.operator).toBe(DictionaryFilterOperator.IsAnyOf);
+    expect(detected.rawValue).toBe("system, user");
+    expect(detected.rawValues).toEqual(["system", "user"]);
+  });
+
+  it("detects the round-tripped `{_type, value}` JSON shape as IsAnyOf", () => {
+    const jsonShape: { _type: ObjectType; value: Array<string> } = {
+      _type: ObjectType.Includes,
+      value: ["system", "user"],
+    };
+
+    const detected: {
+      operator: DictionaryFilterOperator;
+      rawValues?: Array<string> | undefined;
+    } = detectOperatorFromValue(jsonShape);
+
+    expect(detected.operator).toBe(DictionaryFilterOperator.IsAnyOf);
+    expect(detected.rawValues).toEqual(["system", "user"]);
+  });
+
+  it("round-trips build -> detect without losing values", () => {
+    const built: DictionaryEntryValue = buildDictionaryValue({
+      operator: DictionaryFilterOperator.IsAnyOf,
+      rawValue: "",
+      rawValues: ["nice", "softirq", "steal"],
+    });
+
+    const detected: {
+      operator: DictionaryFilterOperator;
+      rawValues?: Array<string> | undefined;
+    } = detectOperatorFromValue(built);
+
+    expect(detected.operator).toBe(DictionaryFilterOperator.IsAnyOf);
+    expect(detected.rawValues).toEqual(["nice", "softirq", "steal"]);
+  });
+
+  it("detects an empty Includes as IsAnyOf with an empty raw value", () => {
+    const detected: {
+      operator: DictionaryFilterOperator;
+      rawValue: string;
+      rawValues?: Array<string> | undefined;
+    } = detectOperatorFromValue(new Includes([]));
+
+    expect(detected.operator).toBe(DictionaryFilterOperator.IsAnyOf);
+    expect(detected.rawValue).toBe("");
+    expect(detected.rawValues).toEqual([]);
+  });
+
+  it("leaves a bare string mapping to EqualTo (existing single-value filters keep working)", () => {
+    const detected: {
+      operator: DictionaryFilterOperator;
+      rawValue: string;
+    } = detectOperatorFromValue("system");
+
+    expect(detected.operator).toBe(DictionaryFilterOperator.EqualTo);
+    expect(detected.rawValue).toBe("system");
+  });
+});
+
+describe("DictionaryFilterOperator - IsNoneOf (multi-value exclusion)", () => {
+  it("builds an IncludesNone wrapper from a multi-value selection", () => {
+    const built: DictionaryEntryValue = buildDictionaryValue({
+      operator: DictionaryFilterOperator.IsNoneOf,
+      rawValue: "",
+      rawValues: ["system", "user"],
+    });
+
+    expect(built).toBeInstanceOf(IncludesNone);
+    expect((built as IncludesNone).values).toEqual(["system", "user"]);
+  });
+
+  it("drops empty-string entries", () => {
+    const built: DictionaryEntryValue = buildDictionaryValue({
+      operator: DictionaryFilterOperator.IsNoneOf,
+      rawValue: "",
+      rawValues: ["system", "", "user"],
+    });
+
+    expect((built as IncludesNone).values).toEqual(["system", "user"]);
+  });
+
+  it("detects a hydrated IncludesNone instance as IsNoneOf with a joined display value", () => {
+    const detected: {
+      operator: DictionaryFilterOperator;
+      rawValue: string;
+      rawValues?: Array<string> | undefined;
+    } = detectOperatorFromValue(new IncludesNone(["system", "user"]));
+
+    expect(detected.operator).toBe(DictionaryFilterOperator.IsNoneOf);
+    expect(detected.rawValue).toBe("system, user");
+    expect(detected.rawValues).toEqual(["system", "user"]);
+  });
+
+  it("detects the round-tripped `{_type, value}` JSON shape as IsNoneOf", () => {
+    const jsonShape: { _type: ObjectType; value: Array<string> } = {
+      _type: ObjectType.IncludesNone,
+      value: ["system", "user"],
+    };
+
+    const detected: {
+      operator: DictionaryFilterOperator;
+      rawValues?: Array<string> | undefined;
+    } = detectOperatorFromValue(jsonShape);
+
+    expect(detected.operator).toBe(DictionaryFilterOperator.IsNoneOf);
+    expect(detected.rawValues).toEqual(["system", "user"]);
+  });
+
+  it("round-trips build -> detect without losing values", () => {
+    const built: DictionaryEntryValue = buildDictionaryValue({
+      operator: DictionaryFilterOperator.IsNoneOf,
+      rawValue: "",
+      rawValues: ["nice", "softirq"],
+    });
+
+    const detected: {
+      operator: DictionaryFilterOperator;
+      rawValues?: Array<string> | undefined;
+    } = detectOperatorFromValue(built);
+
+    expect(detected.operator).toBe(DictionaryFilterOperator.IsNoneOf);
+    expect(detected.rawValues).toEqual(["nice", "softirq"]);
+  });
+});

package/Tests/UI/Components/EmptyState/EmptyState.test.tsx

@@ -6,7 +6,7 @@ import React from "react";
 
 describe("EmptyState", () => {
   test("renders correctly with all props", () => {
-    render(
+    const { container } = render(
       <EmptyState
         id="empty-state"
         title="Empty State Title"
@@ -18,13 +18,14 @@ describe("EmptyState", () => {
     const titleElement: HTMLElement = screen.getByText("Empty State Title");
     const descriptionElement: HTMLElement =
       screen.getByText("Empty State Title");
-    const iconElement: HTMLElement = screen.getByRole("icon");
+    // The icon renders an inline <svg> (no invalid role="icon"; WCAG 4.1.2).
+    const iconElement: Element | null = container.querySelector("svg");
     const footerElement: HTMLElement = screen.getByText(
       "This is a footer element",
     );
     expect(titleElement).toBeInTheDocument();
     expect(descriptionElement).toBeInTheDocument();
-    expect(iconElement).toBeInTheDocument();
+    expect(iconElement).not.toBeNull();
     expect(footerElement).toBeInTheDocument();
   });
   test("renders without an icon", () => {

package/Tests/UI/Components/Input.test.tsx

@@ -281,9 +281,10 @@ describe("Input", () => {
   test("displays error icon", () => {
     const error: string = "error";
 
-    render(<Input {...{ error }} />);
+    const { container } = render(<Input {...{ error }} />);
 
-    expect(screen.getByRole("icon", { hidden: true })).toBeInTheDocument();
+    // The error icon renders an inline <svg> (no role="icon"; WCAG 4.1.2).
+    expect(container.querySelector("svg")).not.toBeNull();
   });
 
   test("sets error style if error exists", () => {

package/Tests/UI/Components/Pill.test.tsx

@@ -52,8 +52,10 @@ describe("<Pill />", () => {
     const { container } = render(
       <Pill text="Love" color={color} icon={IconProp.Label} />,
     );
-    // The icon renders an inline <svg>. (It no longer uses the invalid
-    // role="icon" ARIA role, which was removed for WCAG 4.1.2 compliance.)
+    /*
+     * The icon renders an inline <svg>. (It no longer uses the invalid
+     * role="icon" ARIA role, which was removed for WCAG 4.1.2 compliance.)
+     */
     expect(container.querySelector("svg")).not.toBeNull();
   });
 });

package/Tests/UI/Components/SideMenuItem.test.tsx

@@ -60,9 +60,12 @@ describe("Side Menu Item", () => {
   });
 
   it("Should render icon if provided", () => {
-    render(<SideMenuItem {...defaultProps} icon={IconProp.Home} />);
+    const { container } = render(
+      <SideMenuItem {...defaultProps} icon={IconProp.Home} />,
+    );
 
-    expect(screen.getByRole("icon")).toBeInTheDocument();
+    // The icon renders an inline <svg> (no invalid role="icon"; WCAG 4.1.2).
+    expect(container.querySelector("svg")).not.toBeNull();
   });
 
   it("Should render the sub item link with given title and Icon", () => {
@@ -73,7 +76,7 @@ describe("Side Menu Item", () => {
       title: "Sub Page",
       to: new Route("/sub-page"),
     };
-    render(
+    const { container } = render(
       <SideMenuItem
         {...defaultProps}
         subItemLink={subLink}
@@ -87,7 +90,8 @@ describe("Side Menu Item", () => {
       .closest("a");
 
     expect(subLinkElement).toBeInTheDocument();
-    expect(screen.getAllByRole("icon")).toHaveLength(2);
+    // Main and sub-item icons each render an inline <svg> (no role="icon").
+    expect(container.querySelectorAll("svg")).toHaveLength(2);
   });
 
   it("Should render link badge if provided", () => {
@@ -104,15 +108,21 @@ describe("Side Menu Item", () => {
   });
 
   it("Should show alert", () => {
-    render(<SideMenuItem {...defaultProps} showAlert={true} />);
+    const { container } = render(
+      <SideMenuItem {...defaultProps} showAlert={true} />,
+    );
 
-    expect(screen.getByRole("icon")).toBeInTheDocument();
+    // The alert icon renders an inline <svg> (no role="icon"; WCAG 4.1.2).
+    expect(container.querySelector("svg")).not.toBeNull();
   });
 
   it("Should show warning", () => {
-    render(<SideMenuItem {...defaultProps} showWarning={true} />);
+    const { container } = render(
+      <SideMenuItem {...defaultProps} showWarning={true} />,
+    );
 
-    expect(screen.getByRole("icon")).toBeInTheDocument();
+    // The warning icon renders an inline <svg> (no role="icon"; WCAG 4.1.2).
+    expect(container.querySelector("svg")).not.toBeNull();
   });
 
   it("Should highlights the main link when on the same page", () => {

package/Tests/UI/Components/TextArea.test.tsx

@@ -117,13 +117,15 @@ describe("TextArea", () => {
   });
 
   test("displays error icon", () => {
-    const { getByRole } = render(<TextArea error="error" initialValue="" />);
-    expect(getByRole("icon", { hidden: true })).toBeInTheDocument();
+    const { container } = render(<TextArea error="error" initialValue="" />);
+    // The error icon renders an inline <svg> (no role="icon"; WCAG 4.1.2).
+    expect(container.querySelector("svg")).not.toBeNull();
   });
 
   test("does not display error icon without error", () => {
-    const { queryByRole } = render(<TextArea initialValue="" />);
-    expect(queryByRole("icon", { hidden: true })).not.toBeInTheDocument();
+    const { container } = render(<TextArea initialValue="" />);
+    // Without an error there is no icon, so no <svg> is rendered.
+    expect(container.querySelector("svg")).toBeNull();
   });
 
   test("applies error styles", () => {

package/Types/Monitor/IncomingMonitor/IncidentGroupingConfig.ts

@@ -0,0 +1,74 @@
+import Zod, { ZodSchema } from "../../../Utils/Schema/Zod";
+
+/**
+ * Per-criteria configuration that lets a single Incoming Request /
+ * webhook monitor open MULTIPLE concurrent incidents — one per distinct
+ * value extracted from the incoming payload — instead of the default
+ * one-active-incident-per-criteria behaviour.
+ *
+ * This is what makes a single Grafana/Alertmanager webhook endpoint fan
+ * out into separate incidents ("High RAM Usage", "High CPU Usage", ...)
+ * that can all be active at the same time. Under the hood the extracted
+ * value is hashed into the same `seriesFingerprint` dedupe key that
+ * metric monitors already use for per-series incidents, so the existing
+ * create + dedupe machinery handles the rest.
+ *
+ * When this is absent on a criteria, the monitor behaves exactly as
+ * before (one active incident per criteria) — the feature is strictly
+ * opt-in.
+ */
+export default interface IncidentGroupingConfig {
+  /**
+   * Path into the incoming request body used to derive the grouping /
+   * dedupe key. Uses the same `requestBody`-rooted convention as incident
+   * templates and JavaScript-expression filters; both of these resolve
+   * identically (the `{{ … }}` template wrapper is optional):
+   *
+   *   `{{requestBody.alerts[*].labels.alertname}}`
+   *   `requestBody.alerts[*].labels.alertname`
+   *
+   * The `requestBody` root is required. Supports dotted paths and array
+   * indexing (`[0]`, `[last]`) per the
+   * shared `VMUtil.deepFind` syntax, plus a single `[*]` wildcard to fan
+   * out over an array — one incident per element. For Grafana's
+   * Alertmanager-shaped webhook this is typically
+   * `requestBody.alerts[*].labels.alertname` or
+   * `requestBody.commonLabels.alertname`.
+   */
+  groupByJSONPath: string;
+
+  /**
+   * Optional explicit "resolved" classifier for event-driven sources.
+   * Webhooks are event-driven: a single POST describes only the alerts in
+   * that payload, not the full set of everything currently firing, so an
+   * incident must NOT be auto-resolved merely because its key is absent
+   * from a later payload (that's the snapshot model metric monitors use).
+   * Instead, when the value at `resolvedWhenJSONPath` equals
+   * `resolvedWhenValue`, the event resolves the incident for that key.
+   *
+   * Uses the same `requestBody`-rooted convention as `groupByJSONPath`.
+   * For Grafana this is `requestBody.status` == `resolved` (payload-level),
+   * or `requestBody.alerts[*].status` == `resolved` when `groupByJSONPath`
+   * also fans out over `alerts[*]` (the resolve check is then evaluated per
+   * element).
+   *
+   * When unset, every matching event is treated as firing and grouped
+   * incidents are only ever resolved manually.
+   */
+  resolvedWhenJSONPath?: string | undefined;
+  resolvedWhenValue?: string | undefined;
+
+  /**
+   * Safety cap on the number of distinct keys processed from a single
+   * payload. Protects against a high-cardinality field (or a key that
+   * changes every fire) spawning unbounded incidents. Defaults to 100.
+   */
+  maxKeysPerPayload?: number | undefined;
+}
+
+export const IncidentGroupingConfigSchema: ZodSchema = Zod.object({
+  groupByJSONPath: Zod.string(),
+  resolvedWhenJSONPath: Zod.string().optional(),
+  resolvedWhenValue: Zod.string().optional(),
+  maxKeysPerPayload: Zod.number().optional(),
+});

package/Types/Monitor/MonitorCriteriaInstance.ts

@@ -15,6 +15,9 @@ import {
   CriteriaFilterSchema,
 } from "./CriteriaFilter";
 import { CriteriaIncident, CriteriaIncidentSchema } from "./CriteriaIncident";
+import IncidentGroupingConfig, {
+  IncidentGroupingConfigSchema,
+} from "./IncomingMonitor/IncidentGroupingConfig";
 import MonitorType from "./MonitorType";
 import { FindOperator } from "typeorm";
 import Zod, { ZodSchema } from "../../Utils/Schema/Zod";
@@ -31,6 +34,12 @@ export interface MonitorCriteriaInstanceType {
   createIncidents?: boolean | undefined;
   createAlerts?: boolean | undefined;
   isEnabled?: boolean | undefined;
+  /**
+   * Incoming Request monitors only: opt-in config to open one incident
+   * per distinct value extracted from the webhook payload (e.g. one per
+   * Grafana alert name) instead of a single active incident per criteria.
+   */
+  incidentGrouping?: IncidentGroupingConfig | undefined;
   id: string;
 }
 
@@ -1482,6 +1491,16 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
     return this;
   }
 
+  public setIncidentGrouping(
+    incidentGrouping: IncidentGroupingConfig | undefined,
+  ): MonitorCriteriaInstance {
+    if (this.data) {
+      this.data.incidentGrouping = incidentGrouping;
+    }
+
+    return this;
+  }
+
   public override toJSON(): JSONObject {
     if (!this.data) {
       return MonitorCriteriaInstance.getNewMonitorCriteriaInstanceAsJSON();
@@ -1500,6 +1519,7 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
         changeMonitorStatus: this.data.changeMonitorStatus,
         createIncidents: this.data.createIncidents,
         isEnabled: this.data.isEnabled,
+        incidentGrouping: this.data.incidentGrouping,
         name: this.data.name,
         description: this.data.description,
       } as any,
@@ -1609,6 +1629,7 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
       createAlerts: (json["createAlerts"] as boolean) || false,
       isEnabled:
         json["isEnabled"] === undefined ? true : (json["isEnabled"] as boolean),
+      incidentGrouping: (json["incidentGrouping"] as any) || undefined,
       filters: filters as any,
       incidents: incidents as any,
       alerts: alerts as any,
@@ -1635,6 +1656,7 @@ export default class MonitorCriteriaInstance extends DatabaseProperty {
         createIncidents: Zod.boolean().optional(),
         createAlerts: Zod.boolean().optional(),
         isEnabled: Zod.boolean().optional(),
+        incidentGrouping: IncidentGroupingConfigSchema.optional(),
       }).openapi({
         type: "object",
         example: {