@camstack/types 0.1.14 → 0.1.16

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

@@ -0,0 +1,356 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * addons — system-scoped singleton capability for addon package
+ * management (install, update, configure, restart) and per-addon log
+ * streaming.
+ *
+ * Implementation lives in the server's `AddonRegistryService`,
+ * `AddonPackageService`, and `LoggingService`. The provider is
+ * registered from `trpc.router.ts` against those services — no addon
+ * owns this surface end-to-end (it manages addons themselves).
+ *
+ * Phase E of the API consolidation: previously a hand-written core
+ * router. Cap conversion lets `useAddonsList`, `useAddonsInstallPackage`,
+ * `useAddonsOnAddonLogs`, etc. flow through the same codegen pipeline
+ * as every other cap.
+ */
+declare const LogLevelSchema: z.ZodEnum<{
+    info: "info";
+    error: "error";
+    debug: "debug";
+    warn: "warn";
+}>;
+declare const ChannelSchema: z.ZodEnum<{
+    off: "off";
+    latest: "latest";
+    beta: "beta";
+}>;
+declare const ChannelWithInheritSchema: z.ZodEnum<{
+    off: "off";
+    latest: "latest";
+    beta: "beta";
+    inherit: "inherit";
+}>;
+declare const AddonListItemSchema: z.ZodObject<{
+    manifest: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodString>;
+        capabilities: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodUnknown>>>;
+        packageName: z.ZodString;
+        packageVersion: z.ZodString;
+        packageDisplayName: z.ZodOptional<z.ZodString>;
+        bundle: z.ZodOptional<z.ZodObject<{
+            displayName: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            icon: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        protected: z.ZodOptional<z.ZodBoolean>;
+        removable: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    declaration: z.ZodOptional<z.ZodUnknown>;
+    source: z.ZodString;
+    installSource: z.ZodOptional<z.ZodString>;
+    process: z.ZodOptional<z.ZodObject<{
+        pid: z.ZodOptional<z.ZodNumber>;
+        mode: z.ZodString;
+        state: z.ZodString;
+    }, z.core.$strip>>;
+    hasBackup: z.ZodOptional<z.ZodBoolean>;
+    health: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        phase: z.ZodEnum<{
+            pending: "pending";
+            healthy: "healthy";
+            failed: "failed";
+        }>;
+        retryCount: z.ZodNumber;
+        firstFailureAt: z.ZodNullable<z.ZodNumber>;
+        lastAttemptAt: z.ZodNullable<z.ZodNumber>;
+        lastError: z.ZodNullable<z.ZodObject<{
+            message: z.ZodString;
+            stack: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        nextRetryAt: z.ZodNullable<z.ZodNumber>;
+        alertEmitted: z.ZodBoolean;
+        retrying: z.ZodBoolean;
+        inGracePeriod: z.ZodBoolean;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const InstalledPackageSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    dir: z.ZodString;
+    installSource: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const PackageUpdateSchema: z.ZodObject<{
+    name: z.ZodString;
+    currentVersion: z.ZodString;
+    latestVersion: z.ZodString;
+    category: z.ZodEnum<{
+        addon: "addon";
+        core: "core";
+    }>;
+    requiresRestart: z.ZodBoolean;
+}, z.core.$strip>;
+declare const PackageVersionInfoSchema: z.ZodObject<{
+    version: z.ZodString;
+    publishedAt: z.ZodString;
+    deprecated: z.ZodOptional<z.ZodString>;
+    distTags: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const SearchResultSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodString;
+    keywords: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    publishedAt: z.ZodString;
+    author: z.ZodString;
+    installed: z.ZodBoolean;
+    installedVersion: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const AutoUpdateSettingsSchema: z.ZodObject<{
+    channel: z.ZodEnum<{
+        off: "off";
+        latest: "latest";
+        beta: "beta";
+    }>;
+    intervalSeconds: z.ZodNumber;
+}, z.core.$strip>;
+declare const AddonAutoUpdateSchema: z.ZodEnum<{
+    off: "off";
+    latest: "latest";
+    beta: "beta";
+    inherit: "inherit";
+}>;
+declare const LogStreamEntrySchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    level: z.ZodString;
+    message: z.ZodString;
+    scope: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const CustomActionInputSchema: z.ZodObject<{
+    addonId: z.ZodString;
+    action: z.ZodString;
+    input: z.ZodUnknown;
+}, z.core.$strip>;
+export declare const addonsCapability: {
+    readonly name: "addons";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        readonly list: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            manifest: z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodOptional<z.ZodString>;
+                version: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                icon: z.ZodOptional<z.ZodString>;
+                color: z.ZodOptional<z.ZodString>;
+                capabilities: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodUnknown>>>;
+                packageName: z.ZodString;
+                packageVersion: z.ZodString;
+                packageDisplayName: z.ZodOptional<z.ZodString>;
+                bundle: z.ZodOptional<z.ZodObject<{
+                    displayName: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    icon: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                protected: z.ZodOptional<z.ZodBoolean>;
+                removable: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>;
+            declaration: z.ZodOptional<z.ZodUnknown>;
+            source: z.ZodString;
+            installSource: z.ZodOptional<z.ZodString>;
+            process: z.ZodOptional<z.ZodObject<{
+                pid: z.ZodOptional<z.ZodNumber>;
+                mode: z.ZodString;
+                state: z.ZodString;
+            }, z.core.$strip>>;
+            hasBackup: z.ZodOptional<z.ZodBoolean>;
+            health: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                phase: z.ZodEnum<{
+                    pending: "pending";
+                    healthy: "healthy";
+                    failed: "failed";
+                }>;
+                retryCount: z.ZodNumber;
+                firstFailureAt: z.ZodNullable<z.ZodNumber>;
+                lastAttemptAt: z.ZodNullable<z.ZodNumber>;
+                lastError: z.ZodNullable<z.ZodObject<{
+                    message: z.ZodString;
+                    stack: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                nextRetryAt: z.ZodNullable<z.ZodNumber>;
+                alertEmitted: z.ZodBoolean;
+                retrying: z.ZodBoolean;
+                inGracePeriod: z.ZodBoolean;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getLogs: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addonId: z.ZodString;
+            limit: z.ZodDefault<z.ZodNumber>;
+            level: z.ZodOptional<z.ZodEnum<{
+                info: "info";
+                error: "error";
+                debug: "debug";
+                warn: "warn";
+            }>>;
+        }, z.core.$strip>, z.ZodArray<z.ZodUnknown>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly listPackages: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+            dir: z.ZodString;
+            installSource: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly installPackage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            packageName: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodUnknown, "mutation">;
+        readonly installFromWorkspace: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            packageName: z.ZodString;
+        }, z.core.$strip>, z.ZodUnknown, "mutation">;
+        readonly isWorkspaceAvailable: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly listWorkspacePackages: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodUnknown>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly uninstallPackage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            packageName: z.ZodString;
+        }, z.core.$strip>, z.ZodUnknown, "mutation">;
+        readonly reloadPackages: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodUnknown, "mutation">;
+        readonly searchAvailable: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            query: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+            description: z.ZodString;
+            keywords: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            publishedAt: z.ZodString;
+            author: z.ZodString;
+            installed: z.ZodBoolean;
+            installedVersion: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly listUpdates: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            currentVersion: z.ZodString;
+            latestVersion: z.ZodString;
+            category: z.ZodEnum<{
+                addon: "addon";
+                core: "core";
+            }>;
+            requiresRestart: z.ZodBoolean;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly updatePackage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodUnknown, "mutation">;
+        /**
+         * Roll back an addon to the version it had before the most recent
+         * `updatePackage` call. The backup directory pointer is kept in the
+         * central addon manifest until the post-update health-check
+         * confirms the new install works (then it's cleared automatically),
+         * so this only succeeds when the most recent update either failed
+         * its restart or the user explicitly wants to revert.
+         *
+         * Returns `{ rolledBackTo: <version> }` on success, or
+         * `{ rolledBackTo: null }` when there's no backup to roll back to
+         * (caller can show a "no backup available" UI).
+         */
+        readonly rollbackPackage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            rolledBackTo: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>, "mutation">;
+        readonly forceRefresh: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodUnknown, "mutation">;
+        readonly restartServer: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            confirm: z.ZodLiteral<true>;
+        }, z.core.$strip>, z.ZodUnknown, "mutation">;
+        readonly getVersions: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            version: z.ZodString;
+            publishedAt: z.ZodString;
+            deprecated: z.ZodOptional<z.ZodString>;
+            distTags: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly restartAddon: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addonId: z.ZodString;
+        }, z.core.$strip>, z.ZodUnknown, "mutation">;
+        /**
+         * Force-retry a failed addon NOW. Resets the retry counter so the
+         * next failure starts from the 60s interval again. Used by the
+         * "Retry now" button in the Addons admin page row + AlertCenter
+         * alert action. Idempotent on healthy addons (no-op).
+         */
+        readonly retryLoad: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            packageName: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        readonly getAutoUpdateSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            channel: z.ZodEnum<{
+                off: "off";
+                latest: "latest";
+                beta: "beta";
+            }>;
+            intervalSeconds: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly setAutoUpdateSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            channel: z.ZodEnum<{
+                off: "off";
+                latest: "latest";
+                beta: "beta";
+            }>;
+            intervalSeconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodUnknown, "mutation">;
+        readonly getAddonAutoUpdate: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addonId: z.ZodString;
+        }, z.core.$strip>, z.ZodEnum<{
+            off: "off";
+            latest: "latest";
+            beta: "beta";
+            inherit: "inherit";
+        }>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly setAddonAutoUpdate: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addonId: z.ZodString;
+            channel: z.ZodEnum<{
+                off: "off";
+                latest: "latest";
+                beta: "beta";
+                inherit: "inherit";
+            }>;
+        }, z.core.$strip>, z.ZodUnknown, "mutation">;
+        readonly applyAutoUpdateToAll: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            channel: z.ZodEnum<{
+                off: "off";
+                latest: "latest";
+                beta: "beta";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        readonly custom: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addonId: z.ZodString;
+            action: z.ZodString;
+            input: z.ZodUnknown;
+        }, z.core.$strip>, z.ZodUnknown, "mutation">;
+        readonly onAddonLogs: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addonId: z.ZodString;
+            level: z.ZodOptional<z.ZodEnum<{
+                info: "info";
+                error: "error";
+                debug: "debug";
+                warn: "warn";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            timestamp: z.ZodString;
+            level: z.ZodString;
+            message: z.ZodString;
+            scope: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, "subscription">;
+    };
+};
+export type IAddonsProvider = InferProvider<typeof addonsCapability>;
+export { AddonListItemSchema, InstalledPackageSchema, PackageUpdateSchema, PackageVersionInfoSchema, SearchResultSchema, AutoUpdateSettingsSchema, AddonAutoUpdateSchema, LogStreamEntrySchema, CustomActionInputSchema, LogLevelSchema, ChannelSchema, ChannelWithInheritSchema, };
+//# sourceMappingURL=addons.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"addons.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/addons.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;;;;;;;;;;;;;GAcG;AAYH,QAAA,MAAM,cAAc;;;;;EAA6C,CAAA;AACjE,QAAA,MAAM,aAAa;;;;EAAoC,CAAA;AACvD,QAAA,MAAM,wBAAwB;;;;;EAA+C,CAAA;AAiE7E,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAevB,CAAA;AAEF,QAAA,MAAM,sBAAsB;;;;;iBAK1B,CAAA;AAEF,QAAA,MAAM,mBAAmB;;;;;;;;;iBAMvB,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;iBAK5B,CAAA;AAEF,QAAA,MAAM,kBAAkB;;;;;;;;;iBAStB,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;;;iBAG5B,CAAA;AAEF,QAAA,MAAM,qBAAqB;;;;;EAA2B,CAAA;AAQtD,QAAA,MAAM,oBAAoB;;;;;iBAKxB,CAAA;AAQF,QAAA,MAAM,uBAAuB;;;;iBAI3B,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA2DzB;;;;;;;;;;;WAWG;;;;;;;;;;;;;;;;;;;;;QAsBH;;;;;WAKG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsDkC,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEpE,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,mBAAmB,EACnB,wBAAwB,EACxB,kBAAkB,EAClB,wBAAwB,EACxB,qBAAqB,EACrB,oBAAoB,EACpB,uBAAuB,EACvB,cAAc,EACd,aAAa,EACb,wBAAwB,GACzB,CAAA"}

package/dist/capabilities/admin-ui.cap.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+export declare const adminUiCapability: {
+    readonly name: "admin-ui";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly internal: true;
+    readonly methods: {
+        readonly getStaticDir: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodString, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getVersion: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodString, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IAdminUiProvider = InferProvider<typeof adminUiCapability>;
+//# sourceMappingURL=admin-ui.cap.d.ts.map

package/dist/capabilities/admin-ui.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admin-ui.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/admin-ui.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG,eAAO,MAAM,iBAAiB;;;;;;;;;CASW,CAAA;AAEzC,MAAM,MAAM,gBAAgB,GAAG,aAAa,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/capabilities/advanced-notifier.cap.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+declare const NotificationRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    enabled: z.ZodBoolean;
+    conditions: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    actions: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const NotificationHistoryEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    ruleId: z.ZodString;
+    timestamp: z.ZodNumber;
+    deviceId: z.ZodOptional<z.ZodNumber>;
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const advancedNotifierCapability: {
+    readonly name: "advanced-notifier";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly internal: true;
+    readonly methods: {
+        readonly getRules: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            enabled: z.ZodBoolean;
+            conditions: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            actions: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly upsertRule: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            enabled: z.ZodBoolean;
+            conditions: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            actions: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly deleteRule: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            ruleId: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly testRule: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            ruleId: z.ZodString;
+            lookbackMinutes: z.ZodNumber;
+        }, z.core.$strip>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>, "mutation">;
+        readonly getHistory: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            ruleId: z.ZodOptional<z.ZodString>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            ruleId: z.ZodString;
+            timestamp: z.ZodNumber;
+            deviceId: z.ZodOptional<z.ZodNumber>;
+            success: z.ZodBoolean;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IAdvancedNotifierProvider = InferProvider<typeof advancedNotifierCapability>;
+export { NotificationRuleSchema, NotificationHistoryEntrySchema };
+//# sourceMappingURL=advanced-notifier.cap.d.ts.map

package/dist/capabilities/advanced-notifier.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advanced-notifier.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/advanced-notifier.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG,QAAA,MAAM,sBAAsB;;;;;;iBAM1B,CAAA;AAEF,QAAA,MAAM,8BAA8B;;;;;;;iBAOlC,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmBE,CAAA;AAEzC,MAAM,MAAM,yBAAyB,GAAG,aAAa,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAExF,OAAO,EAAE,sBAAsB,EAAE,8BAA8B,EAAE,CAAA"}

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

@@ -0,0 +1,164 @@
+/**
+ * Alerts capability — collection-based internal alert system.
+ *
+ * Multiple providers can register. Each provider filters by EventBus category
+ * and creates/updates alerts. The built-in Alert Center addon persists alerts
+ * in the DB and serves them to the admin UI.
+ */
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+export declare const AlertSeveritySchema: z.ZodEnum<{
+    info: "info";
+    error: "error";
+    success: "success";
+    warning: "warning";
+}>;
+export declare const AlertStatusSchema: z.ZodEnum<{
+    active: "active";
+    failed: "failed";
+    "in-progress": "in-progress";
+    completed: "completed";
+    dismissed: "dismissed";
+}>;
+export declare const AlertSourceSchema: z.ZodObject<{
+    type: z.ZodString;
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const AlertSchema: z.ZodObject<{
+    id: z.ZodString;
+    category: z.ZodString;
+    severity: z.ZodEnum<{
+        info: "info";
+        error: "error";
+        success: "success";
+        warning: "warning";
+    }>;
+    title: z.ZodString;
+    message: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        failed: "failed";
+        "in-progress": "in-progress";
+        completed: "completed";
+        dismissed: "dismissed";
+    }>;
+    progress: z.ZodOptional<z.ZodNumber>;
+    read: z.ZodBoolean;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    source: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type AlertSeverity = z.infer<typeof AlertSeveritySchema>;
+export type AlertStatus = z.infer<typeof AlertStatusSchema>;
+export type Alert = z.infer<typeof AlertSchema>;
+export declare const alertsCapability: {
+    readonly name: "alerts";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        readonly emit: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            id: z.ZodString;
+            category: z.ZodString;
+            severity: z.ZodEnum<{
+                info: "info";
+                error: "error";
+                success: "success";
+                warning: "warning";
+            }>;
+            title: z.ZodString;
+            message: z.ZodString;
+            status: z.ZodEnum<{
+                active: "active";
+                failed: "failed";
+                "in-progress": "in-progress";
+                completed: "completed";
+                dismissed: "dismissed";
+            }>;
+            progress: z.ZodOptional<z.ZodNumber>;
+            read: z.ZodBoolean;
+            createdAt: z.ZodNumber;
+            updatedAt: z.ZodNumber;
+            source: z.ZodOptional<z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+            }, z.core.$strip>>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly update: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            alertId: z.ZodString;
+            patch: z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                category: z.ZodOptional<z.ZodString>;
+                severity: z.ZodOptional<z.ZodEnum<{
+                    info: "info";
+                    error: "error";
+                    success: "success";
+                    warning: "warning";
+                }>>;
+                title: z.ZodOptional<z.ZodString>;
+                message: z.ZodOptional<z.ZodString>;
+                status: z.ZodOptional<z.ZodEnum<{
+                    active: "active";
+                    failed: "failed";
+                    "in-progress": "in-progress";
+                    completed: "completed";
+                    dismissed: "dismissed";
+                }>>;
+                progress: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+                read: z.ZodOptional<z.ZodBoolean>;
+                createdAt: z.ZodOptional<z.ZodNumber>;
+                updatedAt: z.ZodOptional<z.ZodNumber>;
+                source: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                    type: z.ZodString;
+                    id: z.ZodString;
+                }, z.core.$strip>>>;
+                metadata: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly list: import("./capability-definition.js").CapabilityMethodSchema<z.ZodOptional<z.ZodObject<{
+            unreadOnly: z.ZodOptional<z.ZodBoolean>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            category: z.ZodString;
+            severity: z.ZodEnum<{
+                info: "info";
+                error: "error";
+                success: "success";
+                warning: "warning";
+            }>;
+            title: z.ZodString;
+            message: z.ZodString;
+            status: z.ZodEnum<{
+                active: "active";
+                failed: "failed";
+                "in-progress": "in-progress";
+                completed: "completed";
+                dismissed: "dismissed";
+            }>;
+            progress: z.ZodOptional<z.ZodNumber>;
+            read: z.ZodBoolean;
+            createdAt: z.ZodNumber;
+            updatedAt: z.ZodNumber;
+            source: z.ZodOptional<z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+            }, z.core.$strip>>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getUnreadCount: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodNumber, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly markRead: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            alertId: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly markAllRead: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodVoid, "mutation">;
+        readonly dismiss: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            alertId: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+};
+export type IAlertsProvider = InferProvider<typeof alertsCapability>;
+//# sourceMappingURL=alerts.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"alerts.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/alerts.cap.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAIlG,eAAO,MAAM,mBAAmB;;;;;EAAkD,CAAA;AAElF,eAAO,MAAM,iBAAiB;;;;;;EAAwE,CAAA;AAEtG,eAAO,MAAM,iBAAiB;;;iBAG5B,CAAA;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAatB,CAAA;AAIF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC3D,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAI/C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBY,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/dist/capabilities/audio-analysis.cap.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+import type { AudioAnalysisSettings } from '../types/io.js';
+/**
+ * audio-analysis — device-scoped facade over the system `audio-analyzer`.
+ *
+ * Pairs with `audio-analyzer` (system, singleton) the way `camera-streams`
+ * pairs with `stream-broker`: the system cap owns the compute path
+ * (`processChunk`, engine lifecycle) while `audio-analysis` exposes the
+ * per-device surface — settings resolution, device-settings contribution,
+ * audio-level events — and is the binding row every camera sees in the
+ * device-manager bindings UI.
+ *
+ * Registered as a wrapper with `defaultActive: true` by `addon-audio-analysis`
+ * so every camera picks up audio analysis automatically; operators can
+ * disable per-device via `device-manager.setWrapperActive` when they don't
+ * want a given camera to be analysed (e.g. muted / motion-only cams).
+ */
+export declare const audioAnalysisCapability: {
+    readonly name: "audio-analysis";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly exposesDeviceSettings: true;
+    readonly methods: {
+        /**
+         * Resolve per-device audio analysis settings (minConfidence,
+         * allowedClasses) from the addon settings store for a given camera.
+         * Orchestrator callers use this before handing chunks to
+         * `audio-analyzer.processChunk`.
+         */
+        readonly resolveDeviceSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodCustom<AudioAnalysisSettings | null, AudioAnalysisSettings | null>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+    readonly events: {
+        readonly onAudioLevel: import("./capability-definition.js").CapabilityEventSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            rms: z.ZodNumber;
+            dbfs: z.ZodNumber;
+        }, z.core.$strip>>;
+    };
+};
+export type IAudioAnalysisProvider = InferProvider<typeof audioAnalysisCapability>;
+//# sourceMappingURL=audio-analysis.cap.d.ts.map

package/dist/capabilities/audio-analysis.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audio-analysis.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/audio-analysis.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA4C,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AACzG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AACrD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AAE3D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,uBAAuB;;;;;;;QAOhC;;;;;WAKG;;;;;;;;;;;;CAakC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA"}