@camstack/system 1.2.390 → 1.2.391

package/dist/builtins/device-manager/device-aggregation.d.ts

@@ -1,306 +1,329 @@
-import { AddonContext, CapabilityDefinition, DeviceBindingEntry, DeviceConfigSpec, DeviceSettingsContribution, ICapabilityRegistry, IDevice, InferProvider, StreamProfile, StreamProfilePatch, deviceManagerCapability } from '@camstack/types';
-import { BindingsDeps, RemoteNativeCaps } from './device-bindings-store.js';
-import { ContributionShape, DriverConfigSchemaResult } from './device-meta-types.js';
 /**
- * Dependencies the aggregation + update routing functions consume. Assembled
- * by the addon from its own state and passed in explicitly — no hidden `this`
- * capture. `bindingsDeps` carries the lower-level context the bindings-store
- * resolvers need so this module can call them directly.
- */
+* Device-details aggregation + field-update routing for the device-manager
+* addon. Extracted from `device-manager.addon.ts` as free functions that
+* receive an explicit `AggregationDeps` context (DI) rather than closing over
+* the addon instance.
+*
+* This module owns the binding-driven settings/live/status aggregators
+* (`getDeviceAggregate`, `collectSystemDeviceContributions`,
+* `deriveDeviceConfigContribution`, `buildBaseDeviceSection`,
+* `getDeviceStatusAggregate`, `resolveDriverConfigSchema`) and the
+* field-update routing (`updateDeviceField`, `updateDeviceFieldsBatch`,
+* `applyGroupPatch`, `resolveContributionProvider`, `dispatchDeviceAction`)
+* plus the wrapper-activation mutators (`setWrapperActive`,
+* `listWrappersForCap`, `listBindableCapsForDeviceType`).
+*
+* Sibling aggregator functions call each other directly (passing `deps`);
+* cross-domain leaf calls (`getBindings`, `resolveRemoteNativeCapFromRegistry`,
+* read/writeBindingsStore) route through the bindings-store module via
+* `deps.bindingsDeps`. EXACT semantics, ordering, and side effects of the
+* original class methods are preserved; the addon keeps thin delegator
+* methods over these functions.
+*/
+import type { AddonContext, CapabilityDefinition, DeviceBindingEntry, DeviceConfigSpec, DeviceSettingsContribution, ICapabilityRegistry, IDevice, InferProvider, StreamProfile, StreamProfilePatch } from "@camstack/types";
+import { deviceManagerCapability } from "@camstack/types";
+import { type BindingsDeps, type RemoteNativeCaps } from "./device-bindings-store.js";
+import type { ContributionShape, DriverConfigSchemaResult } from "./device-meta-types.js";
+/**
+* Dependencies the aggregation + update routing functions consume. Assembled
+* by the addon from its own state and passed in explicitly — no hidden `this`
+* capture. `bindingsDeps` carries the lower-level context the bindings-store
+* resolvers need so this module can call them directly.
+*/
 export interface AggregationDeps {
-    readonly ctx: AddonContext;
-    readonly capabilityRegistry: ICapabilityRegistry | undefined;
-    readonly remoteNativeCaps: RemoteNativeCaps;
-    readonly bindingsDeps: BindingsDeps;
-    /**
-     * The keychain side of a driver's device form (D789): the STORED blob (its
-     * markers, never resolved), the device's declared secret paths, and the
-     * door's explicit clear. Without it a driver form carries what the driver
-     * hydrated and a clear cannot be applied.
-     */
-    readonly deviceFormSecrets?: DeviceFormSecretsDeps;
+	readonly ctx: AddonContext;
+	readonly capabilityRegistry: ICapabilityRegistry | undefined;
+	readonly remoteNativeCaps: RemoteNativeCaps;
+	readonly bindingsDeps: BindingsDeps;
+	/**
+	* The keychain side of a driver's device form (D789): the STORED blob (its
+	* markers, never resolved), the device's declared secret paths, and the
+	* door's explicit clear. Without it a driver form carries what the driver
+	* hydrated and a clear cannot be applied.
+	*/
+	readonly deviceFormSecrets?: DeviceFormSecretsDeps;
 }
 export interface DeviceFormSecretsDeps {
-    readonly readStored: (deviceId: number) => Promise<Record<string, unknown>>;
-    readonly declaredPaths: (deviceId: number) => readonly string[];
-    readonly clear: (deviceId: number, keys: readonly string[]) => Promise<void>;
+	readonly readStored: (deviceId: number) => Promise<Record<string, unknown>>;
+	readonly declaredPaths: (deviceId: number) => readonly string[];
+	readonly clear: (deviceId: number, keys: readonly string[]) => Promise<void>;
 }
 type IDeviceManagerProvider = InferProvider<typeof deviceManagerCapability>;
-export declare function getDeviceAggregate(deps: AggregationDeps, deviceId: number, kind: 'settings' | 'live'): Promise<ContributionShape | null>;
+export declare function getDeviceAggregate(deps: AggregationDeps, deviceId: number, kind: "settings" | "live"): Promise<ContributionShape | null>;
 /**
- * System-scoped per-device contributions — the deliberate exception to
- * binding-driven aggregation (D12).
- *
- * A `scope: 'system'` cap with `exposesDeviceSettings: true` holds per-device
- * state but is NOT bound per-device: it is a system addon, not a BaseDevice,
- * so it never calls `registerNativeCap` and never appears in
- * `getBindings(deviceId)`. The binding-driven loop therefore skips it and its
- * per-device panel never renders. Two such caps ship today:
- *   - `stream-broker` (singleton) — the RTSP-restream / pre-buffer settings
- *     tab, scoped to the cameras whose streams it serves.
- *   - `device-export` (collection) — the "Export" panel; a device can be
- *     exposed to MULTIPLE exporters at once (Alexa + HomeKit + HA-MQTT).
- *
- * D12 bans fanning a per-device call out to every same-named provider of a
- * `scope: 'device'` cap, because vendor providers SHARE cap names
- * (`stream-params`/`ptz` from reolink AND hikvision). System caps are NOT
- * vendor-shared — a system cap name maps to one active provider (singleton)
- * or one declared collection — so consulting the cap's own provider(s)
- * directly is safe. Each provider gates internally by deviceId and returns
- * null for devices it does not own.
- *
- * `seenCaps` skips any system cap that already contributed via a binding so
- * its section is never duplicated.
- */
-export declare function collectSystemDeviceContributions(deps: AggregationDeps, deviceId: number, kind: 'settings' | 'live', seenCaps: ReadonlySet<string>): Promise<ContributionShape[]>;
+* System-scoped per-device contributions — the deliberate exception to
+* binding-driven aggregation (D12).
+*
+* A `scope: 'system'` cap with `exposesDeviceSettings: true` holds per-device
+* state but is NOT bound per-device: it is a system addon, not a BaseDevice,
+* so it never calls `registerNativeCap` and never appears in
+* `getBindings(deviceId)`. The binding-driven loop therefore skips it and its
+* per-device panel never renders. Two such caps ship today:
+*   - `stream-broker` (singleton) — the RTSP-restream / pre-buffer settings
+*     tab, scoped to the cameras whose streams it serves.
+*   - `device-export` (collection) — the "Export" panel; a device can be
+*     exposed to MULTIPLE exporters at once (Alexa + HomeKit + HA-MQTT).
+*
+* D12 bans fanning a per-device call out to every same-named provider of a
+* `scope: 'device'` cap, because vendor providers SHARE cap names
+* (`stream-params`/`ptz` from reolink AND hikvision). System caps are NOT
+* vendor-shared — a system cap name maps to one active provider (singleton)
+* or one declared collection — so consulting the cap's own provider(s)
+* directly is safe. Each provider gates internally by deviceId and returns
+* null for devices it does not own.
+*
+* `seenCaps` skips any system cap that already contributed via a binding so
+* its section is never duplicated.
+*/
+export declare function collectSystemDeviceContributions(deps: AggregationDeps, deviceId: number, kind: "settings" | "live", seenCaps: ReadonlySet<string>): Promise<ContributionShape[]>;
 /**
- * D14: framework-derived device-config contribution.
- *
- * `kind === 'live'` — device-config caps contribute nothing to the live
- * aggregate (they hold editable config, not live observables).
- *
- * `ui.kind === 'widget'` — emits a single structural `type:'widget'`
- * section; the widget self-persists via the cap's own mutations.
- *
- * `ui.kind === 'derived-form'` — calls `getOptions`/`getStatus` on the
- * bound provider, runs the registered pure builder, and returns the
- * derived form sections. Returns null when the camera exposes nothing
- * configurable or the provider is not yet registered.
- */
+* D14: framework-derived device-config contribution.
+*
+* `kind === 'live'` — device-config caps contribute nothing to the live
+* aggregate (they hold editable config, not live observables).
+*
+* `ui.kind === 'widget'` — emits a single structural `type:'widget'`
+* section; the widget self-persists via the cap's own mutations.
+*
+* `ui.kind === 'derived-form'` — calls `getOptions`/`getStatus` on the
+* bound provider, runs the registered pure builder, and returns the
+* derived form sections. Returns null when the camera exposes nothing
+* configurable or the provider is not yet registered.
+*/
 export declare function deriveDeviceConfigContribution(deps: AggregationDeps, registry: ICapabilityRegistry, def: CapabilityDefinition & {
-    deviceConfig: DeviceConfigSpec;
-}, entry: DeviceBindingEntry, deviceId: number, kind: 'settings' | 'live'): Promise<ContributionShape | null>;
+	deviceConfig: DeviceConfigSpec;
+}, entry: DeviceBindingEntry, deviceId: number, kind: "settings" | "live"): Promise<ContributionShape | null>;
 /**
- * Build the device-manager's own contribution to the aggregator — the
- * device identity (id, stableId, addonId, type, online) + the
- * driver-specific config exposed by the device class via
- * `zodEntriesToConfigUI`.
- *
- * Two paths, deliberately symmetric with `getSettingsSchema`:
- *
- *  - Hub-local: device's IDevice instance lives in this process'
- *    DeviceRegistry, we read config + schema directly by reference.
- *  - Cross-process: device lives in a forked worker (RtspCamera on
- *    provider-rtsp, ONVIF on provider-onvif, …). We ask the worker's
- *    `device-ops.getSettingsSchema` native provider for a wire-
- *    serializable ConfigUISchema and merge it in under the same
- *    "Driver Config" section, so the UI sees the same shape regardless
- *    of where the IDevice physically runs.
- *
- *  Returns `null` only when the device genuinely doesn't exist anywhere
- *  (no hub-local, no persisted ownership, no device-ops native). The
- *  aggregator falls back to contributor sections only in that case.
- */
+* Build the device-manager's own contribution to the aggregator — the
+* device identity (id, stableId, addonId, type, online) + the
+* driver-specific config exposed by the device class via
+* `zodEntriesToConfigUI`.
+*
+* Two paths, deliberately symmetric with `getSettingsSchema`:
+*
+*  - Hub-local: device's IDevice instance lives in this process'
+*    DeviceRegistry, we read config + schema directly by reference.
+*  - Cross-process: device lives in a forked worker (RtspCamera on
+*    provider-rtsp, ONVIF on provider-onvif, …). We ask the worker's
+*    `device-ops.getSettingsSchema` native provider for a wire-
+*    serializable ConfigUISchema and merge it in under the same
+*    "Driver Config" section, so the UI sees the same shape regardless
+*    of where the IDevice physically runs.
+*
+*  Returns `null` only when the device genuinely doesn't exist anywhere
+*  (no hub-local, no persisted ownership, no device-ops native). The
+*  aggregator falls back to contributor sections only in that case.
+*/
 export declare function buildBaseDeviceSection(deps: AggregationDeps, deviceId: number): Promise<ContributionShape | null>;
 /**
- * Lookup the native owner for `device-ops` on `deviceId` — the native-cap
- * registry (hub-local and remote) is keyed by numeric id.
- */
+* Lookup the native owner for `device-ops` on `deviceId` — the native-cap
+* registry (hub-local and remote) is keyed by numeric id.
+*/
 export declare function resolveNativeDeviceOwner(deps: AggregationDeps, deviceId: number): {
-    addonId: string;
-    nodeId: string;
+	addonId: string;
+	nodeId: string;
 } | null;
 /**
- * How long ONE cap's `getStatus` may take before the aggregate gives up on it
- * and reports `null`.
- *
- * A cap call for a device owned by another node crosses the cluster, where the
- * transport's own ceiling is `REMOTE_CALL_TIMEOUT_MS` — SIXTY seconds. That
- * ceiling is right for a deliberate operator action; it is catastrophic here,
- * because this aggregate is what a camera LIST asks for on every boot, and it
- * has no answer to give until the slowest cap replies.
- *
- * The failure this bounds is not a node that is DOWN — `classifyCapRoute`
- * rejects those immediately with `node-offline`, which the catch below turns
- * into `null` in microseconds. It is a node that is FLAPPING: a crash-looping
- * agent re-registers every few seconds, so the registry believes it is online,
- * the call is routed, and the peer dies mid-flight. Then nothing throws and
- * nothing resolves. On 2026-08-08 little-unraid did exactly that for 22
- * minutes and the viewer showed a loading skeleton the whole time.
- *
- * 3s is chosen against what a HEALTHY remote cap costs (a same-LAN cap call is
- * single-digit ms; the slowest observed live is ~300ms) — so this cannot cut
- * off a working node — and against what a human waits for a camera list.
- */
-export declare const STATUS_CALL_DEADLINE_MS = 3000;
+* How long ONE cap's `getStatus` may take before the aggregate gives up on it
+* and reports `null`.
+*
+* A cap call for a device owned by another node crosses the cluster, where the
+* transport's own ceiling is `REMOTE_CALL_TIMEOUT_MS` — SIXTY seconds. That
+* ceiling is right for a deliberate operator action; it is catastrophic here,
+* because this aggregate is what a camera LIST asks for on every boot, and it
+* has no answer to give until the slowest cap replies.
+*
+* The failure this bounds is not a node that is DOWN — `classifyCapRoute`
+* rejects those immediately with `node-offline`, which the catch below turns
+* into `null` in microseconds. It is a node that is FLAPPING: a crash-looping
+* agent re-registers every few seconds, so the registry believes it is online,
+* the call is routed, and the peer dies mid-flight. Then nothing throws and
+* nothing resolves. On 2026-08-08 little-unraid did exactly that for 22
+* minutes and the viewer showed a loading skeleton the whole time.
+*
+* 3s is chosen against what a HEALTHY remote cap costs (a same-LAN cap call is
+* single-digit ms; the slowest observed live is ~300ms) — so this cannot cut
+* off a working node — and against what a human waits for a camera list.
+*/
+export declare const STATUS_CALL_DEADLINE_MS = 3e3;
 /** Per-call bound for a status aggregation. Tests pass a small value; nothing
- *  in production overrides the default. */
+*  in production overrides the default. */
 export interface StatusAggregateOptions {
-    /** Deadline for a single cap's `getStatus`. Defaults to
-     *  {@link STATUS_CALL_DEADLINE_MS}. */
-    readonly deadlineMs?: number;
+	/** Deadline for a single cap's `getStatus`. Defaults to
+	*  {@link STATUS_CALL_DEADLINE_MS}. */
+	readonly deadlineMs?: number;
 }
 export declare function getDeviceStatusAggregate(deps: AggregationDeps, input: {
-    readonly deviceId: number;
-    readonly caps?: readonly string[];
+	readonly deviceId: number;
+	readonly caps?: readonly string[];
 }, options?: StatusAggregateOptions): Promise<Record<string, unknown | null>>;
 /**
- * `getDeviceStatusAggregate` for a LIST of devices, in one round-trip.
- *
- * Each device is aggregated by the SAME function the single-device call uses —
- * deliberately, because that function already encodes the behaviour that
- * matters: a provider that throws or returns an invalid status yields `null`
- * for that cap instead of poisoning the result. Re-implementing the walk here
- * to "batch it properly" would mean two copies of that rule and one of them
- * eventually missing it.
- *
- * A device whose whole aggregation fails still gets an ENTRY (all caps null)
- * rather than being omitted: a caller that reads a missing key as "not
- * answered yet" would keep the previous badge on screen forever.
- *
- * ## The response is BOUNDED, and that is load-bearing
- *
- * The windows are walked SEQUENTIALLY, so before the per-cap deadline existed a
- * single unanswerable device did not merely cost its own window — it held every
- * later window behind it, and the call never returned at all. That is the whole
- * mechanism behind "one node offline and the app loads nothing": this is the
- * one call a camera list makes for every card, the client has no timeout of its
- * own, and a tRPC query that never settles is `isLoading` forever.
- *
- * The ceiling is now `ceil(devices / STATUS_BATCH_WINDOW) × STATUS_CALL_DEADLINE_MS`
- * in the worst case (a dead device in every window), and unchanged when every
- * node is healthy. It is never unbounded.
- */
+* `getDeviceStatusAggregate` for a LIST of devices, in one round-trip.
+*
+* Each device is aggregated by the SAME function the single-device call uses —
+* deliberately, because that function already encodes the behaviour that
+* matters: a provider that throws or returns an invalid status yields `null`
+* for that cap instead of poisoning the result. Re-implementing the walk here
+* to "batch it properly" would mean two copies of that rule and one of them
+* eventually missing it.
+*
+* A device whose whole aggregation fails still gets an ENTRY (all caps null)
+* rather than being omitted: a caller that reads a missing key as "not
+* answered yet" would keep the previous badge on screen forever.
+*
+* ## The response is BOUNDED, and that is load-bearing
+*
+* The windows are walked SEQUENTIALLY, so before the per-cap deadline existed a
+* single unanswerable device did not merely cost its own window — it held every
+* later window behind it, and the call never returned at all. That is the whole
+* mechanism behind "one node offline and the app loads nothing": this is the
+* one call a camera list makes for every card, the client has no timeout of its
+* own, and a tRPC query that never settles is `isLoading` forever.
+*
+* The ceiling is now `ceil(devices / STATUS_BATCH_WINDOW) × STATUS_CALL_DEADLINE_MS`
+* in the worst case (a dead device in every window), and unchanged when every
+* node is healthy. It is never unbounded.
+*/
 export declare function getDeviceStatusAggregateBatch(deps: AggregationDeps, input: {
-    readonly deviceIds: readonly number[];
-    readonly caps?: readonly string[];
+	readonly deviceIds: readonly number[];
+	readonly caps?: readonly string[];
 }, options?: StatusAggregateOptions): Promise<Record<string, Record<string, unknown | null>>>;
 /**
- * Return the driver-specific device-settings contribution. Hub-local
- * devices call `getSettingsUISchema()` directly; forked-worker devices
- * go through the `device-ops.getSettingsSchema` cap method on the
- * numeric-id-keyed native registry.
- *
- * Returns a discriminated result so callers can distinguish three states:
- *   'ok'          – schema obtained successfully
- *   'none'        – driver genuinely has no settings schema
- *   'unavailable' – worker was unreachable after retries (transient)
- */
+* Return the driver-specific device-settings contribution. Hub-local
+* devices call `getSettingsUISchema()` directly; forked-worker devices
+* go through the `device-ops.getSettingsSchema` cap method on the
+* numeric-id-keyed native registry.
+*
+* Returns a discriminated result so callers can distinguish three states:
+*   'ok'          – schema obtained successfully
+*   'none'        – driver genuinely has no settings schema
+*   'unavailable' – worker was unreachable after retries (transient)
+*/
 export declare function resolveDriverConfigSchema(deps: AggregationDeps, deviceId: number, hubLocal: {
-    addonId: string;
-    device: IDevice;
+	addonId: string;
+	device: IDevice;
 } | null): Promise<DriverConfigSchemaResult>;
 /**
- * Provider surface for a `derived-form` device-config cap's save path.
- * Exactly one of `setProfile` / `setSettings` is present on the actual
- * bound provider — which one is present tells us how to route the
- * patch. `stream-params` exposes `setProfile` (profile axis); `day-night`
- * / `image-settings` expose `setSettings` (no profile axis). Never branch
- * on the cap name here — the method surface is the source of truth.
- */
+* Provider surface for a `derived-form` device-config cap's save path.
+* Exactly one of `setProfile` / `setSettings` is present on the actual
+* bound provider — which one is present tells us how to route the
+* patch. `stream-params` exposes `setProfile` (profile axis); `day-night`
+* / `image-settings` expose `setSettings` (no profile axis). Never branch
+* on the cap name here — the method surface is the source of truth.
+*/
 export interface DerivedFormSaveSurface {
-    setProfile?: (input: {
-        deviceId: number;
-        profile: StreamProfile;
-        patch: StreamProfilePatch;
-    }) => Promise<void>;
-    setSettings?: (input: {
-        deviceId: number;
-        settings: Record<string, unknown>;
-    }) => Promise<void>;
+	setProfile?: (input: {
+		deviceId: number;
+		profile: StreamProfile;
+		patch: StreamProfilePatch;
+	}) => Promise<void>;
+	setSettings?: (input: {
+		deviceId: number;
+		settings: Record<string, unknown>;
+	}) => Promise<void>;
 }
 /**
- * Route a `derived-form` device-config cap's flat form patch to whichever
- * mutation the bound provider actually exposes — inspecting the
- * provider's method surface, not the cap name. `setSettings` fires once
- * with the parsed flat patch; `setProfile` fans the patch out per-profile
- * via the registered builderId reducer.
- */
+* Route a `derived-form` device-config cap's flat form patch to whichever
+* mutation the bound provider actually exposes — inspecting the
+* provider's method surface, not the cap name. `setSettings` fires once
+* with the parsed flat patch; `setProfile` fans the patch out per-profile
+* via the registered builderId reducer.
+*/
 export declare function dispatchDerivedFormSave(builderId: string, deviceId: number, patch: Record<string, unknown>, dcProvider: DerivedFormSaveSurface, capName: string): Promise<void>;
 export declare function updateDeviceField(deps: AggregationDeps, input: {
-    deviceId: number;
-    writerCapName: string;
-    writerAddonId: string;
-    key: string;
-    value: unknown;
+	deviceId: number;
+	writerCapName: string;
+	writerAddonId: string;
+	key: string;
+	value: unknown;
 }): Promise<{
-    success: true;
+	success: true;
 }>;
 /**
- * Dispatch a device custom action. Hub-local devices run it directly;
- * forked/remote devices route through the `device-ops` native cap
- * (`runAction`) — the same hub-local-then-device-ops fan-out that
- * `updateDeviceField` uses for `applySettingsPatch`.
- */
+* Dispatch a device custom action. Hub-local devices run it directly;
+* forked/remote devices route through the `device-ops` native cap
+* (`runAction`) — the same hub-local-then-device-ops fan-out that
+* `updateDeviceField` uses for `applySettingsPatch`.
+*/
 export declare function dispatchDeviceAction(deps: AggregationDeps, deviceId: number, action: string, input: unknown): Promise<unknown>;
 /**
- * Resolve the `DeviceSettingsContribution` provider that owns a tagged
- * field. The `writerAddonId` on a tagged field equals `entry.providerAddonId`
- * from the binding that produced it — for `kind:'wrapped'` entries, that is
- * the wrapper addon id (e.g. 'snapshot-addon'); for native-only entries,
- * the system addon id.
- *
- * Resolution order (Bug-3 fix):
- *  1. `getProviderByAddon(capName, writerAddonId)` — resolves the
- *     system-registered provider by the addon id from the tagged field.
- *     For wrapper bindings (snapshot, motion-detection, etc.) this directly
- *     returns the wrapper provider, bypassing the native-first resolution
- *     order of `getProviderForDevice` that caused "method not found".
- *  2. `getSingleton(capName)` — fallback for stale/mismatched writerAddonIds.
- *     The active singleton handles the contribution even if the addonId
- *     stored in the field is out of date (e.g. after an addon rename).
- *
- * `getProviderForDevice` is intentionally NOT used here: it returns the
- * per-device native first when present (e.g. Reolink/ONVIF), and the native
- * does NOT implement contribution methods — the root cause of Bug-3.
- */
+* Resolve the `DeviceSettingsContribution` provider that owns a tagged
+* field. The `writerAddonId` on a tagged field equals `entry.providerAddonId`
+* from the binding that produced it — for `kind:'wrapped'` entries, that is
+* the wrapper addon id (e.g. 'snapshot-addon'); for native-only entries,
+* the system addon id.
+*
+* Resolution order (Bug-3 fix):
+*  1. `getProviderByAddon(capName, writerAddonId)` — resolves the
+*     system-registered provider by the addon id from the tagged field.
+*     For wrapper bindings (snapshot, motion-detection, etc.) this directly
+*     returns the wrapper provider, bypassing the native-first resolution
+*     order of `getProviderForDevice` that caused "method not found".
+*  2. `getSingleton(capName)` — fallback for stale/mismatched writerAddonIds.
+*     The active singleton handles the contribution even if the addonId
+*     stored in the field is out of date (e.g. after an addon rename).
+*
+* `getProviderForDevice` is intentionally NOT used here: it returns the
+* per-device native first when present (e.g. Reolink/ONVIF), and the native
+* does NOT implement contribution methods — the root cause of Bug-3.
+*/
 export declare function resolveContributionProvider(registry: ICapabilityRegistry, _def: CapabilityDefinition, writerCapName: string, writerAddonId: string, deviceId: number): DeviceSettingsContribution;
 /**
- * Batched counterpart of `updateDeviceField`. Groups changes by
- * `(writerCapName, writerAddonId)` so each contributor receives a
- * single `applyDeviceSettingsPatch` with all of its updates merged —
- * avoids N round-trips for simultaneous edits in the same save.
- *
- * Per-provider failures are captured in the `failures[]` output so the
- * admin UI can highlight which sections didn't persist; a failure on
- * one provider does NOT abort the others.
- */
+* Batched counterpart of `updateDeviceField`. Groups changes by
+* `(writerCapName, writerAddonId)` so each contributor receives a
+* single `applyDeviceSettingsPatch` with all of its updates merged —
+* avoids N round-trips for simultaneous edits in the same save.
+*
+* Per-provider failures are captured in the `failures[]` output so the
+* admin UI can highlight which sections didn't persist; a failure on
+* one provider does NOT abort the others.
+*/
 export declare function updateDeviceFieldsBatch(deps: AggregationDeps, input: {
-    deviceId: number;
-    changes: ReadonlyArray<{
-        writerCapName: string;
-        writerAddonId: string;
-        key: string;
-        value: unknown;
-    }>;
+	deviceId: number;
+	changes: ReadonlyArray<{
+		writerCapName: string;
+		writerAddonId: string;
+		key: string;
+		value: unknown;
+	}>;
 }): Promise<{
-    success: true;
-    failures: {
-        writerCapName: string;
-        writerAddonId: string;
-        error: string;
-    }[];
+	success: true;
+	failures: {
+		writerCapName: string;
+		writerAddonId: string;
+		error: string;
+	}[];
 }>;
 /** Apply a single grouped patch to the appropriate provider. Mirrors
- * `updateDeviceField` routing (special-case device-manager, else
- * registry lookup). Used by `updateDeviceFieldsBatch`. */
+* `updateDeviceField` routing (special-case device-manager, else
+* registry lookup). Used by `updateDeviceFieldsBatch`. */
 export declare function applyGroupPatch(deps: AggregationDeps, deviceId: number, group: {
-    writerCapName: string;
-    writerAddonId: string;
-    patch: Record<string, unknown>;
+	writerCapName: string;
+	writerAddonId: string;
+	patch: Record<string, unknown>;
 }): Promise<void>;
 export declare function listWrappersForCap(deps: AggregationDeps, input: {
-    capName: string;
+	capName: string;
 }): Promise<string[]>;
 export declare function listBindableCapsForDeviceType(deps: AggregationDeps, input: {
-    deviceType: string;
+	deviceType: string;
 }): Promise<Array<{
-    capName: string;
-    wrappers: string[];
+	capName: string;
+	wrappers: string[];
 }>>;
 /**
- * Per-device wireable-field catalog — the domain status fields a device's
- * bound caps expose, for the operator's cross-device wiring UI. Binding-driven:
- * walks `getBindings(deviceId)`, skips wrapper caps (their status schemas are
- * internal book-keeping, not wireable domain data), and enumerates each cap's
- * status schema leaf fields (per-item fields included for item-array caps).
- *
- * `includeSynthesizable: true` (TARGET pickers only) additionally unions in
- * UNBOUND device-scoped caps that declare `status.empty` (the synthesize-target
- * marker) and whose `deviceTypes` admit this device's persisted type — so the
- * FIRST link to a synthesize-only cap (consumables on an HA vacuum) can be
- * authored before any binding exists. Default (absent/false) behavior is
- * byte-identical to the binding-driven catalog.
- */
-export declare function getWireableFields(deps: AggregationDeps, input: Parameters<IDeviceManagerProvider['getWireableFields']>[0]): ReturnType<IDeviceManagerProvider['getWireableFields']>;
+* Per-device wireable-field catalog — the domain status fields a device's
+* bound caps expose, for the operator's cross-device wiring UI. Binding-driven:
+* walks `getBindings(deviceId)`, skips wrapper caps (their status schemas are
+* internal book-keeping, not wireable domain data), and enumerates each cap's
+* status schema leaf fields (per-item fields included for item-array caps).
+*
+* `includeSynthesizable: true` (TARGET pickers only) additionally unions in
+* UNBOUND device-scoped caps that declare `status.empty` (the synthesize-target
+* marker) and whose `deviceTypes` admit this device's persisted type — so the
+* FIRST link to a synthesize-only cap (consumables on an HA vacuum) can be
+* authored before any binding exists. Default (absent/false) behavior is
+* byte-identical to the binding-driven catalog.
+*/
+export declare function getWireableFields(deps: AggregationDeps, input: Parameters<IDeviceManagerProvider["getWireableFields"]>[0]): ReturnType<IDeviceManagerProvider["getWireableFields"]>;
 export {};