@camstack/types 0.1.14 → 0.1.16

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

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * Authentication-provider summary metadata. Drives the admin UI's
+ * "Authentication Providers" page and the login screen's provider
+ * picker (Google / Microsoft / SAML / etc. buttons next to the
+ * username/password form).
+ *
+ * Keep the shape lean: the admin UI doesn't render runtime
+ * credentials, only enough to identify the provider and its UX
+ * affordances. Per-provider config still lives in the addon's own
+ * settings panel.
+ */
+declare const AuthProviderInfoSchema: z.ZodObject<{
+    addonId: z.ZodString;
+    displayName: z.ZodString;
+    kind: z.ZodEnum<{
+        other: "other";
+        local: "local";
+        oidc: "oidc";
+        saml: "saml";
+        ldap: "ldap";
+    }>;
+    icon: z.ZodOptional<z.ZodString>;
+    hasRedirectFlow: z.ZodBoolean;
+    hasCredentialFlow: z.ZodBoolean;
+    status: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodBoolean;
+}, z.core.$strip>;
+export type AuthProviderInfo = z.infer<typeof AuthProviderInfoSchema>;
+/**
+ * `authentication` — singleton facade over the `auth-provider`
+ * collection. Consumed by:
+ *   - Login page (enumerate provider buttons)
+ *   - Admin UI Authentication page (list/configure/enable/disable)
+ *
+ * Mirrors the pattern of `backup` (singleton facade over the
+ * `backup-destination` collection) — UI consumers don't need to know
+ * about individual `auth-provider` providers; they call this and
+ * receive a curated view.
+ *
+ * The actual login flow still goes through the `auth-provider`
+ * collection (validateCredentials / getLoginUrl / handleCallback);
+ * this cap only listing/orchestration.
+ */
+export declare const authenticationCapability: {
+    readonly name: "authentication";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        /** All registered auth providers, both enabled and disabled. */
+        readonly listProviders: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            addonId: z.ZodString;
+            displayName: z.ZodString;
+            kind: z.ZodEnum<{
+                other: "other";
+                local: "local";
+                oidc: "oidc";
+                saml: "saml";
+                ldap: "ldap";
+            }>;
+            icon: z.ZodOptional<z.ZodString>;
+            hasRedirectFlow: z.ZodBoolean;
+            hasCredentialFlow: z.ZodBoolean;
+            status: z.ZodOptional<z.ZodString>;
+            enabled: z.ZodBoolean;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Toggle a provider's enabled flag. Disabled providers stay
+         * registered but aren't surfaced on the login page. The orchestrator
+         * persists the state in `addon-settings` so it survives restarts.
+         */
+        readonly setProviderEnabled: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addonId: z.ZodString;
+            enabled: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+    };
+};
+export type IAuthenticationProvider = InferProvider<typeof authenticationCapability>;
+export { AuthProviderInfoSchema };
+//# sourceMappingURL=authentication.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"authentication.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/authentication.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;;;;;;;;;GAUG;AACH,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;iBA2B1B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,wBAAwB;;;;;QAKjC,gEAAgE;;;;;;;;;;;;;;;;;QAEhE;;;;WAIG;;;;;;;;CAOkC,CAAA;AAEzC,MAAM,MAAM,uBAAuB,GAAG,aAAa,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEpF,OAAO,EAAE,sBAAsB,EAAE,CAAA"}

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

@@ -0,0 +1,269 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * Per-destination metadata returned by `backup-destination.listDestinations`.
+ * Defined here (not in `backup-destination.cap.ts`) because both caps need
+ * it and `backup` is the foundation — the destination cap imports from us.
+ */
+/**
+ * Provider-side destination metadata. The addon returns a SHORT id
+ * (`subId`) — orchestrator-internal-only routing prepends the addon's
+ * manifest id to produce the externally-visible globally-unique id.
+ *
+ * Why split: the addon shouldn't have to know its own manifest id.
+ * That id is owned by `package.json` and the kernel's registry; making
+ * the addon repeat it leaks framework state into addon code and
+ * breaks if the manifest is ever renamed.
+ */
+declare const BackupSubDestinationInfoSchema: z.ZodObject<{
+    subId: z.ZodString;
+    displayName: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    kind: z.ZodString;
+    triggerSupported: z.ZodBoolean;
+    restoreSupported: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Orchestrator-side destination metadata. The orchestrator computes
+ * `id = <addonId>:<subId>` from its provider lookup so consumers
+ * (admin UI, restore flow) see one canonical key.
+ *
+ * Phase 4 (admin UI redesign) adds the per-destination policy fields
+ * (`enabled`, `retentionCount`, `label`) so the destinations table can
+ * render the joined view without a follow-up round-trip. The backend
+ * already joins these in `listDestinations` — we now surface them on
+ * the wire.
+ *
+ * `lastSuccessAt` / `lastSuccessSizeBytes` are computed from each
+ * location's `manifests.json` (newest archive). Optional — locations
+ * with no archives yet leave them undefined.
+ */
+declare const BackupDestinationInfoSchema: z.ZodObject<{
+    subId: z.ZodString;
+    displayName: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    kind: z.ZodString;
+    triggerSupported: z.ZodBoolean;
+    restoreSupported: z.ZodBoolean;
+    id: z.ZodString;
+    addonId: z.ZodString;
+    enabled: z.ZodBoolean;
+    retentionCount: z.ZodNumber;
+    label: z.ZodOptional<z.ZodString>;
+    lastSuccessAt: z.ZodOptional<z.ZodNumber>;
+    lastSuccessSizeBytes: z.ZodOptional<z.ZodNumber>;
+    cron: z.ZodOptional<z.ZodString>;
+    nextRunAt: z.ZodOptional<z.ZodNumber>;
+    lastRunAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Per-archive entry returned by `backup.listArchives({ destinationId })`.
+ * Same shape the destination drill-in renders. Sourced from the per-
+ * location `manifests.json` (no per-archive tarball read required).
+ */
+declare const BackupArchiveEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    filename: z.ZodString;
+    createdAt: z.ZodNumber;
+    sizeBytes: z.ZodNumber;
+    label: z.ZodOptional<z.ZodString>;
+    locations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const BackupEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    destinationId: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    sizeBytes: z.ZodNumber;
+    locations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const ArchiveEntrySchema: z.ZodObject<{
+    path: z.ZodString;
+    kind: z.ZodEnum<{
+        file: "file";
+        dir: "dir";
+        symlink: "symlink";
+    }>;
+    sizeBytes: z.ZodNumber;
+    mtime: z.ZodNumber;
+}, z.core.$strip>;
+declare const ArchiveManifestSchema: z.ZodObject<{
+    archiveVersion: z.ZodLiteral<1>;
+    createdAt: z.ZodNumber;
+    dataDir: z.ZodString;
+    locations: z.ZodArray<z.ZodString>;
+    entries: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        kind: z.ZodEnum<{
+            file: "file";
+            dir: "dir";
+            symlink: "symlink";
+        }>;
+        sizeBytes: z.ZodNumber;
+        mtime: z.ZodNumber;
+    }, z.core.$strip>>;
+    totalBytes: z.ZodNumber;
+    totalFiles: z.ZodNumber;
+}, z.core.$strip>;
+declare const LocationStatSchema: z.ZodObject<{
+    name: z.ZodString;
+    sizeBytes: z.ZodNumber;
+    fileCount: z.ZodNumber;
+    present: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * backup — singleton capability for backup management.
+ *
+ * Implemented by `local-backup` addon. Future providers (S3, rsync)
+ * can replace it by registering the same capability.
+ */
+export declare const backupCapability: {
+    readonly name: "backup";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        /**
+         * Flat aggregate of every destination across every registered
+         * `backup-destination` provider. This is the orchestrator-side
+         * surface; it expands per-addon `listDestinations()` results into
+         * one list the UI can render directly.
+         */
+        readonly listDestinations: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            subId: z.ZodString;
+            displayName: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            kind: z.ZodString;
+            triggerSupported: z.ZodBoolean;
+            restoreSupported: z.ZodBoolean;
+            id: z.ZodString;
+            addonId: z.ZodString;
+            enabled: z.ZodBoolean;
+            retentionCount: z.ZodNumber;
+            label: z.ZodOptional<z.ZodString>;
+            lastSuccessAt: z.ZodOptional<z.ZodNumber>;
+            lastSuccessSizeBytes: z.ZodOptional<z.ZodNumber>;
+            cron: z.ZodOptional<z.ZodString>;
+            nextRunAt: z.ZodOptional<z.ZodNumber>;
+            lastRunAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Trigger a backup. Without `destinations` the orchestrator fans
+         * out to every destination flagged as enabled in the routing
+         * config; with it, only the listed addons receive the archive.
+         */
+        readonly trigger: import("./capability-definition.js").CapabilityMethodSchema<z.ZodOptional<z.ZodObject<{
+            destinations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            locations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            destinationId: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            createdAt: z.ZodNumber;
+            sizeBytes: z.ZodNumber;
+            locations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>, "mutation">;
+        /** Union of every destination's archives, each tagged with `destinationId`. */
+        readonly list: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            destinationId: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            createdAt: z.ZodNumber;
+            sizeBytes: z.ZodNumber;
+            locations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Pre-backup snapshot of the well-known locations on disk — sizes
+         * + file counts. Powers the opt-in checklist that lets the
+         * operator pick which subsections of state get archived.
+         */
+        readonly listLocations: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            fileCount: z.ZodNumber;
+            present: z.ZodBoolean;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Read the embedded `.camstack-backup-manifest.json` from a
+         * previously-created archive. The manifest carries the full
+         * file/dir listing with sizes + mtimes — the readdir snapshot
+         * the UI shows in the "Contents" panel. Returns `null` when the
+         * archive predates manifests (created before this feature
+         * shipped).
+         */
+        readonly getEntries: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            destinationId: z.ZodString;
+            backupId: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            archiveVersion: z.ZodLiteral<1>;
+            createdAt: z.ZodNumber;
+            dataDir: z.ZodString;
+            locations: z.ZodArray<z.ZodString>;
+            entries: z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                kind: z.ZodEnum<{
+                    file: "file";
+                    dir: "dir";
+                    symlink: "symlink";
+                }>;
+                sizeBytes: z.ZodNumber;
+                mtime: z.ZodNumber;
+            }, z.core.$strip>>;
+            totalBytes: z.ZodNumber;
+            totalFiles: z.ZodNumber;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly restore: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            destinationId: z.ZodString;
+            backupId: z.ZodString;
+            locations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly delete: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            destinationId: z.ZodString;
+            backupId: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /**
+         * List archives at a single destination. Reads the per-location
+         * `manifests.json` and returns one entry per archive (newest
+         * first). Powers the destinations-table drill-in in admin UI.
+         */
+        readonly listArchives: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            destinationId: z.ZodString;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            filename: z.ZodString;
+            createdAt: z.ZodNumber;
+            sizeBytes: z.ZodNumber;
+            label: z.ZodOptional<z.ZodString>;
+            locations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Upsert a per-destination policy row. The `locationId` MUST be
+         * the id of an existing `backups`-typed `StorageLocation`. Used
+         * by the admin-UI destinations table (enable toggle + retention
+         * input + optional label).
+         */
+        readonly upsertDestinationPolicy: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            locationId: z.ZodString;
+            enabled: z.ZodBoolean;
+            retentionCount: z.ZodNumber;
+            label: z.ZodOptional<z.ZodString>;
+            cron: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /**
+         * Validate a cron expression and peek the next N firing times.
+         * Used by the admin-UI CronEditor to render a live "next-run"
+         * preview as the operator edits the pattern.
+         */
+        readonly previewSchedule: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            cron: z.ZodString;
+            count: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            ok: z.ZodBoolean;
+            error: z.ZodOptional<z.ZodString>;
+            nextRuns: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IBackupProvider = InferProvider<typeof backupCapability>;
+export { BackupEntrySchema, BackupSubDestinationInfoSchema, BackupDestinationInfoSchema, BackupArchiveEntrySchema, ArchiveEntrySchema, ArchiveManifestSchema, LocationStatSchema, };
+//# sourceMappingURL=backup.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"backup.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/backup.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;;;GAIG;AACH;;;;;;;;;GASG;AACH,QAAA,MAAM,8BAA8B;;;;;;;iBAalC,CAAA;AAEF;;;;;;;;;;;;;;GAcG;AACH,QAAA,MAAM,2BAA2B;;;;;;;;;;;;;;;;;iBAwB/B,CAAA;AAEF;;;;GAIG;AACH,QAAA,MAAM,wBAAwB;;;;;;;iBAQ5B,CAAA;AAEF,QAAA,MAAM,iBAAiB;;;;;;;iBAQrB,CAAA;AAEF,QAAA,MAAM,kBAAkB;;;;;;;;;iBAKtB,CAAA;AAEF,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;iBAQzB,CAAA;AAEF,QAAA,MAAM,kBAAkB;;;;;iBAKtB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;;;QAKzB;;;;;WAKG;;;;;;;;;;;;;;;;;;;QAMH;;;;WAIG;;;;;;;;;;;;;QAWH,+EAA+E;;;;;;;;;QAE/E;;;;WAIG;;;;;;;QAEH;;;;;;;WAOG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA2BH;;;;WAIG;;;;;;;;;;;QAMH;;;;;WAKG;;;;;;;;QAmBH;;;;WAIG;;;;;;;;;;CAakC,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEpE,OAAO,EACL,iBAAiB,EACjB,8BAA8B,EAC9B,2BAA2B,EAC3B,wBAAwB,EACxB,kBAAkB,EAClB,qBAAqB,EACrB,kBAAkB,GACnB,CAAA"}

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

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Battery status snapshot. Emitted by providers whose device is
+ * battery-operated (cameras with `DeviceFeature.BatteryOperated`,
+ * future sensor/button accessories). Consumers build their own "low
+ * battery" alerting on top — the cap deliberately does NOT enforce a
+ * threshold.
+ */
+export declare const BatteryStatusSchema: z.ZodObject<{
+    percentage: z.ZodNumber;
+    charging: z.ZodEnum<{
+        none: "none";
+        dc: "dc";
+        solar: "solar";
+    }>;
+    sleeping: z.ZodBoolean;
+    lastUpdated: z.ZodNumber;
+}, z.core.$strip>;
+export type BatteryStatus = z.infer<typeof BatteryStatusSchema>;
+export declare const batteryCapability: {
+    readonly name: "battery";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch];
+    readonly methods: {};
+    readonly events: {
+        /**
+         * Emitted whenever the cached status changes (firmware push OR
+         * poll observes a delta). The DeviceEventPropagator mirrors this
+         * event on the parent chain — subscribing to a camera's source
+         * receives battery events from child accessories automatically.
+         */
+        readonly onStatusChanged: {
+            readonly data: z.ZodObject<{
+                deviceId: z.ZodNumber;
+                status: z.ZodObject<{
+                    percentage: z.ZodNumber;
+                    charging: z.ZodEnum<{
+                        none: "none";
+                        dc: "dc";
+                        solar: "solar";
+                    }>;
+                    sleeping: z.ZodBoolean;
+                    lastUpdated: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        };
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            percentage: z.ZodNumber;
+            charging: z.ZodEnum<{
+                none: "none";
+                dc: "dc";
+                solar: "solar";
+            }>;
+            sleeping: z.ZodBoolean;
+            lastUpdated: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    /**
+     * Runtime-state slice — every provider that registers this cap
+     * stores the same shape under `device.runtimeState[battery]`.
+     * Cross-provider uniformity: a Reolink Argus, a Frigate sensor
+     * proxy, an ONVIF battery cam all read/write the same keys.
+     * Consumers (BatteryBadge, snapshot wrapper sleep gate) read once
+     * via `device.runtimeState.getCapState('battery')` regardless of
+     * the underlying driver.
+     */
+    readonly runtimeState: z.ZodObject<{
+        percentage: z.ZodNumber;
+        charging: z.ZodEnum<{
+            none: "none";
+            dc: "dc";
+            solar: "solar";
+        }>;
+        sleeping: z.ZodBoolean;
+        lastUpdated: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IBatteryProvider = InferProvider<typeof batteryCapability>;
+//# sourceMappingURL=battery.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"battery.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/battery.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;iBAkB9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,eAAO,MAAM,iBAAiB;;;;;;;QAO1B;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUL;;;;;;;;OAQG;;;;;;;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

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

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Dimmable-light brightness control. Co-exists with `switch` on the
+ * same device — the switch toggles on/off, this cap sets the level
+ * applied when the light is on. Modeled after Scrypted's `Brightness`
+ * interface so drivers can map their per-vendor dim controls cleanly.
+ *
+ * The cap is intentionally minimal: a single `setBrightness({deviceId,
+ * percentage})` mutation plus the auto-injected `getStatus`. Drivers
+ * that expose richer controls (color temperature, scenes, schedules)
+ * should surface those via the device's `getSettingsUISchema()`
+ * instead of bloating this cap.
+ */
+export declare const BrightnessStatusSchema: z.ZodObject<{
+    percentage: z.ZodNumber;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type BrightnessStatus = z.infer<typeof BrightnessStatusSchema>;
+export declare const brightnessCapability: {
+    readonly name: "brightness";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Light];
+    readonly methods: {
+        readonly setBrightness: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            percentage: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly events: {
+        /**
+         * Emitted whenever the brightness changes — operator action OR
+         * firmware push. Subscribers (UI sliders, automation engines) react
+         * without polling.
+         */
+        readonly onBrightnessChanged: {
+            readonly data: z.ZodObject<{
+                deviceId: z.ZodNumber;
+                percentage: z.ZodNumber;
+                lastChangedAt: z.ZodNumber;
+            }, z.core.$strip>;
+        };
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            percentage: z.ZodNumber;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "command-driven";
+    };
+    /**
+     * Runtime-state slice — the last applied brightness level, mirrored
+     * by the kernel. Read via `device.state.brightness.value` so UI
+     * sliders surface the current level without polling the provider.
+     */
+    readonly runtimeState: z.ZodObject<{
+        percentage: z.ZodNumber;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IBrightnessProvider = InferProvider<typeof brightnessCapability>;
+//# sourceMappingURL=brightness.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"brightness.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/brightness.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;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB;;;iBAKjC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;QAgB7B;;;;WAIG;;;;;;;;;;;;;;;;IAWL;;;;OAIG;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,mBAAmB,GAAG,aAAa,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

package/dist/capabilities/camera-credentials.cap.d.ts

@@ -0,0 +1,102 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * camera-credentials — device-scoped cap exposing the camera's network
+ * + auth surface in a vendor-neutral shape.
+ *
+ * Why it exists: cross-vendor wrappers (the planned ONVIF generic addon
+ * for PTZ / intercom / events; future homekit / mqtt bridges) need the
+ * camera's IP + port + creds without each wrapper re-implementing
+ * vendor-specific config-blob extraction. With this cap, every camera
+ * provider returns a uniform CameraCredentials and consumers stay
+ * vendor-agnostic.
+ *
+ * Implementations:
+ *   - Each camera-providing addon registers this cap natively per
+ *     device (Reolink, Hikvision, RTSP, Frigate, ONVIF self).
+ *   - Returns a snapshot from the persisted device config blob — no
+ *     extra round-trip to the camera, no probing.
+ *   - The cap is admin-only (`auth: 'admin'`) — credentials must not
+ *     leak through user-scoped paths.
+ *
+ * Sensitive data handling:
+ *   - getCredentials returns the full snapshot to admin callers only.
+ *   - Wrappers are expected to use the value to construct a per-call
+ *     client and NOT to log / event-bus-emit the password field.
+ *   - The cap status payload (mirrored to runtime-state) carries
+ *     non-sensitive metadata only — host + ports + protocol hints. The
+ *     password / username live on `getCredentials` exclusively.
+ *
+ * See `docs/onvif-generic-addon-plan.md` for the consuming wrapper
+ * design.
+ */
+export declare const CameraCredentialsSchema: z.ZodObject<{
+    host: z.ZodString;
+    port: z.ZodOptional<z.ZodNumber>;
+    onvifPort: z.ZodOptional<z.ZodNumber>;
+    rtspPort: z.ZodOptional<z.ZodNumber>;
+    https: z.ZodOptional<z.ZodBoolean>;
+    username: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    onvifProfile: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CameraCredentials = z.infer<typeof CameraCredentialsSchema>;
+/**
+ * Non-sensitive camera-credentials status — host + ports + protocol
+ * hints only. Mirrors what shows up in the bindings UI / device
+ * aggregate. The full credentials (with password) are exposed only via
+ * `getCredentials` to admin callers.
+ */
+export declare const CameraCredentialsStatusSchema: z.ZodObject<{
+    host: z.ZodString;
+    port: z.ZodNullable<z.ZodNumber>;
+    onvifPort: z.ZodNullable<z.ZodNumber>;
+    rtspPort: z.ZodNullable<z.ZodNumber>;
+    https: z.ZodNullable<z.ZodBoolean>;
+    hasUsername: z.ZodBoolean;
+    hasPassword: z.ZodBoolean;
+    onvifProfile: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type CameraCredentialsStatus = z.infer<typeof CameraCredentialsStatusSchema>;
+export declare const cameraCredentialsCapability: {
+    readonly name: "camera-credentials";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly methods: {
+        /**
+         * Return the camera's full credential bundle for admin consumers.
+         * Each provider implementation returns a snapshot of its persisted
+         * config — no I/O to the camera. Returns null when the device is
+         * not owned by this addon (deviceId mismatch).
+         */
+        readonly getCredentials: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            host: z.ZodString;
+            port: z.ZodOptional<z.ZodNumber>;
+            onvifPort: z.ZodOptional<z.ZodNumber>;
+            rtspPort: z.ZodOptional<z.ZodNumber>;
+            https: z.ZodOptional<z.ZodBoolean>;
+            username: z.ZodOptional<z.ZodString>;
+            password: z.ZodOptional<z.ZodString>;
+            onvifProfile: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>, "query">;
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            host: z.ZodString;
+            port: z.ZodNullable<z.ZodNumber>;
+            onvifPort: z.ZodNullable<z.ZodNumber>;
+            rtspPort: z.ZodNullable<z.ZodNumber>;
+            https: z.ZodNullable<z.ZodBoolean>;
+            hasUsername: z.ZodBoolean;
+            hasPassword: z.ZodBoolean;
+            onvifProfile: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        readonly kind: "command-driven";
+    };
+};
+export type ICameraCredentialsProvider = InferProvider<typeof cameraCredentialsCapability>;
+//# sourceMappingURL=camera-credentials.cap.d.ts.map

package/dist/capabilities/camera-credentials.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera-credentials.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/camera-credentials.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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;iBAiBlC,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;iBASxC,CAAA;AAEF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA;AAEnF,eAAO,MAAM,2BAA2B;;;;;;QAMpC;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWkC,CAAA;AAEzC,MAAM,MAAM,0BAA0B,GAAG,aAAa,CAAC,OAAO,2BAA2B,CAAC,CAAA"}