@camstack/types 1.2.402 → 1.2.403

package/dist/device/cap-vocabulary/types.d.ts

@@ -0,0 +1,398 @@
+/**
+ * The SHAPE of the cap vocabulary (D920): what an operator can make a device
+ * DO, and what a device can be WATCHED for, phrased for humans — keyed by
+ * capability name, typed against the capability definitions themselves.
+ *
+ * Every key type here is DERIVED from the cap registry
+ * (`generated/capability-router-map.ts`, imported as a TYPE only — no runtime
+ * cost, no Zod graph in a browser bundle): a method, status field or event
+ * name that does not exist on the cap is a TypeScript error, and so is a
+ * missing cap. `scripts/check-cap-vocabulary.ts` checks what a type cannot:
+ * that every operate method is phrased or excused, that offered values agree
+ * with the method's Zod input, that every placeholder has an arg, and that
+ * every label carries both languages.
+ *
+ * Translations live INLINE (`{ en, it }`) next to the entry they translate —
+ * one source, so a new action cannot ship in one language.
+ */
+import type { z } from 'zod';
+import type * as CapRegistry from '../../generated/capability-router-map.js';
+import type { EventCategory } from '../../enums/event-category.js';
+import type { ICON_KEYS } from '../icon-catalog.generated.js';
+import type { DeviceRole, DeviceType } from '../device-type.js';
+/** One catalog icon key (lucide id) — the same vocabulary as `IconKey`. */
+export type VocabIcon = (typeof ICON_KEYS)[number];
+/** A human string in every language the map carries. */
+export interface L10n {
+    readonly en: string;
+    readonly it: string;
+}
+/** A language the vocabulary is written in. */
+export type VocabLocale = keyof L10n;
+type CapRegistryModule = typeof CapRegistry;
+/** The minimal structural shape that tells a cap definition export apart. */
+interface CapDefinitionLike {
+    readonly name: string;
+    readonly scope: 'system' | 'device';
+    readonly methods: object;
+}
+/** Cap name → its definition TYPE, for every cap the registry exports. */
+export type CapDefinitionsByName = {
+    readonly [K in keyof CapRegistryModule as CapRegistryModule[K] extends CapDefinitionLike ? CapRegistryModule[K]['name'] : never]: CapRegistryModule[K];
+};
+/** Every capability name. */
+export type VocabCapName = keyof CapDefinitionsByName & string;
+type CapDef<C extends VocabCapName> = CapDefinitionsByName[C];
+/** Device-scoped cap names (the ones a device's vocabulary is made of). */
+export type DeviceVocabCapName = {
+    [C in VocabCapName]: CapDef<C>['scope'] extends 'device' ? C : never;
+}[VocabCapName];
+/** System-scoped cap names (never part of a device's vocabulary). */
+export type SystemVocabCapName = Exclude<VocabCapName, DeviceVocabCapName>;
+/** A method name declared by cap `C`. */
+export type CapMethodName<C extends VocabCapName> = keyof CapDef<C>['methods'] & string;
+type MethodSchemaOf<C extends VocabCapName, M extends CapMethodName<C>> = CapDef<C>['methods'][M];
+type MethodInputOf<C extends VocabCapName, M extends CapMethodName<C>> = MethodSchemaOf<C, M> extends {
+    readonly input: infer I extends z.ZodType;
+} ? z.input<I> : never;
+/** The operator-supplied part of a method input (`deviceId` is the target). */
+export type ActionArgs<C extends VocabCapName, M extends CapMethodName<C>> = MethodInputOf<C, M> extends object ? Omit<MethodInputOf<C, M>, 'deviceId'> : Record<never, never>;
+/** A key of {@link ActionArgs}. */
+export type ActionArgKey<C extends VocabCapName, M extends CapMethodName<C>> = keyof ActionArgs<C, M> & string;
+type StatusOf<C extends VocabCapName> = CapDef<C> extends {
+    readonly status: {
+        readonly schema: infer S extends z.ZodType;
+    };
+} ? z.output<S> : CapDef<C> extends {
+    readonly runtimeState: infer R extends z.ZodType;
+} ? z.output<R> : never;
+/** A top-level status field of cap `C`. */
+export type CapStatusField<C extends VocabCapName> = [StatusOf<C>] extends [never] ? never : keyof StatusOf<C> & string;
+/** An event name declared by cap `C`. */
+export type CapEventName<C extends VocabCapName> = CapDef<C> extends {
+    readonly events: infer E;
+} ? keyof E & string : never;
+/** One choice of a closed set, with its label. */
+export interface VocabChoice {
+    readonly value: string | number;
+    readonly label: L10n;
+}
+/** A closed set — every value MUST be one the method's Zod input accepts. */
+export interface EnumOffer {
+    readonly kind: 'enum';
+    readonly values: readonly VocabChoice[];
+}
+/** A number, within the Zod input's bounds. `unit` is a display suffix. */
+export interface NumberOffer {
+    readonly kind: 'number';
+    readonly min?: number;
+    readonly max?: number;
+    readonly step?: number;
+    readonly unit?: string;
+}
+/** Free text. */
+export interface TextOffer {
+    readonly kind: 'text';
+    /** True for a secret the UI should mask (a PIN code). */
+    readonly secret?: boolean;
+}
+/** A yes/no. */
+export interface BooleanOffer {
+    readonly kind: 'boolean';
+}
+/**
+ * Values the DEVICE knows, read at authoring time from the same cap:
+ * a status field holding a list, or a read method returning one.
+ * `valueKey` / `labelKey` pick the fields of an object item (omit both for a
+ * list of strings); `where` keeps only items whose field equals a value.
+ */
+export type DynamicOffer<C extends VocabCapName> = {
+    readonly kind: 'dynamic';
+    readonly from: 'status';
+    readonly field: CapStatusField<C>;
+    readonly valueKey?: string;
+    readonly labelKey?: string;
+    readonly where?: {
+        readonly key: string;
+        readonly equals: string | number | boolean;
+    };
+    /** The type of the value the method takes (default string). */
+    readonly valueKind?: 'string' | 'number';
+} | {
+    readonly kind: 'dynamic';
+    readonly from: 'method';
+    readonly method: CapMethodName<C>;
+    readonly valueKey?: string;
+    readonly labelKey?: string;
+    readonly where?: {
+        readonly key: string;
+        readonly equals: string | number | boolean;
+    };
+    readonly valueKind?: 'string' | 'number';
+};
+/** How the authoring UI offers a value for an open arg. */
+export type VocabOffer<C extends VocabCapName> = EnumOffer | NumberOffer | TextOffer | BooleanOffer | DynamicOffer<C>;
+/** An arg the operator fills after picking the action. */
+export interface VocabOpenArg<C extends VocabCapName, K extends string> {
+    readonly key: K;
+    readonly label: L10n;
+    readonly offer: VocabOffer<C>;
+    /** The method accepts the call without it. */
+    readonly optional?: boolean;
+}
+/** One operator-facing action: a cap method call with a phrase. */
+export interface VocabActionFor<C extends VocabCapName, M extends CapMethodName<C>> {
+    /** Stable id — persisted by pickers as a select value (`switch.on`). */
+    readonly id: string;
+    readonly method: M;
+    /** Short label for a picker ("Turn on"). */
+    readonly label: L10n;
+    /**
+     * The sentence ("Turn on {device}", "Move {device} to {presetId}").
+     * Placeholders: `{device}` and any open or fixed arg key.
+     */
+    readonly phrase: L10n;
+    readonly icon: VocabIcon;
+    /** Args baked into the action — never asked. */
+    readonly args?: Partial<ActionArgs<C, M>>;
+    /** Args the operator fills. */
+    readonly openArgs?: readonly VocabOpenArg<C, ActionArgKey<C, M>>[];
+}
+/** Any action of cap `C`, discriminated by `method`. */
+export type VocabAction<C extends VocabCapName> = {
+    [M in CapMethodName<C>]: VocabActionFor<C, M>;
+}[CapMethodName<C>];
+/** A true/false field: one phrase per edge. */
+export interface BooleanStateTrigger<C extends VocabCapName> {
+    readonly kind: 'boolean';
+    readonly field: CapStatusField<C>;
+    /** What the field is ("Contact", "Motion") — a picker label. */
+    readonly label: L10n;
+    readonly whenTrue: L10n;
+    readonly whenFalse: L10n;
+    readonly icon: VocabIcon;
+}
+/** A number: rises above / falls below / changes by, with a unit. */
+export interface NumericStateTrigger<C extends VocabCapName> {
+    readonly kind: 'numeric';
+    readonly field: CapStatusField<C>;
+    /** The quantity WITH its article, as it reads in a sentence ("the temperature" / "la temperatura"). */
+    readonly quantity: L10n;
+    readonly label: L10n;
+    /** Display unit; omit when the device states it (see `unitField`). */
+    readonly unit?: string;
+    /** A status field carrying the device's own unit (`numeric-sensor.unit`). */
+    readonly unitField?: CapStatusField<C>;
+    readonly icon: VocabIcon;
+}
+/** One value of an enum field, with how "becomes" reads for it. */
+export interface EnumStateValue {
+    readonly value: string;
+    readonly label: L10n;
+    /** Override of the default "When {device} changes to {value}". */
+    readonly phrase?: L10n;
+}
+/** A closed set of states. */
+export interface EnumStateTrigger<C extends VocabCapName> {
+    readonly kind: 'enum';
+    readonly field: CapStatusField<C>;
+    readonly label: L10n;
+    readonly values: readonly EnumStateValue[];
+    readonly icon: VocabIcon;
+}
+/** A free string the device reports (a presence zone, an enum sensor's state). */
+export interface ValueStateTrigger<C extends VocabCapName> {
+    readonly kind: 'value';
+    readonly field: CapStatusField<C>;
+    readonly label: L10n;
+    /** Where known values come from, when the device lists them. */
+    readonly offer?: DynamicOffer<C>;
+    /** Override of the default "When {device} changes to {value}". */
+    readonly phrase?: L10n;
+    readonly icon: VocabIcon;
+}
+/** A state field worth triggering on. */
+export type VocabStateTrigger<C extends VocabCapName> = BooleanStateTrigger<C> | NumericStateTrigger<C> | EnumStateTrigger<C> | ValueStateTrigger<C>;
+/** A bus event the device emits, phrased ("When {device} rings"). */
+export interface VocabEventTrigger {
+    readonly category: EventCategory;
+    readonly label: L10n;
+    readonly phrase: L10n;
+    readonly icon: VocabIcon;
+}
+/** A declared cap event that is not an automation trigger, and why. */
+export interface VocabEventExcused {
+    readonly notOperatorFacing: string;
+}
+/** Re-wording of one action for a kind of device. */
+export interface VocabActionWording {
+    readonly label?: L10n;
+    readonly phrase?: L10n;
+    readonly icon?: VocabIcon;
+}
+/** Re-wording of one state trigger for a kind of device. */
+export interface VocabStateWording {
+    readonly label?: L10n;
+    readonly whenTrue?: L10n;
+    readonly whenFalse?: L10n;
+    readonly quantity?: L10n;
+    readonly icon?: VocabIcon;
+}
+/** Wording that differs for a device type or role (a switch that is a siren). */
+export interface VocabWording<C extends VocabCapName> {
+    /** Keyed by action id. */
+    readonly actions?: Readonly<Record<string, VocabActionWording>>;
+    readonly state?: {
+        readonly [F in CapStatusField<C>]?: VocabStateWording;
+    };
+}
+/** Overrides, keyed in the same map: a role beats a type. */
+export interface VocabOverrides<C extends VocabCapName> {
+    readonly byType?: {
+        readonly [T in DeviceType]?: VocabWording<C>;
+    };
+    readonly byRole?: {
+        readonly [R in DeviceRole]?: VocabWording<C>;
+    };
+}
+type DeviceEventsBlock<C extends VocabCapName> = [CapEventName<C>] extends [never] ? {
+    readonly events?: undefined;
+} : {
+    /** EVERY declared cap event: a trigger, or an excuse. */
+    readonly events: {
+        readonly [E in CapEventName<C>]: VocabEventTrigger | VocabEventExcused;
+    };
+};
+/** The vocabulary of a device-scoped cap. */
+export type DeviceCapVocabulary<C extends VocabCapName> = {
+    readonly scope: 'device';
+    /** What the cap is, for grouping ("Switch" / "Interruttore"). */
+    readonly noun: L10n;
+    readonly actions?: readonly VocabAction<C>[];
+    /** Operate methods deliberately NOT offered, with the reason. */
+    readonly notOperatorFacing?: {
+        readonly [M in CapMethodName<C>]?: string;
+    };
+    readonly state?: readonly VocabStateTrigger<C>[];
+    /** Bus events the cap's devices emit with no declared cap event behind them. */
+    readonly extraEvents?: readonly VocabEventTrigger[];
+    readonly overrides?: VocabOverrides<C>;
+} & DeviceEventsBlock<C>;
+/** A system-scoped cap: never a device's vocabulary, and why. */
+export interface SystemCapVocabulary {
+    readonly scope: 'system';
+    readonly notOperatorFacing: string;
+}
+/** The entry a cap must have. */
+export type CapVocabularyEntry<C extends VocabCapName> = CapDef<C>['scope'] extends 'device' ? DeviceCapVocabulary<C> : SystemCapVocabulary;
+/** The complete map: one entry per cap, no more, no fewer. */
+export type CapVocabularyMap = {
+    readonly [C in VocabCapName]: CapVocabularyEntry<C>;
+};
+/** A slice of the map, for files that hold a family of caps. */
+export type CapVocabularySlice<K extends VocabCapName> = {
+    readonly [C in K]: CapVocabularyEntry<C>;
+};
+/** A dynamic offer with no cap-specific key type. */
+export type LooseDynamicOffer = {
+    readonly kind: 'dynamic';
+    readonly from: 'status';
+    readonly field: string;
+    readonly valueKey?: string;
+    readonly labelKey?: string;
+    readonly where?: {
+        readonly key: string;
+        readonly equals: string | number | boolean;
+    };
+    readonly valueKind?: 'string' | 'number';
+} | {
+    readonly kind: 'dynamic';
+    readonly from: 'method';
+    readonly method: string;
+    readonly valueKey?: string;
+    readonly labelKey?: string;
+    readonly where?: {
+        readonly key: string;
+        readonly equals: string | number | boolean;
+    };
+    readonly valueKind?: 'string' | 'number';
+};
+/** An offer as a consumer reads it. */
+export type LooseVocabOffer = EnumOffer | NumberOffer | TextOffer | BooleanOffer | LooseDynamicOffer;
+/** An open arg as a consumer reads it, with no cap-specific key type. */
+export interface LooseVocabOpenArg {
+    readonly key: string;
+    readonly label: L10n;
+    readonly offer: LooseVocabOffer;
+    readonly optional?: boolean;
+}
+/** An action as a consumer reads it. */
+export interface LooseVocabAction {
+    readonly id: string;
+    readonly method: string;
+    readonly label: L10n;
+    readonly phrase: L10n;
+    readonly icon: VocabIcon;
+    readonly args?: Readonly<Record<string, unknown>>;
+    readonly openArgs?: readonly LooseVocabOpenArg[];
+}
+/** A boolean state trigger, string-keyed. */
+export interface LooseBooleanStateTrigger {
+    readonly kind: 'boolean';
+    readonly field: string;
+    readonly label: L10n;
+    readonly whenTrue: L10n;
+    readonly whenFalse: L10n;
+    readonly icon: VocabIcon;
+}
+/** A numeric state trigger, string-keyed. */
+export interface LooseNumericStateTrigger {
+    readonly kind: 'numeric';
+    readonly field: string;
+    readonly quantity: L10n;
+    readonly label: L10n;
+    readonly unit?: string;
+    readonly unitField?: string;
+    readonly icon: VocabIcon;
+}
+/** An enum state trigger, string-keyed. */
+export interface LooseEnumStateTrigger {
+    readonly kind: 'enum';
+    readonly field: string;
+    readonly label: L10n;
+    readonly values: readonly EnumStateValue[];
+    readonly icon: VocabIcon;
+}
+/** A free-value state trigger, string-keyed. */
+export interface LooseValueStateTrigger {
+    readonly kind: 'value';
+    readonly field: string;
+    readonly label: L10n;
+    readonly offer?: LooseDynamicOffer;
+    readonly phrase?: L10n;
+    readonly icon: VocabIcon;
+}
+/** A state trigger as a consumer reads it. */
+export type LooseVocabStateTrigger = LooseBooleanStateTrigger | LooseNumericStateTrigger | LooseEnumStateTrigger | LooseValueStateTrigger;
+/** Wording overrides as a consumer reads them. */
+export interface LooseVocabWording {
+    readonly actions?: Readonly<Record<string, VocabActionWording>>;
+    readonly state?: Readonly<Record<string, VocabStateWording | undefined>>;
+}
+/** Overrides as a consumer reads them. */
+export interface LooseVocabOverrides {
+    readonly byType?: Readonly<Record<string, LooseVocabWording | undefined>>;
+    readonly byRole?: Readonly<Record<string, LooseVocabWording | undefined>>;
+}
+/** Any entry of the map, string-keyed. */
+export interface LooseCapVocabularyEntry {
+    readonly scope: 'device' | 'system';
+    readonly noun?: L10n;
+    readonly actions?: readonly LooseVocabAction[];
+    readonly notOperatorFacing?: string | Readonly<Record<string, string | undefined>>;
+    readonly state?: readonly LooseVocabStateTrigger[];
+    readonly events?: Readonly<Record<string, VocabEventTrigger | VocabEventExcused>>;
+    readonly extraEvents?: readonly VocabEventTrigger[];
+    readonly overrides?: LooseVocabOverrides;
+}
+export {};

package/dist/device/cap-vocabulary/vocabulary.d.ts

@@ -0,0 +1,5 @@
+import type { CapVocabularyMap, LooseCapVocabularyEntry } from './types.js';
+/** Every capability's vocabulary, keyed by cap name. */
+export declare const CAP_VOCABULARY: CapVocabularyMap;
+/** The same map, read by a string cap name (a binding names caps as strings). */
+export declare const CAP_VOCABULARY_BY_NAME: Readonly<Record<string, LooseCapVocabularyEntry>>;

package/dist/device/device-do-actions.d.ts

@@ -1,9 +1,14 @@
+import type { LooseVocabOffer } from './cap-vocabulary/types.js';
 import { DeviceType } from './device-type.js';
 /** An arg the authoring UI collects (not baked into the catalogue entry). */
 export interface DeviceDoOpenArg {
     readonly key: string;
     readonly label: string;
     readonly kind: 'string' | 'number';
+    /** How the vocabulary says to offer values (enum, range, the device's own list). */
+    readonly offer?: LooseVocabOffer;
+    /** The method accepts the call without it. */
+    readonly optional?: boolean;
 }
 /** One operator-facing action that becomes a cap method call. */
 export interface DeviceDoAction {
@@ -22,8 +27,9 @@ export interface DeviceDoAction {
     readonly openArgs?: readonly DeviceDoOpenArg[];
 }
 /**
- * The curated catalogue. Order is the order the select draws.
- * Args are baked in so the authoring UI never asks for JSON for these.
+ * The catalogue: every device-cap action of the vocabulary, in the
+ * vocabulary's order (the order the select draws). Args are baked in so the
+ * authoring UI never asks for JSON for these.
  */
 export declare const DEVICE_DO_ACTIONS: readonly DeviceDoAction[];
 /** True when METHOD_ACCESS_MAP still exposes this cap.method as actuatable. */

package/dist/generated/addon-api.d.ts

@@ -12942,6 +12942,11 @@ export type AppRouter = TrpcCoreRouter<{
                         access: ("delete" | "view" | "create")[];
                     } | {
                         type: "preferences-self";
+                    } | {
+                        type: "viewer";
+                        allow: "*" | number[];
+                        block: number[];
+                        features: ("face-assignment" | "plate-assignment" | "retrain" | "scenes")[];
                     })[];
                     createdAt: number;
                     expiresAt: number | null;
@@ -12999,6 +13004,11 @@ export type AppRouter = TrpcCoreRouter<{
                     access: ("delete" | "view" | "create")[];
                 } | {
                     type: "preferences-self";
+                } | {
+                    type: "viewer";
+                    allow: "*" | number[];
+                    block: number[];
+                    features: ("face-assignment" | "plate-assignment" | "retrain" | "scenes")[];
                 })[];
                 createdAt: number;
                 expiresAt: number | null;
@@ -13056,6 +13066,11 @@ export type AppRouter = TrpcCoreRouter<{
                     access: ("delete" | "view" | "create")[];
                 } | {
                     type: "preferences-self";
+                } | {
+                    type: "viewer";
+                    allow: "*" | number[];
+                    block: number[];
+                    features: ("face-assignment" | "plate-assignment" | "retrain" | "scenes")[];
                 })[];
                 createdAt: number;
                 expiresAt: number | null;
@@ -13550,6 +13565,8 @@ export type AppRouter = TrpcCoreRouter<{
                 isApiKey: boolean;
                 scope?: {
                     isAdmin: boolean;
+                    role: "scoped" | "admin" | "viewer";
+                    features: readonly ("face-assignment" | "plate-assignment" | "retrain" | "scenes")[];
                     allDevicesViewable: boolean;
                     viewableDeviceCount: number;
                     device: {
@@ -13586,6 +13603,8 @@ export type AppRouter = TrpcCoreRouter<{
             };
             output: {
                 isAdmin: boolean;
+                role: "scoped" | "admin" | "viewer";
+                features: readonly ("face-assignment" | "plate-assignment" | "retrain" | "scenes")[];
                 allDevicesViewable: boolean;
                 viewableDeviceCount: number;
                 device: {
@@ -13918,6 +13937,11 @@ export type AppRouter = TrpcCoreRouter<{
                         access: ("delete" | "view" | "create")[];
                     } | {
                         type: "preferences-self";
+                    } | {
+                        type: "viewer";
+                        allow: "*" | number[];
+                        block: number[];
+                        features: ("face-assignment" | "plate-assignment" | "retrain" | "scenes")[];
                     })[];
                     createdAt: number;
                     expiresAt: number | null;
@@ -13975,6 +13999,11 @@ export type AppRouter = TrpcCoreRouter<{
                     access: ("delete" | "view" | "create")[];
                 } | {
                     type: "preferences-self";
+                } | {
+                    type: "viewer";
+                    allow: "*" | number[];
+                    block: number[];
+                    features: ("face-assignment" | "plate-assignment" | "retrain" | "scenes")[];
                 })[];
                 createdAt: number;
                 expiresAt: number | null;
@@ -14032,6 +14061,11 @@ export type AppRouter = TrpcCoreRouter<{
                     access: ("delete" | "view" | "create")[];
                 } | {
                     type: "preferences-self";
+                } | {
+                    type: "viewer";
+                    allow: "*" | number[];
+                    block: number[];
+                    features: ("face-assignment" | "plate-assignment" | "retrain" | "scenes")[];
                 })[];
                 createdAt: number;
                 expiresAt: number | null;
@@ -14526,6 +14560,8 @@ export type AppRouter = TrpcCoreRouter<{
                 isApiKey: boolean;
                 scope?: {
                     isAdmin: boolean;
+                    role: "scoped" | "admin" | "viewer";
+                    features: readonly ("face-assignment" | "plate-assignment" | "retrain" | "scenes")[];
                     allDevicesViewable: boolean;
                     viewableDeviceCount: number;
                     device: {
@@ -14562,6 +14598,8 @@ export type AppRouter = TrpcCoreRouter<{
             };
             output: {
                 isAdmin: boolean;
+                role: "scoped" | "admin" | "viewer";
+                features: readonly ("face-assignment" | "plate-assignment" | "retrain" | "scenes")[];
                 allDevicesViewable: boolean;
                 viewableDeviceCount: number;
                 device: {

package/dist/generated/method-access-map.d.ts

@@ -8,12 +8,15 @@
  *
  * Coverage: 1384 method paths across 179 capabilities.
  */
+import type { MethodRole } from '../auth/viewer-access.js';
 import type { CapabilityMethodAccess } from '../capabilities/capability-definition.js';
 export interface MethodAccessRecord {
     readonly capName: string;
     readonly capScope: 'device' | 'system';
     readonly addonId: string | null;
     readonly access: CapabilityMethodAccess;
+    /** What the method is for a viewer (D921): `public`, `viewer`, `admin` or `feature:<id>`. */
+    readonly role: MethodRole;
 }
 export declare const METHOD_ACCESS_MAP: Readonly<Record<string, MethodAccessRecord>>;
 /** Set of all known cap names — handy for the scope picker. */

package/dist/index.d.ts

@@ -152,6 +152,7 @@ export * from './types/pipeline-step.js';
 export * from './types/tracked.js';
 export { type BearerPayloadShape, type BearerPrincipal, classifyBearerPrincipal, methodAccessForHttpMethod, type PrincipalAddonReachInput, type PrincipalAddonReachVerdict, principalMayReachAddon, scopesAllowAddon, scopesAllowDeviceCap, } from './auth/principal-scope.js';
 export { ADMIN_SCOPE, ALL_METHOD_ACCESS, type AddonRoutesScope, AddonRoutesScopeSchema, capabilityScopesOf, CREDENTIAL_TOKEN_AUDIENCE, CREDENTIAL_TOKEN_KIND, isCredentialTokenPayload, type CredentialScope, CredentialScopeSchema, type CredentialTokenClaims, CredentialTokenClaimsSchema, parseCredentialScopes, PREFERENCES_SELF_SCOPE, type PreferencesSelfScope, PreferencesSelfScopeSchema, SHARE_VIEW_MAX_DEVICES, scopesAllowAddonRoutes, scopesAllowOwnPreferences, scopesGrantAdmin, type ShareViewGrant, ShareViewGrantSchema, type ShareViewScope, ShareViewScopeSchema, shareViewGrantOf, } from './auth/credential-scope.js';
+export { DEFAULT_VIEWER_SCOPE, featureOfRole, type MethodRole, type MethodRoleDecl, type MethodRoleSource, methodRoleOf, resolveMethodRole, type ViewerAncestorLookup, viewerAdmitsDevice, type ViewerDeviceAllow, ViewerDeviceAllowSchema, VIEWER_FEATURE_IDS, VIEWER_FEATURES, type ViewerFeatureId, ViewerFeatureIdSchema, type ViewerFeatureSpec, viewerHoldsRole, type ViewerTokenScope, ViewerTokenScopeSchema, } from './auth/viewer-access.js';
 export { type PreferenceNamespace, PreferenceNamespaceSchema, type PreferenceRow, PreferenceRowSchema, type PreferenceValue, PreferenceValueSchema, PreferenceDeviceIdSchema, type PreferencesChangedSinceInput, PreferencesChangedSinceInputSchema, type PreferencesChangedSinceOutput, PreferencesChangedSinceOutputSchema, type PreferencesDeleteInput, PreferencesDeleteInputSchema, type PreferencesDeleteOutput, PreferencesDeleteOutputSchema, type PreferencesGetInput, PreferencesGetInputSchema, type PreferencesGetOutput, PreferencesGetOutputSchema, type PreferencesPutInput, PreferencesPutInputSchema, type PreferencesPutOutput, PreferencesPutOutputSchema, PREFERENCES_MAX_DEVICE_ID_LENGTH, PREFERENCES_MAX_NAMESPACES, PREFERENCES_MAX_VALUE_BYTES, PREFERENCES_NAMESPACE_PATTERN, } from './schemas/user-preferences.js';
 export { APP_AUTH_CALLBACK_MAX_LENGTH, APP_AUTH_CALLBACK_URLS, canonicalizeAppCallback, hasUrlScheme, parseAppAuthCallback, } from './auth/app-callback.js';
 export { APP_FLOW_DEFAULT_REDIRECT, APP_FLOW_REFUSAL_MESSAGES, APP_FLOW_STATE_PREFIX, APP_REFUSED_PATH, APP_START_REFUSAL_MESSAGES, type AppFlowParse, type AppFlowPurpose, AppFlowPurposeSchema, type AppFlowRefusal, type AppFlowRequest, type AppPageLang, AppPageLangSchema, type AppLoginPath, AppLoginPathSchema, type AppStartRefusal, appFlowLocation, isAppStartRefusal, parseAppFlowRequest, parseAppPageLang, } from './auth/app-flow.js';
@@ -162,6 +163,7 @@ export type { AutomationAction, AutomationCondition, AutomationConditionAll, Aut
 export { AutomationActionSchema, AutomationConditionOperatorSchema, AutomationConditionSchema, AutomationRecipeSchema, AutomationTriggerSchema, conditionDepth, countConditionLeaves, generateAutomationBlock, MAX_CONDITION_DEPTH, MAX_CONDITION_LEAVES, validateRecipeBounds, } from './automation/index.js';
 export * from './cap-call-context.js';
 export * from './capabilities/index.js';
+export * from './clips/clip-event-labels.js';
 export * from './device-extension/index.js';
 export * from './composition/index.js';
 export { APPLE_SA_TO_MACRO, AUDIO_MACRO_LABELS, getAudioMacroClassIds, mapAudioLabelToMacro, YAMNET_TO_MACRO, } from './catalogs/audio-classmap.js';
@@ -197,6 +199,8 @@ export type { AccessoryControlInput, AccessoryControlKind, AccessoryControlPick,
 export { DEVICE_TYPE_CONTROL_KIND, hasMotionTrigger, isNode, MOTION_TRIGGER_FEATURE, pickAccessoryControl, resolveDeviceControlKind, resolveMutate, SENSOR_FEATURES, SENSOR_MAP, } from './device/device-control-resolution.js';
 export type { DeviceDoAction, DeviceDoOpenArg } from './device/device-do-actions.js';
 export { actionsForBoundCaps, actionsForDevice, actionsForDevices, actionsForDeviceType, allDoActions, DEVICE_DO_ACTIONS, DEVICE_TYPE_DO_CAPS, deviceDoFamily, doActionSelectValue, isDoActionActuatable, isDoPickerDeviceType, matchDoAction, sameDoFamily, } from './device/device-do-actions.js';
+export type { CapVocabularyEntry, CapVocabularyMap, L10n as VocabL10n, LooseCapVocabularyEntry, LooseVocabOffer, LooseVocabOpenArg, ResolvedBooleanTrigger, ResolvedEnumTrigger, ResolvedEnumValue, ResolvedEventTrigger, ResolvedNumericTrigger, ResolvedValueTrigger, ResolvedVocabAction, ResolvedVocabTrigger, VocabBindingsInput, VocabCapName, VocabLocale, } from './device/cap-vocabulary/index.js';
+export { actionsForDevice as vocabularyActionsForDevice, CAP_VOCABULARY, CAP_VOCABULARY_BY_NAME, renderVocabPhrase, triggersForDevice as vocabularyTriggersForDevice, VOCAB_TEMPLATES, } from './device/cap-vocabulary/index.js';
 export type { ChildLayout, ChildLayoutEntry, CreateDeviceSpec, DeviceCapDisplayOverride, DeviceDiscovery, DeviceDisplayOverride, DeviceManualCreation, DeviceMeta, DiscoveredDevice, InitialDeviceMeta, RoleDisplayDefault, SavedDevice, } from './device/device-management.js';
 export type { DeviceProfile, DeviceProfileDefaults, DeviceProfileMatch, PipelinePhaseMode, } from './device/device-profile.js';
 export { BATTERY_DEVICE_PROFILE, DEVICE_PROFILES, deviceMatchesProfile, resolveDeviceProfile, } from './device/device-profile.js';
@@ -303,8 +307,8 @@ export { DEFAULT_DETAIL_CROP_CONVENTION, DETAIL_CROP_PADDING_FIELD, DETAIL_CROP_
 export { FACE_RESCORE_INTERVAL_FIELD, FACE_RESCORE_INTERVAL_KEY, FACE_RESCORE_INTERVAL_MIN_RUNNING, FACE_RESCORE_SECTION_ID, type FaceRescoreSettingsView, pickFaceRescoreIntervalMinutes, readFaceRescoreIntervalMinutes, } from './pipeline/face-rescore-schedule.js';
 export { DEFAULT_NATIVE_LEASE_SETTINGS, NATIVE_LEASE_ACTIVITY_FIELD, NATIVE_LEASE_ACTIVITY_KEY, NATIVE_LEASE_ADMISSION_FIELD, NATIVE_LEASE_ADMISSION_KEY, NATIVE_LEASE_BUDGET_FIELD, NATIVE_LEASE_BUDGET_KEY, NATIVE_LEASE_HOLD_FIELD, NATIVE_LEASE_HOLD_KEY, NATIVE_LEASE_SCENE_BUDGET_FIELD, NATIVE_LEASE_SCENE_BUDGET_KEY, NATIVE_LEASE_SECTION_ID, NATIVE_LEASE_TILE_BUDGET_FIELD, NATIVE_LEASE_TILE_BUDGET_KEY, type NativeLeaseAdmission, NativeLeaseAdmissionSchema, type NativeLeaseKnob, type NativeLeaseNumberKnob, type NativeLeaseSettings, type NativeLeaseSettingsOverride, NativeLeaseSettingsSchema, pickNativeLeaseOverride, readNativeLeaseOverride, } from './pipeline/native-lease.js';
 export { ACCESS_ROLES, type AccessRoleAssignment, type AccessRoleId, type AccessRoleSpec, buildRoleScopes, detectAccessRole, roleSpec, } from './schemas/access-roles.js';
-export { type CapScope, CapScopeSchema, type DeviceSelector, DeviceSelectorSchema, type DeviceTokenScope, type MethodAccess, MethodAccessSchema, type ScopedToken, ScopedTokenSchema, type TokenScope, TokenScopeSchema, type UserRecord, UserRecordSchema, } from './schemas/auth-records.js';
-export { type DeviceMetaLike, type DeviceReachSummary, deviceSelectorMatches, type EffectiveScope, normalizeTokenScopes, resolveViewableDeviceIds, type ScopeGrantSummary, scopeInherits, summarizeEffectiveScope, } from './schemas/device-selector.js';
+export { type CapScope, CapScopeSchema, type DeviceSelector, DeviceSelectorSchema, type DeviceTokenScope, type MethodAccess, MethodAccessSchema, type ScopedToken, ScopedTokenSchema, type TokenScope, TokenScopeSchema, type UserRecord, UserRecordSchema, type UserScope, UserScopeSchema, } from './schemas/auth-records.js';
+export { type DeviceMetaLike, type DeviceReachSummary, deviceSelectorMatches, type EffectiveScope, grantRowsOf, normalizeTokenScopes, resolveViewableDeviceIds, type ScopeGrantSummary, scopeInherits, summarizeEffectiveScope, viewerScopeOf, } from './schemas/device-selector.js';
 export type { CameraDetectionCapabilities, CameraMotionConfig, CameraNativeDetectionConfig, } from './types/camera-detection.js';
 export { DEVICE_TYPE_INFO, type DeviceTypeInfo } from './types/device-type.js';
 export * from './units/index.js';