@camstack/types 0.1.40 → 0.1.41

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

@@ -0,0 +1,167 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Unified user-settable input cap. Models HA's `number` /
+ * `input_number` / `select` / `input_select` / `text` / `input_text`
+ * / `input_datetime` domains as a single device-scoped cap on
+ * `DeviceType.Control`.
+ *
+ * The slice is a discriminated union over four `kind` values that
+ * mirror the corresponding `DeviceRole` sub-roles
+ * (NumericControl / SelectControl / TextControl / DateTimeControl)
+ * — the device's `role` and the slice's `kind` are populated in
+ * lockstep at materialisation time. The UI reads `device.role`
+ * (or equivalently the slice's `kind`) to render the correct input
+ * widget (slider / dropdown / text field / date picker).
+ *
+ * The `select` branch carries its `options` list IN THE SLICE
+ * (not in `sourceInfo`) because HA `select.*` entities can update
+ * their options dynamically at runtime — the slice is the live
+ * source of truth. Numeric `unit`/`min`/`max`/`step` also live IN
+ * THE SLICE — populated live from the upstream source on each state
+ * push (HA `attributes.unit_of_measurement` / `min` / `max` /
+ * `step`). The slice is the single source of truth; there is no
+ * separate `sourceInfo` or device-config blob for these values.
+ */
+export declare const ControlKindSchema: z.ZodEnum<{
+    text: "text";
+    select: "select";
+    datetime: "datetime";
+    numeric: "numeric";
+}>;
+export type ControlKind = z.infer<typeof ControlKindSchema>;
+/**
+ * Status slice — flat object (the framework's `runtimeState` contract
+ * requires a `ZodObject`, not a discriminated union). The `kind`
+ * field discriminates the value type at the type level via the
+ * `ControlNumericValue` / `ControlStringValue` aliases; consumers
+ * narrow with a kind check.
+ *
+ * The `value` field is typed as `number | string`:
+ *   - `kind === 'numeric'` → `value` is `number`
+ *   - `kind === 'select' | 'text' | 'datetime'` → `value` is `string`
+ *
+ * The `options` array is populated only when `kind === 'select'`
+ * (empty array for the other kinds). It lives in the slice because
+ * HA `select.*` entities may update their options at runtime.
+ *
+ * The `unit`/`min`/`max`/`step` fields are meaningful for
+ * `kind === 'numeric'` and are absent (undefined) for all other
+ * kinds. They are populated live from HA attributes on each state
+ * push — consistent with `options` and the sensor-unit approach.
+ */
+export declare const ControlStatusSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        text: "text";
+        select: "select";
+        datetime: "datetime";
+        numeric: "numeric";
+    }>;
+    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+    options: z.ZodArray<z.ZodString>;
+    lastChangedAt: z.ZodNumber;
+    unit: z.ZodOptional<z.ZodString>;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    step: z.ZodOptional<z.ZodNumber>;
+    precision: z.ZodOptional<z.ZodNumber>;
+    format: z.ZodOptional<z.ZodEnum<{
+        date: "date";
+        datetime: "datetime";
+        time: "time";
+    }>>;
+}, z.core.$strip>;
+export type ControlStatus = z.infer<typeof ControlStatusSchema>;
+declare const ControlSetValueInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"numeric">;
+    value: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"select">;
+    value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"text">;
+    value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"datetime">;
+    value: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type ControlSetValueInput = z.infer<typeof ControlSetValueInputSchema>;
+export declare const controlCapability: {
+    readonly name: "control";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Control];
+    readonly methods: {
+        readonly setValue: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            control: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"numeric">;
+                value: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"select">;
+                value: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"text">;
+                value: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"datetime">;
+                value: z.ZodString;
+            }, z.core.$strip>], "kind">;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            kind: z.ZodEnum<{
+                text: "text";
+                select: "select";
+                datetime: "datetime";
+                numeric: "numeric";
+            }>;
+            value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            options: z.ZodArray<z.ZodString>;
+            lastChangedAt: z.ZodNumber;
+            unit: z.ZodOptional<z.ZodString>;
+            min: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            step: z.ZodOptional<z.ZodNumber>;
+            precision: z.ZodOptional<z.ZodNumber>;
+            format: z.ZodOptional<z.ZodEnum<{
+                date: "date";
+                datetime: "datetime";
+                time: "time";
+            }>>;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    /**
+     * Runtime-state slice — mirrored by the kernel. UI widgets (slider /
+     * dropdown / text field / date picker) read the slice's discriminant
+     * and value directly without polling the provider.
+     */
+    readonly runtimeState: z.ZodObject<{
+        kind: z.ZodEnum<{
+            text: "text";
+            select: "select";
+            datetime: "datetime";
+            numeric: "numeric";
+        }>;
+        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+        options: z.ZodArray<z.ZodString>;
+        lastChangedAt: z.ZodNumber;
+        unit: z.ZodOptional<z.ZodString>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        step: z.ZodOptional<z.ZodNumber>;
+        precision: z.ZodOptional<z.ZodNumber>;
+        format: z.ZodOptional<z.ZodEnum<{
+            date: "date";
+            datetime: "datetime";
+            time: "time";
+        }>>;
+    }, z.core.$strip>;
+};
+export type IControlProvider = InferProvider<typeof controlCapability>;
+export {};
+//# sourceMappingURL=control.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"control.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/control.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,eAAO,MAAM,iBAAiB;;;;;EAAoD,CAAA;AAClF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;iBAkC9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,QAAA,MAAM,0BAA0B;;;;;;;;;;;;2BAK9B,CAAA;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAE7E,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoB5B;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

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

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Window covering / blinds / garage door / valve cap. Models HA
+ * `cover.*` entities — anything that moves between an open and a
+ * closed state with optional intermediate positioning and tilt.
+ *
+ * State follows HA's canonical lifecycle: `open` / `opening` /
+ * `closing` / `closed` / `stopped`. `position` (0 closed, 100 open)
+ * and `tiltPosition` are nullable — some shutters only support
+ * full open/close, some Venetian blinds add tilt but no slat
+ * positioning, garage doors are usually positionless. Providers
+ * populate only what the hardware reports.
+ *
+ * The cap intentionally does NOT split tilt into a sibling cap:
+ * physical hardware that has tilt always has the main position
+ * surface too, so the coupling stays inside one slice + one method
+ * group rather than spreading across two registrations.
+ *
+ * Sub-surface gating paired with `DeviceFeature` flags:
+ *   - `CoverPositionable` — intermediate `position` slider
+ *   - `CoverTilt` — slat-tilt slider
+ */
+export declare const CoverStateSchema: z.ZodEnum<{
+    open: "open";
+    stopped: "stopped";
+    opening: "opening";
+    closing: "closing";
+    closed: "closed";
+}>;
+export type CoverState = z.infer<typeof CoverStateSchema>;
+export declare const CoverStatusSchema: z.ZodObject<{
+    state: z.ZodEnum<{
+        open: "open";
+        stopped: "stopped";
+        opening: "opening";
+        closing: "closing";
+        closed: "closed";
+    }>;
+    position: z.ZodNullable<z.ZodNumber>;
+    tiltPosition: z.ZodNullable<z.ZodNumber>;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type CoverStatus = z.infer<typeof CoverStatusSchema>;
+export declare const coverCapability: {
+    readonly name: "cover";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Cover];
+    readonly methods: {
+        readonly open: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly close: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly stop: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly setPosition: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            position: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly setTiltPosition: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            tiltPosition: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            state: z.ZodEnum<{
+                open: "open";
+                stopped: "stopped";
+                opening: "opening";
+                closing: "closing";
+                closed: "closed";
+            }>;
+            position: z.ZodNullable<z.ZodNumber>;
+            tiltPosition: z.ZodNullable<z.ZodNumber>;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    /**
+     * Runtime-state slice — mirrored by the kernel. UI controls watch
+     * the slice for live position changes during a move.
+     */
+    readonly runtimeState: z.ZodObject<{
+        state: z.ZodEnum<{
+            open: "open";
+            stopped: "stopped";
+            opening: "opening";
+            closing: "closing";
+            closed: "closed";
+        }>;
+        position: z.ZodNullable<z.ZodNumber>;
+        tiltPosition: z.ZodNullable<z.ZodNumber>;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type ICoverProvider = InferProvider<typeof coverCapability>;
+//# sourceMappingURL=cover.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cover.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/cover.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,eAAO,MAAM,gBAAgB;;;;;;EAM3B,CAAA;AACF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,eAAO,MAAM,iBAAiB;;;;;;;;;;;iBAU5B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA2C1B;;;OAGG;;;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,cAAc,GAAG,aAAa,CAAC,OAAO,eAAe,CAAC,CAAA"}

package/dist/capabilities/custom-actions.d.ts

@@ -44,4 +44,10 @@ export interface CustomActionOptions<TKind extends 'query' | 'mutation' | 'subsc
 export declare function customAction<TIn extends z.ZodType, TOut extends z.ZodType, TKind extends 'query' | 'mutation' | 'subscription' = 'query', TAuth extends CapabilityMethodAuth = 'protected'>(input: TIn, output: TOut, options?: CustomActionOptions<TKind, TAuth>): CustomActionSpec<TIn, TOut, TKind, TAuth, {
     readonly kind: 'system';
 }>;
+export declare function deviceCustomAction<TIn extends z.ZodType, TOut extends z.ZodType, TKind extends 'query' | 'mutation' | 'subscription' = 'query', TAuth extends CapabilityMethodAuth = 'protected'>(input: TIn, output: TOut, options?: Omit<CustomActionOptions<TKind, TAuth>, 'scope'> & {
+    readonly deviceTypes?: readonly DeviceType[];
+}): CustomActionSpec<TIn, TOut, TKind, TAuth, {
+    readonly kind: 'device';
+    readonly deviceTypes?: readonly DeviceType[];
+}>;
 //# sourceMappingURL=custom-actions.d.ts.map

package/dist/capabilities/custom-actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"custom-actions.d.ts","sourceRoot":"","sources":["../../src/capabilities/custom-actions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAC5B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAA;AAEtE,iFAAiF;AACjF,MAAM,MAAM,iBAAiB,GACzB;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAC3B;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,UAAU,EAAE,CAAA;CAAE,CAAA;AAE7E,MAAM,WAAW,gBAAgB,CAC/B,GAAG,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO,EACjC,IAAI,SAAS,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,OAAO,EAClC,KAAK,SAAS,OAAO,GAAG,UAAU,GAAG,cAAc,GAAG,OAAO,GAAG,UAAU,GAAG,cAAc,EAC3F,KAAK,SAAS,oBAAoB,GAAG,oBAAoB,EACzD,MAAM,SAAS,iBAAiB,GAAG,iBAAiB;IAEpD,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAA;IACnB,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB;AAED,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAA;AAEhE;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAEjF;AAED,MAAM,WAAW,mBAAmB,CAClC,KAAK,SAAS,OAAO,GAAG,UAAU,GAAG,cAAc,GAAG,OAAO,EAC7D,KAAK,SAAS,oBAAoB,GAAG,WAAW;IAEhD,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,KAAK,CAAC,EAAE,iBAAiB,CAAA;CACnC;AAED,wBAAgB,YAAY,CAC1B,GAAG,SAAS,CAAC,CAAC,OAAO,EACrB,IAAI,SAAS,CAAC,CAAC,OAAO,EACtB,KAAK,SAAS,OAAO,GAAG,UAAU,GAAG,cAAc,GAAG,OAAO,EAC7D,KAAK,SAAS,oBAAoB,GAAG,WAAW,EAEhD,KAAK,EAAE,GAAG,EACV,MAAM,EAAE,IAAI,EACZ,OAAO,CAAC,EAAE,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,GAC1C,gBAAgB,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,CAQxE"}
+{"version":3,"file":"custom-actions.d.ts","sourceRoot":"","sources":["../../src/capabilities/custom-actions.ts"],"names":[],"mappings":"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"}

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

@@ -91,8 +91,8 @@ export declare const decoderCapability: {
             sessionId: z.ZodString;
             packet: z.ZodObject<{
                 type: z.ZodEnum<{
-                    audio: "audio";
                     video: "video";
+                    audio: "audio";
                 }>;
                 data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
                 pts: z.ZodNumber;

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

@@ -0,0 +1,203 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * `device-adoption` — generic discovery + adoption surface,
+ * system-scoped singleton. The de-HA-ified successor to `ha-discovery`:
+ * keyed by `integrationId` (the addon resolves integrationId → broker
+ * internally) rather than a connection-specific `brokerId`, and it
+ * REUSES the shared `DiscoveredChildDevice` candidate type from
+ * `device-discovery.cap.ts` so a single shared adoption panel renders
+ * any integration's candidate tree.
+ *
+ * UI flow (Integrations page → integration detail):
+ *   1. `listCandidates({integrationId, page, pageSize, filter})` →
+ *      paginated candidate list, each row collapsed.
+ *   2. User expands a row → `getCandidate({integrationId,
+ *      childNativeId})` returns the single candidate (with its nested
+ *      `children`) for the accordion render.
+ *   3. User clicks "Adopt" on one or more candidates →
+ *      `adopt({integrationId, childNativeIds, perCandidate?})`
+ *      materialises one parent CamStack device per candidate plus its
+ *      accessory children. `perCandidate[childNativeId]` carries an
+ *      optional display-name override + a `hiddenChildIds` pre-hide set
+ *      (the parent's `accessories.hiddenChildIds` gates UI visibility).
+ *   4. User clicks "Release" → `release({integrationId, camDeviceId})`
+ *      removes the parent + every child from the kernel registry.
+ */
+/**
+ * Provider-declared discovery *granularity* filter (the keystone of the
+ * single-entity-import design). A provider advertises which discovery
+ * granularities it supports via `listCandidateFilters`; the operator picks
+ * one and it is passed back as the opaque `filter` string on
+ * `listCandidates`/`adopt`.
+ *
+ * - **`id`** is provider-defined and OPAQUE to the cap + UI layers — only the
+ *   declaring provider interprets it. The reserved id `'devices'` is the
+ *   universal default (every provider's current behavior IS the `devices`
+ *   filter). A provider that declares no filters is treated as a single
+ *   implicit `{ id:'devices', label:'Devices', isDefault:true }`.
+ * - **`label`** is the human label for the UI selector.
+ * - **`isDefault`** marks the default filter; exactly one SHOULD be default.
+ */
+export declare const AdoptionFilterSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type AdoptionFilter = z.infer<typeof AdoptionFilterSchema>;
+/**
+ * Candidate-list TEXT/query filter. Mirrors the prior `ha-discovery` filter,
+ * de-HA-ified — `area` / `manufacturer` stay free-form strings so any
+ * integration can populate them from its own metadata. Distinct from the
+ * granularity `AdoptionFilter` above: this narrows the candidate set within a
+ * chosen granularity, whereas the granularity `filter` selects WHAT a
+ * candidate is (a device vs an entity).
+ */
+export declare const CandidateQueryFilterSchema: z.ZodObject<{
+    search: z.ZodOptional<z.ZodString>;
+    area: z.ZodOptional<z.ZodString>;
+    manufacturer: z.ZodOptional<z.ZodString>;
+    adoptedOnly: z.ZodOptional<z.ZodBoolean>;
+    unadoptedOnly: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const ListCandidatesInputSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    page: z.ZodDefault<z.ZodNumber>;
+    pageSize: z.ZodDefault<z.ZodNumber>;
+    filter: z.ZodOptional<z.ZodString>;
+    filterText: z.ZodOptional<z.ZodObject<{
+        search: z.ZodOptional<z.ZodString>;
+        area: z.ZodOptional<z.ZodString>;
+        manufacturer: z.ZodOptional<z.ZodString>;
+        adoptedOnly: z.ZodOptional<z.ZodBoolean>;
+        unadoptedOnly: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ListCandidatesOutputSchema: z.ZodObject<{
+    candidates: z.ZodReadonly<z.ZodArray<z.ZodType<import("./device-discovery.cap.js").DiscoveredChildDevice, unknown, z.core.$ZodTypeInternals<import("./device-discovery.cap.js").DiscoveredChildDevice, unknown>>>>;
+    totalCount: z.ZodNumber;
+    page: z.ZodNumber;
+    pageSize: z.ZodNumber;
+}, z.core.$strip>;
+export declare const GetCandidateInputSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    childNativeId: z.ZodString;
+}, z.core.$strip>;
+export declare const AdoptionStatusSchema: z.ZodObject<{
+    lastDiscoveryAt: z.ZodNullable<z.ZodNumber>;
+    candidateCount: z.ZodNumber;
+    adoptedCount: z.ZodNumber;
+    lastError: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const AdoptInputSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    childNativeIds: z.ZodArray<z.ZodString>;
+    filter: z.ZodOptional<z.ZodString>;
+    importLocations: z.ZodOptional<z.ZodBoolean>;
+    perCandidate: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        hiddenChildIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const AdoptResultSchema: z.ZodObject<{
+    adopted: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        childNativeId: z.ZodString;
+        parentDeviceId: z.ZodNumber;
+        accessoryDeviceIds: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const ReleaseInputSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    camDeviceId: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ResyncInputSchema: z.ZodObject<{
+    camDeviceId: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ResyncResultSchema: z.ZodObject<{
+    changed: z.ZodBoolean;
+    rebuiltChildren: z.ZodNumber;
+}, z.core.$strip>;
+export declare const deviceAdoptionCapability: {
+    readonly name: "device-adoption";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            lastDiscoveryAt: z.ZodNullable<z.ZodNumber>;
+            candidateCount: z.ZodNumber;
+            adoptedCount: z.ZodNumber;
+            lastError: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        readonly kind: "poll";
+    };
+    readonly methods: {
+        readonly listCandidateFilters: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            integrationId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            filters: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                isDefault: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly listCandidates: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            integrationId: z.ZodString;
+            page: z.ZodDefault<z.ZodNumber>;
+            pageSize: z.ZodDefault<z.ZodNumber>;
+            filter: z.ZodOptional<z.ZodString>;
+            filterText: z.ZodOptional<z.ZodObject<{
+                search: z.ZodOptional<z.ZodString>;
+                area: z.ZodOptional<z.ZodString>;
+                manufacturer: z.ZodOptional<z.ZodString>;
+                adoptedOnly: z.ZodOptional<z.ZodBoolean>;
+                unadoptedOnly: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            candidates: z.ZodReadonly<z.ZodArray<z.ZodType<import("./device-discovery.cap.js").DiscoveredChildDevice, unknown, z.core.$ZodTypeInternals<import("./device-discovery.cap.js").DiscoveredChildDevice, unknown>>>>;
+            totalCount: z.ZodNumber;
+            page: z.ZodNumber;
+            pageSize: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getCandidate: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            integrationId: z.ZodString;
+            childNativeId: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodType<import("./device-discovery.cap.js").DiscoveredChildDevice, unknown, z.core.$ZodTypeInternals<import("./device-discovery.cap.js").DiscoveredChildDevice, unknown>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly refresh: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            integrationId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            lastDiscoveryAt: z.ZodNullable<z.ZodNumber>;
+            candidateCount: z.ZodNumber;
+            adoptedCount: z.ZodNumber;
+            lastError: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>, "mutation">;
+        readonly adopt: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            integrationId: z.ZodString;
+            childNativeIds: z.ZodArray<z.ZodString>;
+            filter: z.ZodOptional<z.ZodString>;
+            importLocations: z.ZodOptional<z.ZodBoolean>;
+            perCandidate: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                hiddenChildIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            adopted: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                childNativeId: z.ZodString;
+                parentDeviceId: z.ZodNumber;
+                accessoryDeviceIds: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, "mutation">;
+        readonly release: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            integrationId: z.ZodString;
+            camDeviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly resync: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            camDeviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            changed: z.ZodBoolean;
+            rebuiltChildren: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
+    };
+};
+export type IDeviceAdoptionProvider = InferProvider<typeof deviceAdoptionCapability>;
+export type AdoptionStatus = z.infer<typeof AdoptionStatusSchema>;
+//# sourceMappingURL=device-adoption.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"device-adoption.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/device-adoption.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAGlG;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB;;;;iBAI/B,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B;;;;;;iBAWrC,CAAA;AAEF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;iBAiBpC,CAAA;AACF,eAAO,MAAM,0BAA0B;;;;;iBAKrC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;iBAGlC,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;;;iBAS/B,CAAA;AASF,eAAO,MAAM,gBAAgB;;;;;;;;;iBAqB3B,CAAA;AACF,eAAO,MAAM,iBAAiB;;;;;;iBAQ5B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;iBAK7B,CAAA;AAEF,eAAO,MAAM,iBAAiB;;iBAM5B,CAAA;AACF,eAAO,MAAM,kBAAkB;;;iBAK7B,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBI,CAAA;AAEzC,MAAM,MAAM,uBAAuB,GAAG,aAAa,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACpF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA"}