@oneuptime/common 11.3.21 → 11.3.23

package/Server/Services/TelemetryExceptionService.ts

@@ -15,6 +15,17 @@ import AIAgentTaskTelemetryExceptionService from "./AIAgentTaskTelemetryExceptio
 import QueryHelper from "../Types/Database/QueryHelper";
 import ModelPermission from "../Types/Database/Permissions/Index";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import Query from "../Types/Database/Query";
+import Includes from "../../Types/BaseDatabase/Includes";
+import logger from "../Utils/Logger";
+
+/*
+ * Hard cap on the fingerprint NOT IN list handed to the ClickHouse count
+ * query. ClickHouse receives query params via the request URI (default
+ * http_max_uri_size 1 MiB ≈ 14k sha256 fingerprints); 5k keeps a wide
+ * safety margin while covering all realistic projects.
+ */
+export const EXCLUDED_FINGERPRINT_LIMIT: number = 5000;
 
 export interface CreateAIAgentTaskForExceptionParams {
   telemetryExceptionId: ObjectID;
@@ -263,6 +274,118 @@ export class Service extends DatabaseService<Model> {
     };
   }
 
+  /**
+   * Fingerprints of exception groups marked resolved and/or archived —
+   * used by the exception monitor to exclude occurrences of those groups
+   * from the exception count. Resolution state lives on this Postgres
+   * model per (projectId, primaryEntityId, fingerprint) group, while
+   * occurrences live in ClickHouse; fingerprints are the join key.
+   * Fingerprints hash projectId + primaryEntityId into the digest, so a
+   * fingerprint never collides across services and excluding by
+   * fingerprint alone is exact.
+   *
+   * The result is capped at EXCLUDED_FINGERPRINT_LIMIT, keeping the most
+   * recently seen groups: the ClickHouse client ships query params in the
+   * request URI, so an unbounded NOT IN list would blow past ClickHouse's
+   * http_max_uri_size (~1 MiB, roughly 14k fingerprints) and hard-fail the
+   * monitor's count query. Overflow groups simply stay counted (fail-open:
+   * better a stale incident than a silently swallowed one), and the
+   * lastSeenAt-descending order means what gets dropped is the groups
+   * least likely to have occurrences in the monitor window.
+   *
+   * Deliberately NO lastSeenAt lower bound: ExceptionInstance.time is the
+   * client-reported occurrence timestamp while lastSeenAt is server-side
+   * ingest time, so any window-derived cutoff breaks under client clock
+   * skew (and under monitor configs with no time window at all).
+   */
+  @CaptureSpan()
+  public async getResolvedOrArchivedFingerprints(data: {
+    projectId: ObjectID;
+    telemetryServiceIds?: Array<ObjectID> | undefined;
+    resolved: boolean;
+    archived: boolean;
+  }): Promise<Array<string>> {
+    const statusFilters: Array<Query<Model>> = [];
+
+    if (data.resolved) {
+      statusFilters.push({ isResolved: true });
+    }
+
+    if (data.archived) {
+      statusFilters.push({ isArchived: true });
+    }
+
+    if (statusFilters.length === 0) {
+      return [];
+    }
+
+    // resolved-OR-archived needs two indexed lookups — findBy has no OR.
+    const resultsPerStatus: Array<Array<Model>> = await Promise.all(
+      statusFilters.map(
+        async (statusFilter: Query<Model>): Promise<Array<Model>> => {
+          const query: Query<Model> = {
+            projectId: data.projectId,
+            ...statusFilter,
+          };
+
+          if (data.telemetryServiceIds && data.telemetryServiceIds.length > 0) {
+            query.primaryEntityId = new Includes(data.telemetryServiceIds);
+          }
+
+          /*
+           * Per-status limit equals the final cap: the merged most-recent
+           * EXCLUDED_FINGERPRINT_LIMIT groups are necessarily within the
+           * top EXCLUDED_FINGERPRINT_LIMIT of their own status query.
+           */
+          return this.findBy({
+            query: query,
+            select: {
+              fingerprint: true,
+              lastSeenAt: true,
+            },
+            sort: {
+              lastSeenAt: SortOrder.Descending,
+            },
+            limit: EXCLUDED_FINGERPRINT_LIMIT,
+            skip: 0,
+            props: {
+              isRoot: true,
+            },
+          });
+        },
+      ),
+    );
+
+    // Merge the status lists most-recently-seen first, dedupe, then cap.
+    const merged: Array<Model> = resultsPerStatus
+      .flat()
+      .sort((a: Model, b: Model): number => {
+        return (b.lastSeenAt?.getTime() || 0) - (a.lastSeenAt?.getTime() || 0);
+      });
+
+    const fingerprints: Set<string> = new Set<string>();
+    let truncated: boolean = false;
+
+    for (const exception of merged) {
+      if (!exception.fingerprint) {
+        continue;
+      }
+      if (fingerprints.size >= EXCLUDED_FINGERPRINT_LIMIT) {
+        truncated = true;
+        break;
+      }
+      fingerprints.add(exception.fingerprint);
+    }
+
+    if (truncated) {
+      logger.warn(
+        `TelemetryException fingerprint exclusion list for project ${data.projectId.toString()} exceeds ${EXCLUDED_FINGERPRINT_LIMIT}; least recently seen resolved/archived exception groups will still be counted by exception monitors.`,
+      );
+    }
+
+    return Array.from(fingerprints);
+  }
+
   @CaptureSpan()
   private async aggregateUnresolvedByService(
     projectId: ObjectID,

package/Server/Services/UserNotificationSettingService.ts

@@ -580,6 +580,18 @@ export class Service extends DatabaseService<UserNotificationSetting> {
     await this.addAlertNotificationSettings(userId, projectId);
     await this.addAlertEpisodeNotificationSettings(userId, projectId);
     await this.addIncidentEpisodeNotificationSettings(userId, projectId);
+    await this.addScheduledMaintenanceNotificationSettings(userId, projectId);
+  }
+
+  private async addScheduledMaintenanceNotificationSettings(
+    userId: ObjectID,
+    projectId: ObjectID,
+  ): Promise<void> {
+    await this.addNotificationSettingIfNotExists(
+      userId,
+      projectId,
+      NotificationSettingEventType.SEND_SCHEDULED_MAINTENANCE_REMINDER_OWNER_NOTIFICATION,
+    );
   }
 
   private async addProbeOwnerNotificationSettings(
@@ -614,6 +626,12 @@ export class Service extends DatabaseService<UserNotificationSetting> {
       projectId,
       NotificationSettingEventType.SEND_INCIDENT_STATE_CHANGED_OWNER_NOTIFICATION,
     );
+
+    await this.addNotificationSettingIfNotExists(
+      userId,
+      projectId,
+      NotificationSettingEventType.SEND_INCIDENT_REMINDER_OWNER_NOTIFICATION,
+    );
   }
 
   private async addMonitorNotificationSettings(
@@ -689,6 +707,12 @@ export class Service extends DatabaseService<UserNotificationSetting> {
       projectId,
       NotificationSettingEventType.SEND_ALERT_STATE_CHANGED_OWNER_NOTIFICATION,
     );
+
+    await this.addNotificationSettingIfNotExists(
+      userId,
+      projectId,
+      NotificationSettingEventType.SEND_ALERT_REMINDER_OWNER_NOTIFICATION,
+    );
   }
 
   private async addAlertEpisodeNotificationSettings(

package/Server/Utils/AnalyticsDatabase/Statement.ts

@@ -5,6 +5,7 @@ import TableColumnType from "../../../Types/AnalyticsDatabase/TableColumnType";
 import GreaterThan from "../../../Types/BaseDatabase/GreaterThan";
 import GreaterThanOrEqual from "../../../Types/BaseDatabase/GreaterThanOrEqual";
 import Includes from "../../../Types/BaseDatabase/Includes";
+import IncludesNone from "../../../Types/BaseDatabase/IncludesNone";
 import LessThan from "../../../Types/BaseDatabase/LessThan";
 import LessThanOrEqual from "../../../Types/BaseDatabase/LessThanOrEqual";
 import LessThanOrNull from "../../../Types/BaseDatabase/LessThanOrNull";
@@ -108,7 +109,7 @@ export class Statement implements BaseQueryParams {
       v.value instanceof NotEqual
     ) {
       finalValue = v.value.value;
-    } else if (v.value instanceof Includes) {
+    } else if (v.value instanceof Includes || v.value instanceof IncludesNone) {
       if (
         v.type === TableColumnType.Text ||
         v.type === TableColumnType.ObjectID
@@ -198,9 +199,12 @@ export class Statement implements BaseQueryParams {
       [TableColumnType.UInt64]: "UInt64",
     };
 
-    if ((statementParam as StatementParameter).value instanceof Includes) {
+    if (
+      (statementParam as StatementParameter).value instanceof Includes ||
+      (statementParam as StatementParameter).value instanceof IncludesNone
+    ) {
       const includesValues: Array<string | number | ObjectID> = (
-        (statementParam as StatementParameter).value as Includes
+        (statementParam as StatementParameter).value as Includes | IncludesNone
       ).values as Array<string | number | ObjectID>;
 
       const isNumberArray: boolean = includesValues.every(

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -675,6 +675,41 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
             type: tableColumn.type,
           }}`,
         );
+      } else if (
+        value instanceof IncludesNone &&
+        tableColumn.type === TableColumnType.ArrayText
+      ) {
+        /*
+         * Array(String) exclusion — the negation of the Includes/hasAny
+         * branch above. An empty IncludesNone excludes nothing, so it
+         * drops to no predicate (mirrors the empty-Includes behavior).
+         */
+        const arrayExcludeValues: Array<string> =
+          ((value as IncludesNone).values as Array<string>) || [];
+        if (arrayExcludeValues.length > 0) {
+          whereStatement.append(
+            SQL`AND NOT hasAny(${key}, ${{
+              value: arrayExcludeValues,
+              type: TableColumnType.ArrayText,
+            }})`,
+          );
+        }
+      } else if (value instanceof IncludesNone) {
+        /*
+         * Scalar exclusion ("is none of"): `col NOT IN (v1, v2, ...)`.
+         * An empty IncludesNone means "exclude nothing" — skip the
+         * predicate entirely rather than emitting `NOT IN ()`.
+         */
+        const excludeValues: Array<string | ObjectID | number> =
+          ((value as IncludesNone).values as Array<string | ObjectID>) || [];
+        if (excludeValues.length > 0) {
+          whereStatement.append(
+            SQL`AND ${key} NOT IN ${{
+              value: value,
+              type: tableColumn.type,
+            }}`,
+          );
+        }
       } else if (value instanceof IsNull) {
         if (tableColumn.type === TableColumnType.Text) {
           whereStatement.append(SQL`AND (${key} IS NULL OR ${key} = '')`);

package/Server/Utils/EventLoop.ts

@@ -0,0 +1,28 @@
+export default class EventLoop {
+  /**
+   * Yields control back to the Node.js event loop, resuming on a later
+   * "check" phase tick.
+   *
+   * Use this to break up CPU-bound synchronous work — e.g. transforming
+   * tens of thousands of OTLP datapoints / spans / log records inside a
+   * single ingest job — so the process can service pending I/O between
+   * chunks. Most importantly, this lets the Kubernetes liveness and
+   * readiness probe handlers (/status/live, /status/ready) run. Without a
+   * periodic yield a large batch pins the single-threaded event loop for
+   * seconds at a time, the probe HTTP handler never gets scheduled, the
+   * kubelet marks the probe as failed, and the pod is restarted.
+   *
+   * IMPORTANT: this is implemented with setImmediate, NOT
+   * `await Promise.resolve()`. Awaiting a resolved promise only drains the
+   * microtask queue; the event loop never advances to its poll phase, so
+   * queued I/O (including probe requests) stays starved no matter how often
+   * you await. setImmediate schedules a macrotask in the check phase, which
+   * runs only after the poll phase has had a chance to process I/O — so a
+   * loop that periodically awaits this genuinely unblocks the event loop.
+   */
+  public static async yieldToEventLoop(): Promise<void> {
+    return new Promise<void>((resolve: () => void) => {
+      setImmediate(resolve);
+    });
+  }
+}

package/Server/Utils/WhatsAppTemplateUtil.ts

@@ -35,6 +35,8 @@ const templateDashboardLinkVariableMap: Partial<
   [WhatsAppTemplateIds.IncidentStateChangedOwnerNotification]: "incident_link",
   [WhatsAppTemplateIds.IncidentOwnerAddedNotification]: "incident_link",
   [WhatsAppTemplateIds.IncidentMemberAddedNotification]: "incident_link",
+  [WhatsAppTemplateIds.IncidentReminderOwnerNotification]: "incident_link",
+  [WhatsAppTemplateIds.AlertReminderOwnerNotification]: "alert_link",
   [WhatsAppTemplateIds.MonitorOwnerAddedNotification]: "monitor_link",
   [WhatsAppTemplateIds.MonitorCreatedOwnerNotification]: "monitor_link",
   [WhatsAppTemplateIds.MonitorStatusChangedOwnerNotification]: "monitor_link",
@@ -48,6 +50,8 @@ const templateDashboardLinkVariableMap: Partial<
     "maintenance_link",
   [WhatsAppTemplateIds.ScheduledMaintenanceStateChangedOwnerNotification]:
     "maintenance_link",
+  [WhatsAppTemplateIds.ScheduledMaintenanceReminderOwnerNotification]:
+    "event_link",
   [WhatsAppTemplateIds.StatusPageAnnouncementCreatedOwnerNotification]:
     "status_page_link",
   [WhatsAppTemplateIds.StatusPageCreatedOwnerNotification]: "status_page_link",
@@ -78,6 +82,10 @@ const templateIdByEventType: Record<
     WhatsAppTemplateIds.IncidentOwnerAddedNotification,
   [NotificationSettingEventType.SEND_INCIDENT_MEMBER_ADDED_NOTIFICATION]:
     WhatsAppTemplateIds.IncidentMemberAddedNotification,
+  [NotificationSettingEventType.SEND_INCIDENT_REMINDER_OWNER_NOTIFICATION]:
+    WhatsAppTemplateIds.IncidentReminderOwnerNotification,
+  [NotificationSettingEventType.SEND_ALERT_REMINDER_OWNER_NOTIFICATION]:
+    WhatsAppTemplateIds.AlertReminderOwnerNotification,
   [NotificationSettingEventType.SEND_ALERT_CREATED_OWNER_NOTIFICATION]:
     WhatsAppTemplateIds.AlertCreatedOwnerNotification,
   [NotificationSettingEventType.SEND_ALERT_NOTE_POSTED_OWNER_NOTIFICATION]:
@@ -124,6 +132,8 @@ const templateIdByEventType: Record<
     WhatsAppTemplateIds.ScheduledMaintenanceOwnerAddedNotification,
   [NotificationSettingEventType.SEND_SCHEDULED_MAINTENANCE_STATE_CHANGED_OWNER_NOTIFICATION]:
     WhatsAppTemplateIds.ScheduledMaintenanceStateChangedOwnerNotification,
+  [NotificationSettingEventType.SEND_SCHEDULED_MAINTENANCE_REMINDER_OWNER_NOTIFICATION]:
+    WhatsAppTemplateIds.ScheduledMaintenanceReminderOwnerNotification,
   [NotificationSettingEventType.SEND_STATUS_PAGE_ANNOUNCEMENT_CREATED_OWNER_NOTIFICATION]:
     WhatsAppTemplateIds.StatusPageAnnouncementCreatedOwnerNotification,
   [NotificationSettingEventType.SEND_STATUS_PAGE_CREATED_OWNER_NOTIFICATION]:

package/Tests/Server/Utils/AnalyticsDatabase/StatementGenerator.test.ts

@@ -672,6 +672,55 @@ describe("StatementGenerator", () => {
         expect(statement.query).toBe("");
         expect(statement.query_params).toStrictEqual({});
       });
+
+      test("emits NOT hasAny(...) for IncludesNone on an Array(String) column", () => {
+        const statement: Statement = arrayGenerator.toWhereStatement({
+          entityKeys: new IncludesNone(["210dac24142f1baa"]),
+        } as any);
+        expect(statement.query).toBe(
+          "AND NOT hasAny({p0:Identifier}, {p1:Array(String)})",
+        );
+        expect(statement.query_params).toStrictEqual({
+          p0: "entityKeys",
+          p1: ["210dac24142f1baa"],
+        });
+      });
+
+      test("drops empty IncludesNone instead of NOT hasAny(col, [])", () => {
+        const statement: Statement = arrayGenerator.toWhereStatement({
+          entityKeys: new IncludesNone([]),
+        } as any);
+        expect(statement.query).toBe("");
+        expect(statement.query_params).toStrictEqual({});
+      });
+    });
+
+    describe("scalar IncludesNone exclusion", () => {
+      /*
+       * "is none of" on a scalar column compiles to `col NOT IN (...)` —
+       * the exception monitor uses this to exclude occurrences of
+       * resolved/archived exception groups by fingerprint.
+       */
+      test("emits NOT IN (...) for IncludesNone on a Text column", () => {
+        const statement: Statement = generator.toWhereStatement({
+          column_1: new IncludesNone(["<fingerprint-1>", "<fingerprint-2>"]),
+        } as any);
+        expect(statement.query).toBe(
+          "AND {p0:Identifier} NOT IN {p1:Array(String)}",
+        );
+        expect(statement.query_params).toStrictEqual({
+          p0: "column_1",
+          p1: ["<fingerprint-1>", "<fingerprint-2>"],
+        });
+      });
+
+      test("drops empty IncludesNone instead of producing NOT IN ()", () => {
+        const statement: Statement = generator.toWhereStatement({
+          column_1: new IncludesNone([]),
+        } as any);
+        expect(statement.query).toBe("");
+        expect(statement.query_params).toStrictEqual({});
+      });
     });
 
     describe("entityScope synthetic key", () => {

package/Types/Email/EmailTemplateType.ts

@@ -37,11 +37,13 @@ enum EmailTemplateType {
   IncidentOwnerNotePosted = "IncidentOwnerNotePosted.hbs",
   IncidentOwnerResourceCreated = "IncidentOwnerResourceCreated.hbs",
   IncidentMemberAdded = "IncidentMemberAdded.hbs",
+  IncidentOwnerUnresolvedReminder = "IncidentOwnerUnresolvedReminder.hbs",
 
   AlertOwnerAdded = "AlertOwnerAdded.hbs",
   AlertOwnerStateChanged = "AlertOwnerStateChanged.hbs",
   AlertOwnerNotePosted = "AlertOwnerNotePosted.hbs",
   AlertOwnerResourceCreated = "AlertOwnerResourceCreated.hbs",
+  AlertOwnerUnresolvedReminder = "AlertOwnerUnresolvedReminder.hbs",
 
   AlertEpisodeOwnerAdded = "AlertEpisodeOwnerAdded.hbs",
   AlertEpisodeOwnerStateChanged = "AlertEpisodeOwnerStateChanged.hbs",
@@ -63,6 +65,7 @@ enum EmailTemplateType {
   ScheduledMaintenanceOwnerAdded = "ScheduledMaintenanceOwnerAdded.hbs",
   ScheduledMaintenanceOwnerStateChanged = "ScheduledMaintenanceOwnerStateChanged.hbs",
   ScheduledMaintenanceOwnerResourceCreated = "ScheduledMaintenanceOwnerResourceCreated.hbs",
+  ScheduledMaintenanceOwnerUnresolvedReminder = "ScheduledMaintenanceOwnerUnresolvedReminder.hbs",
   StatusPageOwnerResourceCreated = "StatusPageOwnerResourceCreated.hbs",
   StatusPageOwnerAdded = "StatusPageOwnerAdded.hbs",
   StatusPageOwnerAnnouncementPosted = "StatusPageOwnerAnnouncementPosted.hbs",

package/Types/NotificationSetting/NotificationSettingEventType.ts

@@ -5,6 +5,7 @@ enum NotificationSettingEventType {
   SEND_INCIDENT_STATE_CHANGED_OWNER_NOTIFICATION = "Send incident state changed notification when I am the owner of the incident",
   SEND_INCIDENT_OWNER_ADDED_NOTIFICATION = "Send notification when I am added as a owner to the incident",
   SEND_INCIDENT_MEMBER_ADDED_NOTIFICATION = "Send notification when I am assigned to an incident as a member",
+  SEND_INCIDENT_REMINDER_OWNER_NOTIFICATION = "Send reminder notification when an incident I own is still open",
 
   // Alerts
 
@@ -12,6 +13,7 @@ enum NotificationSettingEventType {
   SEND_ALERT_NOTE_POSTED_OWNER_NOTIFICATION = "Send alert note posted notification when I am the owner of the alert",
   SEND_ALERT_STATE_CHANGED_OWNER_NOTIFICATION = "Send alert state changed notification when I am the owner of the alert",
   SEND_ALERT_OWNER_ADDED_NOTIFICATION = "Send notification when I am added as a owner to the alert",
+  SEND_ALERT_REMINDER_OWNER_NOTIFICATION = "Send reminder notification when an alert I own is still open",
 
   // Alert Episodes
 
@@ -41,6 +43,7 @@ enum NotificationSettingEventType {
   SEND_SCHEDULED_MAINTENANCE_NOTE_POSTED_OWNER_NOTIFICATION = "Send event note posted notification when I am the owner of the event",
   SEND_SCHEDULED_MAINTENANCE_OWNER_ADDED_NOTIFICATION = "Send notification when I am added as a owner to the event",
   SEND_SCHEDULED_MAINTENANCE_STATE_CHANGED_OWNER_NOTIFICATION = "Send event state changed notification when I am the owner of the event",
+  SEND_SCHEDULED_MAINTENANCE_REMINDER_OWNER_NOTIFICATION = "Send reminder notification when a scheduled maintenance event I own is still not complete",
 
   // Status Page
   SEND_STATUS_PAGE_ANNOUNCEMENT_CREATED_OWNER_NOTIFICATION = "Send status page announcement created notification when I am the owner of the status page",

package/Types/Permission.ts

@@ -421,6 +421,12 @@ enum Permission {
   EditScheduledMaintenanceLabelRule = "EditScheduledMaintenanceLabelRule",
   ReadScheduledMaintenanceLabelRule = "ReadScheduledMaintenanceLabelRule",
 
+  // Scheduled Maintenance Reminder Rule Permissions
+  CreateScheduledMaintenanceReminderRule = "CreateScheduledMaintenanceReminderRule",
+  DeleteScheduledMaintenanceReminderRule = "DeleteScheduledMaintenanceReminderRule",
+  EditScheduledMaintenanceReminderRule = "EditScheduledMaintenanceReminderRule",
+  ReadScheduledMaintenanceReminderRule = "ReadScheduledMaintenanceReminderRule",
+
   CreateStatusPageOwnerTeam = "CreateStatusPageOwnerTeam",
   DeleteStatusPageOwnerTeam = "DeleteStatusPageOwnerTeam",
   EditStatusPageOwnerTeam = "EditStatusPageOwnerTeam",
@@ -1407,6 +1413,12 @@ enum Permission {
   EditAlertGroupingRule = "EditAlertGroupingRule",
   ReadAlertGroupingRule = "ReadAlertGroupingRule",
 
+  // Alert Reminder Rule Permissions
+  CreateAlertReminderRule = "CreateAlertReminderRule",
+  DeleteAlertReminderRule = "DeleteAlertReminderRule",
+  EditAlertReminderRule = "EditAlertReminderRule",
+  ReadAlertReminderRule = "ReadAlertReminderRule",
+
   // Alert On-Call Rule Permissions
   CreateAlertOnCallRule = "CreateAlertOnCallRule",
   DeleteAlertOnCallRule = "DeleteAlertOnCallRule",
@@ -1587,6 +1599,12 @@ enum Permission {
   EditIncidentSlaRule = "EditIncidentSlaRule",
   ReadIncidentSlaRule = "ReadIncidentSlaRule",
 
+  // Incident Reminder Rule Permissions
+  CreateIncidentReminderRule = "CreateIncidentReminderRule",
+  DeleteIncidentReminderRule = "DeleteIncidentReminderRule",
+  EditIncidentReminderRule = "EditIncidentReminderRule",
+  ReadIncidentReminderRule = "ReadIncidentReminderRule",
+
   // Incident SLA Permissions
   CreateIncidentSla = "CreateIncidentSla",
   DeleteIncidentSla = "DeleteIncidentSla",
@@ -11996,6 +12014,48 @@ export class PermissionHelper {
         group: PermissionGroup.ScheduledMaintenance,
       },
 
+      // Scheduled Maintenance Reminder Rule Permissions
+      {
+        permission: Permission.CreateScheduledMaintenanceReminderRule,
+        title: "Create Scheduled Maintenance Reminder Rule",
+        description:
+          "This permission can create Scheduled Maintenance Reminder Rules in this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.ScheduledMaintenance,
+      },
+      {
+        permission: Permission.DeleteScheduledMaintenanceReminderRule,
+        title: "Delete Scheduled Maintenance Reminder Rule",
+        description:
+          "This permission can delete Scheduled Maintenance Reminder Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.ScheduledMaintenance,
+      },
+      {
+        permission: Permission.EditScheduledMaintenanceReminderRule,
+        title: "Edit Scheduled Maintenance Reminder Rule",
+        description:
+          "This permission can edit Scheduled Maintenance Reminder Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.ScheduledMaintenance,
+      },
+      {
+        permission: Permission.ReadScheduledMaintenanceReminderRule,
+        title: "Read Scheduled Maintenance Reminder Rule",
+        description:
+          "This permission can read Scheduled Maintenance Reminder Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.ScheduledMaintenance,
+      },
+
       // Alert Episode Permissions
       {
         permission: Permission.CreateAlertEpisode,
@@ -12120,6 +12180,48 @@ export class PermissionHelper {
         group: PermissionGroup.Alert,
       },
 
+      // Alert Reminder Rule Permissions
+      {
+        permission: Permission.CreateAlertReminderRule,
+        title: "Create Alert Reminder Rule",
+        description:
+          "This permission can create Alert Reminder Rules in this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.Alert,
+      },
+      {
+        permission: Permission.DeleteAlertReminderRule,
+        title: "Delete Alert Reminder Rule",
+        description:
+          "This permission can delete Alert Reminder Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.Alert,
+      },
+      {
+        permission: Permission.EditAlertReminderRule,
+        title: "Edit Alert Reminder Rule",
+        description:
+          "This permission can edit Alert Reminder Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.Alert,
+      },
+      {
+        permission: Permission.ReadAlertReminderRule,
+        title: "Read Alert Reminder Rule",
+        description:
+          "This permission can read Alert Reminder Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.Alert,
+      },
+
       // Alert On-Call Rule Permissions
       {
         permission: Permission.CreateAlertOnCallRule,
@@ -13402,6 +13504,48 @@ export class PermissionHelper {
         group: PermissionGroup.Incident,
       },
 
+      // Incident Reminder Rule Permissions
+      {
+        permission: Permission.CreateIncidentReminderRule,
+        title: "Create Incident Reminder Rule",
+        description:
+          "This permission can create Incident Reminder Rules in this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.Incident,
+      },
+      {
+        permission: Permission.DeleteIncidentReminderRule,
+        title: "Delete Incident Reminder Rule",
+        description:
+          "This permission can delete Incident Reminder Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.Incident,
+      },
+      {
+        permission: Permission.EditIncidentReminderRule,
+        title: "Edit Incident Reminder Rule",
+        description:
+          "This permission can edit Incident Reminder Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.Incident,
+      },
+      {
+        permission: Permission.ReadIncidentReminderRule,
+        title: "Read Incident Reminder Rule",
+        description:
+          "This permission can read Incident Reminder Rules of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+        isRolePermission: false,
+        group: PermissionGroup.Incident,
+      },
+
       // Incident SLA Permissions
       {
         permission: Permission.CreateIncidentSla,

package/Types/Reminder/ReminderStopState.ts

@@ -0,0 +1,6 @@
+enum ReminderStopState {
+  Acknowledged = "Acknowledged",
+  Resolved = "Resolved",
+}
+
+export default ReminderStopState;

package/Types/Reminder/ScheduledMaintenanceReminderStopState.ts

@@ -0,0 +1,6 @@
+enum ScheduledMaintenanceReminderStopState {
+  Ongoing = "Ongoing",
+  Completed = "Completed",
+}
+
+export default ScheduledMaintenanceReminderStopState;