@camstack/addon-agent-ui 1.2.165 → 1.2.167

package/dist/addon.js

@@ -19846,14 +19846,52 @@ var NcAlarmNonBlockingEditSchema = object({
 	nonBlocking: boolean()
 });
 /**
+* Controllable openings: opt IN to blocking (default is do not block). Contacts
+* keep using {@link NcAlarmNonBlockingEditSchema}.
+*/
+var NcAlarmBlockingEditSchema = object({
+	mode: AlarmArmModeSchema,
+	deviceId: number().int().positive(),
+	/** true = on the list (blocks when open); false = off the list (default). */
+	blocking: boolean()
+});
+/**
+* Controllable openings: opt OUT of secure-on-arm (default is secure ON —
+* close / lock / turn off when this mode arms).
+*/
+var NcAlarmSecureOnArmEditSchema = object({
+	mode: AlarmArmModeSchema,
+	deviceId: number().int().positive(),
+	/** true = secure on arm (default); false = do not actuate on arm. */
+	secureOnArm: boolean()
+});
+/**
+* One arm mode's device-id list (non-blocking, blocking, or secure-on-arm-off).
+*/
+var NcAlarmModeDeviceListSchema = object({
+	mode: AlarmArmModeSchema,
+	deviceIds: array(number().int()).max(200)
+});
+/**
+* One arm mode's non-blocking list: devices that may be open when that mode
+* arms, without the arm being refused.
+*/
+var NcAlarmNonBlockingSchema = NcAlarmModeDeviceListSchema;
+/** Controllable devices that DO block when open (opt-in; default empty). */
+var NcAlarmBlockingSchema = NcAlarmModeDeviceListSchema;
+/**
+* Controllable devices that do NOT secure on arm (opt-out; default empty =
+* every controllable secures).
+*/
+var NcAlarmSecureOnArmOffSchema = NcAlarmModeDeviceListSchema;
+/**
 * The per-mode lists, at most one per mode. Two lists for one mode have no
 * meaning a reader could agree on (union? the last one?), so they are refused
 * at the boundary rather than interpreted.
 */
-var NcAlarmNonBlockingListSchema = array(object({
-	mode: AlarmArmModeSchema,
-	deviceIds: array(number().int()).max(200)
-})).max(8).refine(uniqueModes, { message: "nonBlocking: at most one list per arm mode" });
+var NcAlarmNonBlockingListSchema = array(NcAlarmNonBlockingSchema).max(8).refine(uniqueModes, { message: "nonBlocking: at most one list per arm mode" });
+var NcAlarmBlockingListSchema = array(NcAlarmBlockingSchema).max(8).refine(uniqueModes, { message: "blocking: at most one list per arm mode" });
+var NcAlarmSecureOnArmOffListSchema = array(NcAlarmSecureOnArmOffSchema).max(8).refine(uniqueModes, { message: "secureOnArmOff: at most one list per arm mode" });
 /**
 * 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.
@@ -19896,9 +19934,23 @@ var NcAlarmSettingsSchema = object({
 	* arm (a window left ajar for the cat under `home`, say). At most one entry
 	* per mode is meaningful. Defaulted to `[]` so a blob stored before D630
 	* parses as "every opening blocks" — the behaviour it was written under.
+	* Contacts use this list; controllable openings use {@link blocking} instead
+	* (default: do not block).
 	*/
 	nonBlocking: NcAlarmNonBlockingListSchema.default([]),
 	/**
+	* Per arm mode, controllable openings that DO refuse the arm when open.
+	* Default `[]` = none block (secure-on-arm closes them instead). Absent on a
+	* blob older than this field — read as empty.
+	*/
+	blocking: NcAlarmBlockingListSchema.default([]),
+	/**
+	* Per arm mode, controllable openings that must NOT be actuated on arm.
+	* Default `[]` = every controllable secures (close / lock / off). Absent on
+	* an older blob — read as empty (secure ON).
+	*/
+	secureOnArmOff: NcAlarmSecureOnArmOffListSchema.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`.
@@ -19908,7 +19960,7 @@ var NcAlarmSettingsSchema = object({
 /**
 * Every field optional — a tab edits one control at a time.
 *
-* `nonBlocking` and `modeDelays` are re-declared WITHOUT their defaults:
+* List fields 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
@@ -19916,11 +19968,15 @@ var NcAlarmSettingsSchema = object({
 */
 var NcAlarmSettingsPatchSchema = NcAlarmSettingsSchema.extend({
 	nonBlocking: NcAlarmNonBlockingListSchema,
+	blocking: NcAlarmBlockingListSchema,
+	secureOnArmOff: NcAlarmSecureOnArmOffListSchema,
 	/** 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" });
+	nonBlockingEdit: NcAlarmNonBlockingEditSchema,
+	blockingEdit: NcAlarmBlockingEditSchema,
+	secureOnArmEdit: NcAlarmSecureOnArmEditSchema
+}).partial().refine((p) => p.nonBlocking === void 0 || p.nonBlockingEdit === void 0, { message: "nonBlocking and nonBlockingEdit are exclusive — send the whole lists or one edit" }).refine((p) => p.blocking === void 0 || p.blockingEdit === void 0, { message: "blocking and blockingEdit are exclusive — send the whole lists or one edit" }).refine((p) => p.secureOnArmOff === void 0 || p.secureOnArmEdit === void 0, { message: "secureOnArmOff and secureOnArmEdit 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
@@ -20035,7 +20091,13 @@ var NcAlarmSensorStateSchema = object({
 	/** Why `unknown`: the read failed, or the slice holds no word its cap defines (a placeholder included). */
 	unknownWhy: _enum(["read-failed", "unknown-word"]).nullable(),
 	/** The device manager's liveness as the centre mirrors it; null = not known. */
-	online: boolean().nullable()
+	online: boolean().nullable(),
+	/**
+	* True when the opening is a cover / lock / switch — the table shows the
+	* Secure-on-arm switch and uses the controllable defaults. False for contacts
+	* and for non-openings. Defaulted so an older hub answer still parses.
+	*/
+	controllable: boolean().default(false)
 });
 var NcAlarmSensorsInputSchema = object({ deviceIds: array(number().int().positive()).max(500) });
 var NcAlarmSensorsSchema = object({
@@ -28090,6 +28152,65 @@ DeviceType.Button, method(object({ deviceId: number().int().nonnegative() }), _v
 	auth: "protected"
 });
 /**
+* `calendar-source` — collection cap exposing per-provider calendars and
+* their events. Every addon that contributes calendars (Home Assistant,
+* a future Google Calendar addon, …) registers a provider here. The hub
+* singleton `calendars` walks the collection and merges the answers.
+*
+* Mirrors `addon-pages-source`: the public listing is a different shape
+* (source-stamped ids) and lives on the aggregator.
+*/
+var CalendarSourceKindSchema = _enum(["ha", "addon"]);
+var CalendarInfoSchema = object({
+	/** Provider-local id (e.g. HA `calendar.family`). The aggregator prefixes. */
+	id: string().min(1),
+	name: string().min(1),
+	source: CalendarSourceKindSchema,
+	enabled: boolean()
+});
+var CalendarEventSchema = object({
+	id: string().min(1),
+	calendarId: string().min(1),
+	title: string(),
+	startMs: number().int(),
+	endMs: number().int(),
+	allDay: boolean().optional(),
+	description: string().optional(),
+	location: string().optional()
+});
+var CalendarListEventsInputSchema = object({
+	calendarIds: array(string().min(1)).max(64).optional(),
+	startMs: number().int(),
+	endMs: number().int()
+});
+method(_void(), array(CalendarInfoSchema).readonly(), { auth: "admin" }), method(CalendarListEventsInputSchema, array(CalendarEventSchema).readonly(), { auth: "admin" });
+/**
+* `calendars` — system-scoped singleton. Public surface admin-ui and the
+* notification-center calendar-events producer consume.
+*
+* Walks every `calendar-source` provider, stamps each calendar with a
+* cluster-stable id (`<sourceAddonId>:<localId>`) and the providing
+* addon's id, and fans `listEvents` out the same way. Home Assistant
+* import is a built-in refresh of the HA source rather than a second
+* registry — `importFromHomeAssistant` asks that source to re-discover.
+*/
+var CalendarEntrySchema = CalendarInfoSchema.extend({
+	/** Cluster-stable id: `<providerAddonId>:<localId>`. */
+	id: string().min(1),
+	/** The addon that registered the calendar-source provider. */
+	providerAddonId: string().min(1).optional()
+});
+var CalendarImportResultSchema = object({
+	imported: number().int().nonnegative(),
+	/** Absent when no HA calendar-source provider was reachable. */
+	providerAddonId: string().min(1).optional(),
+	error: string().optional()
+});
+method(_void(), array(CalendarEntrySchema).readonly(), { auth: "admin" }), method(CalendarListEventsInputSchema, array(CalendarEventSchema).readonly(), { auth: "admin" }), method(_void(), CalendarImportResultSchema, {
+	auth: "admin",
+	kind: "mutation"
+});
+/**
 * camera-credentials — device-scoped cap exposing the camera's network
 * + auth surface in a vendor-neutral shape.
 *
@@ -31340,22 +31461,35 @@ DeviceType.Camera, method(object({
 	deviceId: number(),
 	status: OsdStatusSchema
 });
+_enum([
+	"value",
+	"unit",
+	"full"
+]);
+_enum([
+	"value+unit",
+	"value",
+	"unit"
+]);
 /**
-* `osd-manager` — the ORCHESTRATOR over the device-scope `osd` cap.
-*
-* The `osd` cap is the firmware contract: it probes a camera's overlay
-* SLOTS and writes literal text into one. It has no idea WHERE that text
-* comes from, and it must not — a driver that grew a "show the temperature
-* here" feature would grow it once per vendor.
-*
-* This cap owns the other half: a per-(camera, slot) BINDING that says
-* which value feeds the slot, how it is formatted, and under which
-* conditions it is shown at all. Named TEMPLATES combine many device
-* fields into one overlay string (Scrypted OSD Manager parity).
+* How the operator reached the leaf device. `deviceId` is ALWAYS the
+* OSD-supported leaf that is read; `containerId` is set when the pick
+* went through a container (gateway) first.
 */
-/** One field reference inside a named multi-device template. */
-var OsdTemplateFieldSchema = object({
-	deviceId: number().int(),
+var OsdTemplatePickSchema = object({
+	containerId: number().int().optional(),
+	deviceId: number().int()
+});
+/**
+* One named binding inside a multi-device template: device path + unit
+* selection + precision. The parser expands `{alias}`, `{alias.value}`,
+* `{alias.unit}`, or `{alias.full}` from the same binding — there is no
+* per-binding format lock.
+*/
+var OsdTemplateBindingSchema = object({
+	/** Token stem in the parser, e.g. `t` → `{t}` / `{t.value}`. Unique within the template. */
+	alias: string().min(1).max(32).regex(/^[A-Za-z][A-Za-z0-9_-]*$/, "alias must start with a letter"),
+	pick: OsdTemplatePickSchema,
 	capName: string().min(1).max(64),
 	valuePath: string().min(1).max(64),
 	/** Convert TO this unit at render (`tryConvertUnit`). Absent = source unit. */
@@ -31363,14 +31497,14 @@ var OsdTemplateFieldSchema = object({
 	maxDecimals: number().int().min(0).max(4).default(1)
 });
 /**
-* A named template: several device fields → one parser string with
-* `{deviceId.capName.valuePath}` tokens (Scrypted `{deviceId.sensorId}`).
+* A named template: bindings (alias → leaf field) + a parser that
+* references `{alias}` / `{alias.value}` / `{alias.unit}` / `{alias.full}`.
 */
 var OsdNamedTemplateSchema = object({
 	id: string().min(1).max(64),
 	name: string().min(1).max(64),
-	fields: array(OsdTemplateFieldSchema).max(32).default([]),
-	/** Parser with multi-token placeholders, e.g. `T {12.thermometer.value}°`. */
+	bindings: array(OsdTemplateBindingSchema).max(32).default([]),
+	/** Parser with alias placeholders, e.g. `{t.value} {t.unit} / {h}`. */
 	parser: string().max(256).default("")
 });
 /** Where a slot's value comes from. */
@@ -37773,6 +37907,36 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"calendars.importFromHomeAssistant": {
+		capName: "calendars",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"calendars.listCalendars": {
+		capName: "calendars",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"calendars.listEvents": {
+		capName: "calendars",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"calendarSource.listCalendars": {
+		capName: "calendar-source",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"calendarSource.listEvents": {
+		capName: "calendar-source",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"cameraCredentials.getCredentials": {
 		capName: "camera-credentials",
 		capScope: "device",
@@ -47756,7 +47920,7 @@ var AgentUIAddon = class extends BaseAddon {
 			capability: adminUiCapability,
 			provider: {
 				getStaticDir: async () => ({ staticDir: path.resolve(__dirname) }),
-				getVersion: async () => ({ version: "1.2.165" })
+				getVersion: async () => ({ version: "1.2.167" })
 			}
 		}];
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-agent-ui",
-  "version": "1.2.165",
+  "version": "1.2.167",
   "description": "Agent UI — lightweight status dashboard served by every agent node",
   "keywords": [
     "camstack",