@camstack/types 1.1.46 → 1.1.48

package/dist/interfaces/recording-config.d.ts

@@ -143,6 +143,53 @@ export declare const RecordingRetentionSchema: z.ZodObject<{
     maxSizeGb: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type RecordingRetention = z.infer<typeof RecordingRetentionSchema>;
+/**
+ * Scrub-thumbnail fidelity preset — the single per-camera selector bundling the
+ * sprite tile RESOLUTION + JPEG QUALITY the recorder packs timeline-scrub
+ * previews at. Five graduated steps; absent on a config = `standard` (the
+ * shipped default, matching `sheet-geometry`/`sheet-composer`).
+ *
+ * Existing sheets are IMMUTABLE — a changed preset applies to NEW windows only.
+ * Each window's index sidecar carries its own tile dims, so a camera whose
+ * preset changed over time renders every historical window at the dims it was
+ * written with.
+ */
+export declare const ScrubThumbnailPresetSchema: z.ZodEnum<{
+    standard: "standard";
+    high: "high";
+    low: "low";
+    max: "max";
+    minimal: "minimal";
+}>;
+export type ScrubThumbnailPreset = z.infer<typeof ScrubThumbnailPresetSchema>;
+/** Resolved sprite geometry + encode quality for a scrub-thumbnail preset. */
+export interface ScrubThumbnailGeometry {
+    /** Tile width in px (16:9). */
+    readonly tileWidth: number;
+    /** Tile height in px (16:9). */
+    readonly tileHeight: number;
+    /** Sheet JPEG quality, 1..100 (higher = better). */
+    readonly quality: number;
+}
+/** The default preset when a config omits `scrubThumbnails`. */
+export declare const DEFAULT_SCRUB_THUMBNAIL_PRESET: ScrubThumbnailPreset;
+/**
+ * Preset → tile geometry + JPEG quality. Every step is 16:9; the graduated
+ * ladder trades sheet size (and remote fetch cost) for scrub crispness.
+ * `standard` matches the shipped `sheet-geometry`/`sheet-composer` defaults
+ * (480×270 q72), so an unset config is byte-identical to today. The map is
+ * strictly monotone in resolution AND quality across the ordered steps.
+ */
+export declare const SCRUB_THUMBNAIL_PRESETS: Record<ScrubThumbnailPreset, ScrubThumbnailGeometry>;
+/** Human labels for each preset (resolution-tagged), for settings UIs. */
+export declare const SCRUB_THUMBNAIL_PRESET_LABELS: Record<ScrubThumbnailPreset, string>;
+/** Ordered low→high so a UI can render the ladder in graduated order. */
+export declare const SCRUB_THUMBNAIL_PRESET_ORDER: readonly ScrubThumbnailPreset[];
+/**
+ * Resolve the geometry for a recording config's scrub-thumbnail preset,
+ * defaulting to `standard` when unset. Pure — no I/O.
+ */
+export declare function resolveScrubThumbnailGeometry(preset: ScrubThumbnailPreset | undefined): ScrubThumbnailGeometry;
 /**
  * The full per-camera recording intent — the wire shape of a RecordingTarget.
  *
@@ -224,5 +271,12 @@ export declare const RecordingConfigSchema: z.ZodObject<{
         maxAgeDays: z.ZodOptional<z.ZodNumber>;
         maxSizeGb: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
+    scrubThumbnails: z.ZodOptional<z.ZodEnum<{
+        standard: "standard";
+        high: "high";
+        low: "low";
+        max: "max";
+        minimal: "minimal";
+    }>>;
 }, z.core.$strip>;
 export type RecordingConfig = z.infer<typeof RecordingConfigSchema>;

package/dist/readiness/readiness-registry.d.ts

@@ -98,19 +98,42 @@ export declare class ReadinessRegistry implements IReadinessRegistry {
      */
     getSnapshotForTransport(): readonly ReadinessRecord[];
     /**
-     * Hydrate the snapshot from an authoritative source. Entries already
-     * present locally are skipped — live deltas (received via the event
-     * bus subscription) always take precedence over the snapshot. For
-     * each newly hydrated entry, a one-shot transition is dispatched to
-     * matching subscriptions so pending `awaitReady` callers unblock
-     * without having to wait for a fresh event.
+     * Hydrate the snapshot from an authoritative source — a RECONCILE, not
+     * an add-only merge (D8: readiness events are telemetry and may be
+     * lost; the on-reconnect/periodic snapshot re-pull is the repair path,
+     * so it MUST be able to advance a stale record — the 2026-07-17
+     * "still awaiting platform-probe forever" wedge was this method
+     * skipping every already-seen key).
      *
-     * Local `epoch` is reset to 1 per entry — consumer-side epoch is
-     * derived from observed generation transitions, so this mirrors the
-     * value that would have been assigned had the consumer observed the
-     * first `ready` event directly.
+     *  - **Unseen keys** are added (epoch 1 — mirrors the value the
+     *    consumer would have derived from the first observed `ready`).
+     *  - **Existing keys** are UPDATED when the authoritative record
+     *    carries a different generation (producer restart / synthetic-down
+     *    superseded — epoch bumps on a new-generation `ready`, mirroring
+     *    `ingest`), or a FORWARD state move within the same generation
+     *    (`starting → ready → down`; within one producer generation a
+     *    snapshot can only be ahead of a lost delta, never behind it).
+     *  - **Never a same-generation regress** — a snapshot pulled just
+     *    before a live delta landed must not un-ready a record (the next
+     *    reconcile round converges it anyway).
+     *  - **Never a record this process is authoritative for** — node-scoped
+     *    records for our own nodeId, and device/global records we emitted,
+     *    keep local truth (an authority's stale copy of OUR record must
+     *    not regress us).
+     *
+     * Every applied entry dispatches a one-shot transition to matching
+     * subscriptions so pending `awaitReady` callers unblock without having
+     * to wait for a fresh event.
      */
     hydrate(records: readonly ReadinessRecord[]): void;
+    /**
+     * True when THIS process is the origin authority for `record` — a
+     * snapshot pulled from elsewhere must never overwrite it:
+     *  - node-scoped records whose `scope.nodeId` is our own node id
+     *    (this process — or a child bridged onto our bus — emits them);
+     *  - device/global-scoped records whose latest transition WE emitted.
+     */
+    private isLocallyAuthoritative;
     /** Shallow copy of the full snapshot — mainly for diagnostics/tests. */
     getAll(): ReadonlyMap<string, ReadinessRecord>;
     /**

package/dist/{sleep-Br7r_3fq.mjs → sleep-B3OHhFkL.mjs}

@@ -1,4 +1,4 @@
-import { t as EventCategory } from "./event-category-CFZs3jI4.mjs";
+import { t as EventCategory } from "./event-category-H4AVePnn.mjs";
 import { z } from "zod";
 //#region src/disposer-chain.ts
 var DisposerChain = class {
@@ -1487,6 +1487,19 @@ function scopeKey(scope) {
 		case "device": return `device:${scope.deviceId}`;
 	}
 }
+/**
+* Producer transition order within ONE generation: `starting → ready →
+* down`. Used by `hydrate` to accept only forward moves for
+* same-generation snapshot records (a snapshot can be ahead of a lost
+* delta, never behind it, within one producer generation).
+*/
+function stateRank(state) {
+	switch (state) {
+		case "starting": return 0;
+		case "ready": return 1;
+		case "down": return 2;
+	}
+}
 function scopesEqual(a, b) {
 	if (a.type !== b.type) return false;
 	if (a.type === "global" || b.type === "global") return true;
@@ -1537,43 +1550,70 @@ var ReadinessRegistry = class {
 		return Array.from(this.snapshot.values());
 	}
 	/**
-	* Hydrate the snapshot from an authoritative source. Entries already
-	* present locally are skipped — live deltas (received via the event
-	* bus subscription) always take precedence over the snapshot. For
-	* each newly hydrated entry, a one-shot transition is dispatched to
-	* matching subscriptions so pending `awaitReady` callers unblock
-	* without having to wait for a fresh event.
+	* Hydrate the snapshot from an authoritative source — a RECONCILE, not
+	* an add-only merge (D8: readiness events are telemetry and may be
+	* lost; the on-reconnect/periodic snapshot re-pull is the repair path,
+	* so it MUST be able to advance a stale record — the 2026-07-17
+	* "still awaiting platform-probe forever" wedge was this method
+	* skipping every already-seen key).
+	*
+	*  - **Unseen keys** are added (epoch 1 — mirrors the value the
+	*    consumer would have derived from the first observed `ready`).
+	*  - **Existing keys** are UPDATED when the authoritative record
+	*    carries a different generation (producer restart / synthetic-down
+	*    superseded — epoch bumps on a new-generation `ready`, mirroring
+	*    `ingest`), or a FORWARD state move within the same generation
+	*    (`starting → ready → down`; within one producer generation a
+	*    snapshot can only be ahead of a lost delta, never behind it).
+	*  - **Never a same-generation regress** — a snapshot pulled just
+	*    before a live delta landed must not un-ready a record (the next
+	*    reconcile round converges it anyway).
+	*  - **Never a record this process is authoritative for** — node-scoped
+	*    records for our own nodeId, and device/global records we emitted,
+	*    keep local truth (an authority's stale copy of OUR record must
+	*    not regress us).
 	*
-	* Local `epoch` is reset to 1 per entry — consumer-side epoch is
-	* derived from observed generation transitions, so this mirrors the
-	* value that would have been assigned had the consumer observed the
-	* first `ready` event directly.
+	* Every applied entry dispatches a one-shot transition to matching
+	* subscriptions so pending `awaitReady` callers unblock without having
+	* to wait for a fresh event.
 	*/
 	hydrate(records) {
 		const now = this.now();
 		for (const record of records) {
 			const key = readinessKey(record.capName, record.scope);
-			if (this.snapshot.has(key)) continue;
+			const prev = this.snapshot.get(key) ?? null;
+			let epoch;
+			let durationInPrevState;
+			if (prev !== null) {
+				if (this.isLocallyAuthoritative(prev)) continue;
+				const sameGeneration = prev.generation === record.generation;
+				if (sameGeneration && stateRank(record.state) <= stateRank(prev.state)) continue;
+				epoch = !sameGeneration && record.state === "ready" ? prev.epoch + 1 : prev.epoch;
+				durationInPrevState = Math.max(0, now - prev.lastChange);
+			} else {
+				epoch = 1;
+				durationInPrevState = 0;
+			}
 			const hydrated = {
 				capName: record.capName,
 				scope: record.scope,
 				state: record.state,
 				generation: record.generation,
-				epoch: 1,
+				epoch,
 				lastChange: now,
 				sourceNodeId: record.sourceNodeId
 			};
 			this.snapshot.set(key, hydrated);
-			if (this.logger) this.logger.debug(`readiness: ${record.capName} (${scopeKey(record.scope)}) → ${record.state} (hydrated, gen=${record.generation.slice(0, 6)})`);
+			if (this.logger) this.logger.debug(`readiness: ${record.capName} (${scopeKey(record.scope)}) → ${record.state} (hydrated${prev !== null ? " update" : ""}, gen=${record.generation.slice(0, 6)})`);
 			const transition = {
 				capName: record.capName,
 				scope: record.scope,
 				state: record.state,
-				epoch: 1,
+				epoch,
 				generation: record.generation,
 				sourceNodeId: "hydrated",
 				ts: now,
-				durationInPrevState: 0
+				durationInPrevState
 			};
 			for (const sub of this.subscriptions) {
 				if (sub.capName !== record.capName) continue;
@@ -1586,6 +1626,17 @@ var ReadinessRegistry = class {
 			}
 		}
 	}
+	/**
+	* True when THIS process is the origin authority for `record` — a
+	* snapshot pulled from elsewhere must never overwrite it:
+	*  - node-scoped records whose `scope.nodeId` is our own node id
+	*    (this process — or a child bridged onto our bus — emits them);
+	*  - device/global-scoped records whose latest transition WE emitted.
+	*/
+	isLocallyAuthoritative(record) {
+		if (record.scope.type === "node") return record.scope.nodeId === this.sourceNodeId;
+		return record.sourceNodeId === this.sourceNodeId;
+	}
 	/** Shallow copy of the full snapshot — mainly for diagnostics/tests. */
 	getAll() {
 		return new Map(this.snapshot);
@@ -2787,7 +2838,12 @@ function createDeviceProxy(api, binding, opts) {
 			getRawState: (input) => dispatch("device-ops", "deviceOps", "getRawState", "query", input)
 		},
 		deviceStatus: { getStatus: (input) => dispatch("device-status", "deviceStatus", "getStatus", "query", input) },
-		doorbell: { getStatus: (input) => dispatch("doorbell", "doorbell", "getStatus", "query", input) },
+		doorbell: {
+			getStatus: (input) => dispatch("doorbell", "doorbell", "getStatus", "query", input),
+			getDeviceSettingsContribution: (input) => dispatch("doorbell", "doorbell", "getDeviceSettingsContribution", "query", input),
+			getDeviceLiveContribution: (input) => dispatch("doorbell", "doorbell", "getDeviceLiveContribution", "query", input),
+			applyDeviceSettingsPatch: (input) => dispatch("doorbell", "doorbell", "applyDeviceSettingsPatch", "mutation", input)
+		},
 		enumSensor: { getStatus: (input) => dispatch("enum-sensor", "enumSensor", "getStatus", "query", input) },
 		eventEmitter: { getStatus: (input) => dispatch("event-emitter", "eventEmitter", "getStatus", "query", input) },
 		events: {
@@ -2906,10 +2962,13 @@ function createDeviceProxy(api, binding, opts) {
 			getActiveTracks: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getActiveTracks", "query", input),
 			getTrack: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getTrack", "query", input),
 			listTracks: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listTracks", "query", input),
+			listRecentTracks: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listRecentTracks", "query", input),
 			clearTracks: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "clearTracks", "mutation", input),
 			getMotionEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getMotionEvents", "query", input),
 			getObjectEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getObjectEvents", "query", input),
 			getAudioEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getAudioEvents", "query", input),
+			listEventKinds: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listEventKinds", "query", input),
+			getSensorEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getSensorEvents", "query", input),
 			getKeyEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getKeyEvents", "query", input),
 			getEventDensity: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getEventDensity", "query", input),
 			pruneEventsBefore: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "pruneEventsBefore", "mutation", input),
@@ -3083,6 +3142,7 @@ function createDeviceProxy(api, binding, opts) {
 			setMetadata: (input) => dispatchSystem("deviceManager", "setMetadata", "mutation", input),
 			setDisabled: (input) => dispatchSystem("deviceManager", "setDisabled", "mutation", input),
 			getDevice: (input) => dispatchSystem("deviceManager", "getDevice", "query", input),
+			getLinkedDevices: (input) => dispatchSystem("deviceManager", "getLinkedDevices", "query", input),
 			getStreamSources: (input) => dispatchSystem("deviceManager", "getStreamSources", "query", input),
 			getConfigSchema: (input) => dispatchSystem("deviceManager", "getConfigSchema", "query", input),
 			getSettingsSchema: (input) => dispatchSystem("deviceManager", "getSettingsSchema", "query", input),
@@ -3103,7 +3163,10 @@ function createDeviceProxy(api, binding, opts) {
 			updateDeviceField: (input) => dispatchSystem("deviceManager", "updateDeviceField", "mutation", input),
 			updateDeviceFieldsBatch: (input) => dispatchSystem("deviceManager", "updateDeviceFieldsBatch", "mutation", input),
 			testField: (input) => dispatchSystem("deviceManager", "testField", "mutation", input),
-			getDeviceStatusAggregate: (input) => dispatchSystem("deviceManager", "getDeviceStatusAggregate", "query", input)
+			getDeviceStatusAggregate: (input) => dispatchSystem("deviceManager", "getDeviceStatusAggregate", "query", input),
+			getDeviceSettingsContribution: (input) => dispatchSystem("deviceManager", "getDeviceSettingsContribution", "query", input),
+			getDeviceLiveContribution: (input) => dispatchSystem("deviceManager", "getDeviceLiveContribution", "query", input),
+			applyDeviceSettingsPatch: (input) => dispatchSystem("deviceManager", "applyDeviceSettingsPatch", "mutation", input)
 		},
 		deviceState: {
 			getSnapshot: (input) => dispatchSystem("deviceState", "getSnapshot", "query", input),

package/dist/{sleep-Vh_bux78.js → sleep-BoTIF1d4.js}

@@ -1,4 +1,4 @@
-const require_event_category = require("./event-category-BXd6yeJi.js");
+const require_event_category = require("./event-category-AkBNxg_X.js");
 let zod = require("zod");
 //#region src/disposer-chain.ts
 var DisposerChain = class {
@@ -1487,6 +1487,19 @@ function scopeKey(scope) {
 		case "device": return `device:${scope.deviceId}`;
 	}
 }
+/**
+* Producer transition order within ONE generation: `starting → ready →
+* down`. Used by `hydrate` to accept only forward moves for
+* same-generation snapshot records (a snapshot can be ahead of a lost
+* delta, never behind it, within one producer generation).
+*/
+function stateRank(state) {
+	switch (state) {
+		case "starting": return 0;
+		case "ready": return 1;
+		case "down": return 2;
+	}
+}
 function scopesEqual(a, b) {
 	if (a.type !== b.type) return false;
 	if (a.type === "global" || b.type === "global") return true;
@@ -1537,43 +1550,70 @@ var ReadinessRegistry = class {
 		return Array.from(this.snapshot.values());
 	}
 	/**
-	* Hydrate the snapshot from an authoritative source. Entries already
-	* present locally are skipped — live deltas (received via the event
-	* bus subscription) always take precedence over the snapshot. For
-	* each newly hydrated entry, a one-shot transition is dispatched to
-	* matching subscriptions so pending `awaitReady` callers unblock
-	* without having to wait for a fresh event.
+	* Hydrate the snapshot from an authoritative source — a RECONCILE, not
+	* an add-only merge (D8: readiness events are telemetry and may be
+	* lost; the on-reconnect/periodic snapshot re-pull is the repair path,
+	* so it MUST be able to advance a stale record — the 2026-07-17
+	* "still awaiting platform-probe forever" wedge was this method
+	* skipping every already-seen key).
+	*
+	*  - **Unseen keys** are added (epoch 1 — mirrors the value the
+	*    consumer would have derived from the first observed `ready`).
+	*  - **Existing keys** are UPDATED when the authoritative record
+	*    carries a different generation (producer restart / synthetic-down
+	*    superseded — epoch bumps on a new-generation `ready`, mirroring
+	*    `ingest`), or a FORWARD state move within the same generation
+	*    (`starting → ready → down`; within one producer generation a
+	*    snapshot can only be ahead of a lost delta, never behind it).
+	*  - **Never a same-generation regress** — a snapshot pulled just
+	*    before a live delta landed must not un-ready a record (the next
+	*    reconcile round converges it anyway).
+	*  - **Never a record this process is authoritative for** — node-scoped
+	*    records for our own nodeId, and device/global records we emitted,
+	*    keep local truth (an authority's stale copy of OUR record must
+	*    not regress us).
 	*
-	* Local `epoch` is reset to 1 per entry — consumer-side epoch is
-	* derived from observed generation transitions, so this mirrors the
-	* value that would have been assigned had the consumer observed the
-	* first `ready` event directly.
+	* Every applied entry dispatches a one-shot transition to matching
+	* subscriptions so pending `awaitReady` callers unblock without having
+	* to wait for a fresh event.
 	*/
 	hydrate(records) {
 		const now = this.now();
 		for (const record of records) {
 			const key = readinessKey(record.capName, record.scope);
-			if (this.snapshot.has(key)) continue;
+			const prev = this.snapshot.get(key) ?? null;
+			let epoch;
+			let durationInPrevState;
+			if (prev !== null) {
+				if (this.isLocallyAuthoritative(prev)) continue;
+				const sameGeneration = prev.generation === record.generation;
+				if (sameGeneration && stateRank(record.state) <= stateRank(prev.state)) continue;
+				epoch = !sameGeneration && record.state === "ready" ? prev.epoch + 1 : prev.epoch;
+				durationInPrevState = Math.max(0, now - prev.lastChange);
+			} else {
+				epoch = 1;
+				durationInPrevState = 0;
+			}
 			const hydrated = {
 				capName: record.capName,
 				scope: record.scope,
 				state: record.state,
 				generation: record.generation,
-				epoch: 1,
+				epoch,
 				lastChange: now,
 				sourceNodeId: record.sourceNodeId
 			};
 			this.snapshot.set(key, hydrated);
-			if (this.logger) this.logger.debug(`readiness: ${record.capName} (${scopeKey(record.scope)}) → ${record.state} (hydrated, gen=${record.generation.slice(0, 6)})`);
+			if (this.logger) this.logger.debug(`readiness: ${record.capName} (${scopeKey(record.scope)}) → ${record.state} (hydrated${prev !== null ? " update" : ""}, gen=${record.generation.slice(0, 6)})`);
 			const transition = {
 				capName: record.capName,
 				scope: record.scope,
 				state: record.state,
-				epoch: 1,
+				epoch,
 				generation: record.generation,
 				sourceNodeId: "hydrated",
 				ts: now,
-				durationInPrevState: 0
+				durationInPrevState
 			};
 			for (const sub of this.subscriptions) {
 				if (sub.capName !== record.capName) continue;
@@ -1586,6 +1626,17 @@ var ReadinessRegistry = class {
 			}
 		}
 	}
+	/**
+	* True when THIS process is the origin authority for `record` — a
+	* snapshot pulled from elsewhere must never overwrite it:
+	*  - node-scoped records whose `scope.nodeId` is our own node id
+	*    (this process — or a child bridged onto our bus — emits them);
+	*  - device/global-scoped records whose latest transition WE emitted.
+	*/
+	isLocallyAuthoritative(record) {
+		if (record.scope.type === "node") return record.scope.nodeId === this.sourceNodeId;
+		return record.sourceNodeId === this.sourceNodeId;
+	}
 	/** Shallow copy of the full snapshot — mainly for diagnostics/tests. */
 	getAll() {
 		return new Map(this.snapshot);
@@ -2787,7 +2838,12 @@ function createDeviceProxy(api, binding, opts) {
 			getRawState: (input) => dispatch("device-ops", "deviceOps", "getRawState", "query", input)
 		},
 		deviceStatus: { getStatus: (input) => dispatch("device-status", "deviceStatus", "getStatus", "query", input) },
-		doorbell: { getStatus: (input) => dispatch("doorbell", "doorbell", "getStatus", "query", input) },
+		doorbell: {
+			getStatus: (input) => dispatch("doorbell", "doorbell", "getStatus", "query", input),
+			getDeviceSettingsContribution: (input) => dispatch("doorbell", "doorbell", "getDeviceSettingsContribution", "query", input),
+			getDeviceLiveContribution: (input) => dispatch("doorbell", "doorbell", "getDeviceLiveContribution", "query", input),
+			applyDeviceSettingsPatch: (input) => dispatch("doorbell", "doorbell", "applyDeviceSettingsPatch", "mutation", input)
+		},
 		enumSensor: { getStatus: (input) => dispatch("enum-sensor", "enumSensor", "getStatus", "query", input) },
 		eventEmitter: { getStatus: (input) => dispatch("event-emitter", "eventEmitter", "getStatus", "query", input) },
 		events: {
@@ -2906,10 +2962,13 @@ function createDeviceProxy(api, binding, opts) {
 			getActiveTracks: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getActiveTracks", "query", input),
 			getTrack: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getTrack", "query", input),
 			listTracks: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listTracks", "query", input),
+			listRecentTracks: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listRecentTracks", "query", input),
 			clearTracks: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "clearTracks", "mutation", input),
 			getMotionEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getMotionEvents", "query", input),
 			getObjectEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getObjectEvents", "query", input),
 			getAudioEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getAudioEvents", "query", input),
+			listEventKinds: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listEventKinds", "query", input),
+			getSensorEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getSensorEvents", "query", input),
 			getKeyEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getKeyEvents", "query", input),
 			getEventDensity: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getEventDensity", "query", input),
 			pruneEventsBefore: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "pruneEventsBefore", "mutation", input),
@@ -3083,6 +3142,7 @@ function createDeviceProxy(api, binding, opts) {
 			setMetadata: (input) => dispatchSystem("deviceManager", "setMetadata", "mutation", input),
 			setDisabled: (input) => dispatchSystem("deviceManager", "setDisabled", "mutation", input),
 			getDevice: (input) => dispatchSystem("deviceManager", "getDevice", "query", input),
+			getLinkedDevices: (input) => dispatchSystem("deviceManager", "getLinkedDevices", "query", input),
 			getStreamSources: (input) => dispatchSystem("deviceManager", "getStreamSources", "query", input),
 			getConfigSchema: (input) => dispatchSystem("deviceManager", "getConfigSchema", "query", input),
 			getSettingsSchema: (input) => dispatchSystem("deviceManager", "getSettingsSchema", "query", input),
@@ -3103,7 +3163,10 @@ function createDeviceProxy(api, binding, opts) {
 			updateDeviceField: (input) => dispatchSystem("deviceManager", "updateDeviceField", "mutation", input),
 			updateDeviceFieldsBatch: (input) => dispatchSystem("deviceManager", "updateDeviceFieldsBatch", "mutation", input),
 			testField: (input) => dispatchSystem("deviceManager", "testField", "mutation", input),
-			getDeviceStatusAggregate: (input) => dispatchSystem("deviceManager", "getDeviceStatusAggregate", "query", input)
+			getDeviceStatusAggregate: (input) => dispatchSystem("deviceManager", "getDeviceStatusAggregate", "query", input),
+			getDeviceSettingsContribution: (input) => dispatchSystem("deviceManager", "getDeviceSettingsContribution", "query", input),
+			getDeviceLiveContribution: (input) => dispatchSystem("deviceManager", "getDeviceLiveContribution", "query", input),
+			applyDeviceSettingsPatch: (input) => dispatchSystem("deviceManager", "applyDeviceSettingsPatch", "mutation", input)
 		},
 		deviceState: {
 			getSnapshot: (input) => dispatchSystem("deviceState", "getSnapshot", "query", input),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/types",
-  "version": "1.1.46",
+  "version": "1.1.48",
   "description": "Shared types, interfaces, and model catalogs for the CamStack detection ecosystem",
   "keywords": [
     "camstack",