@camstack/types 1.2.253 → 1.2.255

package/dist/index.js

@@ -13866,11 +13866,22 @@ var LlmGenerateOkSchema = zod.z.object({
 	truncated: zod.z.boolean(),
 	latencyMs: zod.z.number()
 });
+/**
+* WHO refused, on a `refusal`. `guardrail` = a safety filter in front of the
+* model rejected the request before it answered (Apple Foundation Models
+* refuses surveillance-framed prompts in 0.1 s); `model` = the model itself
+* declined. They are different faults: a guardrail refusal is a property of
+* the BACKEND, so the provider falls back to the next profile; a model refusal
+* is an answer. Absent on every other code, and on a refusal a wire cannot
+* attribute.
+*/
+var LlmRefusalSourceSchema = zod.z.enum(["guardrail", "model"]);
 var LlmGenerateErrSchema = zod.z.object({
 	ok: zod.z.literal(false),
 	code: LlmErrorCodeSchema,
 	message: zod.z.string(),
-	retryAfterMs: zod.z.number().optional()
+	retryAfterMs: zod.z.number().optional(),
+	refusalSource: LlmRefusalSourceSchema.optional()
 });
 var LlmGenerateResultSchema = zod.z.discriminatedUnion("ok", [LlmGenerateOkSchema, LlmGenerateErrSchema]);
 /**
@@ -14127,6 +14138,71 @@ var LlmRuntimeCompleteInputSchema = LlmGenerateBaseInputSchema.extend({
 	/** The managed profile's timeout, threaded by the hub provider. */
 	timeoutMs: zod.z.number().int().positive().optional()
 });
+/**
+* Why Apple Foundation Models cannot run on a node that has it in principle.
+* The first three are Apple's own `UnavailableReason`s, verbatim; the rest are
+* ours: the OS predates the framework (macOS < 26), the helper binary is not
+* in the installed addon, or it crashed past the respawn bound.
+*/
+var AppleFmUnavailableReasonSchema = zod.z.enum([
+	"deviceNotEligible",
+	"appleIntelligenceNotEnabled",
+	"modelNotReady",
+	"osTooOld",
+	"helperMissing",
+	"helperCrashed"
+]);
+/**
+* Apple Foundation Models on ONE node — four states, never a boolean (D315).
+*
+*   - `available`            — the helper probed it; what it CAN do is reported
+*                              here (`imageInput`, `contextSize`, languages),
+*                              never typed by an operator.
+*   - `unavailable`          — a known absence, with the reason to act on.
+*   - `unsupported-platform` — not a Mac; there is nothing to enable.
+*   - `unknown`              — the probe did not answer (not yet run, timed
+*                              out, helper crashed mid-probe). A failed
+*                              measurement is NEVER `unavailable` (D393).
+*/
+var AppleFmAvailabilitySchema = zod.z.discriminatedUnion("state", [
+	zod.z.object({
+		state: zod.z.literal("available"),
+		osVersion: zod.z.string(),
+		/** Tokens, as the framework reports it. Read at runtime, never assumed. */
+		contextSize: zod.z.number().int().positive(),
+		/** BCP-47-ish tags (`it-IT`) of the languages the model supports. */
+		languages: zod.z.array(zod.z.string()),
+		/** Whether prompts may carry images. `false` on a macOS 26 build. */
+		imageInput: zod.z.boolean()
+	}),
+	zod.z.object({
+		state: zod.z.literal("unavailable"),
+		reason: AppleFmUnavailableReasonSchema,
+		osVersion: zod.z.string().nullable(),
+		detail: zod.z.string()
+	}),
+	zod.z.object({
+		state: zod.z.literal("unsupported-platform"),
+		platform: zod.z.string()
+	}),
+	zod.z.object({
+		state: zod.z.literal("unknown"),
+		error: zod.z.string()
+	})
+]);
+/**
+* A generation on the node's Apple Foundation Models helper. A separate verb
+* from `complete`, whose `runtime` is a llama.cpp config: overloading it would
+* drag a GGUF model reference into a backend that has none. `images` is part
+* of the contract so vision needs no cap change later; a node whose model has
+* no image input REFUSES them (`unavailable`), never drops them.
+*/
+var LlmRuntimeAppleCompleteInputSchema = LlmGenerateBaseInputSchema.extend({
+	images: zod.z.array(LlmImageSchema).optional(),
+	/** The profile's timeout, threaded by the hub provider. */
+	timeoutMs: zod.z.number().int().positive().optional()
+});
+var LlmRuntimeCancelInputSchema = zod.z.object({ requestId: zod.z.string() });
 var llmRuntimeCapability = {
 	name: "llm-runtime",
 	scope: "system",
@@ -14171,7 +14247,28 @@ var llmRuntimeCapability = {
 			auth: "admin"
 		}),
 		listLocalModels: require_sleep.method(zod.z.object({}), zod.z.array(LlmNodeModelSchema), { auth: "admin" }),
-		getDiskUsage: require_sleep.method(zod.z.object({}), LlmRuntimeDiskUsageSchema, { auth: "admin" })
+		getDiskUsage: require_sleep.method(zod.z.object({}), LlmRuntimeDiskUsageSchema, { auth: "admin" }),
+		/**
+		* Stop a node-side generation started with a `requestId` — `complete` or
+		* `completeApple`. The hub's `llm.cancel` forwards here with the same
+		* nodePin the generation took; before this existed a cancelled
+		* managed-local generation kept running on the node to its own timeout.
+		* Idempotent: an unknown or finished id is a no-op.
+		*/
+		cancel: require_sleep.method(LlmRuntimeCancelInputSchema, zod.z.void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* This node's Apple Foundation Models state, answered from a mirror the
+		* node refreshes in the background — it never waits on a probe.
+		*/
+		appleAvailability: require_sleep.method(zod.z.object({}), AppleFmAvailabilitySchema, { auth: "admin" }),
+		completeApple: require_sleep.method(LlmRuntimeAppleCompleteInputSchema, LlmGenerateResultSchema, {
+			kind: "mutation",
+			auth: "admin",
+			timeoutMs: AI_CAP_TRANSPORT_TIMEOUT_MS
+		})
 	}
 };
 //#endregion
@@ -14192,7 +14289,8 @@ var LlmProfileKindSchema = zod.z.enum([
 	"openai",
 	"anthropic",
 	"google",
-	"managed-local"
+	"managed-local",
+	"apple-foundation"
 ]);
 var LlmProfileSchema = zod.z.object({
 	id: zod.z.string(),
@@ -14250,7 +14348,14 @@ var LlmProfileSchema = zod.z.object({
 	toolsEnabled: zod.z.boolean().default(false),
 	extraHeaders: zod.z.record(zod.z.string(), zod.z.string()).optional(),
 	/** kind === 'managed-local' only (spec §4). */
-	runtime: ManagedRuntimeConfigSchema.optional()
+	runtime: ManagedRuntimeConfigSchema.optional(),
+	/**
+	* kind === 'apple-foundation' only: WHERE it runs — the only thing there is
+	* to configure (no key, no URL, no download; `model` is `apple-system`).
+	* `supportsVision` on such a row is stamped by the provider from the node's
+	* reported `imageInput`, never taken from the operator (D62).
+	*/
+	appleFoundation: zod.z.object({ nodeId: zod.z.string() }).optional()
 });
 /** ConfigUISchema tree passed through untyped on the wire (the
 *  notification-output `ConfigSchemaPassthrough` precedent at
@@ -14332,7 +14437,9 @@ var LlmRuntimeNodeSchema = zod.z.object({
 	reachable: zod.z.boolean(),
 	status: LlmRuntimeStatusSchema.optional(),
 	disk: LlmRuntimeDiskUsageSchema.optional(),
-	error: zod.z.string().optional()
+	error: zod.z.string().optional(),
+	/** Absent = the node did not answer the question (render as unknown). */
+	apple: AppleFmAvailabilitySchema.optional()
 });
 var GenerateVisionInputSchema = LlmGenerateBaseInputSchema.extend({ images: zod.z.array(LlmImageSchema).min(1) });
 var ProfileRefInputSchema = zod.z.object({
@@ -18221,9 +18328,29 @@ var NcTestResultSchema = zod.z.object({
 	className: zod.z.string().optional(),
 	label: zod.z.string().optional()
 });
-/** The five rule kinds, as data. `NcRuleKind` in `notification/rule-kinds.ts`
-*  is the same union; the template-vars spec pins the two together. */
+/** The rule kinds, as data. `NcRuleKind` in `notification/rule-kinds.ts` is the
+*  same union; the template-vars spec pins the two together. `mixed` is DERIVED
+*  (a stored system rule whose kinds span families, D637) and never authored. */
 var NcRuleKindSchema = zod.z.enum([
+	"detection",
+	"sensor",
+	"occupancy",
+	"sound",
+	"device-events",
+	"system",
+	"alarm",
+	"mixed"
+]);
+/**
+* The kinds a SERVED template-variable descriptor may name: the five that
+* existed before D637, frozen. `getTemplateCatalog` ships `kinds` to every
+* installed viewer, and a viewer at `@camstack/types` 1.2.25x parses them with a
+* strict five-member enum — one `device-events` in one descriptor fails the
+* whole catalog parse. So the WIRE says `system`, and the MATCH widens it:
+* `templateVarKindApplies` reads a `system` descriptor as applying to every
+* system rule kind (`device-events`, `system`, `alarm`, `mixed`).
+*/
+var NcTemplateVarKindSchema = zod.z.enum([
 	"detection",
 	"sensor",
 	"occupancy",
@@ -18261,7 +18388,7 @@ var NcTemplateVarGroupSchema = zod.z.enum([
 *
 * `families` / `fields` / `kinds` / `deliveries` / `systemEventKinds` say WHERE
 * it has a value; absent = no restriction on that axis. `systemEventKinds` is
-* read only for a `system` rule. `dynamic` declares a FAMILY of names
+* read only for a system-event rule (any family, or `mixed`). `dynamic` declares a FAMILY of names
 * (`count_<class>`): the descriptor's `name` is the example member.
 */
 var NcTemplateVarDescriptorSchema = zod.z.object({
@@ -18272,7 +18399,7 @@ var NcTemplateVarDescriptorSchema = zod.z.object({
 	group: NcTemplateVarGroupSchema,
 	families: zod.z.array(NcTemplateFamilySchema).min(1),
 	fields: zod.z.array(NcTemplateFieldSchema).optional(),
-	kinds: zod.z.array(NcRuleKindSchema).optional(),
+	kinds: zod.z.array(NcTemplateVarKindSchema).optional(),
 	deliveries: zod.z.array(NcDeliverySchema).optional(),
 	systemEventKinds: zod.z.array(NcSystemEventKindSchema).optional(),
 	dynamic: zod.z.object({
@@ -35640,6 +35767,35 @@ var RenameNodeResultSchema = zod.z.object({
 	name: zod.z.string()
 });
 /**
+* One row of the CHEAP node list (D637): what a node picker needs and nothing
+* else. Read from the hub's in-memory registry plus the durable node history.
+* No per-node RPC, unlike `topology`, which walks the whole cluster (32–51 s).
+*/
+var NodeDirectoryEntrySchema = zod.z.object({
+	id: zod.z.string(),
+	name: zod.z.string(),
+	isHub: zod.z.boolean(),
+	isOnline: zod.z.boolean()
+});
+/**
+* The cheap node list. A consumer's rule for a STORED node id (a rule's
+* `nodeIds`) that is missing from `nodes`, whatever `complete` says: render it
+* as a removable chip labelled unknown, never drop it (D49). Even a complete
+* list omits a node that joined and left between two history captures, so a
+* missing id means "not known to the hub", never "removed". Only the operator
+* removes it.
+*
+* `complete` changes only the WORDING: `false` = no history read has ever
+* answered, so the list may be missing offline nodes the hub does know (D315).
+*
+* `name` is the history row's name (≤ 30 s behind a rename), or the id when
+* the history has none.
+*/
+var NodeDirectorySchema = zod.z.object({
+	nodes: zod.z.array(NodeDirectoryEntrySchema).readonly(),
+	complete: zod.z.boolean()
+});
+/**
 * `nodes` is a **hub-centric** cluster-management cap: the hub hosts
 * the single provider and every per-node method (`getNodeAddons`,
 * `restartProcess`, `restartNode`, `undeployAddon`, …) takes `nodeId`
@@ -35658,6 +35814,12 @@ var nodesCapability = {
 	nodeIdMode: "data",
 	methods: {
 		topology: require_sleep.method(zod.z.void(), zod.z.array(TopologyNodeSchema).readonly(), { auth: "admin" }),
+		/**
+		* The cheap node list for pickers (D637): the hub's in-memory registry plus
+		* the durable node history, no per-node RPC. `complete: false` when the
+		* history could not be read.
+		*/
+		directory: require_sleep.method(zod.z.void(), NodeDirectorySchema, { auth: "admin" }),
 		deployAddon: require_sleep.method(NodeAddonInputSchema, SuccessSchema, {
 			kind: "mutation",
 			auth: "admin"
@@ -51831,12 +51993,30 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"llmRuntime.appleAvailability": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llmRuntime.cancel": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"llmRuntime.complete": {
 		capName: "llm-runtime",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"llmRuntime.completeApple": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"llmRuntime.deleteModel": {
 		capName: "llm-runtime",
 		capScope: "system",
@@ -52509,6 +52689,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"nodes.directory": {
+		capName: "nodes",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"nodes.executeQuery": {
 		capName: "nodes",
 		capScope: "system",
@@ -59491,6 +59677,7 @@ function createSystemProxy(api) {
 		networkQuality: { getAllStats: (input) => dispatch("networkQuality", "getAllStats", "query", input) },
 		nodes: {
 			topology: (input) => dispatch("nodes", "topology", "query", input),
+			directory: (input) => dispatch("nodes", "directory", "query", input),
 			deployAddon: (input) => dispatch("nodes", "deployAddon", "mutation", input),
 			undeployAddon: (input) => dispatch("nodes", "undeployAddon", "mutation", input),
 			restartAddon: (input) => dispatch("nodes", "restartAddon", "mutation", input),
@@ -60543,7 +60730,285 @@ function prepareNotification(caps, n) {
 	};
 }
 //#endregion
+//#region src/notification/system-event-filters.ts
+/** Every filter, for the callers that must cover all four (guards, tests). */
+var NC_SYSTEM_EVENT_FILTER_KEYS = [
+	"deviceIds",
+	"deviceTypes",
+	"nodeIds",
+	"packageNames"
+];
+/**
+* Does `filter` say anything about `kind`?
+*
+* `false` means the filter is not part of this kind's vocabulary: the engine
+* ignores it and an editor hides its input. It never means "excluded".
+*/
+function systemEventFilterApplies(kind, filter) {
+	switch (filter) {
+		case "deviceIds": return kind.startsWith("device-") || kind.startsWith("stream-") || kind === "detection-blind" || kind === "alarm-triggered";
+		case "deviceTypes": return kind.startsWith("device-") || kind === "detection-blind";
+		case "nodeIds": return kind.startsWith("node-") || kind === "addon-crash-loop" || kind === "addon-update-available" || kind === "addon-updated" || kind === "server-update-available" || kind === "wrapper-update-available" || kind === "server-updated";
+		case "packageNames": return kind.endsWith("update-available") || kind === "addon-updated" || kind === "server-updated";
+	}
+}
+/**
+* Does `filter` say anything about AT LEAST ONE of the selected kinds?
+*
+* The editor's question: a rule selects several kinds at once and renders one
+* filter input for the set, so a filter is shown when any selected kind can be
+* narrowed by it. The kinds it cannot narrow are then simply not narrowed —
+* which is the engine's half of the same rule.
+*/
+function systemEventFilterAppliesToAnyKind(kinds, filter) {
+	return kinds.some((kind) => systemEventFilterApplies(kind, filter));
+}
+//#endregion
+//#region src/notification/system-event-families.ts
+/**
+* WHICH FAMILY every system-event kind belongs to, and which narrowing filters
+* each family may carry: one table, read by the hub validator, by `ruleKindOf`
+* and by both rule editors (D637).
+*
+* A system rule used to be one editor for thirty-one kinds and five filters.
+* "Eventi di sistema" carried battery kinds under a liveness `deviceTypes` filter
+* and went silent for two weeks (D636). The three families are three questions:
+* about devices, about the installation, and about the alarm panel. A rule
+* answers one of them. The engine never needed to know, and it still does not:
+* a mixed stored rule keeps firing. Only AUTHORING is strict.
+*
+* The legacy `camera-*` tail has no family (`null`). It is parsed, never produced,
+* never offered.
+*/
+var NC_SYSTEM_EVENT_FAMILIES = [
+	"device-events",
+	"system",
+	"alarm"
+];
+function isSystemEventFamily(value) {
+	return NC_SYSTEM_EVENT_FAMILIES.some((family) => family === value);
+}
+/** Total over the enum: a kind added to the cap without a family fails tsc here. */
+var NC_SYSTEM_EVENT_FAMILY = {
+	"device-online": "device-events",
+	"device-offline": "device-events",
+	"device-disabled": "device-events",
+	"device-enabled": "device-events",
+	"device-battery-low": "device-events",
+	"device-battery-normal": "device-events",
+	"device-consumable-low": "device-events",
+	"device-consumable-normal": "device-events",
+	"stream-online": "device-events",
+	"stream-offline": "device-events",
+	"detection-blind": "device-events",
+	"node-online": "system",
+	"node-offline": "system",
+	"node-inference-unavailable": "system",
+	"addon-crash-loop": "system",
+	"addon-update-available": "system",
+	"addon-updated": "system",
+	"server-update-available": "system",
+	"server-updated": "system",
+	"wrapper-update-available": "system",
+	"backup-completed": "system",
+	"export-completed": "system",
+	"alarm-triggered": "alarm",
+	"alarm-armed": "alarm",
+	"alarm-disarmed": "alarm",
+	"alarm-arming": "alarm",
+	"alarm-arm-refused": "alarm",
+	"alarm-pending": "alarm",
+	"alarm-rearmed": "alarm",
+	"alarm-sensor-bypass": "alarm",
+	"alarm-check-failed": "alarm",
+	"camera-online": null,
+	"camera-offline": null,
+	"camera-disabled": null,
+	"camera-enabled": null
+};
+/** Read by NAME, for kinds that arrive as plain strings (a newer hub, the viewer's mirror). */
+var FAMILY_BY_NAME = new Map(Object.entries(NC_SYSTEM_EVENT_FAMILY));
+var NC_SYSTEM_EVENT_CONDITION_FILTER_KEYS = [...NC_SYSTEM_EVENT_FILTER_KEYS, "excludeDeviceIds"];
+/**
+* The filters a family may carry. The four 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.
+*/
+var NC_SYSTEM_EVENT_FAMILY_FILTERS = {
+	"device-events": [
+		"deviceIds",
+		"excludeDeviceIds",
+		"deviceTypes"
+	],
+	system: ["nodeIds", "packageNames"],
+	alarm: ["deviceIds"]
+};
+var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
+	{
+		id: "device-state",
+		family: "device-events",
+		label: "Device state",
+		kinds: [
+			"device-offline",
+			"device-online",
+			"device-disabled",
+			"device-enabled"
+		]
+	},
+	{
+		id: "streams",
+		family: "device-events",
+		label: "Streams",
+		kinds: ["stream-offline", "stream-online"]
+	},
+	{
+		id: "battery",
+		family: "device-events",
+		label: "Battery",
+		kinds: ["device-battery-low", "device-battery-normal"]
+	},
+	{
+		id: "consumables",
+		family: "device-events",
+		label: "Consumables",
+		kinds: ["device-consumable-low", "device-consumable-normal"]
+	},
+	{
+		id: "detection-blind",
+		family: "device-events",
+		label: "Detecting nothing",
+		kinds: ["detection-blind"]
+	},
+	{
+		id: "nodes",
+		family: "system",
+		label: "Nodes",
+		kinds: [
+			"node-offline",
+			"node-online",
+			"node-inference-unavailable"
+		]
+	},
+	{
+		id: "addons",
+		family: "system",
+		label: "Addons",
+		kinds: [
+			"addon-crash-loop",
+			"addon-update-available",
+			"addon-updated"
+		]
+	},
+	{
+		id: "updates",
+		family: "system",
+		label: "Server & container updates",
+		kinds: [
+			"server-update-available",
+			"server-updated",
+			"wrapper-update-available"
+		]
+	},
+	{
+		id: "backups-exports",
+		family: "system",
+		label: "Backups & exports",
+		kinds: ["backup-completed", "export-completed"]
+	},
+	{
+		id: "alarm",
+		family: "alarm",
+		label: "Alarm",
+		kinds: NC_ALARM_SYSTEM_EVENT_KINDS
+	}
+];
+function systemEventKindsOfFamily(family) {
+	return NC_SYSTEM_EVENT_KIND_GROUP_SPECS.filter((g) => g.family === family).flatMap((g) => g.kinds);
+}
+/** The kind names on an UNTYPED condition, or `undefined` when it has none. */
+function systemEventKindNamesOf(condition) {
+	if (typeof condition !== "object" || condition === null || !("kinds" in condition)) return void 0;
+	const kinds = condition.kinds;
+	if (!Array.isArray(kinds)) return void 0;
+	return kinds.filter((kind) => typeof kind === "string");
+}
+/**
+* One family, or `mixed`. Mixed covers kinds that span families, a legacy kind,
+* a kind this build does not know (it fails toward read-only and never toward
+* editable), and an empty selection (nothing to decide on).
+*/
+function systemEventFamilyOf(kindNames) {
+	const families = /* @__PURE__ */ new Set();
+	for (const name of kindNames) {
+		const family = FAMILY_BY_NAME.get(name);
+		if (family === void 0 || family === null) return { kind: "mixed" };
+		families.add(family);
+	}
+	const [only] = [...families];
+	return families.size === 1 && only !== void 0 ? {
+		kind: "family",
+		family: only
+	} : { kind: "mixed" };
+}
+/**
+* Why the hub refuses this condition on a new or updated rule. Empty = accepted.
+* Families are reported in `NC_SYSTEM_EVENT_FAMILIES` order, and filters in
+* `NC_SYSTEM_EVENT_CONDITION_FILTER_KEYS` order, so a refusal reads the same
+* every time.
+*/
+function systemEventFamilyProblems(condition) {
+	if (condition === void 0 || condition.kinds.length === 0) return [{ code: "no-kinds" }];
+	const problems = [];
+	const present = /* @__PURE__ */ new Set();
+	for (const kind of condition.kinds) {
+		const family = NC_SYSTEM_EVENT_FAMILY[kind];
+		if (family === null) problems.push({
+			code: "legacy-kind",
+			kind
+		});
+		else present.add(family);
+	}
+	const families = NC_SYSTEM_EVENT_FAMILIES.filter((f) => present.has(f));
+	if (families.length > 1) problems.push({
+		code: "mixed-families",
+		families
+	});
+	const [family] = families;
+	if (families.length !== 1 || family === void 0) return problems;
+	const allowed = NC_SYSTEM_EVENT_FAMILY_FILTERS[family];
+	for (const filter of NC_SYSTEM_EVENT_CONDITION_FILTER_KEYS) if (condition[filter] !== void 0 && !allowed.includes(filter)) problems.push({
+		code: "filter-outside-family",
+		filter,
+		family
+	});
+	return problems;
+}
+function describeSystemEventFamilyProblem(problem) {
+	switch (problem.code) {
+		case "no-kinds": return "a system-event rule needs at least one event kind";
+		case "legacy-kind": return `'${problem.kind}' is a legacy kind and cannot be authored`;
+		case "mixed-families": return `event kinds span ${problem.families.join(" + ")} — one rule per family`;
+		case "filter-outside-family": return `filter '${problem.filter}' is not allowed on a ${problem.family} rule`;
+	}
+}
+//#endregion
 //#region src/notification/rule-kinds.ts
+/** Every kind a `system-event` rule can derive — the three families and `mixed`. */
+var NC_SYSTEM_RULE_KINDS = [
+	"device-events",
+	"system",
+	"alarm",
+	"mixed"
+];
+/** Is this a kind a `system-event` rule derives (any family, or `mixed`)? */
+function isSystemRuleKind(kind) {
+	return NC_SYSTEM_RULE_KINDS.some((k) => k === kind);
+}
+/** The family a kind authors, or undefined (a camera kind, or `mixed`). */
+function systemFamilyOfKind(kind) {
+	return isSystemEventFamily(kind) ? kind : void 0;
+}
 /**
 * Reasons, written once. Each names the SUBJECT FIELD the engine reads and
 * finds absent — that is what makes the exclusion checkable against the engine
@@ -60561,6 +61026,7 @@ var NC_RULE_KIND_SPECS = [
 		kind: "detection",
 		label: "Conditions",
 		excluded: {},
+		editable: true,
 		carriesMedia: true,
 		carriesSubjectCrop: true
 	},
@@ -60569,6 +61035,7 @@ var NC_RULE_KIND_SPECS = [
 		label: "Conditions",
 		/** Same argument as `detection`: `occupancy` converts, it does not confuse. */
 		excluded: {},
+		editable: true,
 		carriesMedia: true,
 		carriesSubjectCrop: true,
 		blurb: "A doorbell press or a linked sensor changing state. The picture comes from the camera the sensor is attributed to."
@@ -60582,6 +61049,7 @@ var NC_RULE_KIND_SPECS = [
 			eventTypeTokens: NO_EVENT_TOKEN,
 			source: OCCUPANCY_SOURCE
 		},
+		editable: true,
 		carriesMedia: true,
 		carriesSubjectCrop: true,
 		blurb: "Fires when the count in a camera frame or a zone crosses your threshold and holds. Pick the camera first — the zone list is that camera’s."
@@ -60604,25 +61072,66 @@ var NC_RULE_KIND_SPECS = [
 			plates: SOUND_NOT_A_PICTURE,
 			source: AUDIO_SOURCE
 		},
+		editable: true,
 		carriesMedia: true,
 		carriesSubjectCrop: false,
 		blurb: "Fires on a confirmed sampling window of audio, never on a picture. Name the sounds and/or keep a level threshold — with neither it can never match.",
 		mediaBlurb: "A sound owns no frame, so the picture is a photograph of the camera taken at the moment of the match — the whole scene, never a crop. The GIF and the clip are cut around the same instant, from the camera."
 	},
+	{
+		kind: "device-events",
+		label: "Device events",
+		discriminator: "systemEvent",
+		excluded: {},
+		editable: true,
+		carriesMedia: false,
+		carriesSubjectCrop: false,
+		blurb: "A device or its stream going away or coming back, switched off or on, a battery or consumable running low, a camera detecting nothing. There is no frame to attach."
+	},
 	{
 		kind: "system",
-		label: "Events",
+		label: "System events",
+		discriminator: "systemEvent",
+		excluded: {},
+		editable: true,
+		carriesMedia: false,
+		carriesSubjectCrop: false,
+		blurb: "The installation itself: a node leaving, an addon crash-looping, an update available or installed, a backup or an export finishing."
+	},
+	{
+		kind: "alarm",
+		label: "Alarm",
+		discriminator: "systemEvent",
+		excluded: {},
+		editable: true,
+		carriesMedia: false,
+		carriesSubjectCrop: false,
+		blurb: "The alarm panel: refused, arming, armed, entry delay, triggered, re-armed, sensor bypass, disarmed.",
+		mediaBlurb: "An alarm set off by a rule arrives with THAT rule's pictures, combined into one notification. This rule adds none of its own."
+	},
+	{
+		kind: "mixed",
+		label: "To recreate",
 		discriminator: "systemEvent",
 		excluded: {},
+		editable: false,
 		carriesMedia: false,
 		carriesSubjectCrop: false,
-		blurb: "The installation itself: a camera or stream dropping, a node leaving, an update landing. There is no detection behind it and no frame to attach."
+		blurb: "This rule mixes events from more than one family (device events, system, alarm). It keeps firing as it is, but it can no longer be edited: create one rule per family, then delete this one."
 	}
 ];
 /** The spec for a kind. Total by construction — every member has an entry. */
 function ruleKindSpec(kind) {
 	return NC_RULE_KIND_SPECS.find((s) => s.kind === kind) ?? NC_RULE_KIND_SPECS[0];
 }
+/**
+* Every kind a discriminator makes — one kind for `audio` and `occupancy`, the
+* whole system group for `systemEvent`. Empty for a condition that makes no
+* kind. See {@link NcRuleKindSpec.discriminator}.
+*/
+function kindsForDiscriminator(discriminator) {
+	return NC_RULE_KIND_SPECS.filter((s) => s.discriminator === discriminator).map((s) => s.kind);
+}
 /** The delivery a system rule rides — named once, compared everywhere. */
 var NC_SYSTEM_DELIVERY = "system-event";
 /**
@@ -60640,16 +61149,28 @@ function isSystemDelivery(delivery) {
 * the order below is the engine's own: `evaluateRule` checks the system branch
 * first, then the occupancy and audio gates. Takes a plain `delivery` string so
 * a trigger this build does not know still classifies (as `detection`, which is
-* the read-only path's own fallback).
+* the read-only path's own fallback). A system rule classifies by the FAMILY of
+* its event kinds (D637) — see {@link systemRuleKindOf}.
 */
 function ruleKindOf(rule) {
-	if (isSystemDelivery(rule.delivery)) return "system";
+	if (isSystemDelivery(rule.delivery)) return systemRuleKindOf(rule.conditions.systemEvent);
 	if (rule.conditions.occupancy !== void 0 && rule.delivery === "device-event") return "occupancy";
 	if (rule.conditions.audio !== void 0 && rule.delivery === "immediate") return "sound";
 	if (rule.delivery === "device-event") return "sensor";
 	return "detection";
 }
 /**
+* A system rule's kind: its one family, or `mixed` (D637).
+*
+* Takes the UNTYPED condition for the same reason {@link NcRuleConditionsSubject}
+* is structural. `mixed` covers kinds across families, a legacy or unknown kind,
+* and no kinds at all — it fails toward read-only, never toward editable.
+*/
+function systemRuleKindOf(condition) {
+	const verdict = systemEventFamilyOf(systemEventKindNamesOf(condition) ?? []);
+	return verdict.kind === "family" ? verdict.family : "mixed";
+}
+/**
 * Is this condition visible — and authorable — for a rule of this kind?
 *
 * The COMPOSITION, and the only function that decides it: `appliesTo` is the
@@ -60690,35 +61211,64 @@ var NC_RULE_SECTIONS = [
 		label: "All rules",
 		blurb: "Every notification rule, whatever its trigger. Each rule picks a trigger, matches conditions and fans out to one or more delivery targets.",
 		newRuleLabel: "New rule",
-		emptyHint: "No notification rules yet. Create one to be told what your cameras see."
+		emptyHint: "No notification rules yet. Create one to be told what your cameras see.",
+		creatable: true
 	},
 	{
 		key: "detection",
 		label: "Detections & devices",
 		blurb: "Rules driven by what the cameras and sensors SEE — detections, tracks, doorbell presses and package events.",
 		newRuleLabel: "New detection rule",
-		emptyHint: "No detection rules yet. Create one to be told what your cameras see."
+		emptyHint: "No detection rules yet. Create one to be told what your cameras see.",
+		creatable: true
 	},
 	{
 		key: "audio",
 		label: "Sound",
 		blurb: "Rules on what the cameras HEAR: a sustained window of sound loud enough, or classified as one of the sounds you name. A sound rule fires only on a confirmed sampling window, never on a picture.",
 		newRuleLabel: "New sound rule",
-		emptyHint: "No sound rules yet. A new sound rule opens on the sound condition already filled in with a level threshold, so you only have to name the sounds and the targets."
+		emptyHint: "No sound rules yet. A new sound rule opens on the sound condition already filled in with a level threshold, so you only have to name the sounds and the targets.",
+		creatable: true
 	},
 	{
 		key: "occupancy",
 		label: "Occupancy",
 		blurb: "Rules on how many objects are in a camera frame or a zone, and for how long: \"the driveway became occupied\", \"the garden emptied\".",
 		newRuleLabel: "New occupancy rule",
-		emptyHint: "No occupancy rules yet. A new occupancy rule opens on the occupancy condition; pick the camera first, then the zone and the count."
+		emptyHint: "No occupancy rules yet. A new occupancy rule opens on the occupancy condition; pick the camera first, then the zone and the count.",
+		creatable: true
+	},
+	{
+		key: "device-events",
+		label: "Device events",
+		blurb: "Rules about your devices: offline or back, switched off or on, a stream dropping, a battery or consumable running low, a camera detecting nothing.",
+		newRuleLabel: "New device-event rule",
+		emptyHint: "No device-event rules yet. These tell you when a device drops, a battery runs low or a camera goes blind.",
+		creatable: true
 	},
 	{
 		key: "system",
 		label: "System events",
-		blurb: "Rules about the installation itself: a camera or stream dropping, a node leaving the cluster, an addon or server update becoming available. These carry no image and are not tied to a detection.",
+		blurb: "Rules about the installation: a node leaving the cluster, an addon crash-looping, an update available or installed, a backup or export finishing.",
 		newRuleLabel: "New system rule",
-		emptyHint: "No system-event rules yet. These tell you when a camera drops, a node leaves or an update lands."
+		emptyHint: "No system rules yet. These tell you when a node leaves, an update lands or a backup finishes.",
+		creatable: true
+	},
+	{
+		key: "alarm",
+		label: "Alarm",
+		blurb: "Rules about the alarm panel: arming, armed, triggered, disarmed, and the refusals in between.",
+		newRuleLabel: "New alarm rule",
+		emptyHint: "No alarm rules yet. These tell you when the alarm arms, goes off or is disarmed.",
+		creatable: true
+	},
+	{
+		key: "mixed",
+		label: "To recreate",
+		blurb: "System rules authored before the three families existed. Each mixes families, keeps firing as it is, and can only be read or deleted: recreate it as one rule per family.",
+		newRuleLabel: "New rule",
+		emptyHint: "Nothing to recreate.",
+		creatable: false
 	}
 ];
 /** The section for a key, or `undefined` — the lookup behind every label. */
@@ -60741,8 +61291,9 @@ function isOccupancyRule(subject) {
 * Does a rule belong in this section?
 *
 * `all` always matches — a section that hides a rule is how an operator
-* concludes it was deleted. The other four PARTITION the list: sound and
-* occupancy are claimed by their condition, system by its trigger, and
+* concludes it was deleted. The others PARTITION the list: sound and
+* occupancy are claimed by their condition, a system-event rule by its trigger
+* and then by the family of its event kinds (or `mixed`, D637), and
 * everything left over — including a trigger this build has never heard of —
 * counts as a detection rule so it stays visible somewhere.
 *
@@ -60754,21 +61305,23 @@ function isOccupancyRule(subject) {
 */
 function ruleMatchesSection(subject, section) {
 	if (section === "all") return true;
-	if (section === "system") return isSystemDelivery(subject.delivery);
+	if (isSystemDelivery(subject.delivery)) return ruleKindOf(subject) === section;
 	if (section === "audio") return isAudioRule(subject);
 	if (section === "occupancy") return isOccupancyRule(subject);
-	return !isSystemDelivery(subject.delivery) && !isAudioRule(subject) && !isOccupancyRule(subject);
+	if (section === "detection") return !isAudioRule(subject) && !isOccupancyRule(subject);
+	return false;
 }
 /**
 * Which section OWNS this rule — the counter behind a section strip.
 *
-* Derived from {@link ruleMatchesSection} rather than restated, so the strip's
-* counts and the strip's contents can never disagree.
+* The same order as {@link ruleMatchesSection} — trigger first, then the
+* discriminating condition — and the section spec asserts the two agree on
+* every subject, so the strip's counts and its contents cannot disagree.
 */
 function ruleSectionOf(subject) {
-	if (ruleMatchesSection(subject, "system")) return "system";
-	if (ruleMatchesSection(subject, "audio")) return "audio";
-	if (ruleMatchesSection(subject, "occupancy")) return "occupancy";
+	if (isSystemDelivery(subject.delivery)) return systemRuleKindOf(subject.conditions.systemEvent);
+	if (isAudioRule(subject)) return "audio";
+	if (isOccupancyRule(subject)) return "occupancy";
 	return "detection";
 }
 /**
@@ -60806,9 +61359,17 @@ var NC_AUDIO_SEED = {
 };
 function ruleSeedForSection(section) {
 	switch (section) {
+		case "device-events": return {
+			delivery: NC_SYSTEM_DELIVERY,
+			conditions: { systemEvent: { kinds: ["device-offline", "device-online"] } }
+		};
 		case "system": return {
 			delivery: NC_SYSTEM_DELIVERY,
-			conditions: {}
+			conditions: { systemEvent: { kinds: ["node-offline", "node-online"] } }
+		};
+		case "alarm": return {
+			delivery: NC_SYSTEM_DELIVERY,
+			conditions: { systemEvent: { kinds: ["alarm-triggered"] } }
 		};
 		case "audio": return {
 			delivery: "immediate",
@@ -60850,7 +61411,7 @@ var EDITOR_SECTION_LABELS = {
 *
 * Two rules, both of them about a control that would decide nothing:
 *
-*  - a `system-event` rule has no device scope — `conditions.devices` is not
+*  - a system-event rule (any family) has no device scope — `conditions.devices` is not
 *    evaluated for it and the input builder refuses to write it — so the
 *    Cameras section is DROPPED rather than shown and ignored;
 *  - a sound or occupancy rule is NAMED on its conditions section. Neither has
@@ -60868,7 +61429,7 @@ function ruleEditorSectionsForKind(kind) {
 	const spec = ruleKindSpec(kind);
 	const sections = [];
 	for (const key of NC_RULE_EDITOR_SECTION_ORDER) {
-		if (key === "devices" && kind === "system") continue;
+		if (key === "devices" && isSystemRuleKind(kind)) continue;
 		sections.push({
 			key,
 			label: key === "conditions" ? spec.label : EDITOR_SECTION_LABELS[key]
@@ -61677,10 +62238,38 @@ var CAPTION_VARS = {
 function onAxis(declared, asked) {
 	return declared === void 0 || asked === void 0 || declared.includes(asked);
 }
-function onSystemAxis(d, ctx) {
-	if (ctx.kind !== "system" || d.systemEventKinds === void 0) return true;
+/**
+* Does a descriptor declared for `declared` kinds have a value for a rule of
+* `kind`?
+*
+* `system` on the WIRE stands for every system rule kind (D637): the served
+* catalog keeps the five pre-D637 tokens so installed viewers still parse it
+* (`NcTemplateVarKindSchema`), and the family split lives here, in the match.
+* Exported so the admin's local interpreter of the served catalog asks the
+* same question instead of restating it.
+*/
+function templateVarKindApplies(declared, kind) {
+	if (declared === void 0 || kind === void 0) return true;
+	if (declared.some((k) => k === kind)) return true;
+	return isSystemRuleKind(kind) && declared.includes("system");
+}
+/**
+* Is a descriptor that names `systemEventKinds` on the event-kind axis of a
+* system rule? Read only for a system rule kind; any other kind ignores it.
+*
+* Event kinds chosen: the descriptor must speak about one of them. None chosen
+* yet: a FAMILY kind watches its own family's event kinds (a device-events rule
+* is never offered the alarm's `{{mode}}`), and `mixed` watches all of them.
+*/
+function templateVarSystemEventApplies(d, ctx) {
+	if (!isSystemRuleKind(ctx.kind) || d.systemEventKinds === void 0) return true;
+	const declared = d.systemEventKinds;
 	const asked = ctx.systemEventKinds ?? [];
-	return asked.length === 0 || asked.some((k) => d.systemEventKinds?.includes(k) === true);
+	if (asked.length > 0) return asked.some((k) => declared.includes(k));
+	const family = ctx.kind === void 0 ? void 0 : systemFamilyOfKind(ctx.kind);
+	if (family === void 0) return true;
+	const own = systemEventKindsOfFamily(family);
+	return declared.some((k) => own.includes(k));
 }
 /**
 * The variables that have a value in `ctx`, in catalog order. Pure.
@@ -61694,45 +62283,85 @@ function templateVarsFor(ctx) {
 		const allowed = CAPTION_VARS[ctx.field];
 		return NC_TEMPLATE_VARS.filter((d) => d.families.includes(ctx.family) && allowed.includes(d.name) && d.dynamic === void 0);
 	}
-	return NC_TEMPLATE_VARS.filter((d) => d.families.includes(ctx.family) && onAxis(d.fields, ctx.field) && onAxis(d.kinds, ctx.kind) && onAxis(d.deliveries, ctx.delivery) && onSystemAxis(d, ctx));
+	return NC_TEMPLATE_VARS.filter((d) => d.families.includes(ctx.family) && onAxis(d.fields, ctx.field) && templateVarKindApplies(d.kinds, ctx.kind) && onAxis(d.deliveries, ctx.delivery) && templateVarSystemEventApplies(d, ctx));
 }
 /** True when `name` is supplied in `ctx`, dynamic families (`count_<class>`) included. */
 function isKnownTemplateVar(name, ctx) {
 	return templateVarsFor(ctx).some((d) => d.dynamic !== void 0 ? name.startsWith(d.dynamic.prefix) && name.length > d.dynamic.prefix.length : d.name === name);
 }
 //#endregion
-//#region src/notification/system-event-filters.ts
-/** Every filter, for the callers that must cover all four (guards, tests). */
-var NC_SYSTEM_EVENT_FILTER_KEYS = [
-	"deviceIds",
-	"deviceTypes",
-	"nodeIds",
-	"packageNames"
-];
+//#region src/notification/scope-picker-items.ts
+function nodePickerItems(nodes) {
+	return nodes.map((node) => ({
+		id: node.id,
+		name: node.name,
+		type: node.isHub ? "hub" : "agent",
+		location: node.isOnline ? "online" : "offline",
+		...node.name !== node.id ? { detail: node.id } : {}
+	}));
+}
 /**
-* Does `filter` say anything about `kind`?
-*
-* `false` means the filter is not part of this kind's vocabulary: the engine
-* ignores it and an editor hides its input. It never means "excluded".
-*/
-function systemEventFilterApplies(kind, filter) {
-	switch (filter) {
-		case "deviceIds": return kind.startsWith("device-") || kind.startsWith("stream-") || kind === "detection-blind" || kind === "alarm-triggered" || kind === "export-completed";
-		case "deviceTypes": return kind.startsWith("device-") || kind === "detection-blind";
-		case "nodeIds": return kind.startsWith("node-") || kind === "addon-crash-loop" || kind === "addon-update-available" || kind === "addon-updated" || kind === "server-update-available" || kind === "wrapper-update-available" || kind === "server-updated";
-		case "packageNames": return kind.endsWith("update-available") || kind === "addon-updated" || kind === "server-updated";
-	}
+* The server's own package name: `server-update-available` / `server-updated`
+* carry it, and `addons.listPackages` does not list it.
+*/
+var NC_SERVER_PACKAGE_NAME = "@camstack/server";
+/**
+* Every package name an update EVENT carries as `packageName`, one per
+* producer. The package picker offers each of them whether or not
+* `addons.listPackages` lists it, because a rule scoped to a name no event
+* carries can never fire (and one an event carries must be pickable).
+*
+* - `@camstack/server` — `server-update-available` / `server-updated`: the hub
+*   root package (`HUB_ROOT_SPEC.packageName`, `@camstack/node-root`).
+* - `@camstack/system` — `server-update-available` from the framework check,
+*   which checks `[SYSTEM_PACKAGE]` only (`AddonPackageService.listFrameworkPackages`).
+*   `@camstack/types` / `@camstack/sdk` are framework packages for upload
+*   routing but are never announced, so they are NOT here.
+* - `camstack-wrapper` — `wrapper-update-available` (`WRAPPER_PACKAGE_NAME`,
+*   `wrapper-update-checker.ts`).
+*
+* Types cannot import those producers; the backend spec
+* `core/updates/__tests__/update-event-package-names.spec.ts` pins each literal
+* to its producer constant. This is a picker list, never a routing list.
+*/
+var NC_UPDATE_EVENT_PACKAGE_NAMES = [
+	NC_SERVER_PACKAGE_NAME,
+	"@camstack/system",
+	"camstack-wrapper"
+];
+var UPDATE_EVENT_PACKAGE_TYPE = {
+	"@camstack/server": "server",
+	"@camstack/system": "framework",
+	"camstack-wrapper": "wrapper"
+};
+function isUpdateEventPackageName(name) {
+	return NC_UPDATE_EVENT_PACKAGE_NAMES.some((pinned) => pinned === name);
 }
 /**
-* Does `filter` say anything about AT LEAST ONE of the selected kinds?
-*
-* The editor's question: a rule selects several kinds at once and renders one
-* filter input for the set, so a filter is shown when any selected kind can be
-* narrowed by it. The kinds it cannot narrow are then simply not narrowed —
-* which is the engine's half of the same rule.
+* Every update-event package first (always offered: an event carries it), in
+* `NC_UPDATE_EVENT_PACKAGE_NAMES` order, then the installed addons sorted by
+* name. An installed version is the second line.
 */
-function systemEventFilterAppliesToAnyKind(kinds, filter) {
-	return kinds.some((kind) => systemEventFilterApplies(kind, filter));
+function packagePickerItems(packages) {
+	const versions = new Map(packages.map((pkg) => [pkg.name, pkg.version]));
+	const pinned = NC_UPDATE_EVENT_PACKAGE_NAMES.map((name) => {
+		const version = versions.get(name);
+		return {
+			id: name,
+			name,
+			type: UPDATE_EVENT_PACKAGE_TYPE[name],
+			location: null,
+			...version !== void 0 ? { detail: version } : {}
+		};
+	});
+	const addons = packages.filter((pkg) => !isUpdateEventPackageName(pkg.name)).map((pkg) => ({
+		id: pkg.name,
+		name: pkg.name,
+		type: "addon",
+		location: null,
+		detail: pkg.version
+	})).sort((a, b) => a.name.localeCompare(b.name));
+	return [...pinned, ...addons];
 }
 //#endregion
 //#region src/notification/timelapse-rule.ts
@@ -64700,6 +65329,8 @@ exports.AmbientLightSensorStatusSchema = AmbientLightSensorStatusSchema;
 exports.AnalyticsLtsSeriesSchema = AnalyticsLtsSeriesSchema;
 exports.ApiKeyRecordSchema = ApiKeyRecordSchema;
 exports.ApiKeySummarySchema = ApiKeySummarySchema;
+exports.AppleFmAvailabilitySchema = AppleFmAvailabilitySchema;
+exports.AppleFmUnavailableReasonSchema = AppleFmUnavailableReasonSchema;
 exports.ArchiveEntrySchema = ArchiveEntrySchema;
 exports.ArchiveManifestSchema = ArchiveManifestSchema;
 exports.ArchivedDebugNoteQueryInputSchema = ArchivedDebugNoteQueryInputSchema;
@@ -65143,7 +65774,10 @@ exports.LlmNodeModelSchema = LlmNodeModelSchema;
 exports.LlmProfileKindDescriptorSchema = LlmProfileKindDescriptorSchema;
 exports.LlmProfileKindSchema = LlmProfileKindSchema;
 exports.LlmProfileSchema = LlmProfileSchema;
+exports.LlmRefusalSourceSchema = LlmRefusalSourceSchema;
 exports.LlmRetryPolicySchema = LlmRetryPolicySchema;
+exports.LlmRuntimeAppleCompleteInputSchema = LlmRuntimeAppleCompleteInputSchema;
+exports.LlmRuntimeCancelInputSchema = LlmRuntimeCancelInputSchema;
 exports.LlmRuntimeCompleteInputSchema = LlmRuntimeCompleteInputSchema;
 exports.LlmRuntimeDiskUsageSchema = LlmRuntimeDiskUsageSchema;
 exports.LlmRuntimeNodeSchema = LlmRuntimeNodeSchema;
@@ -65312,11 +65946,19 @@ exports.NC_RULE_CLEARABLE_KEYS = NC_RULE_CLEARABLE_KEYS;
 exports.NC_RULE_EDITOR_SECTION_ORDER = NC_RULE_EDITOR_SECTION_ORDER;
 exports.NC_RULE_KIND_SPECS = NC_RULE_KIND_SPECS;
 exports.NC_RULE_SECTIONS = NC_RULE_SECTIONS;
+exports.NC_SERVER_PACKAGE_NAME = NC_SERVER_PACKAGE_NAME;
 exports.NC_SNOOZE_MAX_MINUTES = NC_SNOOZE_MAX_MINUTES;
 exports.NC_SYSTEM_DELIVERY = NC_SYSTEM_DELIVERY;
+exports.NC_SYSTEM_EVENT_CONDITION_FILTER_KEYS = NC_SYSTEM_EVENT_CONDITION_FILTER_KEYS;
+exports.NC_SYSTEM_EVENT_FAMILIES = NC_SYSTEM_EVENT_FAMILIES;
+exports.NC_SYSTEM_EVENT_FAMILY = NC_SYSTEM_EVENT_FAMILY;
+exports.NC_SYSTEM_EVENT_FAMILY_FILTERS = NC_SYSTEM_EVENT_FAMILY_FILTERS;
 exports.NC_SYSTEM_EVENT_FILTER_KEYS = NC_SYSTEM_EVENT_FILTER_KEYS;
+exports.NC_SYSTEM_EVENT_KIND_GROUP_SPECS = NC_SYSTEM_EVENT_KIND_GROUP_SPECS;
+exports.NC_SYSTEM_RULE_KINDS = NC_SYSTEM_RULE_KINDS;
 exports.NC_TAXONOMY = NC_TAXONOMY;
 exports.NC_TEMPLATE_VARS = NC_TEMPLATE_VARS;
+exports.NC_UPDATE_EVENT_PACKAGE_NAMES = NC_UPDATE_EVENT_PACKAGE_NAMES;
 exports.NETWORK_LINK_TYPES = NETWORK_LINK_TYPES;
 exports.NETWORK_LINK_UNKNOWN = NETWORK_LINK_UNKNOWN;
 exports.NativeCropBboxSchema = NativeCropBboxSchema;
@@ -65396,6 +66038,7 @@ exports.NcTemplatePreviewSchema = NcTemplatePreviewSchema;
 exports.NcTemplateVarContextSchema = NcTemplateVarContextSchema;
 exports.NcTemplateVarDescriptorSchema = NcTemplateVarDescriptorSchema;
 exports.NcTemplateVarGroupSchema = NcTemplateVarGroupSchema;
+exports.NcTemplateVarKindSchema = NcTemplateVarKindSchema;
 exports.NcTestResultSchema = NcTestResultSchema;
 exports.NcThrottleGranularitySchema = NcThrottleGranularitySchema;
 exports.NcThrottleSchema = NcThrottleSchema;
@@ -65404,6 +66047,8 @@ exports.NetworkAccessStatusSchema = NetworkAccessStatusSchema;
 exports.NetworkAddressSchema = NetworkAddressSchema;
 exports.NetworkEndpointSchema = NetworkEndpointSchema;
 exports.NetworkLinkStatusSchema = NetworkLinkStatusSchema;
+exports.NodeDirectoryEntrySchema = NodeDirectoryEntrySchema;
+exports.NodeDirectorySchema = NodeDirectorySchema;
 exports.NotificationActionIconSchema = NotificationActionIconSchema;
 exports.NotificationActionSchema = NotificationActionSchema;
 exports.NotificationFormatSchema = NotificationFormatSchema;
@@ -65999,6 +66644,7 @@ exports.describeCustomActions = require_sleep.describeCustomActions;
 exports.describeModelVariant = describeModelVariant;
 exports.describeOnboardClamp = describeOnboardClamp;
 exports.describeOnboardRefusal = describeOnboardRefusal;
+exports.describeSystemEventFamilyProblem = describeSystemEventFamilyProblem;
 exports.detectAccessRole = detectAccessRole;
 exports.detectionPipelineCapability = detectionPipelineCapability;
 exports.deviceAdminLinkCapability = deviceAdminLinkCapability;
@@ -66113,10 +66759,13 @@ exports.isSoftwareDecode = require_canonical_hash.isSoftwareDecode;
 exports.isSourceCap = isSourceCap;
 exports.isStorageLocationMode = isStorageLocationMode;
 exports.isSystemDelivery = isSystemDelivery;
+exports.isSystemEventFamily = isSystemEventFamily;
+exports.isSystemRuleKind = isSystemRuleKind;
 exports.isVoidInput = isVoidInput;
 exports.ituDbfsFromPreEpoch = ituDbfsFromPreEpoch;
 exports.jobKindSchema = jobKindSchema;
 exports.kebabToCamel = kebabToCamel;
+exports.kindsForDiscriminator = kindsForDiscriminator;
 exports.knownValues = knownValues;
 exports.lawnMowerControlCapability = lawnMowerControlCapability;
 exports.legacyAutoLinkIds = legacyAutoLinkIds;
@@ -66169,6 +66818,7 @@ exports.navigationCapability = navigationCapability;
 exports.networkAccessCapability = networkAccessCapability;
 exports.networkLinkCapability = networkLinkCapability;
 exports.networkQualityCapability = networkQualityCapability;
+exports.nodePickerItems = nodePickerItems;
 exports.nodePin = require_sleep.nodePin;
 exports.nodesCapability = nodesCapability;
 exports.normalizeAddonInitResult = require_sleep.normalizeAddonInitResult;
@@ -66187,6 +66837,7 @@ exports.optionalMethod = require_sleep.optionalMethod;
 exports.osdCapability = osdCapability;
 exports.osdManagerCapability = osdManagerCapability;
 exports.overlayClusterStepSettings = overlayClusterStepSettings;
+exports.packagePickerItems = packagePickerItems;
 exports.parseAdminBase = parseAdminBase;
 exports.parseCameraStreamConfig = parseCameraStreamConfig;
 exports.parseExpression = parseExpression;
@@ -66332,13 +66983,21 @@ exports.switchCapability = switchCapability;
 exports.switchedOffIds = switchedOffIds;
 exports.synthesizeSourceInfo = synthesizeSourceInfo;
 exports.systemCapability = systemCapability;
+exports.systemEventFamilyOf = systemEventFamilyOf;
+exports.systemEventFamilyProblems = systemEventFamilyProblems;
 exports.systemEventFilterApplies = systemEventFilterApplies;
 exports.systemEventFilterAppliesToAnyKind = systemEventFilterAppliesToAnyKind;
+exports.systemEventKindNamesOf = systemEventKindNamesOf;
+exports.systemEventKindsOfFamily = systemEventKindsOfFamily;
+exports.systemFamilyOfKind = systemFamilyOfKind;
+exports.systemRuleKindOf = systemRuleKindOf;
 exports.tamperCapability = tamperCapability;
 exports.taskLogEntrySchema = taskLogEntrySchema;
 exports.taskPhaseSchema = taskPhaseSchema;
 exports.taskTargetSchema = taskTargetSchema;
 exports.temperatureSensorCapability = temperatureSensorCapability;
+exports.templateVarKindApplies = templateVarKindApplies;
+exports.templateVarSystemEventApplies = templateVarSystemEventApplies;
 exports.templateVarsFor = templateVarsFor;
 exports.terminalSessionCapability = terminalSessionCapability;
 exports.textToHtml = textToHtml;