@camstack/types 0.1.14 → 0.1.16

package/dist/capabilities/decoder.cap.d.ts

@@ -0,0 +1,173 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import type { HwAccelBackend } from '../interfaces/addon.js';
+import { DecoderSessionConfigSchema } from '../interfaces/stream-broker.js';
+/**
+ * Operator-facing hwaccel selection — wins over `probedBestHwaccel`
+ * when concrete; `'auto'` defers to the session's local resolver
+ * (`ctx.kernel.hwaccel`) which probes the host. Shared across every
+ * decoder addon (node-av, ffmpeg, …) so UI + settings + sessions all
+ * speak the same vocabulary.
+ */
+export type HwAccelChoice = 'auto' | 'none' | HwAccelBackend;
+/**
+ * Stable UI option list for the `hwaccel` setting. Decoder addons
+ * reuse this for `globalSettingsSchema()` so the dropdown is
+ * identical everywhere. Order: auto → off → common backends by
+ * platform affinity (macOS, NVIDIA, Intel/AMD, Windows, Linux).
+ */
+export declare const HWACCEL_OPTIONS: ReadonlyArray<{
+    value: HwAccelChoice;
+    label: string;
+}>;
+/**
+ * Shared shape of a decoder addon's global settings. Every decoder
+ * owns its own instance (node-av, ffmpeg, future backends) — they
+ * don't share a store, but they share this config shape.
+ */
+export interface DecoderHwAccelConfig {
+    readonly hwaccel: HwAccelChoice;
+    readonly probedBestHwaccel: string;
+}
+export declare const DEFAULT_DECODER_HWACCEL_CONFIG: DecoderHwAccelConfig;
+export declare const decoderCapability: {
+    readonly name: "decoder";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        readonly supportsCodec: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            codec: z.ZodString;
+        }, z.core.$strip>, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getInfo: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            isPullMode: z.ZodOptional<z.ZodBoolean>;
+            priority: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly createSession: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            codec: z.ZodString;
+            maxFps: z.ZodDefault<z.ZodNumber>;
+            outputFormat: z.ZodDefault<z.ZodEnum<{
+                jpeg: "jpeg";
+                rgb: "rgb";
+                bgr: "bgr";
+                yuv420: "yuv420";
+                gray: "gray";
+            }>>;
+            scale: z.ZodDefault<z.ZodNumber>;
+            width: z.ZodOptional<z.ZodNumber>;
+            height: z.ZodOptional<z.ZodNumber>;
+            deviceId: z.ZodOptional<z.ZodNumber>;
+            tag: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            sessionId: z.ZodString;
+            nodeId: z.ZodString;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly destroySession: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            sessionId: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly pushPacket: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            sessionId: z.ZodString;
+            packet: z.ZodObject<{
+                type: z.ZodEnum<{
+                    audio: "audio";
+                    video: "video";
+                }>;
+                data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+                pts: z.ZodNumber;
+                dts: z.ZodNumber;
+                keyframe: z.ZodBoolean;
+                codec: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodVoid, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly openStream: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            sessionId: z.ZodString;
+            url: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly pullFrames: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            sessionId: z.ZodString;
+            maxCount: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            format: z.ZodEnum<{
+                jpeg: "jpeg";
+                rgb: "rgb";
+                bgr: "bgr";
+                yuv420: "yuv420";
+                gray: "gray";
+            }>;
+            timestamp: z.ZodNumber;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly updateConfig: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            sessionId: z.ZodString;
+            config: z.ZodObject<{
+                codec: z.ZodOptional<z.ZodString>;
+                maxFps: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+                outputFormat: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+                    jpeg: "jpeg";
+                    rgb: "rgb";
+                    bgr: "bgr";
+                    yuv420: "yuv420";
+                    gray: "gray";
+                }>>>;
+                scale: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+                width: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+                height: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+                deviceId: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+                tag: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodVoid, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getStats: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            sessionId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            inputFps: z.ZodNumber;
+            outputFps: z.ZodNumber;
+            avgDecodeTimeMs: z.ZodNumber;
+            droppedFrames: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly listActiveSessions: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            sessionId: z.ZodString;
+            codec: z.ZodString;
+            outputFormat: z.ZodString;
+            createdAtMs: z.ZodNumber;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Re-run the host platform-probe for the decoder's hwaccel backend
+         * and write the detected value into the addon's own global
+         * settings (`probedBestHwaccel`). Replaces the legacy per-agent
+         * `pipeline-orchestrator.reprobeAgentHwAccel` — each decoder addon
+         * now owns its own probe.
+         *
+         * Returns the backend the probe picked (`'none'` = software-only
+         * host, otherwise one of `HwAccelBackend`). The operator's
+         * `hwaccel` setting (auto / none / backend) is not touched; only
+         * the `probedBestHwaccel` hint.
+         */
+        readonly reprobeHwaccel: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            backend: z.ZodString;
+        }, z.core.$strip>, "mutation">;
+    };
+};
+export type IDecoderCapProvider = InferProvider<typeof decoderCapability>;
+/**
+ * Pure cap-only view of the decoder provider.
+ *
+ * For the in-process interface with live `createSession()`, `id`, `name`,
+ * `priority`, `isPullMode` fields, consumers should import
+ * `IDecoderProvider` from `@camstack/types/interfaces/decoder` — that
+ * remains the canonical in-process contract the broker + tests depend
+ * on. The live `createSession()` + session object cannot cross process
+ * boundaries and will need a session-id based cap API (Phase 4, decoder
+ * forkable work) — tracked separately, not in scope for session 5
+ * Sprint A.
+ *
+ * Prior to session 5 this alias used to extend the inferred cap type
+ * with the live fields, creating a hybrid interface. No consumer ever
+ * referenced `IDecoderProviderV2` — the broker, tests, and addon
+ * implementations all imported `IDecoderProvider` directly. The
+ * extension was therefore dead code and is removed here.
+ */
+export { DecoderSessionConfigSchema };
+//# sourceMappingURL=decoder.cap.d.ts.map

package/dist/capabilities/decoder.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decoder.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/decoder.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAC5D,OAAO,EACL,0BAA0B,EAE3B,MAAM,gCAAgC,CAAA;AAMvC;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,cAAc,CAAA;AAE5D;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,aAAa,CAAC;IAAE,KAAK,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAalF,CAAA;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAA;IAC/B,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;CACnC;AAED,eAAO,MAAM,8BAA8B,EAAE,oBAG5C,CAAA;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA+D1B;;;;;;;;;;;WAWG;;;;;CAOkC,CAAA;AAEzC,MAAM,MAAM,mBAAmB,GAAG,aAAa,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAEzE;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,0BAA0B,EAAE,CAAA"}

package/dist/capabilities/detection-pipeline.cap.d.ts

@@ -0,0 +1,34 @@
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * detection-pipeline — device-scoped facade over the system
+ * `pipeline-executor`.
+ *
+ * Pairs with `pipeline-executor` (system, singleton) the way
+ * `audio-analysis` pairs with `audio-analyzer`: the system cap owns the
+ * engine lifecycle (engines, templates, models, runPipeline) while
+ * `detection-pipeline` is the per-camera binding row in the
+ * device-manager UI.
+ *
+ * Registered as a wrapper with `defaultActive: true` by
+ * `addon-detection-pipeline` so every camera opts into detection
+ * automatically. Operators disable per-device via
+ * `device-manager.setWrapperActive` — replaces the legacy
+ * `pipelineEnabled` / `disableInference` flags previously stored in the
+ * orchestrator's device-settings.
+ *
+ * `exposesDeviceSettings: true` is intentional — the three
+ * DeviceSettingsContribution methods auto-added to the provider
+ * interface serve the per-device detection settings panel in the admin
+ * UI (model selection, class filters, confidence thresholds).
+ */
+export declare const detectionPipelineCapability: {
+    readonly name: "detection-pipeline";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly exposesDeviceSettings: true;
+    readonly methods: {};
+};
+export type IDetectionPipelineProvider = InferProvider<typeof detectionPipelineCapability>;
+//# sourceMappingURL=detection-pipeline.cap.d.ts.map

package/dist/capabilities/detection-pipeline.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detection-pipeline.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/detection-pipeline.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,2BAA2B;;;;;;;CAOC,CAAA;AAEzC,MAAM,MAAM,0BAA0B,GAAG,aAAa,CAAC,OAAO,2BAA2B,CAAC,CAAA"}

package/dist/capabilities/device-discovery.cap.d.ts

@@ -0,0 +1,247 @@
+import { z } from 'zod';
+import { type InferProvider, type InferNativeProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * device-discovery — device-scoped capability for parents that host /
+ * enumerate child devices (Reolink Hub / NVR, ONVIF gateway, future
+ * integrations). Mirrors Scrypted's `DeviceDiscovery` interface
+ * (`scrypted-reolink-native/src/nvr.ts:42-44`): the parent advertises
+ * a list of discoverable children, and the operator promotes a subset
+ * to real devices via `adoptDevice`. Child lifecycle (kernel device
+ * create/remove, parent reference) is owned by the framework so a
+ * single shared `<DiscoveryPanel />` can drive any integration.
+ *
+ * Boundaries:
+ *   - The cap exposes ENUMERATION + ADOPT/RELEASE only. The protocol
+ *     used to discover children (CGI poll, mDNS, push from hub, ...)
+ *     is the integration's business; results land in `runtimeState`
+ *     so the panel can render without a fresh round-trip.
+ *   - `childNativeId` is integration-defined and must be stable across
+ *     reboots so re-discovery doesn't duplicate adopted children.
+ *   - `adoptDevice` returns the new `deviceId` so the UI can navigate
+ *     directly to the freshly-created child's settings page.
+ */
+/**
+ * Status enum for a discovered device. Mirrors the Reolink simpleEvent
+ * lifecycle (`online` / `sleeping` / `offline`) — generic enough for
+ * battery cams, awake cams, and unreachable cams alike.
+ */
+export declare const DiscoveredChildStatusSchema: z.ZodEnum<{
+    unknown: "unknown";
+    sleeping: "sleeping";
+    offline: "offline";
+    online: "online";
+}>;
+export type DiscoveredChildStatus = z.infer<typeof DiscoveredChildStatusSchema>;
+/**
+ * Single discovered child entry. `metadata` is integration-defined
+ * but intentionally typed as a closed shape with the most-common
+ * camera knobs — keeps the panel renderer dumb without forcing every
+ * integration to invent a custom UI.
+ */
+export declare const DiscoveredChildDeviceSchema: z.ZodObject<{
+    childNativeId: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodEnum<typeof DeviceType>;
+    status: z.ZodEnum<{
+        unknown: "unknown";
+        sleeping: "sleeping";
+        offline: "offline";
+        online: "online";
+    }>;
+    metadata: z.ZodDefault<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        serialNumber: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodString>;
+        rtspChannel: z.ZodOptional<z.ZodNumber>;
+        isBattery: z.ZodOptional<z.ZodBoolean>;
+        isDoorbell: z.ZodOptional<z.ZodBoolean>;
+        isMultifocal: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    alreadyAdopted: z.ZodBoolean;
+    adoptedDeviceId: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type DiscoveredChildDevice = z.infer<typeof DiscoveredChildDeviceSchema>;
+/**
+ * Status block — populated by the integration after each
+ * `refreshDiscovery` (or push-driven update). The runtime-state slice
+ * is what the panel reads via the per-device proxy; `getStatus`
+ * returns the same payload via the codegen'd auto-injection.
+ */
+export declare const DeviceDiscoveryStatusSchema: z.ZodObject<{
+    discovered: z.ZodArray<z.ZodObject<{
+        childNativeId: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<typeof DeviceType>;
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            sleeping: "sleeping";
+            offline: "offline";
+            online: "online";
+        }>;
+        metadata: z.ZodDefault<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            serialNumber: z.ZodOptional<z.ZodString>;
+            uid: z.ZodOptional<z.ZodString>;
+            rtspChannel: z.ZodOptional<z.ZodNumber>;
+            isBattery: z.ZodOptional<z.ZodBoolean>;
+            isDoorbell: z.ZodOptional<z.ZodBoolean>;
+            isMultifocal: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        alreadyAdopted: z.ZodBoolean;
+        adoptedDeviceId: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    lastDiscoveryAt: z.ZodNullable<z.ZodNumber>;
+    lastError: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type DeviceDiscoveryStatus = z.infer<typeof DeviceDiscoveryStatusSchema>;
+export declare const deviceDiscoveryCapability: {
+    readonly name: "device-discovery";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Hub];
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            discovered: z.ZodArray<z.ZodObject<{
+                childNativeId: z.ZodString;
+                name: z.ZodString;
+                type: z.ZodEnum<typeof DeviceType>;
+                status: z.ZodEnum<{
+                    unknown: "unknown";
+                    sleeping: "sleeping";
+                    offline: "offline";
+                    online: "online";
+                }>;
+                metadata: z.ZodDefault<z.ZodObject<{
+                    model: z.ZodOptional<z.ZodString>;
+                    serialNumber: z.ZodOptional<z.ZodString>;
+                    uid: z.ZodOptional<z.ZodString>;
+                    rtspChannel: z.ZodOptional<z.ZodNumber>;
+                    isBattery: z.ZodOptional<z.ZodBoolean>;
+                    isDoorbell: z.ZodOptional<z.ZodBoolean>;
+                    isMultifocal: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                alreadyAdopted: z.ZodBoolean;
+                adoptedDeviceId: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>;
+            lastDiscoveryAt: z.ZodNullable<z.ZodNumber>;
+            lastError: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        readonly kind: "poll";
+    };
+    readonly runtimeState: z.ZodObject<{
+        discovered: z.ZodArray<z.ZodObject<{
+            childNativeId: z.ZodString;
+            name: z.ZodString;
+            type: z.ZodEnum<typeof DeviceType>;
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                sleeping: "sleeping";
+                offline: "offline";
+                online: "online";
+            }>;
+            metadata: z.ZodDefault<z.ZodObject<{
+                model: z.ZodOptional<z.ZodString>;
+                serialNumber: z.ZodOptional<z.ZodString>;
+                uid: z.ZodOptional<z.ZodString>;
+                rtspChannel: z.ZodOptional<z.ZodNumber>;
+                isBattery: z.ZodOptional<z.ZodBoolean>;
+                isDoorbell: z.ZodOptional<z.ZodBoolean>;
+                isMultifocal: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            alreadyAdopted: z.ZodBoolean;
+            adoptedDeviceId: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+        lastDiscoveryAt: z.ZodNullable<z.ZodNumber>;
+        lastError: z.ZodNullable<z.ZodString>;
+        lastFetchedAt: z.ZodNumber;
+    }, z.core.$strip>;
+    readonly methods: {
+        /**
+         * Snapshot of the current `discovered` list. Returns the
+         * runtime-state cache — call `refreshDiscovery` first if a
+         * fresh round-trip to the source is required.
+         */
+        readonly listDiscovered: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            childNativeId: z.ZodString;
+            name: z.ZodString;
+            type: z.ZodEnum<typeof DeviceType>;
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                sleeping: "sleeping";
+                offline: "offline";
+                online: "online";
+            }>;
+            metadata: z.ZodDefault<z.ZodObject<{
+                model: z.ZodOptional<z.ZodString>;
+                serialNumber: z.ZodOptional<z.ZodString>;
+                uid: z.ZodOptional<z.ZodString>;
+                rtspChannel: z.ZodOptional<z.ZodNumber>;
+                isBattery: z.ZodOptional<z.ZodBoolean>;
+                isDoorbell: z.ZodOptional<z.ZodBoolean>;
+                isMultifocal: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            alreadyAdopted: z.ZodBoolean;
+            adoptedDeviceId: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Force the integration to re-enumerate and update the
+         * runtime-state slice. Returns the freshly-enumerated list (also
+         * available via `listDiscovered` post-call).
+         */
+        readonly refreshDiscovery: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            childNativeId: z.ZodString;
+            name: z.ZodString;
+            type: z.ZodEnum<typeof DeviceType>;
+            status: z.ZodEnum<{
+                unknown: "unknown";
+                sleeping: "sleeping";
+                offline: "offline";
+                online: "online";
+            }>;
+            metadata: z.ZodDefault<z.ZodObject<{
+                model: z.ZodOptional<z.ZodString>;
+                serialNumber: z.ZodOptional<z.ZodString>;
+                uid: z.ZodOptional<z.ZodString>;
+                rtspChannel: z.ZodOptional<z.ZodNumber>;
+                isBattery: z.ZodOptional<z.ZodBoolean>;
+                isDoorbell: z.ZodOptional<z.ZodBoolean>;
+                isMultifocal: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            alreadyAdopted: z.ZodBoolean;
+            adoptedDeviceId: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>>, "mutation">;
+        /**
+         * Promote a discovered entry to a real child device. The framework
+         * creates the child via `kernel.devices.create()` with
+         * `parentDeviceId = parent.id` and seeds the child's config from
+         * `childInitialConfig` (driver-defined; usually carries channel +
+         * uid + parent reference). Returns the kernel-assigned numeric id.
+         */
+        readonly adoptDevice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            childNativeId: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            deviceId: z.ZodNumber;
+            stableId: z.ZodString;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Inverse of `adoptDevice`: removes the child device from the
+         * kernel registry. The discovered entry remains in the
+         * enumeration (status updates resume) so the operator can re-adopt
+         * it later without a fresh refresh.
+         */
+        readonly releaseDevice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            childDeviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+};
+export type IDeviceDiscoveryProvider = InferProvider<typeof deviceDiscoveryCapability>;
+export type IDeviceDiscoveryNativeProvider = InferNativeProvider<typeof deviceDiscoveryCapability>;
+//# sourceMappingURL=device-discovery.cap.d.ts.map

package/dist/capabilities/device-discovery.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-discovery.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/device-discovery.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,KAAK,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AAC5H,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;GAIG;AACH,eAAO,MAAM,2BAA2B;;;;;EAAuD,CAAA;AAC/F,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAE/E;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;iBA2BtC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAE/E;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;iBAMtC,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAE/E,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAiBlC;;;;WAIG;;;;;;;;;;;;;;;;;;;;;;;;;QAKH;;;;WAIG;;;;;;;;;;;;;;;;;;;;;;;;;QAMH;;;;;;WAMG;;;;;;;;;QAcH;;;;;WAKG;;;;;;CAUkC,CAAA;AAEzC,MAAM,MAAM,wBAAwB,GAAG,aAAa,CAAC,OAAO,yBAAyB,CAAC,CAAA;AACtF,MAAM,MAAM,8BAA8B,GAAG,mBAAmB,CAAC,OAAO,yBAAyB,CAAC,CAAA"}