@camstack/types 1.2.284 → 1.2.285

package/dist/index.js

@@ -21283,6 +21283,41 @@ var NcSnoozeSuppressedSchema = zod.z.object({
 	firstAt: zod.z.number(),
 	lastAt: zod.z.number()
 });
+/** The bounds every alarm delay field carries — settings, per-mode overrides, both editors. */
+var NC_ALARM_DELAY_MAX_SEC = 600;
+var NC_ALARM_TRIGGERED_MAX_SEC = 3600;
+/** At most this many ids on one mode's non-blocking list. */
+var NC_ALARM_NONBLOCKING_MAX = 200;
+var NcAlarmDelaySecSchema = zod.z.number().int().min(0).max(600);
+var NcAlarmTriggeredSecSchema = zod.z.number().int().min(0).max(NC_ALARM_TRIGGERED_MAX_SEC);
+var uniqueModes = (entries) => new Set(entries.map((e) => e.mode)).size === entries.length;
+/** One mode's OVERRIDES. An absent field inherits the global value (D697). */
+var NcAlarmModeDelaysSchema = zod.z.object({
+	mode: AlarmArmModeSchema,
+	exitDelaySec: NcAlarmDelaySecSchema.optional(),
+	entryDelaySec: NcAlarmDelaySecSchema.optional(),
+	triggeredDurationSec: NcAlarmTriggeredSecSchema.optional()
+});
+var NcAlarmModeDelaysListSchema = zod.z.array(NcAlarmModeDelaysSchema).max(8).refine(uniqueModes, { message: "modeDelays: at most one entry per arm mode" });
+/**
+* One mode's EDIT in a patch: a number sets the override, `null` removes it (the mode inherits
+* again), an absent field leaves it alone. Per field, so two editors changing two different
+* delays of one mode never undo each other.
+*/
+var NcAlarmModeDelaysEditSchema = zod.z.object({
+	mode: AlarmArmModeSchema,
+	exitDelaySec: NcAlarmDelaySecSchema.nullable().optional(),
+	entryDelaySec: NcAlarmDelaySecSchema.nullable().optional(),
+	triggeredDurationSec: NcAlarmTriggeredSecSchema.nullable().optional()
+});
+var NcAlarmModeDelaysEditListSchema = zod.z.array(NcAlarmModeDelaysEditSchema).max(8).refine(uniqueModes, { message: "modeDelays: at most one edit per arm mode" });
+/** One switch of the alarm table: put ONE device on, or take it off, ONE mode's list. */
+var NcAlarmNonBlockingEditSchema = zod.z.object({
+	mode: AlarmArmModeSchema,
+	deviceId: zod.z.number().int().positive(),
+	/** true = on the list (may be open, does not block); false = off the list (blocks). */
+	nonBlocking: zod.z.boolean()
+});
 /**
 * One arm mode's non-blocking list: devices that may be open when that mode
 * arms, without the arm being refused.
@@ -21296,10 +21331,10 @@ var NcAlarmNonBlockingSchema = zod.z.object({
 * meaning a reader could agree on (union? the last one?), so they are refused
 * at the boundary rather than interpreted.
 */
-var NcAlarmNonBlockingListSchema = zod.z.array(NcAlarmNonBlockingSchema).max(8).refine((lists) => new Set(lists.map((l) => l.mode)).size === lists.length, { message: "nonBlocking: at most one list per arm mode" });
+var NcAlarmNonBlockingListSchema = zod.z.array(NcAlarmNonBlockingSchema).max(8).refine(uniqueModes, { message: "nonBlocking: at most one list per arm mode" });
 /**
-* The three durations the panel's state machine runs on, who hears about its
-* transitions, and which openings each mode tolerates.
+* The three durations — global, and per mode since D697 — the panel's state
+* machine runs on, who hears about its transitions, and which openings each mode tolerates.
 *
 * They live on the NOTIFICATION-RULES cap, not on `alarm-panel`, on purpose:
 * `alarm-panel` is `deviceNative` and its other provider mirrors somebody
@@ -21309,15 +21344,15 @@ var NcAlarmNonBlockingListSchema = zod.z.array(NcAlarmNonBlockingSchema).max(8).
 */
 var NcAlarmSettingsSchema = zod.z.object({
 	/** Grace period between arming and the mode taking effect. 0 = immediate. */
-	exitDelaySec: zod.z.number().int().min(0).max(600),
+	exitDelaySec: NcAlarmDelaySecSchema,
 	/** Grace period between a trigger and the alarm firing. 0 = immediate. */
-	entryDelaySec: zod.z.number().int().min(0).max(600),
+	entryDelaySec: NcAlarmDelaySecSchema,
 	/**
 	* How long `triggered` lasts before the panel re-arms itself.
 	* **0 = until an operator disarms it** — the behaviour before this field
 	* existed, and therefore what an untouched install keeps doing.
 	*/
-	triggeredDurationSec: zod.z.number().int().min(0).max(3600),
+	triggeredDurationSec: NcAlarmTriggeredSecSchema,
 	/**
 	* Deprecated by D630 — every transition is announced. Parsed, never read;
 	* remove after one release. Optional so an older admin's patch (which still
@@ -21340,17 +21375,30 @@ var NcAlarmSettingsSchema = zod.z.object({
 	* per mode is meaningful. Defaulted to `[]` so a blob stored before D630
 	* parses as "every opening blocks" — the behaviour it was written under.
 	*/
-	nonBlocking: NcAlarmNonBlockingListSchema.default([])
+	nonBlocking: NcAlarmNonBlockingListSchema.default([]),
+	/**
+	* Per arm mode, the delays that mode OVERRIDES (D697). A mode with no entry, or an entry
+	* without a field, uses the global value above — so `[]`, the default, is exactly the
+	* behaviour of a blob stored before this field existed. Read through `resolveModeDelays`.
+	*/
+	modeDelays: NcAlarmModeDelaysListSchema.default([])
 });
 /**
 * Every field optional — a tab edits one control at a time.
 *
-* `nonBlocking` is re-declared WITHOUT its default: `.partial()` does not
-* remove an inner `.default()`, so a patch that never named the field would
-* parse to `nonBlocking: []` and wipe every mode's list on an unrelated edit
-* (the same trap {@link NcRulePatchSchema} documents).
+* `nonBlocking` and `modeDelays` are re-declared WITHOUT their defaults:
+* `.partial()` does not remove an inner `.default()`, so a patch that never
+* named the field would parse to `[]` and wipe every mode's list on an
+* unrelated edit (the same trap {@link NcRulePatchSchema} documents). Here
+* `modeDelays` means EDITS, not the stored overrides.
 */
-var NcAlarmSettingsPatchSchema = NcAlarmSettingsSchema.extend({ nonBlocking: NcAlarmNonBlockingListSchema }).partial();
+var NcAlarmSettingsPatchSchema = NcAlarmSettingsSchema.extend({
+	nonBlocking: NcAlarmNonBlockingListSchema,
+	/** Per-mode, per-field edits — NOT the whole list (see NcAlarmModeDelaysEditSchema). */
+	modeDelays: NcAlarmModeDelaysEditListSchema,
+	/** ONE membership change; the panel applies it to the list it holds at its turn. */
+	nonBlockingEdit: NcAlarmNonBlockingEditSchema
+}).partial().refine((p) => p.nonBlocking === void 0 || p.nonBlockingEdit === void 0, { message: "nonBlocking and nonBlockingEdit are exclusive — send the whole lists or one edit" });
 /**
 * What one arm mode actually arms, DERIVED from the enabled rules gated on it.
 * Never authored, never stored — see `alarm-mode-coverage.ts` for why a stored
@@ -21450,6 +21498,30 @@ var NcAlarmConfigSchema = zod.z.object({
 	*/
 	live: NcAlarmLiveSchema.optional()
 });
+/** At most this many ids in one `getAlarmSensors` call — a validation bound, not a target. */
+var NC_ALARM_SENSORS_MAX = 500;
+var NcAlarmSensorReadingSchema = zod.z.enum([
+	"open",
+	"closed",
+	"unknown",
+	"not-opening"
+]);
+/** One device's state as the alarm reads it — the classifier the arm check uses. */
+var NcAlarmSensorStateSchema = zod.z.object({
+	deviceId: zod.z.number().int().positive(),
+	reading: NcAlarmSensorReadingSchema,
+	/** The word as read (`open`, `closed`, `unlocked`, `stopped`, …); null when unknown / not an opening. */
+	state: zod.z.string().nullable(),
+	/** Why `unknown`: the read failed, or the slice holds no word its cap defines (a placeholder included). */
+	unknownWhy: zod.z.enum(["read-failed", "unknown-word"]).nullable(),
+	/** The device manager's liveness as the centre mirrors it; null = not known. */
+	online: zod.z.boolean().nullable()
+});
+var NcAlarmSensorsInputSchema = zod.z.object({ deviceIds: zod.z.array(zod.z.number().int().positive()).max(500) });
+var NcAlarmSensorsSchema = zod.z.object({
+	sensors: zod.z.array(NcAlarmSensorStateSchema),
+	readAt: zod.z.number().int().nonnegative()
+});
 /**
 * The most seconds of footage any notification rule may ask a camera to retain.
 *
@@ -21709,8 +21781,9 @@ var notificationRulesCapability = {
 		*/
 		getAlarmConfig: require_sleep.method(zod.z.object({}), NcAlarmConfigSchema, { auth: "admin" }),
 		/**
-		* Patch the settings (durations, recipients, per-mode non-blocking lists;
-		* `announceArm` is accepted and ignored — D630). Returns the WHOLE config,
+		* Patch the settings (durations — global and per mode —, recipients,
+		* per-mode non-blocking lists or one membership edit; `announceArm` is
+		* accepted and ignored — D630). Returns the WHOLE config,
 		* coverage and `live` included, so a
 		* client never has to guess what the server settled on — the panel clamps
 		* and normalises, and a form that re-rendered from its own input would
@@ -21719,7 +21792,15 @@ var notificationRulesCapability = {
 		setAlarmConfig: require_sleep.method(zod.z.object({ patch: NcAlarmSettingsPatchSchema }), NcAlarmConfigSchema, {
 			kind: "mutation",
 			auth: "admin"
-		})
+		}),
+		/**
+		* The CURRENT state of each asked device as the alarm reads it (D697) — open, closed,
+		* unknown (why) or not an opening, plus liveness. Classified by the same table the arm
+		* check uses (`alarm-openings.ts`), so the editor and the arm can never disagree. The
+		* caller names the ids (the household openings it already holds); at most
+		* `NC_ALARM_SENSORS_MAX`.
+		*/
+		getAlarmSensors: require_sleep.method(NcAlarmSensorsInputSchema, NcAlarmSensorsSchema, { auth: "admin" })
 	}
 };
 //#endregion
@@ -56424,6 +56505,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"notificationRules.getAlarmSensors": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"notificationRules.getClipRetentionAsks": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -61244,6 +61331,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"notificationRules.getAlarmSensors": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"notificationRules.setDeviceMuted": [{
 		name: "deviceId",
 		form: "single",
@@ -62482,6 +62574,7 @@ var SYSTEM_SCOPE_DEVICE_METHODS = [
 	"faceGallery.listRecentFaces",
 	"networkQuality.getDeviceStats",
 	"networkQuality.reportClientStats",
+	"notificationRules.getAlarmSensors",
 	"notificationRules.setDeviceMuted",
 	"osdManager.clearSlotBinding",
 	"osdManager.copyDeviceConfiguration",
@@ -63422,7 +63515,8 @@ function createSystemProxy(api) {
 			createSnooze: (input) => dispatch("notificationRules", "createSnooze", "mutation", input),
 			cancelSnooze: (input) => dispatch("notificationRules", "cancelSnooze", "mutation", input),
 			getAlarmConfig: (input) => dispatch("notificationRules", "getAlarmConfig", "query", input),
-			setAlarmConfig: (input) => dispatch("notificationRules", "setAlarmConfig", "mutation", input)
+			setAlarmConfig: (input) => dispatch("notificationRules", "setAlarmConfig", "mutation", input),
+			getAlarmSensors: (input) => dispatch("notificationRules", "getAlarmSensors", "query", input)
 		},
 		osdManager: {
 			getConditionSupport: (input) => dispatch("osdManager", "getConditionSupport", "query", input),
@@ -65457,6 +65551,176 @@ function sensorTransitionNeverFires(rule) {
 /** The warning an editor shows for {@link sensorTransitionNeverFires}. */
 var NC_SENSOR_TRANSITION_NEVER_FIRES_WARNING = "This rule belongs to the alarm, and an alarm rule fires only when an opening OPENS. Set to “only when it clears”, it can never fire.";
 //#endregion
+//#region src/notification/alarm-settings.ts
+var NC_ALARM_DELAY_FIELDS = [
+	"exitDelaySec",
+	"entryDelaySec",
+	"triggeredDurationSec"
+];
+/** The mode's value when it overrides the field, else the global one. */
+function pick(override, global) {
+	return override === void 0 ? {
+		value: global,
+		source: "default"
+	} : {
+		value: override,
+		source: "mode"
+	};
+}
+/** What `mode` actually runs on: its own overrides, the global value for every other field. */
+function resolveModeDelays(settings, mode) {
+	const entry = (settings.modeDelays ?? []).find((e) => e.mode === mode);
+	const exit = pick(entry?.exitDelaySec, settings.exitDelaySec);
+	const entryDelay = pick(entry?.entryDelaySec, settings.entryDelaySec);
+	const triggered = pick(entry?.triggeredDurationSec, settings.triggeredDurationSec);
+	return {
+		exitDelaySec: exit.value,
+		entryDelaySec: entryDelay.value,
+		triggeredDurationSec: triggered.value,
+		source: {
+			exitDelaySec: exit.source,
+			entryDelaySec: entryDelay.source,
+			triggeredDurationSec: triggered.source
+		}
+	};
+}
+/** One field of an entry after an edit: number sets, null clears, undefined keeps. */
+function edited(current, edit) {
+	if (edit === void 0) return current;
+	return edit === null ? void 0 : edit;
+}
+/**
+* Apply per-field edits to the stored overrides. Returns new arrays, never mutates the input;
+* an entry with no field left is dropped (the mode inherits everything again).
+*/
+function applyModeDelaysEdits(current, edits) {
+	const out = current.map((e) => ({ ...e }));
+	for (const edit of edits) {
+		const at = out.findIndex((e) => e.mode === edit.mode);
+		const base = at >= 0 ? out[at] ?? { mode: edit.mode } : { mode: edit.mode };
+		const next = { mode: edit.mode };
+		const exit = edited(base.exitDelaySec, edit.exitDelaySec);
+		const entry = edited(base.entryDelaySec, edit.entryDelaySec);
+		const triggered = edited(base.triggeredDurationSec, edit.triggeredDurationSec);
+		if (exit !== void 0) next.exitDelaySec = exit;
+		if (entry !== void 0) next.entryDelaySec = entry;
+		if (triggered !== void 0) next.triggeredDurationSec = triggered;
+		if (at >= 0) out[at] = next;
+		else out.push(next);
+	}
+	return out.filter((e) => e.exitDelaySec !== void 0 || e.entryDelaySec !== void 0 || e.triggeredDurationSec !== void 0);
+}
+/**
+* Put ONE device on, or take it off, ONE mode's list. A no-op answers `changed: false`; an add
+* to a full list is REFUSED by reason (never silently dropped); an emptied list drops its entry.
+*/
+function applyNonBlockingEdit(lists, edit) {
+	const copy = lists.map((l) => ({
+		mode: l.mode,
+		deviceIds: [...l.deviceIds]
+	}));
+	const at = copy.findIndex((l) => l.mode === edit.mode);
+	const held = at >= 0 ? copy[at]?.deviceIds ?? [] : [];
+	const present = held.includes(edit.deviceId);
+	if (edit.nonBlocking === present) return {
+		kind: "applied",
+		lists: copy,
+		changed: false
+	};
+	if (edit.nonBlocking) {
+		if (held.length >= 200) return {
+			kind: "refused",
+			reason: "list-full",
+			mode: edit.mode,
+			max: 200
+		};
+		const next = {
+			mode: edit.mode,
+			deviceIds: [...held, edit.deviceId]
+		};
+		if (at >= 0) copy[at] = next;
+		else copy.push(next);
+	} else {
+		const next = {
+			mode: edit.mode,
+			deviceIds: held.filter((id) => id !== edit.deviceId)
+		};
+		if (at >= 0) copy[at] = next;
+	}
+	return {
+		kind: "applied",
+		lists: copy.filter((l) => l.deviceIds.length > 0),
+		changed: true
+	};
+}
+function sameSet(a, b) {
+	const sa = new Set(a);
+	const sb = new Set(b);
+	return sa.size === sb.size && [...sa].every((x) => sb.has(x));
+}
+/** Per-mode id sets of a lists value, empty lists ignored. */
+function listsByMode(lists) {
+	const out = /* @__PURE__ */ new Map();
+	for (const l of lists) if (l.deviceIds.length > 0) out.set(l.mode, new Set(l.deviceIds));
+	return out;
+}
+function sameLists(a, b) {
+	const ma = listsByMode(a);
+	const mb = listsByMode(b);
+	if (ma.size !== mb.size) return false;
+	for (const [mode, ids] of ma) {
+		const other = mb.get(mode);
+		if (other === void 0 || !sameSet([...ids], [...other])) return false;
+	}
+	return true;
+}
+/** The returned entry's value for one field of a mode-delays edit. */
+function fieldOf(entry, field) {
+	if (entry === void 0) return void 0;
+	switch (field) {
+		case "exitDelaySec": return entry.exitDelaySec;
+		case "entryDelaySec": return entry.entryDelaySec;
+		case "triggeredDurationSec": return entry.triggeredDurationSec;
+	}
+}
+/** The edit's value for one field. */
+function editFieldOf(edit, field) {
+	switch (field) {
+		case "exitDelaySec": return edit.exitDelaySec;
+		case "entryDelaySec": return edit.entryDelaySec;
+		case "triggeredDurationSec": return edit.triggeredDurationSec;
+	}
+}
+/**
+* True iff every key the patch sent is reflected in what the host returned. A host older than
+* this build strips the keys it does not know; this is how a client tells "saved" from "parsed
+* and dropped". `announceArm` is ignored (parsed, never read). A `null` clear "lands" on a host
+* that stripped the key (it lacks the field) — harmless, because such a host stores no overrides.
+* A whole-list `nonBlocking` naming a mode the panel does not offer reads as "not landed" (the host
+* drops it); only older clients and the prune send whole lists, and they do not call this.
+*/
+function alarmPatchLanded(patch, returned) {
+	if (patch.exitDelaySec !== void 0 && patch.exitDelaySec !== returned.exitDelaySec) return false;
+	if (patch.entryDelaySec !== void 0 && patch.entryDelaySec !== returned.entryDelaySec) return false;
+	if (patch.triggeredDurationSec !== void 0 && patch.triggeredDurationSec !== returned.triggeredDurationSec) return false;
+	if (patch.announceTargets !== void 0 && !sameSet(patch.announceTargets, returned.announceTargets)) return false;
+	if (patch.nonBlocking !== void 0 && !sameLists(patch.nonBlocking, returned.nonBlocking ?? [])) return false;
+	for (const edit of patch.modeDelays ?? []) {
+		const entry = (returned.modeDelays ?? []).find((e) => e.mode === edit.mode);
+		for (const field of NC_ALARM_DELAY_FIELDS) {
+			const want = editFieldOf(edit, field);
+			if (want === void 0) continue;
+			const got = fieldOf(entry, field);
+			if (want === null ? got !== void 0 : got !== want) return false;
+		}
+	}
+	if (patch.nonBlockingEdit !== void 0) {
+		const e = patch.nonBlockingEdit;
+		if (((returned.nonBlocking ?? []).find((l) => l.mode === e.mode)?.deviceIds.includes(e.deviceId) ?? false) !== e.nonBlocking) return false;
+	}
+	return true;
+}
+//#endregion
 //#region src/notification/sensor-raised.ts
 /**
 * WHICH WAY A BOOLEAN SENSOR MOVED — read off the one slice a sensor event
@@ -70084,8 +70348,13 @@ exports.NATIVE_LEASE_TILE_BUDGET_KEY = NATIVE_LEASE_TILE_BUDGET_KEY;
 exports.NAVIGATION_ACTION_CATALOG = NAVIGATION_ACTION_CATALOG;
 exports.NAVIGATION_LIGHT_LEVEL_MAX = NAVIGATION_LIGHT_LEVEL_MAX;
 exports.NAVIGATION_LIGHT_LEVEL_MIN = NAVIGATION_LIGHT_LEVEL_MIN;
+exports.NC_ALARM_DELAY_FIELDS = NC_ALARM_DELAY_FIELDS;
+exports.NC_ALARM_DELAY_MAX_SEC = NC_ALARM_DELAY_MAX_SEC;
+exports.NC_ALARM_NONBLOCKING_MAX = NC_ALARM_NONBLOCKING_MAX;
 exports.NC_ALARM_OPENING_EVENT_KINDS = NC_ALARM_OPENING_EVENT_KINDS;
+exports.NC_ALARM_SENSORS_MAX = NC_ALARM_SENSORS_MAX;
 exports.NC_ALARM_SYSTEM_EVENT_KINDS = NC_ALARM_SYSTEM_EVENT_KINDS;
+exports.NC_ALARM_TRIGGERED_MAX_SEC = NC_ALARM_TRIGGERED_MAX_SEC;
 exports.NC_AUDIO_CONFIRM_HITS_DEFAULT = NC_AUDIO_CONFIRM_HITS_DEFAULT;
 exports.NC_AUDIO_CONFIRM_HITS_MAX = NC_AUDIO_CONFIRM_HITS_MAX;
 exports.NC_AUDIO_CONFIRM_HITS_MIN = NC_AUDIO_CONFIRM_HITS_MIN;
@@ -70173,6 +70442,13 @@ exports.NavigationRuntimeStateSchema = NavigationRuntimeStateSchema;
 exports.NavigationStatusSchema = NavigationStatusSchema;
 exports.NcAlarmConfigSchema = NcAlarmConfigSchema;
 exports.NcAlarmModeCoverageSchema = NcAlarmModeCoverageSchema;
+exports.NcAlarmModeDelaysEditSchema = NcAlarmModeDelaysEditSchema;
+exports.NcAlarmModeDelaysSchema = NcAlarmModeDelaysSchema;
+exports.NcAlarmNonBlockingEditSchema = NcAlarmNonBlockingEditSchema;
+exports.NcAlarmSensorReadingSchema = NcAlarmSensorReadingSchema;
+exports.NcAlarmSensorStateSchema = NcAlarmSensorStateSchema;
+exports.NcAlarmSensorsInputSchema = NcAlarmSensorsInputSchema;
+exports.NcAlarmSensorsSchema = NcAlarmSensorsSchema;
 exports.NcAlarmSettingsPatchSchema = NcAlarmSettingsPatchSchema;
 exports.NcAlarmSettingsSchema = NcAlarmSettingsSchema;
 exports.NcAlarmSkipReasonSchema = NcAlarmSkipReasonSchema;
@@ -70745,8 +71021,11 @@ exports.addonsCapability = addonsCapability;
 exports.adminUiCapability = require_sleep.adminUiCapability;
 exports.airQualitySensorCapability = airQualitySensorCapability;
 exports.alarmPanelCapability = alarmPanelCapability;
+exports.alarmPatchLanded = alarmPatchLanded;
 exports.alertsCapability = alertsCapability;
 exports.ambientLightSensorCapability = ambientLightSensorCapability;
+exports.applyModeDelaysEdits = applyModeDelaysEdits;
+exports.applyNonBlockingEdit = applyNonBlockingEdit;
 exports.asBoolean = require_sleep.asBoolean;
 exports.asJsonArray = require_sleep.asJsonArray;
 exports.asJsonObject = require_sleep.asJsonObject;
@@ -71215,6 +71494,7 @@ exports.resolveHydratedFieldValue = require_sleep.resolveHydratedFieldValue;
 exports.resolveLocationIcon = resolveLocationIcon;
 exports.resolveLocationMode = resolveLocationMode;
 exports.resolveMethodAuth = resolveMethodAuth;
+exports.resolveModeDelays = resolveModeDelays;
 exports.resolveMutate = resolveMutate;
 exports.resolvePoolMemoryPolicy = resolvePoolMemoryPolicy;
 exports.resolveRecordingProfiles = resolveRecordingProfiles;