@camstack/types 1.2.396 → 1.2.397

package/dist/interfaces/event-bus.d.ts

@@ -1122,6 +1122,25 @@ export interface EventCatalog {
         nodeId?: string;
         locationName?: string;
     };
+    'notification.rule-broken': {
+        ruleId: string;
+        /** `null` when the row was too broken to say. */
+        ruleName: string | null;
+        /** The first reason; `reasons` carries them all. */
+        reason: 'unparseable' | 'device-deleted' | 'target-deleted';
+        reasons: readonly {
+            code: 'unparseable' | 'device-deleted' | 'target-deleted';
+            /** Device ids (decimal) or target ids; empty for `unparseable`. */
+            ids: readonly string[];
+            /** The first schema issue, for `unparseable`. */
+            detail?: string;
+        }[];
+        offendingIds: readonly string[];
+    };
+    'notification.rule-repaired': {
+        ruleId: string;
+        ruleName: string | null;
+    };
     'recording.segment.written': {
         deviceId: number;
         path?: string;

package/dist/notification/system-event-classes.d.ts

@@ -0,0 +1,73 @@
+/**
+ * D906 — system events that come in PAIRS are one CLASS: a "went bad" edge and
+ * a "came back" edge of the same condition (a stream offline / back online, a
+ * recording stalled / writing again, a rule broken / repaired).
+ *
+ * Nothing new is STORED: a rule keeps listing edge kinds, and a class is the
+ * set of its edges. What the class decides:
+ *
+ *  - an IMMEDIATE system rule that selects a class is told about BOTH edges.
+ *    A stored instant rule listing only one edge of a class is read as the
+ *    whole class (`withSystemEventClasses`) — the operator asked for both
+ *    fronts, and a rule that heard "offline" and never "back online" left
+ *    every outage open-ended on the phone.
+ *  - a SCHEDULED STATE SUMMARY (`systemEventDelivery.mode: 'summary'`) reads a
+ *    class as a SNAPSHOT of the bad state at the scheduled time — never edges,
+ *    never recoveries — so it is NOT widened. The summary already reports a
+ *    state per kind group regardless of which edge was selected (D647).
+ *
+ * One-edge kinds (a node restarting, an update available, a backup done, the
+ * alarm's transitions) stay single. Pure.
+ */
+import type { NcSystemEventCondition, NcSystemEventDelivery, NcSystemEventKind } from '../capabilities/notification-rules.cap.js';
+import { type NcSystemEventFamily } from './system-event-families.js';
+export interface NcSystemEventClassSpec {
+    readonly id: string;
+    readonly family: NcSystemEventFamily;
+    /** The editor's one checkbox. */
+    readonly label: string;
+    /** The edges into the bad state. */
+    readonly bad: readonly NcSystemEventKind[];
+    /** The edges out of it. */
+    readonly recovery: readonly NcSystemEventKind[];
+    /** What the class means on a SCHEDULED summary: the bad state, as a list. */
+    readonly snapshotLabel: string;
+    /**
+     * The state-summary section that snapshots the bad state, or `null` when the
+     * summary has no source for this class (it then reports nothing for it).
+     */
+    readonly snapshotSection: string | null;
+}
+export declare const NC_SYSTEM_EVENT_CLASS_SPECS: readonly NcSystemEventClassSpec[];
+/** Every edge of a class: what an instant rule selecting it listens to. */
+export declare function systemEventClassKinds(spec: NcSystemEventClassSpec): readonly NcSystemEventKind[];
+/** The class a kind belongs to, or `undefined` for a one-edge kind. */
+export declare function systemEventClassOf(kind: string): NcSystemEventClassSpec | undefined;
+/** Is this kind a RECOVERY edge of some class? */
+export declare function isSystemEventRecoveryKind(kind: string): boolean;
+/** The classes of ONE family, for that family's editor. */
+export declare function systemEventClassesFor(family: NcSystemEventFamily): readonly NcSystemEventClassSpec[];
+/**
+ * A kind list with the OTHER front of every class it touches: a bad edge
+ * brings the class's recovery, a recovery brings the class's bad edges. A
+ * sibling bad edge is never added by a bad edge — a rule on
+ * `storage-location-critical` does not start hearing `storage-location-low`.
+ * Input order is kept, each added edge right after the kind that brought it.
+ * Kinds of no class (and legacy names) pass through.
+ */
+export declare function expandSystemEventClasses(kinds: readonly NcSystemEventKind[]): NcSystemEventKind[];
+/** The part of a rule {@link withSystemEventClasses} reads. */
+export interface NcSystemEventClassSubject {
+    readonly delivery: string;
+    readonly conditions: {
+        readonly systemEvent?: NcSystemEventCondition;
+    };
+    readonly systemEventDelivery?: NcSystemEventDelivery;
+}
+/**
+ * An INSTANT system rule with each class it touches completed with both edges;
+ * the rule itself (same object) when there is nothing to add, a summary rule,
+ * or a rule spanning families (`mixed` stays read-only, D637). A copy, never a
+ * mutation.
+ */
+export declare function withSystemEventClasses<T extends NcSystemEventClassSubject>(rule: T): T;

package/dist/{sleep-Re8daN0Y.js → sleep-Bo7fq491.js}

@@ -1,4 +1,4 @@
-const require_event_category = require("./event-category-eSqkye-K.js");
+const require_event_category = require("./event-category-kpu1bZMs.js");
 let zod = require("zod");
 //#region src/audio/audio-chunk-format.ts
 /**

package/dist/{sleep-_sV1BE2f.mjs → sleep-CueztlR1.mjs}

@@ -1,4 +1,4 @@
-import { t as EventCategory } from "./event-category-DOl51-Ij.mjs";
+import { t as EventCategory } from "./event-category-7pZEBmVg.mjs";
 import { z } from "zod";
 //#region src/audio/audio-chunk-format.ts
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/types",
-  "version": "1.2.396",
+  "version": "1.2.397",
   "description": "Shared types, interfaces, and model catalogs for the CamStack detection ecosystem",
   "keywords": [
     "camstack",