@camstack/types 0.1.14 → 0.1.15

package/dist/capabilities/addon-widgets-source.cap.d.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * `addon-widgets-source` — collection cap exposing per-addon raw widget
+ * declarations. Mirrors the addon-pages split: every addon shipping
+ * widgets registers a provider on this collection cap; the hub-local
+ * aggregator (`addon-widgets`, see `addon-widgets.cap.ts`) walks the
+ * collection, stamps versioned `bundleUrl`s onto each declaration, and
+ * exposes the public listing surface that admin-ui consumes.
+ *
+ * The split exists because the public listing has a different output
+ * shape (flat enriched metadata with `addonId` + `bundleUrl`) than the
+ * per-provider raw declarations. Both ends flow through codegen.
+ */
+declare const WidgetHostEnum: z.ZodEnum<{
+    "device-tab": "device-tab";
+    dashboard: "dashboard";
+    "integration-detail": "integration-detail";
+}>;
+declare const WidgetSizeEnum: z.ZodEnum<{
+    xs: "xs";
+    sm: "sm";
+    md: "md";
+    lg: "lg";
+    xl: "xl";
+}>;
+declare const WidgetMetadataSchema: z.ZodObject<{
+    stableId: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    remoteName: z.ZodString;
+    bundle: z.ZodString;
+    hosts: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        "device-tab": "device-tab";
+        dashboard: "dashboard";
+        "integration-detail": "integration-detail";
+    }>>>;
+    requires: z.ZodObject<{
+        deviceContext: z.ZodDefault<z.ZodBoolean>;
+        integrationContext: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+    defaultSize: z.ZodDefault<z.ZodEnum<{
+        xs: "xs";
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+    }>>;
+    allowedSizes: z.ZodDefault<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        xs: "xs";
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+    }>>>>;
+    defaultColumns: z.ZodDefault<z.ZodNumber>;
+    defaultRows: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const addonWidgetsSourceCapability: {
+    readonly name: "addon-widgets-source";
+    readonly scope: "system";
+    readonly mode: "collection";
+    readonly internal: true;
+    readonly methods: {
+        readonly listWidgets: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            stableId: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            icon: z.ZodOptional<z.ZodString>;
+            remoteName: z.ZodString;
+            bundle: z.ZodString;
+            hosts: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                "device-tab": "device-tab";
+                dashboard: "dashboard";
+                "integration-detail": "integration-detail";
+            }>>>;
+            requires: z.ZodObject<{
+                deviceContext: z.ZodDefault<z.ZodBoolean>;
+                integrationContext: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>;
+            defaultSize: z.ZodDefault<z.ZodEnum<{
+                xs: "xs";
+                sm: "sm";
+                md: "md";
+                lg: "lg";
+                xl: "xl";
+            }>>;
+            allowedSizes: z.ZodDefault<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                xs: "xs";
+                sm: "sm";
+                md: "md";
+                lg: "lg";
+                xl: "xl";
+            }>>>>;
+            defaultColumns: z.ZodDefault<z.ZodNumber>;
+            defaultRows: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IAddonWidgetsSourceProvider = InferProvider<typeof addonWidgetsSourceCapability>;
+export { WidgetMetadataSchema, WidgetHostEnum, WidgetSizeEnum };
+//# sourceMappingURL=addon-widgets-source.cap.d.ts.map

package/dist/capabilities/addon-widgets-source.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addon-widgets-source.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/addon-widgets-source.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,cAAc;;;;EAA4D,CAAA;AAChF,QAAA,MAAM,cAAc;;;;;;EAAyC,CAAA;AAE7D,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCxB,CAAA;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQA,CAAA;AAEzC,MAAM,MAAM,2BAA2B,GAAG,aAAa,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAE5F,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,cAAc,EAAE,CAAA"}

package/dist/capabilities/addon-widgets.cap.d.ts

@@ -0,0 +1,98 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * `addon-widgets` — system-scoped singleton aggregator cap. Public-facing
+ * surface that admin-ui consumes through `useAddonWidgetsListWidgets()`.
+ *
+ * The provider iterates every `addon-widgets-source` (collection)
+ * provider and emits `EnrichedWidgetMetadata[]` enriched with versioned
+ * `bundleUrl` strings pointing at
+ * `/api/addon-widgets/<addonId>/<bundle>?v=<mtime>`. The filesystem
+ * `mtime` cache-buster lets the browser pick up addon rebuilds without
+ * manual reload — same scheme used by `addon-pages`.
+ *
+ * The hub-local builtin `addon-widgets-aggregator` (see
+ * `@camstack/core/builtins/addon-widgets-aggregator`) registers the
+ * provider. Splitting the public aggregator from the raw collection
+ * keeps both ends in codegen — there's no hand-written wrapper.
+ */
+declare const EnrichedWidgetMetadataSchema: z.ZodObject<{
+    stableId: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    remoteName: z.ZodString;
+    bundle: z.ZodString;
+    hosts: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        "device-tab": "device-tab";
+        dashboard: "dashboard";
+        "integration-detail": "integration-detail";
+    }>>>;
+    requires: z.ZodObject<{
+        deviceContext: z.ZodDefault<z.ZodBoolean>;
+        integrationContext: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+    defaultSize: z.ZodDefault<z.ZodEnum<{
+        xs: "xs";
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+    }>>;
+    allowedSizes: z.ZodDefault<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        xs: "xs";
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+    }>>>>;
+    defaultColumns: z.ZodDefault<z.ZodNumber>;
+    defaultRows: z.ZodDefault<z.ZodNumber>;
+    addonId: z.ZodString;
+    bundleUrl: z.ZodString;
+}, z.core.$strip>;
+export declare const addonWidgetsCapability: {
+    readonly name: "addon-widgets";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        readonly listWidgets: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            stableId: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            icon: z.ZodOptional<z.ZodString>;
+            remoteName: z.ZodString;
+            bundle: z.ZodString;
+            hosts: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                "device-tab": "device-tab";
+                dashboard: "dashboard";
+                "integration-detail": "integration-detail";
+            }>>>;
+            requires: z.ZodObject<{
+                deviceContext: z.ZodDefault<z.ZodBoolean>;
+                integrationContext: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>;
+            defaultSize: z.ZodDefault<z.ZodEnum<{
+                xs: "xs";
+                sm: "sm";
+                md: "md";
+                lg: "lg";
+                xl: "xl";
+            }>>;
+            allowedSizes: z.ZodDefault<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                xs: "xs";
+                sm: "sm";
+                md: "md";
+                lg: "lg";
+                xl: "xl";
+            }>>>>;
+            defaultColumns: z.ZodDefault<z.ZodNumber>;
+            defaultRows: z.ZodDefault<z.ZodNumber>;
+            addonId: z.ZodString;
+            bundleUrl: z.ZodString;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IAddonWidgetsAggregatorProvider = InferProvider<typeof addonWidgetsCapability>;
+export { EnrichedWidgetMetadataSchema };
+//# sourceMappingURL=addon-widgets.cap.d.ts.map

package/dist/capabilities/addon-widgets.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addon-widgets.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/addon-widgets.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAGlG;;;;;;;;;;;;;;;GAeG;AAEH,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGhC,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOM,CAAA;AAEzC,MAAM,MAAM,+BAA+B,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE1F,OAAO,EAAE,4BAA4B,EAAE,CAAA"}

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

@@ -0,0 +1,280 @@
+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>;
+        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>>;
+}, 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>;
+                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>>;
+        }, 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">;
+        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">;
+        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;AA+B7E,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;iBAMvB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0HY,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"}