@camstack/types 1.2.24 → 1.2.26

package/dist/catalogs/device-state-vocabulary.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Which capability says what a device's STATE is, and how to read it.
+ *
+ * `deviceManager.loadRuntimeState` returns every cap's slice for a device,
+ * keyed by the kebab-case cap name:
+ *
+ *   { 'device-status': { online: true }, switch: { on: true, … } }
+ *
+ * "The state of this device" is not a thing the platform models — a switch has
+ * `on`, a contact has `entryOpen`, an alarm panel has `state`. So the mapping
+ * is a TABLE, declared here, rather than a guess made at read time. An
+ * unmapped cap yields no state, and no state never matches a gate: adding a cap
+ * cannot silently change what an existing rule does.
+ *
+ * ORDER MATTERS. A device usually carries several of these slices (a switch is
+ * also `device-status`), and the first match wins — so the list runs from most
+ * specific to least. `device-status` is deliberately absent: "online" is not a
+ * state a rule should gate on, and having it here would make every device match
+ * the first entry and mask its real one.
+ */
+/** How one capability's slice collapses to a single comparable string. */
+interface StateReader {
+    /** kebab-case cap name, as `loadRuntimeState` keys it. */
+    readonly cap: string;
+    /** Field inside that slice. */
+    readonly field: string;
+    /**
+     * Vocabulary a rule author writes. A boolean field becomes these two words,
+     * in this order — `[whenTrue, whenFalse]`. Absent for a field that is already
+     * a string (the alarm's `state`, the cover's `state`).
+     */
+    readonly booleanWords?: readonly [string, string];
+}
+/**
+ * Most specific first. Extending this list is how a new device kind becomes
+ * gateable; nothing else needs to change.
+ */
+export declare const DEVICE_STATE_READERS: readonly StateReader[];
+/**
+ * Collapse a device's full runtime state to the one string a rule compares
+ * against, or `undefined` when nothing in the table applies.
+ *
+ * `undefined` is the safe answer everywhere: the gate treats it as "does not
+ * match", so a device whose kind we cannot read simply never arms a rule.
+ */
+export declare function readDeviceStateFrom(runtimeState: Readonly<Record<string, unknown>>): string | undefined;
+/**
+ * The states a rule editor can offer for a device, given its runtime state.
+ * Same table, same order — so the picker can never offer a value the gate
+ * would not recognise.
+ */
+export declare function stateVocabularyFor(runtimeState: Readonly<Record<string, unknown>>, alarmStates?: readonly string[]): readonly string[];
+export {};

package/dist/generated/addon-api.d.ts

@@ -4326,6 +4326,27 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof notificationRulesCapability.methods.getHistory.output>;
             meta: object;
         }>;
+        listSnoozes: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof notificationRulesCapability.methods.listSnoozes.input>;
+            output: z.infer<typeof notificationRulesCapability.methods.listSnoozes.output>;
+            meta: object;
+        }>;
+        createSnooze: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof notificationRulesCapability.methods.createSnooze.input>;
+            output: z.infer<typeof notificationRulesCapability.methods.createSnooze.output>;
+            meta: object;
+        }>;
+        cancelSnooze: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof notificationRulesCapability.methods.cancelSnooze.input>;
+            output: z.infer<typeof notificationRulesCapability.methods.cancelSnooze.output>;
+            meta: object;
+        }>;
     }>>;
     notifier: TRPCBuiltRouter<{
         ctx: TrpcContext;

package/dist/generated/device-proxy.d.ts

@@ -49,6 +49,7 @@ import type { motionDetectionCapability } from '../capabilities/motion-detection
 import type { motionTriggerCapability } from '../capabilities/motion-trigger.cap.js';
 import type { motionZonesCapability } from '../capabilities/motion-zones.cap.js';
 import type { nativeObjectDetectionCapability } from '../capabilities/native-object-detection.cap.js';
+import type { notificationRulesCapability } from '../capabilities/notification-rules.cap.js';
 import type { notifierCapability } from '../capabilities/notifier.cap.js';
 import type { numericSensorCapability } from '../capabilities/numeric-sensor.cap.js';
 import type { osdCapability } from '../capabilities/osd.cap.js';
@@ -230,6 +231,7 @@ export interface DeviceProxy {
     readonly motionTrigger?: InferDeviceProxyCap<typeof motionTriggerCapability>;
     readonly motionZones?: InferDeviceProxyCap<typeof motionZonesCapability>;
     readonly nativeObjectDetection?: InferDeviceProxyCap<typeof nativeObjectDetectionCapability>;
+    readonly notificationRules?: InferDeviceProxyCap<typeof notificationRulesCapability>;
     readonly notifier?: InferDeviceProxyCap<typeof notifierCapability>;
     readonly numericSensor?: InferDeviceProxyCap<typeof numericSensorCapability>;
     readonly osd?: InferDeviceProxyCap<typeof osdCapability>;

package/dist/generated/method-access-map.d.ts

@@ -6,7 +6,7 @@
  * scope+access check inside `protectedProcedure` (see
  * `server/backend/src/api/trpc/trpc.middleware.ts`).
  *
- * Coverage: 841 method paths across 118 capabilities.
+ * Coverage: 844 method paths across 118 capabilities.
  */
 import type { CapabilityMethodAccess } from '../capabilities/capability-definition.js';
 export interface MethodAccessRecord {

package/dist/generated/system-proxy.d.ts

@@ -26,7 +26,6 @@ import type { networkAccessCapability } from '../capabilities/network-access.cap
 import type { networkQualityCapability } from '../capabilities/network-quality.cap.js';
 import type { nodesCapability } from '../capabilities/nodes.cap.js';
 import type { notificationOutputCapability } from '../capabilities/notification-output.cap.js';
-import type { notificationRulesCapability } from '../capabilities/notification-rules.cap.js';
 import type { pipelineExecutorCapability } from '../capabilities/pipeline-executor.cap.js';
 import type { pipelineOrchestratorCapability } from '../capabilities/pipeline-orchestrator.cap.js';
 import type { pipelineRunnerCapability } from '../capabilities/pipeline-runner.cap.js';
@@ -77,7 +76,6 @@ export interface SystemProxy {
     readonly networkQuality: Pick<InferProvider<typeof networkQualityCapability>, 'getAllStats'>;
     readonly nodes: Pick<InferProvider<typeof nodesCapability>, 'topology' | 'deployAddon' | 'undeployAddon' | 'restartAddon' | 'restartProcess' | 'restartNode' | 'shutdownNode' | 'renameNode' | 'clusterAddonStatus' | 'getCapUsageGraph' | 'getNodeAddons' | 'setProcessLogLevel' | 'executeQuery'>;
     readonly notificationOutput: Pick<InferProvider<typeof notificationOutputCapability>, 'listTargetKinds' | 'listTargets' | 'discoverTargets' | 'send' | 'testTarget' | 'upsertTarget' | 'deleteTarget' | 'setTargetEnabled'>;
-    readonly notificationRules: Pick<InferProvider<typeof notificationRulesCapability>, 'listRules' | 'getRule' | 'createRule' | 'updateRule' | 'deleteRule' | 'setRuleEnabled' | 'testRule' | 'getConditionCatalog' | 'getHistory'>;
     readonly pipelineExecutor: Pick<InferProvider<typeof pipelineExecutorCapability>, 'getAvailableEngines' | 'getSelectedEngine' | 'getDefaultSteps' | 'getEngineProvisioning' | 'getVideoPipelineSteps' | 'setVideoPipelineSteps' | 'clearDeviceOverrides' | 'getSchema' | 'getGlobalSteps' | 'getGlobalPipelineConfig' | 'getOrchestratorConfigSchema' | 'validatePipeline' | 'listTemplates' | 'saveTemplate' | 'updateTemplate' | 'deleteTemplate' | 'getCapabilities' | 'getAddonModels' | 'downloadModel' | 'deleteModel' | 'cacheFrameInPool' | 'inferCached' | 'uncacheFrame' | 'getEffectiveTuning' | 'listLoadedEngines' | 'spinEngine' | 'killEngine' | 'listReferenceImages' | 'getReferenceImage' | 'getReferenceAudioFiles' | 'getReferenceAudio' | 'getAudioCapabilities' | 'runAudioTest' | 'getDetectionConfigSchema'>;
     readonly pipelineOrchestrator: Pick<InferProvider<typeof pipelineOrchestratorCapability>, 'rebalance' | 'getPipelineAssignments' | 'getAgentLoad' | 'getGlobalMetrics' | 'getCapabilityBindings' | 'setCapabilityBinding' | 'getIngestOwner' | 'getAudioNodeLoad' | 'getAgentSettings' | 'listAgentSettings' | 'removeAgentSettings' | 'setAgentMaxCameras' | 'setAgentDetectWeight' | 'setAgentCapabilities' | 'setAgentReachableHost' | 'setAgentInferenceDevices' | 'getNodeInferenceDevices' | 'resetNodePipelineDefaults' | 'getCameraStatuses' | 'listTemplates' | 'saveTemplate' | 'updateTemplate' | 'deleteTemplate'>;
     readonly pipelineRunner: Pick<InferProvider<typeof pipelineRunnerCapability>, 'attachCamera' | 'reportMotion' | 'getLocalLoad' | 'getLocalMetrics' | 'getAllCameraMetrics' | 'getLocalCameras' | 'getNativeCrop'>;

package/dist/index.d.ts

@@ -121,6 +121,7 @@ export { COCO_80_LABELS, COCO_TO_MACRO, MACRO_LABELS, } from './catalogs/coco-cl
 export { AUDIO_MACRO_LABELS, YAMNET_TO_MACRO, APPLE_SA_TO_MACRO, mapAudioLabelToMacro, getAudioMacroClassIds, } from './catalogs/audio-classmap.js';
 export { EVENT_TAXONOMY, TAXONOMY_COLORS, DEFAULT_EVENT_COLOR, getTaxonomyEntry, colorForKind, subKindsOf, type EventTaxonomyEntry, type EventTaxonomyCategory, type EventTaxonomyLevel, } from './catalogs/event-taxonomy.js';
 export { NcTaxonomyEntrySchema, NcTaxonomySchema, buildNcTaxonomy, NC_TAXONOMY, type NcTaxonomyEntry, type NcTaxonomy, } from './catalogs/nc-taxonomy.js';
+export { DEVICE_STATE_READERS, readDeviceStateFrom, stateVocabularyFor, } from './catalogs/device-state-vocabulary.js';
 export type { CameraMotionConfig, CameraNativeDetectionConfig, CameraDetectionCapabilities, } from './types/camera-detection.js';
 export { type DeviceTypeInfo, DEVICE_TYPE_INFO } from './types/device-type.js';
 export type { DeviceBinding, DeviceBindingEntry } from './device/device-binding.js';

package/dist/index.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-CI7DYokZ.js");
+const require_sleep = require("./sleep-BvSjpsfC.js");
 const require_event_category = require("./event-category-BE4PDZ_3.js");
 const require_enums = require("./enums.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
@@ -2973,6 +2973,78 @@ function buildNcTaxonomy() {
 /** The frozen NC taxonomy, derived once from the taxonomy dictionary. */
 var NC_TAXONOMY = Object.freeze(buildNcTaxonomy());
 //#endregion
+//#region src/catalogs/device-state-vocabulary.ts
+/**
+* Most specific first. Extending this list is how a new device kind becomes
+* gateable; nothing else needs to change.
+*/
+var DEVICE_STATE_READERS = [
+	{
+		cap: "alarm-panel",
+		field: "state"
+	},
+	{
+		cap: "cover",
+		field: "state"
+	},
+	{
+		cap: "presence",
+		field: "state"
+	},
+	{
+		cap: "lock",
+		field: "locked",
+		booleanWords: ["locked", "unlocked"]
+	},
+	{
+		cap: "contact",
+		field: "entryOpen",
+		booleanWords: ["open", "closed"]
+	},
+	{
+		cap: "switch",
+		field: "on",
+		booleanWords: ["on", "off"]
+	},
+	{
+		cap: "binary",
+		field: "on",
+		booleanWords: ["on", "off"]
+	}
+];
+/**
+* Collapse a device's full runtime state to the one string a rule compares
+* against, or `undefined` when nothing in the table applies.
+*
+* `undefined` is the safe answer everywhere: the gate treats it as "does not
+* match", so a device whose kind we cannot read simply never arms a rule.
+*/
+function readDeviceStateFrom(runtimeState) {
+	for (const reader of DEVICE_STATE_READERS) {
+		const slice = runtimeState[reader.cap];
+		if (slice === null || typeof slice !== "object") continue;
+		const value = slice[reader.field];
+		if (typeof value === "string" && value.length > 0) return value;
+		if (typeof value === "boolean" && reader.booleanWords !== void 0) return value ? reader.booleanWords[0] : reader.booleanWords[1];
+	}
+}
+/**
+* The states a rule editor can offer for a device, given its runtime state.
+* Same table, same order — so the picker can never offer a value the gate
+* would not recognise.
+*/
+function stateVocabularyFor(runtimeState, alarmStates = []) {
+	for (const reader of DEVICE_STATE_READERS) {
+		const slice = runtimeState[reader.cap];
+		if (slice === null || typeof slice !== "object") continue;
+		if (reader.booleanWords !== void 0) return [...reader.booleanWords];
+		if (reader.cap === "alarm-panel") return [...alarmStates];
+		const current = slice[reader.field];
+		return typeof current === "string" ? [current] : [];
+	}
+	return [];
+}
+//#endregion
 //#region src/types/device-type.ts
 var DEVICE_TYPE_INFO = { ["camera"]: {
 	type: "camera",
@@ -4784,7 +4856,24 @@ var NcZoneConditionSchema = zod.z.object({
 * The P1 condition set — a flat AND of groups; absent group = pass;
 * membership lists are OR within the list (spec §2.3).
 */
+/**
+* "This rule applies only while `deviceId` is in one of `states`."
+*
+* The states are the DEVICE's own vocabulary — `AlarmState` for a panel,
+* `on`/`off` for a switch — not a normalised set, because normalising would
+* make the condition lie about devices whose states have no equivalent.
+*
+* An unreadable state does NOT match: see the engine's fail-closed gate. A
+* condition that fired on "I could not read it" would be worse than no gate.
+*/
+var NcDeviceStateConditionSchema = zod.z.object({
+	deviceId: zod.z.number().int(),
+	/** Any of these matches. */
+	states: zod.z.array(zod.z.string().min(1)).min(1)
+});
 var NcConditionsSchema = zod.z.object({
+	/** Gate on ANOTHER device's current state (the alarm armed, a switch on). */
+	deviceState: NcDeviceStateConditionSchema.optional(),
 	/** Device scope — absent = all devices. */
 	devices: zod.z.array(zod.z.number()).optional(),
 	/** Detector class names (any overlap with the record's class set). */
@@ -4985,6 +5074,14 @@ var NcMediaPolicySchema = zod.z.object({
 	clipPreRollSec: zod.z.number().int().min(0).max(30).optional(),
 	clipPostRollSec: zod.z.number().int().min(0).max(30).optional(),
 	/**
+	* Playback rate of the attached gif / clip. Absent = 2x.
+	*
+	* A notification clip is GLANCED at on a lock screen, not watched: at real
+	* time an eight-second passage is eight seconds of the recipient's attention
+	* and twice the bytes. 1 is real time for the operator who wants it.
+	*/
+	clipSpeed: zod.z.number().min(1).max(8).optional(),
+	/**
 	* Which stream profile the footage is cut from. Absent = the CHEAPEST
 	* assigned profile: a notification is watched on a phone, so the 4K
 	* rendition would burn CPU to produce a file the client downscales anyway.
@@ -5056,7 +5153,21 @@ var NcRuleInputSchema = zod.z.object({
 	* behaviour, visible to all, read-only in the viewer). Present = personal
 	* rule owned by this userId. Server-stamped; never trusted from a client.
 	*/
-	ownerUserId: zod.z.string().optional()
+	ownerUserId: zod.z.string().optional(),
+	/**
+	* May a non-admin snooze this rule for EVERYONE, not just themselves?
+	*
+	* A snooze is personal by default — it silences the person who set it. This
+	* opts THIS rule into the "the gardener is here all afternoon" case, where
+	* silencing the camera for the whole household is legitimate. It silences
+	* other people, so it is off unless a rule deliberately allows it.
+	*
+	* `.optional()`, deliberately NOT `.default()`: a Zod default does not run on
+	* the addon cap path (three production failures in one day), so absent is
+	* read as `false` by {@link canSetGlobal} in the engine. Admins are not bound
+	* by this flag — see the scope rules on that function.
+	*/
+	snoozeAllowGlobal: zod.z.boolean().optional()
 });
 /**
 * Partial patch for `updateRule` — any subset of the input fields, plus the
@@ -5127,7 +5238,8 @@ var NcConditionDescriptorSchema = zod.z.object({
 		"packagePhase",
 		"crossingSelect",
 		"polygonDraw",
-		"occupancy"
+		"occupancy",
+		"deviceState"
 	]),
 	operator: zod.z.enum([
 		"in",
@@ -5141,7 +5253,28 @@ var NcConditionDescriptorSchema = zod.z.object({
 	/** Which delivery kinds the condition applies to. */
 	appliesTo: zod.z.array(NcDeliverySchema),
 	phase: zod.z.string(),
-	description: zod.z.string().optional()
+	description: zod.z.string().optional(),
+	/**
+	* The CHOICES for a single-choice widget (`sourceSelect`, `crossingSelect`,
+	* `packagePhase`, …), served with the descriptor.
+	*
+	* Before this the descriptor said which widget to render and not what to put
+	* in it, so every option list lived in three places: this file's enums, the
+	* admin's `NC_*_OPTIONS` and the viewer's `NC_*_VALUES`. That triple mirror
+	* is the drift that emptied the viewer's rule editor on 2026-08-04 — the app
+	* mirrors the cap by hand, so it is only ever as current as its last build.
+	*
+	* With the options on the wire, a condition of an EXISTING `valueType` costs
+	* zero client changes. Clients keep a local fallback for an older hub that
+	* does not send them; absent here is "use your own list", not "no choices".
+	*/
+	options: zod.z.array(zod.z.object({
+		/** Written to the rule verbatim. `''` means the ABSENT state. */
+		value: zod.z.string(),
+		label: zod.z.string(),
+		/** What THIS choice matches — shown one at a time, under the control. */
+		hint: zod.z.string().optional()
+	})).readonly().optional()
 });
 /**
 * The P1 condition surface as data — served by `getConditionCatalog` so
@@ -5235,6 +5368,28 @@ var NC_CONDITION_CATALOG = [
 		group: "zones",
 		label: "Zone crossing",
 		valueType: "crossingSelect",
+		options: [
+			{
+				value: "",
+				label: "Not set — entering",
+				hint: "Entries, and every detection that is not a crossing at all. Exits are excluded. This is what a rule without a crossing condition already does, and choosing it writes nothing to the rule."
+			},
+			{
+				value: "enter",
+				label: "Entered a zone",
+				hint: "The same matches as \"not set\", stated explicitly: entries and non-crossing detections pass, exits do not."
+			},
+			{
+				value: "exit",
+				label: "Left a zone",
+				hint: "ONLY an exit crossing. A detection that is not a crossing fails, so this rule cannot fire on ordinary movement — pair it with the zones the subject must have left. Also matches a tripwire crossed against its drawn direction."
+			},
+			{
+				value: "any",
+				label: "Entered or left",
+				hint: "No direction filter: entries, exits and non-crossing detections alike. This is the only choice that adds exits to what the rule already matched."
+			}
+		],
 		operator: "in",
 		appliesTo: ["immediate"],
 		phase: "P1",
@@ -5315,6 +5470,24 @@ var NC_CONDITION_CATALOG = [
 		group: "scope",
 		label: "Detection source",
 		valueType: "sourceSelect",
+		options: [
+			{
+				value: "any",
+				label: "Any source"
+			},
+			{
+				value: "pipeline",
+				label: "Pipeline"
+			},
+			{
+				value: "onboard",
+				label: "Onboard (camera)"
+			},
+			{
+				value: "sensor",
+				label: "Sensor"
+			}
+		],
 		operator: "in",
 		appliesTo: [
 			"immediate",
@@ -5325,6 +5498,21 @@ var NC_CONDITION_CATALOG = [
 		phase: "P1",
 		description: "pipeline / onboard / sensor; a record with no stamped source counts as pipeline."
 	},
+	{
+		id: "deviceState",
+		group: "scope",
+		label: "Device state",
+		valueType: "deviceState",
+		operator: "in",
+		appliesTo: [
+			"immediate",
+			"track-end",
+			"device-event",
+			"package-event"
+		],
+		phase: "P2",
+		description: "Only fire while another device is in one of the chosen states — the alarm armed, a switch on, a contact closed. A state that cannot be read does NOT fire."
+	},
 	{
 		id: "sensorKinds",
 		group: "device",
@@ -5350,6 +5538,20 @@ var NC_CONDITION_CATALOG = [
 		group: "package",
 		label: "Package phase",
 		valueType: "packagePhase",
+		options: [
+			{
+				value: "delivered",
+				label: "Delivered"
+			},
+			{
+				value: "picked-up",
+				label: "Picked up"
+			},
+			{
+				value: "both",
+				label: "Both"
+			}
+		],
 		operator: "in",
 		appliesTo: ["package-event"],
 		phase: "P1",
@@ -5481,6 +5683,78 @@ var NcHistoryFilterSchema = zod.z.object({
 	until: zod.z.number().optional(),
 	limit: zod.z.number().int().min(1).max(500).default(100)
 });
+/**
+* What a snooze covers. Broader scopes win when several overlap, so one window
+* leaves ONE digest rather than a rule snooze and a whole-feed snooze both
+* summarising the same silence.
+*/
+var NcSnoozeScopeSchema = zod.z.enum([
+	"rule",
+	"device",
+	"all"
+]);
+/** Hard ceiling on a window (24h). A snooze that could not expire would be an
+*  outage the operator asked for once and forgot. */
+var NC_SNOOZE_MAX_MINUTES = 1440;
+/**
+* Client-authored snooze. The server stamps `userId`, `startedAt` and
+* `expiresAt` — a DURATION is sent rather than an instant so a client with a
+* skewed clock cannot author a window that is already over, or never ends.
+*/
+var NcSnoozeInputSchema = zod.z.object({
+	scope: NcSnoozeScopeSchema,
+	/** Required when `scope: 'rule'` — a scoped snooze with no id matches
+	*  NOTHING rather than degrading to "everything". */
+	ruleId: zod.z.string().optional(),
+	/** Required when `scope: 'device'`. */
+	deviceId: zod.z.number().int().optional(),
+	durationMinutes: zod.z.number().int().min(1).max(NC_SNOOZE_MAX_MINUTES),
+	/**
+	* Silence this for EVERY recipient, not just the caller. Permission is
+	* checked server-side (the rule's `snoozeAllowGlobal`, or admin for the
+	* broader scopes). Absent = personal.
+	*/
+	global: zod.z.boolean().optional(),
+	/**
+	* Deliver a summary of what was suppressed when the window ends. Absent =
+	* ON: someone silencing a nuisance camera wants it off, someone silencing a
+	* SECURITY camera wants to know what they missed, and choosing "off" for
+	* everybody is how a snooze becomes an outage. Resolved to a concrete
+	* boolean by the server at create time — never left to a Zod default, which
+	* does not run on the addon cap path.
+	*/
+	summary: zod.z.boolean().optional()
+});
+/** A persisted snooze window. */
+var NcSnoozeSchema = zod.z.object({
+	id: zod.z.string(),
+	/** Who set it. Also who it silences, unless `global`. */
+	userId: zod.z.string(),
+	scope: NcSnoozeScopeSchema,
+	ruleId: zod.z.string().optional(),
+	deviceId: zod.z.number().int().optional(),
+	startedAt: zod.z.number(),
+	/** Exclusive: at exactly this instant the snooze is over. Expiry is a
+	*  COMPARISON, not a job — no sweeper can leave the operator silenced. */
+	expiresAt: zod.z.number(),
+	global: zod.z.boolean(),
+	summary: zod.z.boolean(),
+	/** When the end-of-window digest went out. Absent = not sent (yet, or the
+	*  window has not closed, or `summary` is false). */
+	digestSentAt: zod.z.number().optional()
+});
+/** One line of an end-of-window digest: what one rule hid on one camera. */
+var NcSnoozeSuppressedSchema = zod.z.object({
+	snoozeId: zod.z.string(),
+	targetId: zod.z.string(),
+	ruleId: zod.z.string(),
+	ruleName: zod.z.string(),
+	deviceId: zod.z.number().int(),
+	/** How many notifications this snooze hid for that pair. */
+	count: zod.z.number().int(),
+	firstAt: zod.z.number(),
+	lastAt: zod.z.number()
+});
 var notificationRulesCapability = {
 	name: "notification-rules",
 	scope: "system",
@@ -5547,7 +5821,36 @@ var notificationRulesCapability = {
 		* P1 (no user dimension); the P2 viewer History screen adds per-caller
 		* scoping on the same method.
 		*/
-		getHistory: require_sleep.method(zod.z.object({ filter: NcHistoryFilterSchema.default({ limit: 100 }) }), zod.z.object({ entries: zod.z.array(NcHistoryEntrySchema) }), { auth: "admin" })
+		getHistory: require_sleep.method(zod.z.object({ filter: NcHistoryFilterSchema.default({ limit: 100 }) }), zod.z.object({ entries: zod.z.array(NcHistoryEntrySchema) }), { auth: "admin" }),
+		/**
+		* Snooze windows currently in effect, plus any whose digest has not yet
+		* gone out. `caller: 'required'`: a user sees their OWN windows and the
+		* global ones that silence them, never another person's private silence.
+		* An admin sees every window — a household-wide silence is exactly the
+		* thing an operator has to be able to find and cancel.
+		*/
+		listSnoozes: require_sleep.method(zod.z.object({}), zod.z.object({ snoozes: zod.z.array(NcSnoozeSchema) }), { caller: "required" }),
+		/**
+		* Open a window. `userId` is stamped from the caller; a GLOBAL window is
+		* permission-checked server-side (the rule's `snoozeAllowGlobal` for a
+		* rule-scoped one, admin for a camera or the whole feed) — a client asking
+		* for one it may not have is rejected, never silently downgraded, because
+		* a snooze the operator believes is in effect and is not is the same
+		* failure as one they cannot end.
+		*/
+		createSnooze: require_sleep.method(zod.z.object({ snooze: NcSnoozeInputSchema }), zod.z.object({ snooze: NcSnoozeSchema }), {
+			kind: "mutation",
+			caller: "required"
+		}),
+		/**
+		* End a window NOW. The digest still goes out (what was hidden while it
+		* was open is still what the operator missed); only the silence stops.
+		* A user may cancel their own; an admin may cancel any.
+		*/
+		cancelSnooze: require_sleep.method(zod.z.object({ snoozeId: zod.z.string() }), zod.z.object({ success: zod.z.literal(true) }), {
+			kind: "mutation",
+			caller: "required"
+		})
 	}
 };
 //#endregion
@@ -6656,7 +6959,15 @@ var streamBrokerCapability = {
 			format: zod.z.enum(["gif", "mp4"]).default("gif"),
 			maxWidth: zod.z.number().int().min(120).max(1920).default(480),
 			/** GIF only — MP4 keeps the source cadence. */
-			fps: zod.z.number().int().min(1).max(15).default(5)
+			fps: zod.z.number().int().min(1).max(15).default(5),
+			/**
+			* Playback rate. A notification clip is GLANCED at on a lock screen,
+			* not watched, so 2x is the default: the recipient sees the whole
+			* passage in half the time and the GIF is half the bytes. `1` is real
+			* time. Applies to MP4 as well — the operator set a speed, not a GIF
+			* speed.
+			*/
+			speed: zod.z.number().min(1).max(8).default(2)
 		}), zod.z.object({
 			base64: zod.z.string(),
 			mime: zod.z.string(),
@@ -14796,17 +15107,6 @@ function createSystemProxy(api) {
 			deleteTarget: (input) => dispatch("notificationOutput", "deleteTarget", "mutation", input),
 			setTargetEnabled: (input) => dispatch("notificationOutput", "setTargetEnabled", "mutation", input)
 		},
-		notificationRules: {
-			listRules: (input) => dispatch("notificationRules", "listRules", "query", input),
-			getRule: (input) => dispatch("notificationRules", "getRule", "query", input),
-			createRule: (input) => dispatch("notificationRules", "createRule", "mutation", input),
-			updateRule: (input) => dispatch("notificationRules", "updateRule", "mutation", input),
-			deleteRule: (input) => dispatch("notificationRules", "deleteRule", "mutation", input),
-			setRuleEnabled: (input) => dispatch("notificationRules", "setRuleEnabled", "mutation", input),
-			testRule: (input) => dispatch("notificationRules", "testRule", "mutation", input),
-			getConditionCatalog: (input) => dispatch("notificationRules", "getConditionCatalog", "query", input),
-			getHistory: (input) => dispatch("notificationRules", "getHistory", "query", input)
-		},
 		pipelineExecutor: {
 			getAvailableEngines: (input) => dispatch("pipelineExecutor", "getAvailableEngines", "query", input),
 			getSelectedEngine: (input) => dispatch("pipelineExecutor", "getSelectedEngine", "query", input),
@@ -30706,12 +31006,24 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"notificationRules.cancelSnooze": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"notificationRules.createRule": {
 		capName: "notification-rules",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"notificationRules.createSnooze": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"notificationRules.deleteRule": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -30742,6 +31054,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"notificationRules.listSnoozes": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"notificationRules.setRuleEnabled": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -34072,6 +34390,7 @@ exports.DEVICE_BACKEND_TO_FORMAT = DEVICE_BACKEND_TO_FORMAT;
 exports.DEVICE_CAP_NAMES = DEVICE_CAP_NAMES;
 exports.DEVICE_PROFILES = DEVICE_PROFILES;
 exports.DEVICE_SETTINGS_CONTRIBUTION_METHODS = require_sleep.DEVICE_SETTINGS_CONTRIBUTION_METHODS;
+exports.DEVICE_STATE_READERS = DEVICE_STATE_READERS;
 exports.DEVICE_STATUS_METHOD = require_sleep.DEVICE_STATUS_METHOD;
 exports.DEVICE_TYPE_CONTROL_KIND = DEVICE_TYPE_CONTROL_KIND;
 exports.DEVICE_TYPE_INFO = DEVICE_TYPE_INFO;
@@ -34270,6 +34589,7 @@ exports.NC_CONDITION_CATALOG = NC_CONDITION_CATALOG;
 exports.NC_HISTORY_LIMIT_DEFAULT = NC_HISTORY_LIMIT_DEFAULT;
 exports.NC_HISTORY_LIMIT_MAX = NC_HISTORY_LIMIT_MAX;
 exports.NC_MAX_PER_TRACK_IMMEDIATE = NC_MAX_PER_TRACK_IMMEDIATE;
+exports.NC_SNOOZE_MAX_MINUTES = NC_SNOOZE_MAX_MINUTES;
 exports.NC_TAXONOMY = NC_TAXONOMY;
 exports.NativeCropBboxSchema = NativeCropBboxSchema;
 exports.NativeCropRefSchema = NativeCropRefSchema;
@@ -34282,6 +34602,7 @@ exports.NcConditionDescriptorSchema = NcConditionDescriptorSchema;
 exports.NcConditionsSchema = NcConditionsSchema;
 exports.NcCrossingSchema = NcCrossingSchema;
 exports.NcDeliverySchema = NcDeliverySchema;
+exports.NcDeviceStateConditionSchema = NcDeviceStateConditionSchema;
 exports.NcHistoryEntrySchema = NcHistoryEntrySchema;
 exports.NcHistoryFilterSchema = NcHistoryFilterSchema;
 exports.NcHistoryRecordKindSchema = NcHistoryRecordKindSchema;
@@ -34297,6 +34618,10 @@ exports.NcRuleSchema = NcRuleSchema;
 exports.NcRuleTargetSchema = NcRuleTargetSchema;
 exports.NcScheduleSchema = NcScheduleSchema;
 exports.NcScheduleWindowSchema = NcScheduleWindowSchema;
+exports.NcSnoozeInputSchema = NcSnoozeInputSchema;
+exports.NcSnoozeSchema = NcSnoozeSchema;
+exports.NcSnoozeScopeSchema = NcSnoozeScopeSchema;
+exports.NcSnoozeSuppressedSchema = NcSnoozeSuppressedSchema;
 exports.NcTaxonomyEntrySchema = NcTaxonomyEntrySchema;
 exports.NcTaxonomySchema = NcTaxonomySchema;
 exports.NcTestResultSchema = NcTestResultSchema;
@@ -34783,6 +35108,7 @@ exports.procedureAuthKey = procedureAuthKey;
 exports.ptzAutotrackCapability = ptzAutotrackCapability;
 exports.ptzCapability = ptzCapability;
 exports.pythonScriptForBackend = pythonScriptForBackend;
+exports.readDeviceStateFrom = readDeviceStateFrom;
 exports.readNodePin = require_sleep.readNodePin;
 exports.readinessKey = require_sleep.readinessKey;
 exports.rebootCapability = rebootCapability;
@@ -34822,6 +35148,7 @@ exports.smtpProviderCapability = smtpProviderCapability;
 exports.snapshotCapability = snapshotCapability;
 exports.ssoBridgeCapability = ssoBridgeCapability;
 exports.startReachabilityPoll = startReachabilityPoll;
+exports.stateVocabularyFor = stateVocabularyFor;
 exports.storageCapability = storageCapability;
 exports.storageEvictableCapability = storageEvictableCapability;
 exports.storageProviderCapability = storageProviderCapability;