@camstack/types 0.1.14 → 0.1.16

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

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * List of accessory children linked to a parent device (camera, hub).
+ * Returns only numeric device ids — the rest (role, deviceType, name,
+ * caps) is derived by fetching each child via `device-manager.getDevice`.
+ *
+ * The single-source-of-truth for what an accessory IS remains the child
+ * device itself; this cap only surfaces the grouping.
+ */
+export declare const AccessoriesStatusSchema: z.ZodObject<{
+    childDeviceIds: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+export type AccessoriesStatus = z.infer<typeof AccessoriesStatusSchema>;
+export declare const accessoriesCapability: {
+    readonly name: "accessories";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera, DeviceType.Hub];
+    readonly methods: {};
+    readonly events: {
+        /**
+         * Emitted when a child device is created, removed, or its parent
+         * assignment changes. Payload carries the fresh list.
+         */
+        readonly onAccessoriesChanged: {
+            readonly data: z.ZodObject<{
+                deviceId: z.ZodNumber;
+                childDeviceIds: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+            }, z.core.$strip>;
+        };
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            childDeviceIds: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strip>;
+        readonly kind: "command-driven";
+    };
+};
+export type IAccessoriesProvider = InferProvider<typeof accessoriesCapability>;
+//# sourceMappingURL=accessories.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"accessories.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/accessories.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;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB;;iBAElC,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAEvE,eAAO,MAAM,qBAAqB;;;;;;;QAO9B;;;WAGG;;;;;;;;;;;;;;CAUkC,CAAA;AAEzC,MAAM,MAAM,oBAAoB,GAAG,aAAa,CAAC,OAAO,qBAAqB,CAAC,CAAA"}

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

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * `addon-pages-source` — collection cap exposing per-provider raw page
+ * declarations. Every addon that contributes a UI page registers a
+ * provider here. The hub-side singleton aggregator (`addon-pages` cap,
+ * see `addon-pages.cap.ts`) walks this collection, stamps versioned
+ * `bundleUrl` values, and returns the enriched `AddonPageInfo[]` list
+ * that admin-ui consumes.
+ *
+ * The split exists because the public listing has a different output
+ * shape than the per-provider raw declarations, and we want both ends
+ * to flow through codegen instead of relying on a hand-written wrapper.
+ */
+declare const AddonPageDeclarationSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    icon: z.ZodString;
+    path: z.ZodString;
+    remoteName: z.ZodString;
+    bundle: z.ZodString;
+}, z.core.$strip>;
+export declare const addonPagesSourceCapability: {
+    readonly name: "addon-pages-source";
+    readonly scope: "system";
+    readonly mode: "collection";
+    readonly internal: true;
+    readonly methods: {
+        readonly listPages: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            icon: z.ZodString;
+            path: z.ZodString;
+            remoteName: z.ZodString;
+            bundle: z.ZodString;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IAddonPagesSourceProvider = InferProvider<typeof addonPagesSourceCapability>;
+export { AddonPageDeclarationSchema };
+//# sourceMappingURL=addon-pages-source.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"addon-pages-source.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/addon-pages-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,0BAA0B;;;;;;;iBAqB9B,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;CAQE,CAAA;AAEzC,MAAM,MAAM,yBAAyB,GAAG,aAAa,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAExF,OAAO,EAAE,0BAA0B,EAAE,CAAA"}

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

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+declare const AddonPageInfoSchema: z.ZodObject<{
+    addonId: z.ZodString;
+    page: z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        icon: z.ZodString;
+        path: z.ZodString;
+        remoteName: z.ZodString;
+        bundle: z.ZodString;
+    }, z.core.$strip>;
+    bundleUrl: z.ZodString;
+}, z.core.$strip>;
+export declare const addonPagesCapability: {
+    readonly name: "addon-pages";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        readonly listPages: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            addonId: z.ZodString;
+            page: z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                icon: z.ZodString;
+                path: z.ZodString;
+                remoteName: z.ZodString;
+                bundle: z.ZodString;
+            }, z.core.$strip>;
+            bundleUrl: z.ZodString;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IAddonPagesAggregatorProvider = InferProvider<typeof addonPagesCapability>;
+export { AddonPageInfoSchema };
+//# sourceMappingURL=addon-pages.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"addon-pages.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/addon-pages.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AA4BlG,QAAA,MAAM,mBAAmB;;;;;;;;;;;iBAIvB,CAAA;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;CAOQ,CAAA;AAEzC,MAAM,MAAM,6BAA6B,GAAG,aAAa,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEtF,OAAO,EAAE,mBAAmB,EAAE,CAAA"}

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

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+export declare const addonRoutesCapability: {
+    readonly name: "addon-routes";
+    readonly scope: "system";
+    readonly mode: "collection";
+    readonly internal: true;
+    readonly methods: {
+        readonly getRoutes: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodArray<z.ZodObject<{
+            method: z.ZodEnum<{
+                GET: "GET";
+                POST: "POST";
+                PUT: "PUT";
+                DELETE: "DELETE";
+                PATCH: "PATCH";
+            }>;
+            path: z.ZodString;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IAddonRoutesProvider = InferProvider<typeof addonRoutesCapability>;
+//# sourceMappingURL=addon-routes.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"addon-routes.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/addon-routes.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAOlG,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;CAQO,CAAA;AAEzC,MAAM,MAAM,oBAAoB,GAAG,aAAa,CAAC,OAAO,qBAAqB,CAAC,CAAA"}

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

@@ -0,0 +1,170 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+declare const ConfigTabDeclarationSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    icon: z.ZodString;
+    order: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const ConfigSectionWithValuesSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    style: z.ZodOptional<z.ZodEnum<{
+        card: "card";
+        accordion: "accordion";
+    }>>;
+    defaultCollapsed: z.ZodOptional<z.ZodBoolean>;
+    columns: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>>;
+    tab: z.ZodOptional<z.ZodString>;
+    location: z.ZodOptional<z.ZodEnum<{
+        settings: "settings";
+        "top-tab": "top-tab";
+    }>>;
+    order: z.ZodOptional<z.ZodNumber>;
+    fields: z.ZodArray<z.ZodAny>;
+}, z.core.$strip>;
+declare const SettingsSchemaWithValuesSchema: z.ZodObject<{
+    tabs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        icon: z.ZodString;
+        order: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    sections: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        style: z.ZodOptional<z.ZodEnum<{
+            card: "card";
+            accordion: "accordion";
+        }>>;
+        defaultCollapsed: z.ZodOptional<z.ZodBoolean>;
+        columns: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>>;
+        tab: z.ZodOptional<z.ZodString>;
+        location: z.ZodOptional<z.ZodEnum<{
+            settings: "settings";
+            "top-tab": "top-tab";
+        }>>;
+        order: z.ZodOptional<z.ZodNumber>;
+        fields: z.ZodArray<z.ZodAny>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** Patch object — keys are field names, values are the new field values. */
+declare const SettingsPatchSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+/** Standard success response for update operations. */
+declare const SettingsUpdateResultSchema: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+}, z.core.$strip>;
+/**
+ * addon-settings — singleton gateway for three-level addon settings.
+ *
+ * Works like `device-manager`: a single hub-side provider that resolves
+ * `addonId` to the target addon and delegates the call. For hub-local
+ * addons the call is direct; for remote agents it proxies via the
+ * per-addon Moleculer service.
+ *
+ * Replaces the `$addonHost` Moleculer service. Transport transparency
+ * is handled by the provider implementation — callers (admin UI, other
+ * addons via `ctx.api`) never know which node hosts the target addon.
+ *
+ * Three levels:
+ *   - **addon**: addon-scoped settings (installation config, API keys, …)
+ *   - **global**: settings applied to all devices by default
+ *   - **device**: per-device overrides
+ *
+ * Optional `nodeId` allows explicit node targeting. When absent the
+ * provider resolves the addon's host node automatically.
+ */
+/**
+ * `addon-settings` is a **hub-centric** cap: the hub hosts the single
+ * provider, and `nodeId` in the input is data for the hub provider's
+ * internal dispatcher, not a routing hint for the cap-router. See
+ * `CapabilityDefinition.nodeIdMode` for the contract.
+ */
+export declare const addonSettingsCapability: {
+    readonly name: "addon-settings";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly nodeIdMode: "data";
+    readonly methods: {
+        readonly getGlobalSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addonId: z.ZodString;
+            nodeId: z.ZodOptional<z.ZodString>;
+            overlay: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            tabs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                icon: z.ZodString;
+                order: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            sections: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                style: z.ZodOptional<z.ZodEnum<{
+                    card: "card";
+                    accordion: "accordion";
+                }>>;
+                defaultCollapsed: z.ZodOptional<z.ZodBoolean>;
+                columns: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>>;
+                tab: z.ZodOptional<z.ZodString>;
+                location: z.ZodOptional<z.ZodEnum<{
+                    settings: "settings";
+                    "top-tab": "top-tab";
+                }>>;
+                order: z.ZodOptional<z.ZodNumber>;
+                fields: z.ZodArray<z.ZodAny>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly updateGlobalSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addonId: z.ZodString;
+            nodeId: z.ZodOptional<z.ZodString>;
+            patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        readonly getDeviceSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addonId: z.ZodString;
+            deviceId: z.ZodNumber;
+            nodeId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            tabs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                icon: z.ZodString;
+                order: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            sections: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                style: z.ZodOptional<z.ZodEnum<{
+                    card: "card";
+                    accordion: "accordion";
+                }>>;
+                defaultCollapsed: z.ZodOptional<z.ZodBoolean>;
+                columns: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>>;
+                tab: z.ZodOptional<z.ZodString>;
+                location: z.ZodOptional<z.ZodEnum<{
+                    settings: "settings";
+                    "top-tab": "top-tab";
+                }>>;
+                order: z.ZodOptional<z.ZodNumber>;
+                fields: z.ZodArray<z.ZodAny>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly updateDeviceSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addonId: z.ZodString;
+            deviceId: z.ZodNumber;
+            nodeId: z.ZodOptional<z.ZodString>;
+            patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+    };
+};
+export type IAddonSettingsProvider = InferProvider<typeof addonSettingsCapability>;
+export { SettingsSchemaWithValuesSchema, ConfigSectionWithValuesSchema, ConfigTabDeclarationSchema, SettingsPatchSchema, SettingsUpdateResultSchema, };
+//# sourceMappingURL=addon-settings.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"addon-settings.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/addon-settings.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AASlG,QAAA,MAAM,0BAA0B;;;;;iBAK9B,CAAA;AAEF,QAAA,MAAM,6BAA6B;;;;;;;;;;;;;;;;;iBAcjC,CAAA;AAEF,QAAA,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;iBAGlC,CAAA;AAEF,4EAA4E;AAC5E,QAAA,MAAM,mBAAmB,wCAAoC,CAAA;AAE7D,uDAAuD;AACvD,QAAA,MAAM,0BAA0B;;iBAE9B,CAAA;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCK,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAElF,OAAO,EACL,8BAA8B,EAC9B,6BAA6B,EAC7B,0BAA0B,EAC1B,mBAAmB,EACnB,0BAA0B,GAC3B,CAAA"}

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"}