@camstack/addon-model-studio 1.1.191 → 1.1.193

package/dist/model-studio.addon.js

@@ -20519,14 +20519,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.
@@ -20569,9 +20607,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`.
@@ -20581,7 +20633,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
@@ -20589,11 +20641,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
@@ -20708,7 +20764,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({
@@ -28763,6 +28825,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.
 *
@@ -32013,38 +32134,52 @@ DeviceType.Camera, method(object({
 	deviceId: number(),
 	status: OsdStatusSchema
 });
+_enum([
+	"value",
+	"unit",
+	"full"
+]);
+_enum([
+	"value+unit",
+	"value",
+	"unit"
+]);
+/**
+* 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.
+*/
+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. */
+	displayUnit: string().max(16).optional(),
+	maxDecimals: number().int().min(0).max(4).default(1)
+});
 /**
-* `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. One addon renders every binding on every
-* camera, so a new source costs zero driver code.
-*
-* Three deliberate choices, each with a rejected alternative:
-*
-*  1. A source is `(capName, valuePath)` over the kernel's device
-*     runtime-state mirror — NOT a closed enum of source kinds. Every
-*     cap-keyed slice a device publishes is bindable the day the cap
-*     ships. The rejected alternative (one enum member per source, with
-*     a resolver branch each) is what makes "add the humidity too" a
-*     code change.
-*  2. The display gate reuses `NcConditionsSchema` verbatim — the
-*     notification centre's condition vocabulary — rather than a parallel
-*     model. An operator who has learned one condition editor has learned
-*     both.
-*  3. Because the renderer's facts are device STATE and not a detection
-*     record, only a SUBSET of that vocabulary can be answered here.
-*     `setSlotBinding` REJECTS the rest at write time (see
-*     `getConditionSupport`). It does not accept-then-fail-closed: a
-*     condition that can never be true renders a permanently blank
-*     overlay, and a blank overlay looks exactly like a broken camera.
+* 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),
+	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. */
 var OsdSourceSchema = discriminatedUnion("kind", [
 	object({
@@ -32063,11 +32198,17 @@ var OsdSourceSchema = discriminatedUnion("kind", [
 		deviceId: number().int().optional(),
 		capName: string().min(1).max(64),
 		/** Dot path inside the slice, e.g. `detected`, `value`, `mode`. */
-		valuePath: string().min(1).max(64)
+		valuePath: string().min(1).max(64),
+		/** Convert TO this unit at render. Absent = no conversion. */
+		displayUnit: string().max(16).optional()
 	}),
 	object({
 		kind: literal("latest-recognition"),
 		recognition: _enum(["person", "plate"])
+	}),
+	object({
+		kind: literal("template"),
+		templateId: string().min(1).max(64)
 	})
 ]);
 var OsdSlotBindingSchema = object({
@@ -32083,7 +32224,10 @@ var OsdSlotBindingSchema = object({
 	* documented workaround for firmwares that reject `.` in overlay text.
 	*/
 	maxDecimals: number().int().min(0).max(4).default(1),
-	/** Appended via `${unit}`. The state mirror does not carry units. */
+	/**
+	* Appended via `${unit}` when no unit conversion produces a label.
+	* Prefer `source.displayUnit` for converted device-state values.
+	*/
 	unitLabel: string().max(8).optional(),
 	/** Raw value → display text, e.g. `{"true":"MOTION","false":""}`. */
 	valueMap: record(string(), string()).optional(),
@@ -32192,6 +32336,12 @@ method(object({ deviceId: number().int() }), object({
 }), method(object({ deviceId: number().int() }), object({ results: array(OsdRenderResultSchema) }), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({}), object({ templates: array(OsdNamedTemplateSchema) }), { auth: "admin" }), method(object({ template: OsdNamedTemplateSchema }), object({ template: OsdNamedTemplateSchema }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ templateId: string().min(1).max(64) }), object({ success: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
 });
 /**
 * Feeder connectivity / power status — mirrors the HA petkit device-status
@@ -38430,6 +38580,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",
@@ -41424,6 +41604,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"osdManager.deleteTemplate": {
+		capName: "osd-manager",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"osdManager.getConditionSupport": {
 		capName: "osd-manager",
 		capScope: "system",
@@ -41442,6 +41628,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"osdManager.listTemplates": {
+		capName: "osd-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"osdManager.previewSlot": {
 		capName: "osd-manager",
 		capScope: "system",
@@ -41460,6 +41652,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"osdManager.upsertTemplate": {
+		capName: "osd-manager",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"petFeeder.callPet": {
 		capName: "pet-feeder",
 		capScope: "device",