@camstack/types 1.2.255 → 1.2.257

package/dist/notification/alarm-membership.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Does a rule BELONG TO THE ALARM — and, with D640's chosen edge, can it then
+ * still fire at all?
+ *
+ * `ruleBelongsToAlarm` is D630's predicate: such a rule fires on an opening's
+ * OPENING edge only (the engine refuses a closing edge, `rule-engine.ts`). It
+ * lived in the engine alone; it is hoisted here because an EDITOR needs the
+ * same answer to warn about a rule that asks for the other edge — an alarm rule
+ * over contacts set to "only when it clears" passes every save check and never
+ * fires, and the operator was never told. One predicate, so the engine and the
+ * warning cannot disagree about which rules are the alarm.
+ *
+ * Structural inputs (conditions + the enabled `onTrigger` sequences), so the
+ * admin's form state and the engine's rule both answer without a cast.
+ */
+import type { NcConditions, NcRuleActionSequence } from '../capabilities/notification-rules.cap.js';
+/**
+ * The sensor-event kinds that are OPENINGS to the alarm — the keys of the
+ * engine's opening table (`alarm-openings.ts`, which is checked against this
+ * list with `satisfies`). Only these carry an opening edge the alarm refuses.
+ */
+export declare const NC_ALARM_OPENING_EVENT_KINDS: readonly ["contact", "cover", "lock"];
+export type NcAlarmOpeningEventKind = (typeof NC_ALARM_OPENING_EVENT_KINDS)[number];
+/** What the alarm-membership question reads off a rule. */
+export interface NcAlarmMembershipSubject {
+    readonly conditions: Pick<NcConditions, 'deviceState' | 'sensorKinds' | 'sensorTransition'>;
+    readonly onTrigger?: readonly NcRuleActionSequence[];
+}
+/**
+ * A rule belongs to the alarm when its `deviceState` gate names ANY device's
+ * `armed_*` word, or an ENABLED `onTrigger` sequence pulls the alarm panel's
+ * trigger (D630).
+ */
+export declare function ruleBelongsToAlarm(rule: NcAlarmMembershipSubject): boolean;
+/**
+ * An alarm rule over openings only, asking for the CLEAR: the alarm edge
+ * refuses every closing, and the chosen edge refuses every opening, so nothing
+ * is left (D640 × D630). Not refused on save — alarm membership is derived and
+ * can change with an action edit — but every editor must SAY it.
+ */
+export declare function sensorTransitionNeverFires(rule: NcAlarmMembershipSubject): boolean;
+/** The warning an editor shows for {@link sensorTransitionNeverFires}. */
+export declare const NC_SENSOR_TRANSITION_NEVER_FIRES_WARNING = "This rule belongs to the alarm, and an alarm rule fires only when an opening OPENS. Set to \u201Conly when it clears\u201D, it can never fire.";

package/dist/notification/sensor-raised.d.ts

@@ -0,0 +1,45 @@
+/**
+ * WHICH WAY A BOOLEAN SENSOR MOVED — read off the one slice a sensor event
+ * persists (D640 "a sensor rule fires on the raise, the clear, or both").
+ *
+ * A device-event rule over a flood sensor notified on BOTH edges: water
+ * detected, and back to dry. `NcConditions.sensorTransition` lets the rule
+ * name one edge; this file answers, for one `SensorEvent`, which edge it is.
+ *
+ * NOT A SECOND TABLE. The "which boolean of this cap counts as HIGH" question
+ * already has one answer, `SOURCE_CAP_ACTIVE_FIELD`
+ * (`catalogs/sensor-active-state.ts`, the doorbell's and the recorder's edge
+ * table), and a sensor event names its kind, not its cap. So the table here is
+ * DERIVED: event kind → cap (`EVENT_KIND_BY_CAP`) → that cap's active field.
+ * Only kinds whose taxonomy category is `sensor` take part — a switch has an
+ * `on` boolean too, but "it triggers / it clears" is not a sentence about a
+ * light, and offering it there would be a knob with a misleading label.
+ * `presence` is a WORD (`home` / `not_home` / a zone), not a boolean, and is
+ * absent from the source table, so it is absent here.
+ *
+ * `undefined` = never guessed: a kind with no raise (a doorbell press, a
+ * button, a cover), or a slice whose field is missing or not a boolean. The
+ * engine then does NOT filter — a flood alert must not go silent because one
+ * read came back unreadable (the same stance as the alarm's `sensorEdgeOf`).
+ *
+ * Pure, RN-safe: the viewer imports the support rule from here.
+ */
+/** Event kind → the boolean field of its cap slice that means "raised". */
+export declare const NC_SENSOR_RAISED_FIELD_BY_KIND: Readonly<Record<string, string>>;
+/** The sensor kinds `sensorTransition` means something for. */
+export declare const NC_SENSOR_TRANSITION_KINDS: readonly string[];
+/**
+ * true = the sensor is raised (water, smoke, open, tampered…), false = it
+ * cleared, undefined = this kind has no raise or the slice cannot say.
+ */
+export declare function sensorRaisedOf(kind: string, value: Readonly<Record<string, unknown>> | null): boolean | undefined;
+/**
+ * THE SUPPORT RULE, shared by both editors: "Notify when" is offered only when
+ * the rule names at least one sensor kind and EVERY kind it names has a raise.
+ * A mixed rule (flood + doorbell) would hear "only when it clears" as "never
+ * for the doorbell" in the operator's head while the engine lets the doorbell
+ * through — so the choice is not offered, and an editor prunes it on save.
+ */
+export declare function sensorTransitionOffered(sensorKinds: readonly string[] | undefined): boolean;
+/** What an editor tells the operator when it is about to prune the choice. */
+export declare const NC_SENSOR_TRANSITION_UNSUPPORTED_REASON = "Only a sensor that raises and clears (water, smoke, gas, CO, vibration, tamper, motion, contact) can fire on one edge. Pick only such sensor kinds, or the rule fires on every change.";

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

@@ -24,7 +24,7 @@ export declare const NC_SYSTEM_EVENT_FAMILY: Readonly<Record<NcSystemEventKind,
 export type NcSystemEventConditionFilterKey = NcSystemEventFilterKey | 'excludeDeviceIds';
 export declare const NC_SYSTEM_EVENT_CONDITION_FILTER_KEYS: readonly NcSystemEventConditionFilterKey[];
 /**
- * The filters a family may carry. The four base filters are the union of
+ * The filters a family may carry. The base filters are the union of
  * `systemEventFilterApplies` over the family's kinds (the spec pins that
  * equality). `excludeDeviceIds` is a device-events filter only: an alarm is
  * narrowed to the camera that triggered it and excludes nothing.

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

@@ -32,7 +32,7 @@
  * narrows, and still fails CLOSED on a subject that cannot produce the identity
  * it tests (a device the mirror cannot name is not evidence of a camera).
  */
-import type { NcSystemEventKind } from '../capabilities/notification-rules.cap.js';
+import { type NcSystemEventKind } from '../capabilities/notification-rules.cap.js';
 /**
  * A narrowing filter, named by its CONDITION FIELD.
  *
@@ -41,8 +41,16 @@ import type { NcSystemEventKind } from '../capabilities/notification-rules.cap.j
  * two sides has to be able to say which field it is talking about without a
  * translation table in the middle.
  */
-export type NcSystemEventFilterKey = 'deviceIds' | 'deviceTypes' | 'nodeIds' | 'packageNames';
-/** Every filter, for the callers that must cover all four (guards, tests). */
+export type NcSystemEventFilterKey = 'deviceIds' | 'deviceTypes' | 'nodeIds' | 'packageNames' | 'consumableLowPercent';
+/**
+ * Every filter, for the callers that must cover all of them (guards, tests).
+ *
+ * `consumableLowPercent` (D642) is not a list but it is a filter in exactly
+ * this sense: it belongs to a family of kinds (the consumable pair) and the
+ * engine consults it only there. It differs in one way the readers must know —
+ * its ABSENCE is not "no narrowing" but the default threshold, because a
+ * consumable episode is always judged at SOME threshold.
+ */
 export declare const NC_SYSTEM_EVENT_FILTER_KEYS: readonly NcSystemEventFilterKey[];
 /**
  * Does `filter` say anything about `kind`?

package/dist/notification/template-vars.d.ts

@@ -8,11 +8,34 @@
  * `addon-post-analysis` run each producer and compare its keys with this list,
  * so the two cannot drift silently again.
  */
-import { NcRuleKindSchema, NcTemplateFamilySchema, NcTemplateFieldSchema, NcTemplateVarContextSchema, NcTemplateVarDescriptorSchema, NcTemplateVarGroupSchema, type NcTemplateVarContext, type NcTemplateVarDescriptor, type NcTemplateVarKind } from '../capabilities/notification-rules.cap.js';
+import { NcRuleKindSchema, NcTemplateFamilySchema, NcTemplateFieldSchema, NcTemplateVarContextSchema, NcTemplateVarDescriptorSchema, NcTemplateVarGroupSchema, type NcSystemEventKind, type NcTemplateVarContext, type NcTemplateVarDescriptor, type NcTemplateVarKind } from '../capabilities/notification-rules.cap.js';
 import { type NcRuleKind } from './rule-kinds.js';
 export { NcRuleKindSchema, NcTemplateFamilySchema, NcTemplateFieldSchema, NcTemplateVarContextSchema, NcTemplateVarDescriptorSchema, NcTemplateVarGroupSchema, };
 export type { NcTemplateFamily, NcTemplateField, NcTemplateVarContext, NcTemplateVarDescriptor, NcTemplateVarGroup, } from '../capabilities/notification-rules.cap.js';
 export declare const NC_TEMPLATE_VARS: readonly NcTemplateVarDescriptor[];
+/**
+ * System-event kinds the SERVED catalog holds back (D642): the kinds the hub
+ * produces before the installed viewers can parse them.
+ *
+ * The viewer parses `getTemplateCatalog` WHOLE, with its own strict
+ * `NcSystemEventKindSchema` on every descriptor's `systemEventKinds`, so one
+ * kind it does not know — in `{{deviceName}}`, which every device event names —
+ * empties every {{var}} picker on every phone (the same trap
+ * `NcTemplateVarKindSchema` froze the rule kinds for). The in-process catalog
+ * keeps them: the producer parity and the preview render read it.
+ *
+ * SELF-EXPIRING: `scripts/check-nc-mirrors-in-sync.ts` reads this list as the
+ * viewer's allowance and fails the day the viewer mirrors one of these kinds —
+ * delete it from here then, and the served catalog names it again.
+ */
+export declare const NC_TEMPLATE_HELD_BACK_SYSTEM_EVENT_KINDS: readonly NcSystemEventKind[];
+/**
+ * The catalog as `getTemplateCatalog` SERVES it: every descriptor, with the
+ * held-back kinds removed from its `systemEventKinds`. A descriptor that named
+ * only held-back kinds is served with an empty list — offered to no system
+ * rule an installed viewer can author, which is exactly true.
+ */
+export declare function servedTemplateVars(): NcTemplateVarDescriptor[];
 /**
  * Does a descriptor declared for `declared` kinds have a value for a rule of
  * `kind`?

package/dist/{sleep-D_4W7xuQ.mjs → sleep-DU7mu4wb.mjs}

@@ -3752,6 +3752,7 @@ function createDeviceProxy(api, binding, opts) {
 			getTemplateCatalog: (input) => dispatch("notification-rules", "notificationRules", "getTemplateCatalog", "query", input),
 			previewTemplate: (input) => dispatch("notification-rules", "notificationRules", "previewTemplate", "mutation", input),
 			getHistory: (input) => dispatch("notification-rules", "notificationRules", "getHistory", "query", input),
+			getRuleLastRuns: (input) => dispatch("notification-rules", "notificationRules", "getRuleLastRuns", "query", input),
 			resolveArtifactUrl: (input) => dispatch("notification-rules", "notificationRules", "resolveArtifactUrl", "query", input),
 			listSnoozes: (input) => dispatch("notification-rules", "notificationRules", "listSnoozes", "query", input),
 			createSnooze: (input) => dispatch("notification-rules", "notificationRules", "createSnooze", "mutation", input),

package/dist/{sleep-BAgDk7I9.js → sleep-DtomDrRW.js}

@@ -3752,6 +3752,7 @@ function createDeviceProxy(api, binding, opts) {
 			getTemplateCatalog: (input) => dispatch("notification-rules", "notificationRules", "getTemplateCatalog", "query", input),
 			previewTemplate: (input) => dispatch("notification-rules", "notificationRules", "previewTemplate", "mutation", input),
 			getHistory: (input) => dispatch("notification-rules", "notificationRules", "getHistory", "query", input),
+			getRuleLastRuns: (input) => dispatch("notification-rules", "notificationRules", "getRuleLastRuns", "query", input),
 			resolveArtifactUrl: (input) => dispatch("notification-rules", "notificationRules", "resolveArtifactUrl", "query", input),
 			listSnoozes: (input) => dispatch("notification-rules", "notificationRules", "listSnoozes", "query", input),
 			createSnooze: (input) => dispatch("notification-rules", "notificationRules", "createSnooze", "mutation", input),

package/package.json

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