@camstack/types 1.2.16 → 1.2.18

package/dist/index.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-DRg9F6JJ.js");
-const require_event_category = require("./event-category-Cdyife4p.js");
+const require_sleep = require("./sleep-DETsT9rJ.js");
+const require_event_category = require("./event-category-39bpf1r_.js");
 const require_enums = require("./enums.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
 let zod = require("zod");
@@ -792,35 +792,22 @@ var EVENT_PAD_MS = {
 */
 var RecordingWeekdaySchema = zod.z.number().int().min(0).max(6);
 var HHMM = /^([01]\d|2[0-3]):[0-5]\d$/;
-var RecordingScheduleSchema = zod.z.discriminatedUnion("kind", [zod.z.object({ kind: zod.z.literal("always") }), zod.z.object({
-	kind: zod.z.literal("timeOfDay"),
-	start: zod.z.string().regex(HHMM),
-	end: zod.z.string().regex(HHMM),
-	/** Restrict to these weekdays; omit = every day. */
-	days: zod.z.array(RecordingWeekdaySchema).optional()
-})]);
-var RecordingModeSchema = zod.z.enum([
-	"continuous",
-	"onMotion",
-	"onAudioThreshold"
-]);
 /**
-* First-class, authoritative per-camera storage mode — the explicit choice the
-* UI reads directly (never inferred from `rules`):
-*  - `off`        — not recording.
-*  - `events`     — record only around triggers (motion / audio threshold),
-*                   with pre/post-buffer.
-*  - `continuous` — record 24/7 within the schedule.
+* DERIVED per-camera storage summary — the single field cheap consumers read
+* (the viewer's status dot, the camera list) instead of walking `bands`:
+*  - `off`        — no band covers the camera (or it is disabled).
+*  - `events`     — every band records around triggers only.
+*  - `continuous` — at least one band records continuously.
 *
-* `mode` compiles one-way to the internal `rules[]` consumed by the policy
-* engine (see `compileRules`); `rules[]` is never authored directly anymore.
+* NEVER authored: the recorder stamps it from the authoritative `bands` on
+* every save (`activeModeForConfig`). Writing it has no effect.
 */
 var RecordingStorageModeSchema = zod.z.enum([
 	"off",
 	"events",
 	"continuous"
 ]);
-/** Which detectors trigger an `events`-mode recording. */
+/** Which detectors trigger an `events`-mode band. */
 var RecordingTriggersSchema = zod.z.object({
 	motion: zod.z.boolean().optional(),
 	audioThresholdDbfs: zod.z.number().optional()
@@ -856,18 +843,6 @@ var RecordingBandSchema = zod.z.object({
 	preBufferSec: zod.z.number().min(0).optional(),
 	postBufferSec: zod.z.number().min(0).optional()
 });
-var RecordingRuleSchema = zod.z.object({
-	schedule: RecordingScheduleSchema,
-	mode: RecordingModeSchema,
-	/** Seconds of footage to retain BEFORE a trigger (applied at keep/discard). */
-	preBufferSec: zod.z.number().min(0).default(0),
-	/** Keep recording until this many seconds after the last trigger. */
-	postBufferSec: zod.z.number().min(0).default(0),
-	/** Each new trigger restarts the post-buffer window. */
-	resetTimeoutOnNewEvent: zod.z.boolean().default(true),
-	/** onAudioThreshold only — dBFS level that counts as a trigger. */
-	thresholdDbfs: zod.z.number().optional()
-});
 /**
 * Per-device retention overrides. Every field is optional; an unset or `0`
 * value inherits the node-wide recorder default. Only footage-lifetime limits
@@ -960,40 +935,28 @@ function resolveScrubThumbnailGeometry(preset) {
 /**
 * The full per-camera recording intent — the wire shape of a RecordingTarget.
 *
-* `mode` is the authoritative storage choice; `schedule`/`triggers`/`pre`/`post`
-* are its mode-specific parameters. `rules` is a DEPRECATED authoring input kept
-* only for transition + migration (`migrateRulesToMode`); the policy engine
-* consumes the compiled output of `compileRules(config)`, never `rules` directly.
+* `bands` is the ONLY authored recording intent: what to record, when, and on
+* which trigger. `mode` is a derived summary the recorder stamps on save; every
+* other field is a storage knob (profiles, segment length, retention, scrub).
+*
+* STRICT on purpose: the legacy authoring surface (`schedule`/`schedules`/
+* `triggers`/`preBufferSec`/`postBufferSec`/`rules`) was retired 2026-07-30.
+* A stale caller must fail loudly — silently stripping its legacy intent would
+* persist a band-less config, i.e. silently stop recording the camera.
 */
 var RecordingConfigSchema = zod.z.object({
 	enabled: zod.z.boolean(),
-	/** Authoritative storage mode. Absent on legacy targets → derived once via
-	*  `migrateRulesToMode`, then persisted. */
+	/** DERIVED summary of `bands`, stamped by the recorder on every save.
+	*  Authoring it has no effect — see {@link RecordingStorageModeSchema}. */
 	mode: RecordingStorageModeSchema.optional(),
 	profiles: zod.z.array(require_sleep.CamProfileSchema).optional(),
 	segmentSeconds: zod.z.number().int().positive().optional(),
-	/** Shared recording time-bands for `events` & `continuous` — record only when
-	*  the wall-clock falls inside one of these windows. Omit or empty = always.
-	*  `continuous` compiles to one rule per band; `events` to band × trigger. */
-	schedules: zod.z.array(RecordingScheduleSchema).optional(),
-	/** Legacy single-band predecessor of `schedules`. Read-compat only — it is
-	*  normalized into `schedules` on read and never written going forward. (Not
-	*  tagged `@deprecated`: the normalization paths must read it cast-free.) */
-	schedule: RecordingScheduleSchema.optional(),
-	/** `events`-mode only — which detectors trigger a recording. */
-	triggers: RecordingTriggersSchema.optional(),
-	/** `events`-mode only — seconds retained before / after a trigger. */
-	preBufferSec: zod.z.number().min(0).optional(),
-	postBufferSec: zod.z.number().min(0).optional(),
-	/** DEPRECATED authoring input; retained for migration/transition. */
-	rules: zod.z.array(RecordingRuleSchema).optional(),
 	/**
-	* AUTHORITATIVE mode-per-band recording model (recorder). When present it
-	* is the single source of truth; the legacy `mode`/`schedules`/`schedule`/
-	* `triggers`/`rules` fields above are kept for READ-COMPAT only and are
-	* derived into bands once via `migrateConfigToBands`.
+	* AUTHORITATIVE mode-per-band recording model — the single source of truth
+	* the recorder's band engine consumes. An empty array = record nothing;
+	* "off" is the absence of a covering band, never a band value.
 	*/
-	bands: zod.z.array(RecordingBandSchema).optional(),
+	bands: zod.z.array(RecordingBandSchema).default([]),
 	retention: RecordingRetentionSchema.optional(),
 	/**
 	* Per-camera scrub-thumbnail fidelity preset (resolution + JPEG quality for
@@ -1001,62 +964,30 @@ var RecordingConfigSchema = zod.z.object({
 	* windows only — existing sheets are immutable, and each window's index
 	* carries its own tile dims so mixed-preset history renders correctly.
 	*/
-	scrubThumbnails: ScrubThumbnailPresetSchema.optional()
-});
-//#endregion
-//#region src/interfaces/recording-config-migrate.ts
-/** All seven weekdays (0 = Sunday … 6 = Saturday), used when a schedule omits a
-*  weekday filter. */
-var ALL_DAYS = [
-	0,
-	1,
-	2,
-	3,
-	4,
-	5,
-	6
-];
-/** Full-day span used to represent an `always` schedule as a band. The `HHMM`
-*  regex maxes out at 23:59, so a 00:00–23:59 same-day span ≈ all-day (the band
-*  engine treats `end > start` as a normal, non-wrapping span). */
-var ALL_DAY_START = "00:00";
-var ALL_DAY_END = "23:59";
-function bandFromSchedule(schedule, mode, config) {
-	const days = schedule.kind === "timeOfDay" && schedule.days ? schedule.days : [...ALL_DAYS];
-	const start = schedule.kind === "timeOfDay" ? schedule.start : ALL_DAY_START;
-	const end = schedule.kind === "timeOfDay" ? schedule.end : ALL_DAY_END;
-	if (mode === "continuous") return {
-		days,
-		start,
-		end,
-		mode
-	};
-	return {
-		days,
-		start,
-		end,
-		mode,
-		...config.triggers ? { triggers: config.triggers } : {},
-		...config.preBufferSec !== void 0 ? { preBufferSec: config.preBufferSec } : {},
-		...config.postBufferSec !== void 0 ? { postBufferSec: config.postBufferSec } : {}
-	};
-}
-/**
-* One-way migration from the legacy recording-config shape to the authoritative
-* mode-per-band model. Pure (no clock access).
-*
-* - If `config.bands` is present, it is authoritative and returned as-is.
-* - Otherwise the result is derived from the legacy fields: a disabled config or
-*   `mode: 'off'` yields no bands; every legacy schedule maps to one band whose
-*   mode is `continuous` when `config.mode === 'continuous'`, else `events`
-*   (carrying `triggers`/`preBufferSec`/`postBufferSec`).
-*/
-function migrateConfigToBands(config) {
-	if (config.bands) return config.bands;
-	if (!config.enabled || config.mode === "off") return [];
-	const schedules = config.schedules ?? (config.schedule ? [config.schedule] : [{ kind: "always" }]);
-	const bandMode = config.mode === "continuous" ? "continuous" : "events";
-	return schedules.map((schedule) => bandFromSchedule(schedule, bandMode, config));
+	scrubThumbnails: ScrubThumbnailPresetSchema.optional(),
+	/**
+	* OPT-IN thumbnail-strip generation for this camera: every keyframe of the
+	* low recording saved as a JPEG (the fast-drag scrub depth), a derived
+	* cache that eviction reclaims with the footage. Absent/false = no strips
+	* are written and scrub reads exact keyframes at every velocity.
+	*/
+	stripsEnabled: zod.z.boolean().optional()
+}).strict();
+/**
+* Derive the {@link RecordingStorageModeSchema} summary from the authoritative
+* bands: `continuous` when any band records continuously, `events` when a band
+* exists at all, else `off`. Pure.
+*
+* THE one definition: the recorder stamps `config.mode` with it on save and
+* reports it as the cap's `activeMode`, and the settings UI reads it back to
+* decide which authoring tab a config opens in. Two copies would drift, and the
+* symptom (a status dot disagreeing with what is being recorded) is exactly the
+* bug this field was added to fix.
+*/
+function deriveRecordingMode(config) {
+	if (!config.enabled || config.bands.length === 0) return "off";
+	if (config.bands.some((band) => band.mode === "continuous")) return "continuous";
+	return "events";
 }
 //#endregion
 //#region src/interfaces/ops-log.ts
@@ -1078,7 +1009,8 @@ var OpsLogOpSchema = zod.z.enum([
 	"prune",
 	"manual-delete",
 	"rescan",
-	"retention-run"
+	"retention-run",
+	"relocate"
 ]);
 /** Why the operation ran. */
 var OpsLogReasonSchema = zod.z.enum([
@@ -1124,6 +1056,57 @@ var OPS_LOG_RING_DEFAULT_MAX = 500;
 /** Default page size for a `listOpsLog` query when the caller omits `limit`. */
 var OPS_LOG_DEFAULT_LIMIT = 200;
 //#endregion
+//#region src/interfaces/relocate.ts
+/**
+* Entity-relocation job state (storage entity-routing spec, Phase 4).
+*
+* One shape shared by the recorder's `relocateFootage` (segments + strips) and
+* pipeline-analytics' `relocateMedia` (event media blobs) so the admin Data
+* page renders both movers with one component. Jobs are in-RAM (a restart
+* forgets them — re-running is safe by construction: copy-if-absent, delete
+* after verify) and each completed/failed run also lands one durable ops-log
+* row on the owning addon's surface.
+*/
+var RelocateJobStateSchema = zod.z.enum([
+	"running",
+	"done",
+	"failed",
+	"cancelled"
+]);
+var RelocateJobSchema = zod.z.object({
+	jobId: zod.z.string(),
+	state: RelocateJobStateSchema,
+	/** Source location — for media relocation this is informational ('*': rows
+	*  move from wherever they are to the target). */
+	fromLocationId: zod.z.string(),
+	toLocationId: zod.z.string(),
+	/** Scoped device, or null = every device. */
+	deviceId: zod.z.number().nullable(),
+	/** What the job moves (owner-addon specific: segments/strips or media). */
+	entities: zod.z.array(zod.z.string()),
+	filesMoved: zod.z.number().int(),
+	bytesMoved: zod.z.number().int(),
+	/** Total files discovered up front; null while (or when) unknown. */
+	filesTotal: zod.z.number().int().nullable(),
+	startedAt: zod.z.number(),
+	finishedAt: zod.z.number().nullable(),
+	error: zod.z.string().nullable()
+});
+var RelocateFootageInputSchema = zod.z.object({
+	deviceId: zod.z.number().optional(),
+	fromLocationId: zod.z.string(),
+	toLocationId: zod.z.string(),
+	entities: zod.z.array(zod.z.enum(["segments", "strips"])).optional(),
+	/** Copy throttle in MB/s (default 40) — the drain is a background chore,
+	*  never allowed to starve live writers. */
+	throttleMbps: zod.z.number().min(1).max(1e3).optional()
+});
+var RelocateMediaInputSchema = zod.z.object({
+	deviceId: zod.z.number().optional(),
+	toLocationId: zod.z.string(),
+	throttleMbps: zod.z.number().min(1).max(1e3).optional()
+});
+//#endregion
 //#region src/interfaces/logging.ts
 /**
 * Severity ordering. Declared once here because it had already been re-declared
@@ -1197,6 +1180,13 @@ var StorageLocationSchema = zod.z.object({
 	nodeId: zod.z.string().optional(),
 	isDefault: zod.z.boolean().default(false),
 	isSystem: zod.z.boolean().default(false),
+	/** COMPUTED at read time by the orchestrator (statfs of the backing volume
+	*  for node-local locations it can reach) — never persisted, absent when the
+	*  volume is remote/unreachable. The single capacity truth every UI reads. */
+	capacity: zod.z.object({
+		totalBytes: zod.z.number(),
+		availableBytes: zod.z.number()
+	}).nullable().optional(),
 	createdAt: zod.z.number(),
 	updatedAt: zod.z.number()
 });
@@ -4344,9 +4334,20 @@ var DEGRADE_ORDER = {
 		"markdown"
 	]
 };
-/** Pick the best target format the kind supports for a given source format. */
+/**
+* Pick the best target format the kind supports for a given source format.
+*
+* TOLERANT of a source outside the union. `NotificationSchema.format` carries
+* `.default('text')`, but that default only runs where the schema is PARSED —
+* the tRPC router. A cap call arriving from another addon (`ctx.api`) skips
+* that parse, so `format` reaches here `undefined`, and the bare
+* `DEGRADE_ORDER[source]` threw `is not iterable`. That broke the one promise
+* the degrade path makes ("never throws — degradation is reported, never
+* surfaced as an error") and dead-lettered every Notification-Center delivery
+* for a day (2026-07-30). An unknown source degrades like `text`.
+*/
 function resolveFormat(source, supported) {
-	for (const candidate of DEGRADE_ORDER[source]) if (supported.includes(candidate)) return candidate;
+	for (const candidate of DEGRADE_ORDER[source] ?? DEGRADE_ORDER.text) if (supported.includes(candidate)) return candidate;
 	return supported[0] ?? "text";
 }
 /** Transcode a body between formats. */
@@ -4393,7 +4394,7 @@ function resolveLevel(levels, n) {
 	})[0]);
 }
 function splitBody(body, maxLen) {
-	if (maxLen <= 0 || body.length <= maxLen) return [body];
+	if (!Number.isFinite(maxLen) || maxLen <= 0 || body.length <= maxLen) return [body];
 	const parts = [];
 	for (let i = 0; i < body.length; i += maxLen) parts.push(body.slice(i, i + maxLen));
 	return parts;
@@ -4477,6 +4478,114 @@ function prepareNotification(caps, n) {
 	};
 }
 //#endregion
+//#region src/notification/condition-taxonomy.ts
+/** Condition ids that render the class picker (video macros/subs + audio). */
+var CLASS_CONDITION_IDS = new Set(["classes", "classesExclude"]);
+/** Condition ids that render the sensor/control label picker. */
+var LABEL_CONDITION_IDS = new Set(["sensorKinds"]);
+function toOption(entry) {
+	return {
+		value: entry.kind,
+		label: entry.label
+	};
+}
+/**
+* Group detection entries by their macro. A macro entry (`parentKind === null`)
+* opens its own group and is itself the first option in it; subs fall under
+* their `parentKind`. First-appearance order is preserved, which is why
+* `buildNcTaxonomy` emits macros before their subs.
+*/
+function groupVideoClasses(videoClasses) {
+	const order = [];
+	const byKey = /* @__PURE__ */ new Map();
+	const ensure = (key, fallbackLabel) => {
+		const existing = byKey.get(key);
+		if (existing !== void 0) return existing;
+		const created = {
+			fallbackLabel,
+			options: []
+		};
+		byKey.set(key, created);
+		order.push(key);
+		return created;
+	};
+	for (const entry of videoClasses) {
+		const key = entry.parentKind ?? entry.kind;
+		const group = ensure(key, entry.parentKind === null ? entry.label : key);
+		group.options.push(toOption(entry));
+		if (entry.parentKind === null) group.fallbackLabel = entry.label;
+	}
+	return order.flatMap((key) => {
+		const group = byKey.get(key);
+		return group === void 0 ? [] : [{
+			key,
+			fallbackLabel: group.fallbackLabel,
+			options: group.options
+		}];
+	});
+}
+/** Group sensor/control labels by their category parent (`sensor` | `control`). */
+function groupLabels(labels) {
+	const order = [];
+	const byKey = /* @__PURE__ */ new Map();
+	for (const entry of labels) {
+		const key = entry.parentKind ?? "other";
+		const existing = byKey.get(key);
+		if (existing === void 0) {
+			byKey.set(key, [toOption(entry)]);
+			order.push(key);
+		} else existing.push(toOption(entry));
+	}
+	return order.flatMap((key) => {
+		const options = byKey.get(key);
+		return options === void 0 ? [] : [{
+			key,
+			fallbackLabel: key,
+			options
+		}];
+	});
+}
+/**
+* Build the grouped picker model for a condition id, or `null` when the
+* condition has no fixed vocabulary (→ free-text tag input).
+*/
+function pickerForCondition(conditionId, taxonomy) {
+	if (!taxonomy) return null;
+	if (CLASS_CONDITION_IDS.has(conditionId)) {
+		const groups = groupVideoClasses(taxonomy.videoClasses);
+		if (taxonomy.audioKinds.length > 0) groups.push({
+			key: "audio",
+			fallbackLabel: "Audio",
+			options: taxonomy.audioKinds.map(toOption)
+		});
+		return groups.length > 0 ? { groups } : null;
+	}
+	if (LABEL_CONDITION_IDS.has(conditionId)) {
+		const groups = groupLabels(taxonomy.labels);
+		return groups.length > 0 ? { groups } : null;
+	}
+	return null;
+}
+/** All option values across a picker's groups (for custom-value detection). */
+function knownValues(picker) {
+	const set = /* @__PURE__ */ new Set();
+	for (const group of picker.groups) for (const option of group.options) set.add(option.value);
+	return set;
+}
+/**
+* The condition ids shown in the ALWAYS-VISIBLE area of a rule editor. Every
+* other catalog descriptor is advanced and lives behind an expander.
+*
+* Shared for the same reason as the picker model: two surfaces disagreeing
+* about what counts as "basic" is a worse outcome than either choice.
+*/
+var NC_BASE_CONDITION_KEYS = ["devices", "classes"];
+var BASE_CONDITION_SET = new Set(NC_BASE_CONDITION_KEYS);
+/** True when a condition key belongs to the BASE surface. */
+function isBaseConditionKey(key) {
+	return BASE_CONDITION_SET.has(key);
+}
+//#endregion
 //#region src/capabilities/mask-shape.ts
 /**
 * Shared geometry vocabulary for on-frame shape caps — privacy-mask,
@@ -4649,6 +4758,29 @@ var NcOccupancyConditionSchema = zod.z.object({
 	count: zod.z.number().int().min(0).default(1),
 	sustainSeconds: zod.z.number().int().min(0).max(3600).default(15)
 });
+/**
+* Which zone-crossing DIRECTION a rule accepts (`ObjectEvent.zoneCrossing`).
+*
+* The values are not symmetric, and deliberately so — the absent value has to
+* mean exactly what every rule authored before this condition existed already
+* does:
+*  - `enter` — entries and every NON-crossing record (movement state,
+*    package, sensor). Exits are rejected. **This is the absent behaviour**:
+*    an operator who never asked for exits must not start receiving them.
+*  - `exit`  — ONLY an exit crossing. A record that is not a crossing at all
+*    fails closed, because "the car left the drive" is a question about a
+*    boundary, not about a detection.
+*  - `any`   — no direction filter; entries, exits and non-crossings alike.
+*
+* A rule asking for a direction should normally also scope `zones`, which the
+* engine evaluates against the crossed zone as well as the current membership
+* (an exit's membership no longer contains the zone it just left).
+*/
+var NcCrossingSchema = zod.z.enum([
+	"enter",
+	"exit",
+	"any"
+]);
 /** Admin-zone membership condition (zone IDs as stamped by the ZoneEngine). */
 var NcZoneConditionSchema = zod.z.object({
 	ids: zod.z.array(zod.z.string().min(1)).min(1),
@@ -4673,6 +4805,13 @@ var NcConditionsSchema = zod.z.object({
 	/** Veto zones — any hit fails the rule. */
 	zonesExclude: zod.z.array(zod.z.string().min(1)).optional(),
 	/**
+	* Zone-crossing direction. IMMEDIATE only — a crossing is a per-event fact
+	* and a closed track carries none, so a `track-end` rule asking for one
+	* fails closed (use `zones`, which tests `zonesVisited`). ABSENT = `enter`,
+	* which is exactly today's behaviour. See {@link NcCrossingSchema}.
+	*/
+	crossing: NcCrossingSchema.optional(),
+	/**
 	* Exact (case-insensitive) match on the record's collapsed `label`
 	* (identity name / plate text / subclass).
 	*/
@@ -4807,17 +4946,85 @@ var NcRuleTargetSchema = zod.z.object({
 *  - `keyFrame` — the clean scene frame (no subject box).
 *  - `none` — no attachment.
 */
-var NcMediaPolicySchema = zod.z.object({ attach: zod.z.enum([
-	"best",
-	"best-matching",
-	"keyFrame",
-	"none"
-]).default("best") });
+/**
+* WHAT THE PICTURE SHOWS — chosen explicitly, because the implicit ladders
+* conflate it with the selection strategy and betray the request: asking for
+* the clean scene frame on an object-event owner used to start at
+* `fullFrameBoxed`, i.e. the annotated frame (2026-07-30).
+*  - `cropped` — the subject, tight. What "who is at the door" wants.
+*  - `full`    — the clean scene, no annotation. What "what is going on" wants.
+*  - `boxed`   — the scene WITH the detection boxes drawn, for verifying what
+*                the pipeline actually saw.
+*/
+var NcMediaFrameSchema = zod.z.enum([
+	"cropped",
+	"full",
+	"boxed"
+]);
+var NcMediaPolicySchema = zod.z.object({
+	attach: zod.z.enum([
+		"best",
+		"best-matching",
+		"keyFrame",
+		"none"
+	]).default("best"),
+	/** What the still shows. Absent = `cropped` (the historical `best` shape). */
+	frame: NcMediaFrameSchema.optional(),
+	/** Crop the attached still to the rule's condition-zone bbox (padded) —
+	*  "show me the ZONE", not the whole scene or the subject crop. */
+	zoneCrop: zod.z.boolean().optional(),
+	/**
+	* Also attach a short GIF cut from the stream broker's clip ring around the
+	* event — NOT from the recording, so the camera does not have to be
+	* recording, and the window sits AROUND the moment instead of a segment
+	* behind it. Fail-closed: a window the ring does not cover contributes no
+	* gif, never a failed notification.
+	*/
+	gif: zod.z.boolean().optional(),
+	/**
+	* Also attach a short MP4 CLIP of the same cut. Same source and the same
+	* fail-closed rule as `gif`. Prefer it where the backend takes video
+	* (telegram, discord, zentik, webhook); backends that do not are handled by
+	* the degrade engine, which drops the video and keeps the still.
+	*/
+	clip: zod.z.boolean().optional(),
+	/** Seconds of footage BEFORE / AFTER the event instant. Defaults 3 / 7. */
+	clipPreRollSec: zod.z.number().int().min(0).max(30).optional(),
+	clipPostRollSec: zod.z.number().int().min(0).max(30).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.
+	* A profile that is not assigned falls back to the cheapest, and the render
+	* reports which one actually ran.
+	*/
+	profile: require_sleep.CamProfileSchema.optional()
+});
+/**
+* Cooldown GRANULARITY over the subject's class — how much a fired
+* notification suppresses.
+*  - `shared` (default, and the absent value) — one window for the whole
+*    rule/scope: a cat silences the next dog for `cooldownSec`.
+*  - `per-class` — an independent window per detected class, so cat→dog fires
+*    at once and cat→cat still waits.
+*
+* AUDIO subjects are ALWAYS per-class regardless of this setting: a scream
+* must not be swallowed by a bark's window (the precedent this generalizes —
+* see `cooldownKey` in the rule engine).
+*/
+var NcThrottleGranularitySchema = zod.z.enum(["shared", "per-class"]);
 /** Throttle — cooldown survives restarts (rebuilt from the outbox on boot). */
 var NcThrottleSchema = zod.z.object({
 	cooldownSec: zod.z.number().int().min(0).max(86400).default(60),
 	/** `rule` = one shared cooldown; `rule-device` = per-camera cooldown. */
-	scope: zod.z.enum(["rule", "rule-device"]).default("rule-device")
+	scope: zod.z.enum(["rule", "rule-device"]).default("rule-device"),
+	/**
+	* Class granularity of the cooldown key. Optional rather than defaulted:
+	* a Zod default does NOT run on the addon→addon cap path, so a persisted
+	* rule authored before this field simply carries none — and the engine
+	* reads absent as `shared`, the pre-existing behaviour.
+	*/
+	granularity: NcThrottleGranularitySchema.optional()
 });
 /** Client-supplied rule fields (server stamps id/createdBy/createdAt/updatedAt). */
 var NcRuleInputSchema = zod.z.object({
@@ -4826,7 +5033,19 @@ var NcRuleInputSchema = zod.z.object({
 	delivery: NcDeliverySchema,
 	conditions: NcConditionsSchema.default({}),
 	schedule: NcScheduleSchema.optional(),
-	targets: zod.z.array(NcRuleTargetSchema).min(1),
+	/** May be empty when `targetUsers` addresses at least one user — the
+	*  "at least one addressee" invariant is enforced by the provider, because
+	*  a cross-field refine here would break `NcRulePatchSchema.partial()`. */
+	targets: zod.z.array(NcRuleTargetSchema),
+	/**
+	* USERS this rule addresses in addition to `targets` (Phase 4). At fire
+	* time each user fans out to the personal targets they own
+	* (`config.ownerUserId`), filtered by that user's `allowedDevices` for the
+	* firing camera — a user is never notified about a device they cannot open.
+	* Per-user opt-outs (`disabledTargetIds`) still apply to the fanned-out
+	* targets.
+	*/
+	targetUsers: zod.z.array(zod.z.string()).optional(),
 	media: NcMediaPolicySchema.default({ attach: "best" }),
 	throttle: NcThrottleSchema.default({
 		cooldownSec: 60,
@@ -4913,6 +5132,7 @@ var NcConditionDescriptorSchema = zod.z.object({
 		"schedule",
 		"plateMatcher",
 		"packagePhase",
+		"crossingSelect",
 		"polygonDraw",
 		"occupancy"
 	]),
@@ -5017,6 +5237,16 @@ var NC_CONDITION_CATALOG = [
 		],
 		phase: "P1"
 	},
+	{
+		id: "crossing",
+		group: "zones",
+		label: "Zone crossing",
+		valueType: "crossingSelect",
+		operator: "in",
+		appliesTo: ["immediate"],
+		phase: "P1",
+		description: "Direction of the zone crossing: enter (the default, and what every rule authored before this did) / exit / any. An exit rule matches only crossings."
+	},
 	{
 		id: "labelEquals",
 		group: "label",
@@ -5301,7 +5531,20 @@ var notificationRulesCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		getConditionCatalog: require_sleep.method(zod.z.object({}), zod.z.object({ catalog: zod.z.array(NcConditionDescriptorSchema) })),
+		/**
+		* The machine-readable condition surface a rule editor renders from, plus
+		* the picker VOCABULARY those conditions draw on.
+		*
+		* `taxonomy` is optional so an older provider that only returns `catalog`
+		* still validates; a client that receives none keeps free-text inputs.
+		* It was previously served ONLY on the `nc.getConditionCatalog` bridge
+		* action, which is why the viewer had grouped pickers and the admin UI —
+		* which reaches this cap — was stuck typing `person` from memory.
+		*/
+		getConditionCatalog: require_sleep.method(zod.z.object({}), zod.z.object({
+			catalog: zod.z.array(NcConditionDescriptorSchema),
+			taxonomy: NcTaxonomySchema.optional()
+		})),
 		/**
 		* Queryable delivery history — a read-only view over the durable outbox
 		* (fired rule, subject summary, target, status, timestamps, error on a
@@ -6390,6 +6633,48 @@ var streamBrokerCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Render a short GIF or MP4 from the broker's PRE-BUFFER around an instant.
+		*
+		* The pre-buffer is the only source that already holds the seconds BEFORE
+		* an event (it is what it exists for — "when an addon needs the last N
+		* seconds of video for clip creation"). Cutting from recorded segments
+		* cannot: only finalized segments are addressable and the one covering the
+		* moment is still being written, so a segment-sourced clip is either
+		* delayed or shows the approach instead of the event (operator,
+		* 2026-07-30). It also means a camera does not have to be RECORDING to
+		* produce a notification clip.
+		*
+		* Returns muxed BYTES, never packets: the frame plane never crosses a
+		* process boundary at frame rate (D9/D18) — this is one compressed,
+		* on-demand payload per notification.
+		*
+		* Waits up to `postRollSec` for the tail to accumulate, so the window is
+		* CENTRED on `aroundMs`.
+		*/
+		renderPreBufferClip: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			/** Absent = the LOWEST assigned profile — a notification attachment is
+			*  watched on a phone, and the cheap rendition is the right default. */
+			profile: require_sleep.CamProfileSchema.optional(),
+			aroundMs: zod.z.number(),
+			preRollSec: zod.z.number().min(0).max(20).default(3),
+			postRollSec: zod.z.number().min(0).max(20).default(5),
+			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)
+		}), zod.z.object({
+			base64: zod.z.string(),
+			mime: zod.z.string(),
+			bytes: zod.z.number().int(),
+			/** The profile actually rendered (what the default resolved to). */
+			profile: require_sleep.CamProfileSchema,
+			durationMs: zod.z.number()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		listAllCameraStreams: require_sleep.method(zod.z.void(), zod.z.array(require_sleep.CameraStreamSchema).readonly()),
 		listAllProfileSlots: require_sleep.method(zod.z.void(), zod.z.array(require_sleep.ProfileSlotSchema).readonly()),
 		getBrokerStats: require_sleep.method(zod.z.object({ brokerId: zod.z.string() }), require_sleep.BrokerStatsSchema),
@@ -14362,7 +14647,8 @@ function createSystemProxy(api) {
 			discoverAllProviders: (input) => dispatch("deviceManager", "discoverAllProviders", "mutation", input),
 			discoverProvider: (input) => dispatch("deviceManager", "discoverProvider", "mutation", input),
 			providerCreationType: (input) => dispatch("deviceManager", "providerCreationType", "query", input),
-			providerDiscoveryParamsSchema: (input) => dispatch("deviceManager", "providerDiscoveryParamsSchema", "query", input)
+			providerDiscoveryParamsSchema: (input) => dispatch("deviceManager", "providerDiscoveryParamsSchema", "query", input),
+			getDeviceStatusAggregateBatch: (input) => dispatch("deviceManager", "getDeviceStatusAggregateBatch", "query", input)
 		},
 		deviceProvider: {
 			start: (input) => dispatch("deviceProvider", "start", "mutation", input),
@@ -14433,6 +14719,8 @@ function createSystemProxy(api) {
 			list: (input) => dispatch("localNetwork", "list", "query", input),
 			getPreferred: (input) => dispatch("localNetwork", "getPreferred", "query", input),
 			getConnectionEndpoints: (input) => dispatch("localNetwork", "getConnectionEndpoints", "query", input),
+			getNotificationEndpoint: (input) => dispatch("localNetwork", "getNotificationEndpoint", "query", input),
+			setNotificationEndpoint: (input) => dispatch("localNetwork", "setNotificationEndpoint", "mutation", input),
 			getAllowedAddresses: (input) => dispatch("localNetwork", "getAllowedAddresses", "query", input),
 			setAllowedAddresses: (input) => dispatch("localNetwork", "setAllowedAddresses", "mutation", input),
 			resetAllowlistToBestMatch: (input) => dispatch("localNetwork", "resetAllowlistToBestMatch", "mutation", input)
@@ -14603,7 +14891,10 @@ function createSystemProxy(api) {
 		},
 		recording: {
 			getStorageUsage: (input) => dispatch("recording", "getStorageUsage", "query", input),
-			listOpsLog: (input) => dispatch("recording", "listOpsLog", "query", input)
+			listOpsLog: (input) => dispatch("recording", "listOpsLog", "query", input),
+			relocateFootage: (input) => dispatch("recording", "relocateFootage", "mutation", input),
+			getRelocateStatus: (input) => dispatch("recording", "getRelocateStatus", "query", input),
+			cancelRelocate: (input) => dispatch("recording", "cancelRelocate", "mutation", input)
 		},
 		recordingExport: {
 			getExport: (input) => dispatch("recordingExport", "getExport", "query", input),
@@ -18374,7 +18665,29 @@ var deviceManagerCapability = {
 		getDeviceStatusAggregate: require_sleep.method(zod.z.object({
 			deviceId: zod.z.number(),
 			caps: zod.z.array(zod.z.string()).readonly().optional()
-		}), zod.z.record(zod.z.string(), zod.z.unknown().nullable()))
+		}), zod.z.record(zod.z.string(), zod.z.unknown().nullable())),
+		/**
+		* The same aggregate, for a LIST of devices in one round-trip.
+		*
+		* The viewer's camera list is the caller this exists for. Each card asked
+		* for its own badges — battery here, recording mode there — so a ten-camera
+		* install issued N separate procedures per reconcile, each its own message
+		* on the one WebSocket that also carries the WebRTC signalling (the client
+		* has no `httpBatchLink`, so there is no transport-level batching to lean
+		* on: collapsing has to happen at the procedure level, which is here).
+		*
+		* Keyed by device id as a STRING — a JSON object cannot key by number, and
+		* pretending otherwise is how a record survives the wire only in tests.
+		* The per-device value is exactly what `getDeviceStatusAggregate` returns,
+		* so a caller can move between the two without reshaping anything.
+		*
+		* `caps` matters more here than in the single call: a client that needs two
+		* caps should not pay for every status-carrying cap × every device.
+		*/
+		getDeviceStatusAggregateBatch: require_sleep.method(zod.z.object({
+			deviceIds: zod.z.array(zod.z.number()).readonly(),
+			caps: zod.z.array(zod.z.string()).readonly().optional()
+		}), zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.unknown().nullable())))
 	}
 };
 //#endregion
@@ -19645,6 +19958,36 @@ var TargetKindSchema = zod.z.object({
 	icon: zod.z.string(),
 	/** Stamped by each provider so the concat-fanned catalog stays routable. */
 	addonId: zod.z.string(),
+	/**
+	* URL of the kind's bundled BRAND icon, served by the providing addon over
+	* its own `addon-routes` surface (`/addon/<addonId>/icons/<kind>`). Absent
+	* when the addon bundles no icon for that kind — the client then falls back
+	* to a neutral glyph rather than rendering the raw `icon` NAME as text.
+	*
+	* Root-relative on purpose: it resolves against whatever origin serves a web
+	* client, and a native client joins it onto its own hub base.
+	*
+	* DECLARED here deliberately. It used to travel as an undeclared passthrough
+	* field that survived only because the runtime cap-router forwards provider
+	* output verbatim — so every consumer had to re-declare it by hand to stop
+	* its own Zod parse from stripping it, and the whole arrangement would have
+	* broken silently the moment output validation was tightened anywhere.
+	*/
+	iconUrl: zod.z.string().optional(),
+	/**
+	* Media type of {@link iconUrl} (`image/svg+xml`, `image/png`, …).
+	*
+	* The server knows this and therefore says it, because the client cannot
+	* safely guess: a React-Native client renders SVG and raster through two
+	* DIFFERENT components (`react-native-svg` vs `expo-image` — expo-image does
+	* not decode SVG on iOS/Android), so without this it silently fell back to a
+	* placeholder glyph for every vector icon while the web build looked fine.
+	*
+	* Absent when {@link iconUrl} is absent, or for a legacy provider that has
+	* not been updated — a client that cannot determine the type should prefer
+	* its raster path, which is the safe default for an unknown image.
+	*/
+	iconMediaType: zod.z.string().optional(),
 	configSchema: ConfigSchemaPassthrough,
 	supportsDiscovery: zod.z.boolean(),
 	caps: TargetKindCapsSchema
@@ -20118,6 +20461,37 @@ var MotionEventSchema = zod.z.object({
 * Absent on legacy rows ⇒ treat as `pipeline`.
 */
 var DetectionSourceSchema = zod.z.enum(["pipeline", "onboard"]);
+/**
+* Which WAY a subject crossed a zone boundary. An entry and an exit are two
+* different notifications ("the parcel arrived" / "the car left the drive"),
+* and until this existed they were indistinguishable on the persisted record —
+* which is why exits were computed and dropped at the emit boundary rather
+* than doubling every zone-scoped rule.
+*/
+var ZoneCrossingDirectionSchema = zod.z.enum(["enter", "exit"]);
+/**
+* The confirmed zone crossing that produced an object event. Present ONLY on
+* an event emitted BY a crossing (`zone.enter` / `zone.exit`); a movement-state
+* event (`object.entering` / `leaving` / `stationary` / `loitering`) and an
+* appearance event carry none, so a rule asking for a direction fails closed
+* on them.
+*
+* Exactly ONE crossing per event: the emitter turns each confirmed crossing
+* into its own event, so a frame in which a track enters A while leaving B
+* produces two events with two directions — never one ambiguous row.
+*
+* `zoneId` is load-bearing for an EXIT: the event's `zones` list is the
+* membership the box has NOW, and by definition it no longer contains the zone
+* that was just left. Without the id here, a zone-scoped rule could never match
+* the exit it asked for.
+*/
+var ZoneCrossingSchema = zod.z.object({
+	direction: ZoneCrossingDirectionSchema,
+	/** Admin zone id crossed. */
+	zoneId: zod.z.string(),
+	/** Zone display name at crossing time (falls back to the id). */
+	zoneName: zod.z.string().optional()
+});
 var ObjectEventSchema = zod.z.object({
 	...BaseEventFields,
 	kind: zod.z.literal("object"),
@@ -20144,6 +20518,12 @@ var ObjectEventSchema = zod.z.object({
 	zones: zod.z.array(zod.z.string()).readonly().optional(),
 	/** Omitted in slim projection. */
 	state: TrackStateSchema.optional(),
+	/**
+	* The zone crossing this event IS, when it is one. Absent on every other
+	* event kind (movement state, appearance, package) — see
+	* {@link ZoneCrossingSchema}. Omitted in slim projection.
+	*/
+	zoneCrossing: ZoneCrossingSchema.optional(),
 	/** Detection-frame dimensions in pixels — let consumers normalize the
 	*  pixel-space `bbox` onto a displayed image. Omitted in slim projection. */
 	frameWidth: zod.z.number().optional(),
@@ -20523,6 +20903,23 @@ var pipelineAnalyticsCapability = {
 		}),
 		/** The events ops-log rows (newest-first), optionally scoped to one camera.
 		*  Backed by a declared pipeline-analytics SQLite collection. */
+		/**
+		* Move event-media blobs onto `toLocationId` (entity-routing spec Phase
+		* 4): per-row copy → stamp row.locationId → delete old blob. Rows already
+		* at the target are skipped, so a re-run resumes. Single-flight.
+		*/
+		relocateMedia: require_sleep.method(RelocateMediaInputSchema, zod.z.object({ jobId: zod.z.string() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getMediaRelocateStatus: require_sleep.method(zod.z.object({}), zod.z.array(RelocateJobSchema).readonly(), {
+			kind: "query",
+			auth: "admin"
+		}),
+		cancelMediaRelocate: require_sleep.method(zod.z.object({ jobId: zod.z.string() }), zod.z.object({ cancelled: zod.z.boolean() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		listOpsLog: require_sleep.method(OpsLogQueryInputSchema, zod.z.array(OpsLogEntrySchema).readonly(), {
 			kind: "query",
 			auth: "admin"
@@ -24160,6 +24557,17 @@ var ConnectionEndpointSchema = zod.z.object({
 	priority: zod.z.number()
 });
 var GetConnectionEndpointsResultSchema = zod.z.object({ endpoints: zod.z.array(ConnectionEndpointSchema).readonly() });
+/**
+* The chosen outbound endpoint for notification artifacts. `baseUrl: null` =
+* AUTO (resolved from the candidate ranking at send time); `resolved` reports
+* what AUTO currently picks, so the UI can show the effective value either way.
+*/
+var NotificationEndpointSchema = zod.z.object({
+	/** The operator's explicit choice, or null for AUTO. */
+	baseUrl: zod.z.string().nullable(),
+	/** What the ranking currently resolves to (null when nothing is reachable). */
+	resolved: zod.z.string().nullable()
+});
 var AllowedAddressesSchema = zod.z.object({ 
 /**
 * Allowlist of interface addresses operators have explicitly opted
@@ -24211,6 +24619,26 @@ var localNetworkCapability = {
 			scheme: zod.z.enum(["http", "https"]).optional()
 		}), GetConnectionEndpointsResultSchema),
 		/**
+		* The endpoint OUTBOUND artifacts must be addressed by — notification
+		* attachment links and deep links. `baseUrl: null` means AUTO: the first
+		* public candidate (a configured origin, then a connected tunnel, then the
+		* LAN), never loopback.
+		*
+		* Why an explicit marker: the automatic ranking cannot know which of
+		* several reachable addresses the RECIPIENT can actually open. A link is
+		* consumed on someone's phone, off the LAN, possibly hours later — and a
+		* link nobody can open is worse than no link, because the notification
+		* arrives advertising media that 404s.
+		*/
+		getNotificationEndpoint: require_sleep.method(zod.z.void(), NotificationEndpointSchema),
+		/**
+		* Mark which endpoint notification artifacts use. `baseUrl: null` restores
+		* AUTO. The value is stored verbatim (not an index into the candidate
+		* list): interfaces come and go, and an index would silently re-point at a
+		* different address after a reboot.
+		*/
+		setNotificationEndpoint: require_sleep.method(zod.z.object({ baseUrl: zod.z.string().nullable() }), NotificationEndpointSchema, { kind: "mutation" }),
+		/**
 		* Read the operator's allowlist. Empty = "auto" (no filter). Used
 		* by the admin UI's address selector to seed its checkbox state.
 		*/
@@ -25322,7 +25750,12 @@ var RecordingDeviceUsageSchema = zod.z.object({
 var RecordingLocationUsageSchema = zod.z.object({
 	/** StorageLocation id; null for the legacy/degraded single-root fallback. */
 	locationId: zod.z.string().nullable(),
-	/** Bytes of recordings stored on this location. */
+	/** Every location id sharing this row's PHYSICAL volume (aliases). One row
+	*  is emitted per physical disk (2026-07-29): two locations on one root
+	*  previously rendered as two identical "disks" with a nonsensical used
+	*  split — hydrate attribution across aliases is arbitrary by nature. */
+	locationIds: zod.z.array(zod.z.string()).optional(),
+	/** Bytes of recordings stored on this PHYSICAL volume (all aliases). */
 	usedBytes: zod.z.number(),
 	/** Free bytes on the location's volume; null when capacity is unknown (remote). */
 	availableBytes: zod.z.number().nullable(),
@@ -25478,6 +25911,77 @@ var recordingCapability = {
 		listOpsLog: require_sleep.method(OpsLogQueryInputSchema, zod.z.array(OpsLogEntrySchema).readonly(), {
 			kind: "query",
 			auth: "admin"
+		}),
+		/**
+		* Move footage (segments and/or strips) from one recordings location to
+		* another — the drain workflow's mover (entity-routing spec Phase 4).
+		* Throttled copy → size-verify → delete source → index refresh; resumable
+		* by construction (copy-if-absent). Single-flight: one job at a time.
+		*/
+		/**
+		* Render a short GIF from recorded footage around `aroundMs` (low profile,
+		* palette-free ffmpeg gif). Synchronous — the window is a few seconds of
+		* `low`, rendering in ~1-2s. Built for notification attachments: the
+		* caller gets bytes, nothing persists. Fails when no footage covers the
+		* window (camera not recording → caller skips the attachment).
+		*/
+		renderGif: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			aroundMs: zod.z.number(),
+			preRollSec: zod.z.number().min(0).max(30).default(2),
+			postRollSec: zod.z.number().min(0).max(30).default(5),
+			maxWidth: zod.z.number().int().min(120).max(1280).default(480),
+			fps: zod.z.number().int().min(1).max(15).default(5)
+		}), zod.z.object({
+			gifBase64: zod.z.string(),
+			fromMs: zod.z.number(),
+			toMs: zod.z.number()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Render a short MP4 clip from recorded footage around `aroundMs` — the
+		* "send a clip, not a gif" notification attachment. Same window, source
+		* and fail-closed contract as {@link renderGif}: no footage covering the
+		* window ⇒ it throws and the caller ships no attachment. Re-encoded (never
+		* stream-copied) so a concat across segments with different encoder
+		* parameters still plays. Silent by contract.
+		*
+		* The returned window is SEGMENT-GRANULAR: the source playlist is built
+		* from whole segments, so the clip starts at or before `fromMs` and ends
+		* at or after `toMs` — overshoot bounded by one segment per side (an 8 s
+		* ask over 4 s segments measured 12 s). `fromMs`/`toMs` report the window
+		* ASKED for, not the encoded duration.
+		*/
+		renderClip: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			aroundMs: zod.z.number(),
+			preRollSec: zod.z.number().min(0).max(30).default(3),
+			postRollSec: zod.z.number().min(0).max(30).default(7),
+			maxWidth: zod.z.number().int().min(160).max(1920).default(640)
+		}), zod.z.object({
+			clipBase64: zod.z.string(),
+			mime: zod.z.string(),
+			fromMs: zod.z.number(),
+			toMs: zod.z.number(),
+			bytes: zod.z.number().int()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		relocateFootage: require_sleep.method(RelocateFootageInputSchema, zod.z.object({ jobId: zod.z.string() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Every known relocate job (in-RAM, newest-first). */
+		getRelocateStatus: require_sleep.method(zod.z.object({}), zod.z.array(RelocateJobSchema).readonly(), {
+			kind: "query",
+			auth: "admin"
+		}),
+		cancelRelocate: require_sleep.method(zod.z.object({ jobId: zod.z.string() }), zod.z.object({ cancelled: zod.z.boolean() }), {
+			kind: "mutation",
+			auth: "admin"
 		})
 	}
 };
@@ -28416,6 +28920,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"deviceManager.getDeviceStatusAggregateBatch": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceManager.getLinkedDevices": {
 		capName: "device-manager",
 		capScope: "system",
@@ -29310,6 +29820,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"localNetwork.getNotificationEndpoint": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"localNetwork.getPreferred": {
 		capName: "local-network",
 		capScope: "system",
@@ -29334,6 +29850,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"localNetwork.setNotificationEndpoint": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"lockControl.lock": {
 		capName: "lock-control",
 		capScope: "device",
@@ -29976,6 +30498,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.cancelMediaRelocate": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.clearTracks": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -30030,6 +30558,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.getMediaRelocateStatus": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.getMotionEvents": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -30102,6 +30636,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.relocateMedia": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.searchObjectEvents": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -30864,6 +31404,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"recording.cancelRelocate": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"recording.deleteFootprint": {
 		capName: "recording",
 		capScope: "system",
@@ -30894,6 +31440,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"recording.getRelocateStatus": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"recording.getStorageUsage": {
 		capName: "recording",
 		capScope: "system",
@@ -30924,6 +31476,24 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"recording.relocateFootage": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"recording.renderClip": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"recording.renderGif": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"recording.rescanStorage": {
 		capName: "recording",
 		capScope: "system",
@@ -31518,6 +32088,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"streamBroker.renderPreBufferClip": {
+		capName: "stream-broker",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"streamBroker.restartProfile": {
 		capName: "stream-broker",
 		capScope: "system",
@@ -33325,6 +33901,7 @@ exports.MotionZonePatchSchema = MotionZonePatchSchema;
 exports.MotionZoneRegionSchema = MotionZoneRegionSchema;
 exports.MotionZoneStatusSchema = MotionZoneStatusSchema;
 exports.MqttBrokerStatusSchema = StatusSchema;
+exports.NC_BASE_CONDITION_KEYS = NC_BASE_CONDITION_KEYS;
 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;
@@ -33339,12 +33916,14 @@ exports.NativeObjectDetectionRuntimeStateSchema = NativeObjectDetectionRuntimeSt
 exports.NativeObjectDetectionStatusSchema = NativeObjectDetectionStatusSchema;
 exports.NcConditionDescriptorSchema = NcConditionDescriptorSchema;
 exports.NcConditionsSchema = NcConditionsSchema;
+exports.NcCrossingSchema = NcCrossingSchema;
 exports.NcDeliverySchema = NcDeliverySchema;
 exports.NcHistoryEntrySchema = NcHistoryEntrySchema;
 exports.NcHistoryFilterSchema = NcHistoryFilterSchema;
 exports.NcHistoryRecordKindSchema = NcHistoryRecordKindSchema;
 exports.NcHistoryStatusSchema = NcHistoryStatusSchema;
 exports.NcHistorySubjectSchema = NcHistorySubjectSchema;
+exports.NcMediaFrameSchema = NcMediaFrameSchema;
 exports.NcMediaPolicySchema = NcMediaPolicySchema;
 exports.NcOccupancyConditionSchema = NcOccupancyConditionSchema;
 exports.NcPlateMatcherSchema = NcPlateMatcherSchema;
@@ -33357,6 +33936,7 @@ exports.NcScheduleWindowSchema = NcScheduleWindowSchema;
 exports.NcTaxonomyEntrySchema = NcTaxonomyEntrySchema;
 exports.NcTaxonomySchema = NcTaxonomySchema;
 exports.NcTestResultSchema = NcTestResultSchema;
+exports.NcThrottleGranularitySchema = NcThrottleGranularitySchema;
 exports.NcThrottleSchema = NcThrottleSchema;
 exports.NcZoneConditionSchema = NcZoneConditionSchema;
 exports.NetworkAccessStatusSchema = NetworkAccessStatusSchema;
@@ -33451,17 +34031,18 @@ exports.RecordingDaysSchema = RecordingDaysSchema;
 exports.RecordingDeviceUsageSchema = RecordingDeviceUsageSchema;
 exports.RecordingLocationUsageSchema = RecordingLocationUsageSchema;
 exports.RecordingManifestSchema = RecordingManifestSchema;
-exports.RecordingModeSchema = RecordingModeSchema;
 exports.RecordingRangeSchema = RecordingRangeSchema;
 exports.RecordingRetentionSchema = RecordingRetentionSchema;
-exports.RecordingRuleSchema = RecordingRuleSchema;
-exports.RecordingScheduleSchema = RecordingScheduleSchema;
 exports.RecordingStatusSchema = RecordingStatusSchema;
 exports.RecordingStorageModeSchema = RecordingStorageModeSchema;
 exports.RecordingStorageUsageSchema = RecordingStorageUsageSchema;
 exports.RecordingTriggersSchema = RecordingTriggersSchema;
 exports.RecordingWeekdaySchema = RecordingWeekdaySchema;
 exports.RedirectLoginMethodSchema = RedirectLoginMethodSchema;
+exports.RelocateFootageInputSchema = RelocateFootageInputSchema;
+exports.RelocateJobSchema = RelocateJobSchema;
+exports.RelocateJobStateSchema = RelocateJobStateSchema;
+exports.RelocateMediaInputSchema = RelocateMediaInputSchema;
 exports.RenderedAsSchema = RenderedAsSchema;
 exports.ReportMotionInputSchema = ReportMotionInputSchema;
 exports.RingBuffer = RingBuffer;
@@ -33609,6 +34190,8 @@ exports.WidgetMetadataSchema = WidgetMetadataSchema;
 exports.WidgetRemoteSchema = WidgetRemoteSchema;
 exports.WidgetSizeEnum = WidgetSizeEnum;
 exports.YAMNET_TO_MACRO = YAMNET_TO_MACRO;
+exports.ZoneCrossingDirectionSchema = ZoneCrossingDirectionSchema;
+exports.ZoneCrossingSchema = ZoneCrossingSchema;
 exports.ZoneKindEnum = ZoneKindEnum;
 exports.ZoneRuleModeEnum = ZoneRuleModeEnum;
 exports.ZoneRuleSchema = ZoneRuleSchema;
@@ -33693,6 +34276,7 @@ exports.dayNightCapability = dayNightCapability;
 exports.decoderCapability = decoderCapability;
 exports.defaultDeviceFor = defaultDeviceFor;
 exports.defineCustomActions = defineCustomActions;
+exports.deriveRecordingMode = deriveRecordingMode;
 exports.describeModelVariant = describeModelVariant;
 exports.detectionPipelineCapability = detectionPipelineCapability;
 exports.deviceAdoptionCapability = deviceAdoptionCapability;
@@ -33750,6 +34334,7 @@ exports.integrationsCapability = integrationsCapability;
 exports.intercomCapability = intercomCapability;
 exports.isAgentOnlyPlacement = isAgentOnlyPlacement;
 exports.isArrayOutputSchema = isArrayOutputSchema;
+exports.isBaseConditionKey = isBaseConditionKey;
 exports.isCollectionArrayMethod = isCollectionArrayMethod;
 exports.isDeployableToAgent = isDeployableToAgent;
 exports.isDeviceConfigCap = require_sleep.isDeviceConfigCap;
@@ -33759,6 +34344,7 @@ exports.isObjectInput = isObjectInput;
 exports.isVoidInput = isVoidInput;
 exports.jobKindSchema = jobKindSchema;
 exports.kebabToCamel = kebabToCamel;
+exports.knownValues = knownValues;
 exports.lawnMowerControlCapability = lawnMowerControlCapability;
 exports.lifecycleJobSchema = lifecycleJobSchema;
 exports.lifecycleJobScopeSchema = lifecycleJobScopeSchema;
@@ -33784,7 +34370,6 @@ exports.mergeSourceInfo = mergeSourceInfo;
 exports.meshNetworkCapability = meshNetworkCapability;
 exports.method = require_sleep.method;
 exports.metricsProviderCapability = metricsProviderCapability;
-exports.migrateConfigToBands = migrateConfigToBands;
 exports.modelConvertCapability = modelConvertCapability;
 exports.modelDistributorCapability = modelDistributorCapability;
 exports.modelFormatForRuntime = modelFormatForRuntime;
@@ -33817,6 +34402,7 @@ exports.parseStreamParamsFormPatch = parseStreamParamsFormPatch;
 exports.petFeederCapability = petFeederCapability;
 exports.pickAccessoryControl = pickAccessoryControl;
 exports.pickPreferredRtspEntry = pickPreferredRtspEntry;
+exports.pickerForCondition = pickerForCondition;
 exports.pipelineAnalyticsCapability = pipelineAnalyticsCapability;
 exports.pipelineExecutorCapability = pipelineExecutorCapability;
 exports.pipelineOrchestratorCapability = pipelineOrchestratorCapability;