@oneuptime/common 11.5.8 → 11.5.10

package/Types/AI/AIChatPageContext.ts

@@ -0,0 +1,137 @@
+import { JSONObject } from "../JSON";
+
+/*
+ * "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.
+ */
+enum AIChatPageContextType {
+  // Entity pages — carry the entity's id (and usually a display title).
+  Incident = "Incident",
+  Alert = "Alert",
+  Monitor = "Monitor",
+  ScheduledMaintenanceEvent = "ScheduledMaintenanceEvent",
+  TelemetryService = "TelemetryService",
+  Trace = "Trace",
+  Exception = "Exception",
+
+  // Area pages — no id; the user is browsing a list or an explorer.
+  IncidentsList = "IncidentsList",
+  AlertsList = "AlertsList",
+  MonitorsList = "MonitorsList",
+  ScheduledMaintenanceList = "ScheduledMaintenanceList",
+  LogsExplorer = "LogsExplorer",
+  TracesExplorer = "TracesExplorer",
+  MetricsExplorer = "MetricsExplorer",
+  ExceptionsList = "ExceptionsList",
+}
+
+export default AIChatPageContextType;
+
+export interface AIChatPageContext {
+  type: AIChatPageContextType;
+  // The entity on screen (UUID, or a hex trace id). Only set for entity types.
+  entityId?: string | undefined;
+  // Display title of the entity (incident title, monitor name, …). Optional.
+  entityTitle?: string | undefined;
+}
+
+/*
+ * Ids are OneUptime ObjectIDs (UUIDs) — except traces, whose ids are
+ * OpenTelemetry hex strings. Anything else is rejected: the id is echoed into
+ * the LLM prompt and into tool suggestions, so it must never carry free-form
+ * text (e.g. a static route segment like "overview" that a :id URL wildcard
+ * can capture).
+ */
+const UUID_REGEX: RegExp =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const TRACE_ID_REGEX: RegExp = /^[0-9a-fA-F]{8,64}$/;
+
+const MAX_ENTITY_TITLE_LENGTH: number = 200;
+
+const ENTITY_TYPES: Array<AIChatPageContextType> = [
+  AIChatPageContextType.Incident,
+  AIChatPageContextType.Alert,
+  AIChatPageContextType.Monitor,
+  AIChatPageContextType.ScheduledMaintenanceEvent,
+  AIChatPageContextType.TelemetryService,
+  AIChatPageContextType.Trace,
+  AIChatPageContextType.Exception,
+];
+
+export class AIChatPageContextHelper {
+  public static isValidType(
+    value: string | undefined,
+  ): value is AIChatPageContextType {
+    return Object.values(AIChatPageContextType).includes(
+      value as AIChatPageContextType,
+    );
+  }
+
+  // Entity types point at one specific record and require an entityId.
+  public static isEntityType(type: AIChatPageContextType): boolean {
+    return ENTITY_TYPES.includes(type);
+  }
+
+  /*
+   * Validate and sanitize an untrusted client-supplied page context. Returns
+   * undefined when the payload is missing or invalid — page context is a hint,
+   * so a bad one is dropped rather than failing the message.
+   */
+  public static sanitize(
+    json: JSONObject | undefined | null,
+  ): AIChatPageContext | undefined {
+    if (!json || typeof json !== "object" || Array.isArray(json)) {
+      return undefined;
+    }
+
+    const type: string | undefined =
+      typeof json["type"] === "string" ? (json["type"] as string) : undefined;
+
+    if (!this.isValidType(type)) {
+      return undefined;
+    }
+
+    const context: AIChatPageContext = { type: type };
+
+    if (this.isEntityType(type)) {
+      const entityId: string =
+        typeof json["entityId"] === "string"
+          ? (json["entityId"] as string).trim()
+          : "";
+
+      const idRegex: RegExp =
+        type === AIChatPageContextType.Trace ? TRACE_ID_REGEX : UUID_REGEX;
+
+      // An entity context without a usable id is meaningless — drop it whole.
+      if (!idRegex.test(entityId)) {
+        return undefined;
+      }
+
+      context.entityId = entityId;
+
+      if (typeof json["entityTitle"] === "string") {
+        /*
+         * The title is echoed into the system prompt: collapse whitespace and
+         * control characters so it cannot introduce new lines or fake
+         * prompt structure, and cap the length.
+         */
+        const entityTitle: string = (json["entityTitle"] as string)
+          // eslint-disable-next-line no-control-regex
+          .replace(/[\u0000-\u001F\u007F]+/g, " ")
+          .replace(/\s+/g, " ")
+          .trim()
+          .substring(0, MAX_ENTITY_TITLE_LENGTH);
+
+        if (entityTitle) {
+          context.entityTitle = entityTitle;
+        }
+      }
+    }
+
+    return context;
+  }
+}

package/Types/AI/AIChatTypes.ts

@@ -22,6 +22,8 @@ export enum AIChatCitationTargetType {
   AlertView = "AlertView",
   Monitors = "Monitors",
   MonitorView = "MonitorView",
+  ScheduledMaintenanceEvents = "ScheduledMaintenanceEvents",
+  ScheduledMaintenanceView = "ScheduledMaintenanceView",
 }
 
 export interface AIChatCitationTarget {
@@ -197,6 +199,48 @@ export interface AIRunEventResultSummary {
   severity?: string | undefined;
 }
 
+/*
+ * The verbatim content behind one run event — the raw material for debugging
+ * a bad run: exactly what was sent to the model, exactly what it said back,
+ * and exactly what a tool returned.
+ *
+ * This is the ONLY place a code-fix run's LLM content is persisted. It lives
+ * on AIRunEvent.contentPayload, whose read ACL is empty precisely because
+ * this content embeds customer source code: LlmLog deliberately redacts the
+ * same content (CodeFixAgentCompletion passes storeContentPreviews: false)
+ * because LlmLog is readable project-wide, and that redaction stays. Reach it
+ * only through GET /code-fix-run/logs, which gates on ProjectOwner or
+ * ProjectAdmin — the same "sensitive content behind a narrow endpoint" shape
+ * AIRun.pausedState and AIRun.taskContext already use.
+ *
+ * Every field is capped at write time (see AIRunTranscript.ts) so one run can
+ * never write an unbounded row.
+ */
+export interface AIRunEventContentPayload {
+  // Messages newly sent to the model on this call — not the whole history.
+  requestMessages?: Array<{
+    role: string;
+    content: string;
+  }>;
+  // The model's verbatim reply.
+  responseContent?: string | undefined;
+  // Tool calls the model asked for, with their full arguments.
+  responseToolCalls?: Array<{
+    id?: string | undefined;
+    name: string;
+    arguments?: JSONObject | undefined;
+  }>;
+  // A tool's verbatim return value (for tool events).
+  toolResult?: string | undefined;
+  modelName?: string | undefined;
+  stopReason?: string | undefined;
+  promptTokens?: number | undefined;
+  completionTokens?: number | undefined;
+  totalTokens?: number | undefined;
+  // Set when any field above was clipped to its cap.
+  isTruncated?: boolean | undefined;
+}
+
 // What was sent to which LLM during a run — the per-run egress manifest.
 export interface AIRunEgressManifestToolEntry {
   toolName: string;

package/Types/AI/AIFixReadiness.ts

@@ -0,0 +1,46 @@
+/*
+ * What a CodeFix run needs before it can complete, as a wire contract shared
+ * by the server checks and every UI that renders them. Two surfaces consume
+ * this today: the per-exception "Fix with AI Agent" panel
+ * (GET /telemetry-exception/ai-fix-readiness/:id) and the project-wide AI
+ * Tasks page (POST /ai-readiness/code-fix).
+ */
+
+/*
+ * The repository gate comes in two strengths, and they are deliberately
+ * distinct ids — a UI that conflates them would promise more than the check
+ * verified:
+ *
+ * - repositoryResolved: a repository matches THIS exception's stack trace.
+ *   Per-exception, and the stronger claim.
+ * - repositoryConnected: the project has at least one GitHub-App-connected
+ *   repository. Project-wide, and all a page-level check can honestly assert
+ *   — it says nothing about whether any given exception will resolve.
+ */
+export type AIFixReadinessCheckId =
+  | "llmProvider"
+  | "repositoryResolved"
+  | "repositoryConnected"
+  | "agentAvailable";
+
+export interface AIFixReadinessCheck {
+  id: AIFixReadinessCheckId;
+  ok: boolean;
+  /*
+   * The gate's headline. Checks fill in what they actually found where that
+   * is useful ("Repository resolved: acme/api"), so this is not a fixed
+   * label per id.
+   */
+  title: string;
+  /*
+   * When ok is false: exactly what to do next. When ok is true: what is
+   * configured, so the user can tell a project-owned provider from the
+   * shared one without leaving the page. May be empty.
+   */
+  detail: string;
+}
+
+export interface AIFixReadiness {
+  ready: boolean;
+  checks: Array<AIFixReadinessCheck>;
+}

package/Types/AI/AIRunStatus.ts

@@ -18,6 +18,16 @@ enum AIRunStatus {
    */
   WaitingForApproval = "WaitingForApproval",
   Completed = "Completed",
+  /*
+   * The run did its job and concluded there was nothing to change — the agent
+   * read the code and found no fix worth proposing, so it opened no pull
+   * request. A negative result, NOT a failure: nothing broke, and retrying the
+   * same run unchanged would likely reach the same conclusion. Kept distinct
+   * from Error so a quiet "no fix" never lands in an error rate, an alert, or
+   * a red pill. Contrast with Error, which means the run could not finish
+   * (clone failed, LLM errored, no repository resolved).
+   */
+  NoFixFound = "NoFixFound",
   Error = "Error",
   Cancelled = "Cancelled",
   Stale = "Stale",
@@ -29,6 +39,7 @@ export class AIRunStatusHelper {
   public static isTerminalStatus(status: AIRunStatus): boolean {
     return (
       status === AIRunStatus.Completed ||
+      status === AIRunStatus.NoFixFound ||
       status === AIRunStatus.Error ||
       status === AIRunStatus.Cancelled ||
       status === AIRunStatus.Stale

package/Types/AnalyticsDatabase/AnalyticsTableName.ts

@@ -4,6 +4,7 @@ enum AnalyticsTableName {
   ExceptionInstance = "ExceptionItemV3",
   Span = "SpanItemV3",
   MonitorLog = "MonitorLogV3",
+  NetworkFlow = "NetworkFlowV1",
   Profile = "ProfileItemV3",
   ProfileSample = "ProfileSampleItemV3",
   AuditLog = "AuditLogV2",
@@ -20,6 +21,16 @@ enum AnalyticsTableName {
    * hostEntityKey instead of the raw host.name spelling.
    */
   MetricItemAggMV1mByHostV2 = "MetricItemAggMV1mByHostV2",
+  /*
+   * Entity-keyed siblings of MetricItemAggMV1mByHostV2 — same layout,
+   * keyed by the other ingest-stamped scalar entity-key columns
+   * (serviceEntityKey / k8sClusterEntityKey / containerEntityKey) so
+   * entity-scoped chart queries can be served from a pre-aggregated
+   * rollup instead of scanning MetricItemV3.
+   */
+  MetricItemAggMV1mByService = "MetricItemAggMV1mByService",
+  MetricItemAggMV1mByK8sCluster = "MetricItemAggMV1mByK8sCluster",
+  MetricItemAggMV1mByContainer = "MetricItemAggMV1mByContainer",
   MetricBaselineHourly = "MetricBaselineHourly",
   MutableMetric = "MutableMetricItem",
 }

package/Types/BaseDatabase/AggregateBy.ts

@@ -10,8 +10,9 @@ export default interface AggregateBy<TBaseModel extends GenericObject> {
   aggregationType: AggregationType;
   /**
    * Optional explicit time-bucket size. When omitted (the default), the
-   * bucket size is derived from the query window (≤3h → minute, ≤7d →
-   * hour, ≤6w → day, …) — see AggregationIntervalUtil. Set this to pin a
+   * bucket size is derived from the query window (≤3h → minute, ≤12h →
+   * 5 minutes, ≤24h → 15 minutes, ≤3d → 30 minutes, ≤7d → hour, ≤6w →
+   * day, …) — see AggregationIntervalUtil. Set this to pin a
    * granularity independent of the window (e.g. `Day` buckets over a
    * one-week window), or to `Total` to aggregate the whole window into a
    * single value per group (no time bucketing). Invalid values are
@@ -38,4 +39,32 @@ export default interface AggregateBy<TBaseModel extends GenericObject> {
    * `attributes` object containing exactly these keys.
    */
   groupByAttributeKeys?: Array<string> | undefined;
+  /**
+   * Server-side Top-K group selection for grouped aggregations. When
+   * set (and the aggregation is grouped via `groupBy` /
+   * `groupByAttributeKeys`), the server ranks groups by `rankBy`
+   * (max or avg of the aggregated column) over the WHOLE query window,
+   * keeps only the top `count` groups, and reports the total number of
+   * matching groups via `AggregatedResult.totalGroups` — so a chart can
+   * plot the top 10 series without fetching every bucket of every
+   * group. Ignored for ungrouped aggregations. Plain JSON so it
+   * round-trips the API's serialize/deserialize unchanged.
+   */
+  topK?:
+    | {
+        count: number;
+        rankBy: "max" | "avg";
+      }
+    | undefined;
+  /**
+   * What ClickHouse does when the aggregate's execution-time cap fires.
+   * 'break' (the default when omitted) returns the partial buckets
+   * computed so far — acceptable for chart rendering. Callers that
+   * ALERT on the result (the metric-monitor worker) must pass 'throw'
+   * so a timed-out evaluation fails loudly instead of silently scoring
+   * partial data as if it were complete. The server allow-lists the
+   * value before it reaches SQL: anything other than the exact string
+   * "throw" is treated as 'break'.
+   */
+  timeoutOverflowMode?: "break" | "throw" | undefined;
 }

package/Types/BaseDatabase/AggregatedResult.ts

@@ -2,4 +2,26 @@ import AggregatedModel from "./AggregatedModel";
 
 export default interface AggregatedResult {
   data: Array<AggregatedModel>;
+  /**
+   * Total number of distinct groups matching the query window, counted
+   * in the Top-K ranking phase. Only present for grouped aggregations
+   * executed with `AggregateBy.topK`; compare against `topK.count` to
+   * know how many series were left out.
+   */
+  totalGroups?: number | undefined;
+  /**
+   * True when the result is known (or heuristically likely) to be
+   * incomplete: the row count hit the applied LIMIT, or Top-K dropped
+   * groups (`totalGroups > topK.count`). Additive — absent/false means
+   * the window was fully served.
+   */
+  truncated?: boolean | undefined;
+  /**
+   * Human-readable reason this result carries no data — e.g. a metric
+   * formula that failed structural validation (bad syntax, unknown
+   * variable, disjoint groups). Only set by client-side evaluation
+   * layers; never returned by the server. Chart layers should render it
+   * in place of the empty chart instead of showing a silent "no data".
+   */
+  errorMessage?: string | undefined;
 }

package/Types/BaseDatabase/AggregationInterval.ts

@@ -1,5 +1,16 @@
 export enum AggregationInterval {
   Minute = "Minute",
+  /*
+   * The sub-hour tiers are served from the same 1-minute rollup as
+   * `Minute` (any bucket that is a whole multiple of a minute is >= the
+   * MV's resolution). Unlike the calendar units they are NOT valid
+   * ClickHouse `date_trunc`/INTERVAL-1 units, so SQL builders must go
+   * through AggregateUtil.buildBucketTimestampExpression instead of
+   * lowercasing the enum value into the statement.
+   */
+  FiveMinutes = "FiveMinutes",
+  FifteenMinutes = "FifteenMinutes",
+  ThirtyMinutes = "ThirtyMinutes",
   Hour = "Hour",
   Day = "Day",
   Week = "Week",

package/Types/BaseDatabase/AggregationIntervalUtil.ts

@@ -36,9 +36,23 @@ export class AggregationIntervalUtil {
 
     const diff: number = endDate.getTime() - startDate.getTime();
 
+    /*
+     * ~180-point budget per chart: each tier keeps the rendered point
+     * count in the tens-to-hundreds instead of collapsing a 4h window
+     * to ~4 hourly points or exploding a 12h window into 720 minutes.
+     */
     if (diff <= 1000 * 60 * 60 * 3) {
       // if less than 3 hours, then get minute precision
       return AggregationInterval.Minute;
+    } else if (diff <= 1000 * 60 * 60 * 12) {
+      // 12 hours
+      return AggregationInterval.FiveMinutes;
+    } else if (diff <= 1000 * 60 * 60 * 24) {
+      // 24 hours
+      return AggregationInterval.FifteenMinutes;
+    } else if (diff <= 1000 * 60 * 60 * 24 * 3) {
+      // 3 days
+      return AggregationInterval.ThirtyMinutes;
     } else if (diff <= 1000 * 60 * 60 * 24 * 7) {
       // 7 days
       return AggregationInterval.Hour;
@@ -69,6 +83,12 @@ export class AggregationIntervalUtil {
     switch (interval) {
       case AggregationInterval.Minute:
         return 1000 * 60;
+      case AggregationInterval.FiveMinutes:
+        return 1000 * 60 * 5;
+      case AggregationInterval.FifteenMinutes:
+        return 1000 * 60 * 15;
+      case AggregationInterval.ThirtyMinutes:
+        return 1000 * 60 * 30;
       case AggregationInterval.Hour:
         return 1000 * 60 * 60;
       case AggregationInterval.Day:
@@ -102,11 +122,13 @@ export class AggregationIntervalUtil {
    * (the first bucket is partial and its timestamp falls before the axis
    * origin).
    *
-   * Only Minute/Hour/Day are aligned: for those the fixed-ms epoch grid is
-   * an EXACT match for ClickHouse's UTC bucketing (epoch-day == UTC
-   * midnight), and these are the windows where the leading gap is actually
-   * visible. Week/Month/Year snap to calendar boundaries (Monday / 1st /
-   * Jan-1) server-side, which a fixed-ms grid can't reproduce, so those (and
+   * Only the sub-day intervals (Minute through Hour, plus Day) are aligned:
+   * for those the fixed-ms epoch grid is an EXACT match for ClickHouse's
+   * UTC bucketing (5/15/30-minute `toStartOfInterval` grids are counted in
+   * whole intervals since the epoch, and epoch-day == UTC midnight), and
+   * these are the windows where the leading gap is actually visible.
+   * Week/Month/Year snap to calendar boundaries (Monday / 1st / Jan-1)
+   * server-side, which a fixed-ms grid can't reproduce, so those (and
    * `Total`) are returned UNCHANGED rather than risk shifting the gap for
    * long windows — their pre-existing behavior is preserved.
    */
@@ -117,6 +139,9 @@ export class AggregationIntervalUtil {
     const ms: number = OneUptimeDate.fromString(date).getTime();
     const alignableIntervals: Array<AggregationInterval> = [
       AggregationInterval.Minute,
+      AggregationInterval.FiveMinutes,
+      AggregationInterval.FifteenMinutes,
+      AggregationInterval.ThirtyMinutes,
       AggregationInterval.Hour,
       AggregationInterval.Day,
     ];

package/Types/Dashboard/DashboardComponents/DashboardTraceChartComponent.ts

@@ -33,6 +33,22 @@ export default interface DashboardTraceChartComponent extends BaseComponent {
     groupByAttribute?: string | undefined;
     // Cap on the number of series when split (default 10).
     topLimit?: number | undefined;
+    /*
+     * Optional user-chosen lead color for the chart, stored as a hex string
+     * (e.g. "#6366f1"). Single-series → the series color; split charts → the
+     * first unpinned series, with the rest following the default palette.
+     * Same semantics as MetricQueryConfigData.color on the metric Chart
+     * widget. Unset = Auto (default palette).
+     */
+    color?: string | undefined;
+    /*
+     * Per-series color pins for split charts, keyed by "key=value" segment
+     * (e.g. { "url.host=api.example.com": "#10b981" }) — the same storage
+     * shape as MetricQueryConfigData.colorsByGroup, so the shared
+     * SeriesGroupColorSelector editor works unchanged. Unpinned series fall
+     * back to `color` (lead) then the default palette.
+     */
+    colorsByGroup?: Record<string, string> | undefined;
     /*
      * Include non-root spans. Off by default so "Request Count" matches the
      * traces explorer, which is root-spans-only.

package/Types/Email/EmailTemplateType.ts

@@ -86,6 +86,9 @@ enum EmailTemplateType {
   Invoice = "Invoice.hbs",
 
   ClickhouseCapacityWarning = "ClickhouseCapacityWarning.hbs",
+
+  EnterpriseLicenseUserLimitBreach = "EnterpriseLicenseUserLimitBreach.hbs",
+  EnterpriseLicenseExpiryReminder = "EnterpriseLicenseExpiryReminder.hbs",
 }
 
 export default EmailTemplateType;

package/Types/Log/LogSeverity.ts

@@ -8,4 +8,65 @@ enum LogSeverity {
   Fatal = "Fatal",
 }
 
+/*
+ * The OTLP severity number stored alongside each level.
+ *
+ * These are the low end of each OTLP range (Trace 1-4, Debug 5-8, Info 9-12,
+ * Warn 13-16, Error 17-20, Fatal 21-24), so they are the inverse of the
+ * bucketing OtelLogsIngestService.getSeverityText applies on ingest. Anything
+ * that writes severityText must take the number from here too, or the row says
+ * one thing in its text and another in its number.
+ *
+ * https://opentelemetry.io/docs/specs/otel/logs/data-model/#field-severitynumber
+ */
+export const LogSeverityNumber: Record<LogSeverity, number> = {
+  [LogSeverity.Unspecified]: 0,
+  [LogSeverity.Trace]: 1,
+  [LogSeverity.Debug]: 5,
+  [LogSeverity.Information]: 9,
+  [LogSeverity.Warning]: 13,
+  [LogSeverity.Error]: 17,
+  [LogSeverity.Fatal]: 21,
+};
+
+/*
+ * Loose severity text -> the enum member actually stored on a log row.
+ *
+ * Only these seven strings ever reach the database: ingest discards whatever
+ * severityText a client sent and re-derives it from severityNumber. So a value
+ * that is merely severity-shaped ("INFO", "warn") matches nothing — and since
+ * `=` and `IN` are case-sensitive, it fails silently rather than erroring.
+ *
+ * This exists because the filter and severity-remapper dropdowns spent a long
+ * time emitting TRACE/DEBUG/INFO/WARNING/ERROR/FATAL. Those values are still
+ * sitting in saved pipeline configs, so the remapper normalises through here on
+ * the way in rather than trusting what was stored.
+ *
+ * Returns null for anything unrecognised. Callers decide what to do about it —
+ * guessing a severity is worse than admitting we cannot tell.
+ */
+export function normalizeLogSeverity(text: string): LogSeverity | null {
+  const normalized: string = (text || "").trim().toUpperCase();
+
+  if (!normalized) {
+    return null;
+  }
+
+  const aliases: Record<string, LogSeverity> = {
+    UNSPECIFIED: LogSeverity.Unspecified,
+    TRACE: LogSeverity.Trace,
+    DEBUG: LogSeverity.Debug,
+    // INFO and WARN are the two the old dropdowns got wrong by more than case.
+    INFO: LogSeverity.Information,
+    INFORMATION: LogSeverity.Information,
+    WARN: LogSeverity.Warning,
+    WARNING: LogSeverity.Warning,
+    ERR: LogSeverity.Error,
+    ERROR: LogSeverity.Error,
+    FATAL: LogSeverity.Fatal,
+  };
+
+  return aliases[normalized] || null;
+}
+
 export default LogSeverity;

package/Types/Marketing/MarketingConversion.ts

@@ -0,0 +1,11 @@
+export enum MarketingConversionType {
+  SignUp = "SignUp",
+  PaidSubscription = "PaidSubscription",
+}
+
+export enum MarketingConversionUploadStatus {
+  Uploaded = "Uploaded",
+  Failed = "Failed",
+  // No click id relevant to this ad platform — nothing to upload.
+  Skipped = "Skipped",
+}

package/Types/Metrics/MetricQueryConfigData.ts

@@ -13,6 +13,16 @@ export interface ChartSeries {
 }
 
 export default interface MetricQueryConfigData {
+  /*
+   * Stable identity for this query, independent of its position in the
+   * queryConfigs array. Chart layers key per-chart UI state (hidden
+   * series, search, Top-N, sort) on this id so removing/reordering
+   * queries doesn't transfer one chart's state to another. Assigned at
+   * query-creation sites (ObjectID-based); older persisted configs won't
+   * have it, so consumers must tolerate its absence. Intentionally NOT
+   * part of the explorer URL serialization.
+   */
+  id?: string | undefined;
   metricAliasData?: MetricAliasData | undefined;
   metricQueryData: MetricQueryData;
   getSeries?: ((data: AggregatedModel) => ChartSeries) | undefined;
@@ -59,4 +69,15 @@ export default interface MetricQueryConfigData {
    * on agent restart) are clamped to 0.
    */
   transformAsRate?: boolean | undefined;
+  /*
+   * When true, this query is drawn on the PREVIOUS query's chart panel,
+   * sharing its axes, instead of getting a panel of its own. Consecutive
+   * flagged queries chain onto the same panel. Has no effect on the
+   * first query, or when the previous query produced no result (the
+   * query then falls back to its own panel). Both queries are evaluated
+   * over the SAME time window — this is a same-window visual overlay,
+   * not a period-over-period time shift. Plain persisted data like the
+   * fields above (dashboards, saved views, explorer URLs).
+   */
+  overlayWithPreviousQuery?: boolean | undefined;
 }

package/Types/Metrics/MetricQueryData.ts

@@ -17,4 +17,12 @@ export default interface MetricQueryData {
    * whatever) incident creation from a single metric monitor.
    */
   groupByAttributeKeys?: Array<string> | undefined;
+  /**
+   * How many series (groups) to plot for a grouped query. Passed to the
+   * server as `AggregateBy.topK.count` so only the top-N groups (ranked
+   * by max over the window) are fetched, and used as the client-side
+   * display cap. Unset = the default cap (10). Plain persisted data —
+   * saved views and dashboards carry it like any other query field.
+   */
+  topN?: number | undefined;
 }

package/Types/Metrics/MetricViewData.ts

@@ -3,4 +3,12 @@ import MetricsViewConfig from "./MetricsViewConfig";
 
 export default interface MetricViewData extends MetricsViewConfig {
   startAndEndDate: InBetween<Date> | null;
+  /*
+   * Optional relative-time token (a Range enum value from
+   * Common/Types/Time/TimeRange, e.g. "Past 1 Hour"). When set, the
+   * resolved startAndEndDate re-anchors to "now" on fetch/refresh instead
+   * of staying pinned to the instant it was first resolved. Custom /
+   * pinned absolute windows carry no token.
+   */
+  rangeToken?: string | undefined;
 }

package/Types/Monitor/MonitorMetricType.ts

@@ -34,6 +34,14 @@ enum MonitorMetricType {
   SnmpInterfaceUtilizationPercent = "oneuptime.monitor.snmp.interface.utilization.percent",
   SnmpInterfaceErrorsPerSecond = "oneuptime.monitor.snmp.interface.errors.per.second",
 
+  /*
+   * One series per polled OID that returned a numeric value (oid / oidName
+   * attributes) — CPU, memory, temperature from vendor templates and any
+   * custom OID a user adds. This is what makes polled OIDs chartable and
+   * evaluable over time.
+   */
+  SnmpOidValue = "oneuptime.monitor.snmp.oid.value",
+
   /*
    * Extended server/VM metrics. Emitted when the agent payload contains them;
    * absent for older agents, which keeps the pipeline backwards-compatible.

package/Types/Monitor/MonitorStep.ts

@@ -47,6 +47,7 @@ import MonitorStepDnssecMonitor, {
 import MonitorStepSqlMonitor, {
   MonitorStepSqlMonitorUtil,
 } from "./MonitorStepSqlMonitor";
+import SqlDatabaseType from "./SqlDatabaseType";
 import MonitorStepExternalStatusPageMonitor, {
   MonitorStepExternalStatusPageMonitorUtil,
 } from "./MonitorStepExternalStatusPageMonitor";
@@ -780,6 +781,14 @@ export default class MonitorStep extends DatabaseProperty {
       if (!value.data.sqlMonitor.query || !value.data.sqlMonitor.query.trim()) {
         return "SQL query is required";
       }
+
+      if (
+        value.data.sqlMonitor.useWindowsIntegratedAuthentication &&
+        value.data.sqlMonitor.databaseType !==
+          SqlDatabaseType.MicrosoftSqlServer
+      ) {
+        return "Windows Integrated Authentication is only supported for Microsoft SQL Server";
+      }
     }
 
     if (monitorType === MonitorType.ExternalStatusPage) {