@camstack/types 1.2.335 → 1.2.337

package/dist/capabilities/alarm-panel.cap.d.ts

@@ -18,72 +18,72 @@ import { DeviceType } from '../device/device-type.js';
  * mode list — the UI renders only the buttons the panel accepts.
  */
 export declare const AlarmStateSchema: z.ZodEnum<{
-    pending: "pending";
-    disarmed: "disarmed";
-    armed_home: "armed_home";
     armed_away: "armed_away";
+    armed_custom_bypass: "armed_custom_bypass";
+    armed_home: "armed_home";
     armed_night: "armed_night";
     armed_vacation: "armed_vacation";
-    armed_custom_bypass: "armed_custom_bypass";
     arming: "arming";
+    disarmed: "disarmed";
     disarming: "disarming";
+    pending: "pending";
     triggered: "triggered";
 }>;
 export type AlarmState = z.infer<typeof AlarmStateSchema>;
 export declare const AlarmArmModeSchema: z.ZodEnum<{
-    night: "night";
-    home: "home";
     away: "away";
-    vacation: "vacation";
     custom_bypass: "custom_bypass";
+    home: "home";
+    night: "night";
+    vacation: "vacation";
 }>;
 export type AlarmArmMode = z.infer<typeof AlarmArmModeSchema>;
 export declare const AlarmPanelStatusSchema: z.ZodObject<{
     state: z.ZodEnum<{
-        pending: "pending";
-        disarmed: "disarmed";
-        armed_home: "armed_home";
         armed_away: "armed_away";
+        armed_custom_bypass: "armed_custom_bypass";
+        armed_home: "armed_home";
         armed_night: "armed_night";
         armed_vacation: "armed_vacation";
-        armed_custom_bypass: "armed_custom_bypass";
         arming: "arming";
+        disarmed: "disarmed";
         disarming: "disarming";
+        pending: "pending";
         triggered: "triggered";
     }>;
     targetMode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-        night: "night";
-        home: "home";
         away: "away";
-        vacation: "vacation";
         custom_bypass: "custom_bypass";
+        home: "home";
+        night: "night";
+        vacation: "vacation";
     }>>>;
     availableModes: z.ZodArray<z.ZodEnum<{
-        night: "night";
-        home: "home";
         away: "away";
-        vacation: "vacation";
         custom_bypass: "custom_bypass";
+        home: "home";
+        night: "night";
+        vacation: "vacation";
     }>>;
     requiresCode: z.ZodBoolean;
     lastChangedAt: z.ZodNumber;
 }, z.core.$strip>;
 export type AlarmPanelStatus = z.infer<typeof AlarmPanelStatusSchema>;
 export declare const alarmPanelCapability: {
-    readonly name: "alarm-panel";
-    readonly scope: "device";
+    readonly name: 'alarm-panel';
+    readonly scope: 'device';
     readonly deviceNative: true;
-    readonly mode: "singleton";
+    readonly mode: 'singleton';
     readonly deviceTypes: readonly [DeviceType.AlarmPanel];
     readonly methods: {
         readonly arm: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
             mode: z.ZodEnum<{
-                night: "night";
-                home: "home";
                 away: "away";
-                vacation: "vacation";
                 custom_bypass: "custom_bypass";
+                home: "home";
+                night: "night";
+                vacation: "vacation";
             }>;
             code: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, z.ZodVoid, "mutation">;
@@ -105,35 +105,35 @@ export declare const alarmPanelCapability: {
     readonly status: {
         readonly schema: z.ZodObject<{
             state: z.ZodEnum<{
-                pending: "pending";
-                disarmed: "disarmed";
-                armed_home: "armed_home";
                 armed_away: "armed_away";
+                armed_custom_bypass: "armed_custom_bypass";
+                armed_home: "armed_home";
                 armed_night: "armed_night";
                 armed_vacation: "armed_vacation";
-                armed_custom_bypass: "armed_custom_bypass";
                 arming: "arming";
+                disarmed: "disarmed";
                 disarming: "disarming";
+                pending: "pending";
                 triggered: "triggered";
             }>;
             targetMode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-                night: "night";
-                home: "home";
                 away: "away";
-                vacation: "vacation";
                 custom_bypass: "custom_bypass";
+                home: "home";
+                night: "night";
+                vacation: "vacation";
             }>>>;
             availableModes: z.ZodArray<z.ZodEnum<{
-                night: "night";
-                home: "home";
                 away: "away";
-                vacation: "vacation";
                 custom_bypass: "custom_bypass";
+                home: "home";
+                night: "night";
+                vacation: "vacation";
             }>>;
             requiresCode: z.ZodBoolean;
             lastChangedAt: z.ZodNumber;
         }, z.core.$strip>;
-        readonly kind: "push";
+        readonly kind: 'push';
     };
     /**
      * Runtime-state slice — mirrored by the kernel. UI panel reads the
@@ -142,30 +142,30 @@ export declare const alarmPanelCapability: {
      */
     readonly runtimeState: z.ZodObject<{
         state: z.ZodEnum<{
-            pending: "pending";
-            disarmed: "disarmed";
-            armed_home: "armed_home";
             armed_away: "armed_away";
+            armed_custom_bypass: "armed_custom_bypass";
+            armed_home: "armed_home";
             armed_night: "armed_night";
             armed_vacation: "armed_vacation";
-            armed_custom_bypass: "armed_custom_bypass";
             arming: "arming";
+            disarmed: "disarmed";
             disarming: "disarming";
+            pending: "pending";
             triggered: "triggered";
         }>;
         targetMode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            night: "night";
-            home: "home";
             away: "away";
-            vacation: "vacation";
             custom_bypass: "custom_bypass";
+            home: "home";
+            night: "night";
+            vacation: "vacation";
         }>>>;
         availableModes: z.ZodArray<z.ZodEnum<{
-            night: "night";
-            home: "home";
             away: "away";
-            vacation: "vacation";
             custom_bypass: "custom_bypass";
+            home: "home";
+            night: "night";
+            vacation: "vacation";
         }>>;
         requiresCode: z.ZodBoolean;
         lastChangedAt: z.ZodNumber;
@@ -176,7 +176,7 @@ export declare const alarmPanelCapability: {
      * See `RuntimeStateDurability`. Enforced by
      * `scripts/check-runtime-state-durability.ts`.
      */
-    readonly durability: "restored";
+    readonly durability: 'restored';
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastChangedAt"];

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

@@ -8,17 +8,17 @@
 import { z } from 'zod';
 import { type InferProvider } from './capability-definition.js';
 export declare const AlertSeveritySchema: z.ZodEnum<{
+    error: "error";
     info: "info";
     success: "success";
-    error: "error";
     warning: "warning";
 }>;
 export declare const AlertStatusSchema: z.ZodEnum<{
-    failed: "failed";
     active: "active";
     completed: "completed";
-    "in-progress": "in-progress";
     dismissed: "dismissed";
+    failed: "failed";
+    "in-progress": "in-progress";
 }>;
 export declare const AlertSourceSchema: z.ZodObject<{
     type: z.ZodString;
@@ -28,19 +28,19 @@ export declare const AlertSchema: z.ZodObject<{
     id: z.ZodString;
     category: z.ZodString;
     severity: z.ZodEnum<{
+        error: "error";
         info: "info";
         success: "success";
-        error: "error";
         warning: "warning";
     }>;
     title: z.ZodString;
     message: z.ZodString;
     status: z.ZodEnum<{
-        failed: "failed";
         active: "active";
         completed: "completed";
-        "in-progress": "in-progress";
         dismissed: "dismissed";
+        failed: "failed";
+        "in-progress": "in-progress";
     }>;
     progress: z.ZodOptional<z.ZodNumber>;
     read: z.ZodBoolean;
@@ -56,27 +56,27 @@ 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 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<{
+                error: "error";
                 info: "info";
                 success: "success";
-                error: "error";
                 warning: "warning";
             }>;
             title: z.ZodString;
             message: z.ZodString;
             status: z.ZodEnum<{
-                failed: "failed";
                 active: "active";
                 completed: "completed";
-                "in-progress": "in-progress";
                 dismissed: "dismissed";
+                failed: "failed";
+                "in-progress": "in-progress";
             }>;
             progress: z.ZodOptional<z.ZodNumber>;
             read: z.ZodBoolean;
@@ -94,19 +94,19 @@ export declare const alertsCapability: {
                 id: z.ZodOptional<z.ZodString>;
                 category: z.ZodOptional<z.ZodString>;
                 severity: z.ZodOptional<z.ZodEnum<{
+                    error: "error";
                     info: "info";
                     success: "success";
-                    error: "error";
                     warning: "warning";
                 }>>;
                 title: z.ZodOptional<z.ZodString>;
                 message: z.ZodOptional<z.ZodString>;
                 status: z.ZodOptional<z.ZodEnum<{
-                    failed: "failed";
                     active: "active";
                     completed: "completed";
-                    "in-progress": "in-progress";
                     dismissed: "dismissed";
+                    failed: "failed";
+                    "in-progress": "in-progress";
                 }>>;
                 progress: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
                 read: z.ZodOptional<z.ZodBoolean>;
@@ -126,19 +126,19 @@ export declare const alertsCapability: {
             id: z.ZodString;
             category: z.ZodString;
             severity: z.ZodEnum<{
+                error: "error";
                 info: "info";
                 success: "success";
-                error: "error";
                 warning: "warning";
             }>;
             title: z.ZodString;
             message: z.ZodString;
             status: z.ZodEnum<{
-                failed: "failed";
                 active: "active";
                 completed: "completed";
-                "in-progress": "in-progress";
                 dismissed: "dismissed";
+                failed: "failed";
+                "in-progress": "in-progress";
             }>;
             progress: z.ZodOptional<z.ZodNumber>;
             read: z.ZodBoolean;

package/dist/capabilities/ambient-light-sensor.cap.d.ts

@@ -13,10 +13,10 @@ export declare const AmbientLightSensorStatusSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type AmbientLightSensorStatus = z.infer<typeof AmbientLightSensorStatusSchema>;
 export declare const ambientLightSensorCapability: {
-    readonly name: "ambient-light-sensor";
-    readonly scope: "device";
+    readonly name: 'ambient-light-sensor';
+    readonly scope: 'device';
     readonly deviceNative: true;
-    readonly mode: "singleton";
+    readonly mode: 'singleton';
     readonly deviceTypes: readonly [DeviceType.Sensor];
     readonly methods: {};
     readonly status: {
@@ -26,7 +26,7 @@ export declare const ambientLightSensorCapability: {
             unit: z.ZodOptional<z.ZodString>;
             precision: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>;
-        readonly kind: "push";
+        readonly kind: 'push';
     };
     readonly runtimeState: z.ZodObject<{
         lux: z.ZodNumber;
@@ -40,7 +40,7 @@ export declare const ambientLightSensorCapability: {
      * See `RuntimeStateDurability`. Enforced by
      * `scripts/check-runtime-state-durability.ts`.
      */
-    readonly durability: "restored";
+    readonly durability: 'restored';
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastFetchedAt"];

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

@@ -19,10 +19,10 @@ import type { AudioAnalysisSettings } from '../types/io.js';
  * analysed (e.g. muted / motion-only cams).
  */
 export declare const audioAnalysisCapability: {
-    readonly name: "audio-analysis";
-    readonly scope: "device";
-    readonly mode: "singleton";
-    readonly kind: "wrapper";
+    readonly name: 'audio-analysis';
+    readonly scope: 'device';
+    readonly mode: 'singleton';
+    readonly kind: 'wrapper';
     readonly defaultActive: true;
     readonly deviceTypes: readonly [DeviceType.Camera];
     readonly exposesDeviceSettings: true;

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

@@ -18,10 +18,10 @@ declare const AudioAnalysisResultSchema: z.ZodObject<{
     }, z.core.$strip>, z.ZodObject<{
         state: z.ZodLiteral<"not-classified">;
         reason: z.ZodEnum<{
-            superseded: "superseded";
+            disposed: "disposed";
             error: "error";
+            superseded: "superseded";
             timeout: "timeout";
-            disposed: "disposed";
         }>;
     }, z.core.$strip>], "state">;
     timestamp: z.ZodNumber;
@@ -90,14 +90,14 @@ declare const AudioClassificationResultSchema: z.ZodObject<{
  * platform heuristic (Apple SoundAnalysis on macOS, YAMNet elsewhere).
  */
 export declare const AUDIO_BACKEND_CHOICES: readonly [{
-    readonly value: "auto";
-    readonly label: "Auto (platform default)";
+    readonly value: 'auto';
+    readonly label: 'Auto (platform default)';
 }, {
-    readonly value: "apple-soundanalysis";
-    readonly label: "Apple SoundAnalysis (macOS 12+)";
+    readonly value: 'apple-soundanalysis';
+    readonly label: 'Apple SoundAnalysis (macOS 12+)';
 }, {
-    readonly value: "yamnet-onnx";
-    readonly label: "YAMNet ONNX (cross-platform)";
+    readonly value: 'yamnet-onnx';
+    readonly label: 'YAMNet ONNX (cross-platform)';
 }];
 export type AudioBackendChoice = (typeof AUDIO_BACKEND_CHOICES)[number]['value'];
 /**
@@ -124,9 +124,9 @@ export interface AudioAnalyzerGlobalConfig {
 }
 export declare const DEFAULT_AUDIO_ANALYZER_CONFIG: AudioAnalyzerGlobalConfig;
 export declare const audioAnalyzerCapability: {
-    readonly name: "audio-analyzer";
-    readonly scope: "system";
-    readonly mode: "singleton";
+    readonly name: 'audio-analyzer';
+    readonly scope: 'system';
+    readonly mode: 'singleton';
     readonly methods: {
         readonly analyseChunk: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             chunk: z.ZodObject<{
@@ -158,10 +158,10 @@ export declare const audioAnalyzerCapability: {
             }, z.core.$strip>, z.ZodObject<{
                 state: z.ZodLiteral<"not-classified">;
                 reason: z.ZodEnum<{
-                    superseded: "superseded";
+                    disposed: "disposed";
                     error: "error";
+                    superseded: "superseded";
                     timeout: "timeout";
-                    disposed: "disposed";
                 }>;
             }, z.core.$strip>], "state">;
             timestamp: z.ZodNumber;

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

@@ -67,10 +67,10 @@ declare const AudioEncodedChunkSchema: z.ZodObject<{
  * pluggable later) — operators always install one or the other together.
  */
 export declare const audioCodecCapability: {
-    readonly name: "audio-codec";
-    readonly scope: "system";
-    readonly mode: "singleton";
-    readonly preferredProvider: "decoder-nodeav";
+    readonly name: 'audio-codec';
+    readonly scope: 'system';
+    readonly mode: 'singleton';
+    readonly preferredProvider: 'decoder-nodeav';
     readonly methods: {
         /** Probe the local runtime and return the supported codec matrix. */
         readonly listSupportedCodecs: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{

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

@@ -90,9 +90,9 @@ export type AudioMetricsHistory = z.infer<typeof AudioMetricsHistorySchema>;
  * a custom event subscription.
  */
 export declare const audioMetricsCapability: {
-    readonly name: "audio-metrics";
-    readonly scope: "device";
-    readonly mode: "singleton";
+    readonly name: 'audio-metrics';
+    readonly scope: 'device';
+    readonly mode: 'singleton';
     readonly deviceTypes: readonly [DeviceType.Camera];
     readonly methods: {
         /** Latest snapshot for this device. Null until the analytics
@@ -174,7 +174,7 @@ export declare const audioMetricsCapability: {
      * See `RuntimeStateDurability`. Enforced by
      * `scripts/check-runtime-state-durability.ts`.
      */
-    readonly durability: "session";
+    readonly durability: 'session';
 };
 export type IAudioMetricsProvider = InferProvider<typeof audioMetricsCapability>;
 export { AudioMetricsSnapshotSchema, AudioClassSummarySchema, AudioMetricsHistoryPointSchema, AudioMetricsHistorySchema, };

package/dist/capabilities/auth-provider.cap.d.ts

@@ -8,9 +8,9 @@ declare const AuthResultSchema: z.ZodObject<{
     isAdmin: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const authProviderCapability: {
-    readonly name: "auth-provider";
-    readonly scope: "system";
-    readonly mode: "collection";
+    readonly name: 'auth-provider';
+    readonly scope: 'system';
+    readonly mode: 'collection';
     readonly internal: true;
     readonly methods: {
         readonly validateCredentials: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
@@ -45,7 +45,7 @@ export declare const authProviderCapability: {
     };
     /** BIG PLAN 2: declarative mount hint — read by `@camstack/system` `buildCapRouters`. */
     readonly mount: {
-        readonly kind: "skip";
+        readonly kind: 'skip';
     };
 };
 export type IAuthProvider = InferProvider<typeof authProviderCapability>;

package/dist/capabilities/automation-control.cap.d.ts

@@ -21,10 +21,10 @@ export declare const AutomationControlStatusSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type AutomationControlStatus = z.infer<typeof AutomationControlStatusSchema>;
 export declare const automationControlCapability: {
-    readonly name: "automation-control";
-    readonly scope: "device";
+    readonly name: 'automation-control';
+    readonly scope: 'device';
     readonly deviceNative: true;
-    readonly mode: "singleton";
+    readonly mode: 'singleton';
     readonly deviceTypes: readonly [DeviceType.Automation];
     readonly methods: {
         readonly enable: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
@@ -46,7 +46,7 @@ export declare const automationControlCapability: {
             lastError: z.ZodNullable<z.ZodString>;
             lastChangedAt: z.ZodNumber;
         }, z.core.$strip>;
-        readonly kind: "push";
+        readonly kind: 'push';
     };
     /**
      * Runtime-state slice — mirrored by the kernel. UI automation tile
@@ -66,6 +66,6 @@ export declare const automationControlCapability: {
      * See `RuntimeStateDurability`. Enforced by
      * `scripts/check-runtime-state-durability.ts`.
      */
-    readonly durability: "session";
+    readonly durability: 'session';
 };
 export type IAutomationControlProvider = InferProvider<typeof automationControlCapability>;

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

@@ -117,8 +117,8 @@ declare const BackupEntrySchema: z.ZodObject<{
 declare const ArchiveEntrySchema: z.ZodObject<{
     path: z.ZodString;
     kind: z.ZodEnum<{
-        file: "file";
         dir: "dir";
+        file: "file";
         symlink: "symlink";
     }>;
     sizeBytes: z.ZodNumber;
@@ -132,8 +132,8 @@ declare const ArchiveManifestSchema: z.ZodObject<{
     entries: z.ZodArray<z.ZodObject<{
         path: z.ZodString;
         kind: z.ZodEnum<{
-            file: "file";
             dir: "dir";
+            file: "file";
             symlink: "symlink";
         }>;
         sizeBytes: z.ZodNumber;
@@ -164,10 +164,10 @@ declare const LocationStatSchema: z.ZodObject<{
 }, z.core.$strip>;
 /** Lifecycle of a backup run. Terminal states: succeeded / failed / cancelled. */
 declare const BackupRunStateSchema: z.ZodEnum<{
+    cancelled: "cancelled";
+    failed: "failed";
     queued: "queued";
     running: "running";
-    failed: "failed";
-    cancelled: "cancelled";
     succeeded: "succeeded";
 }>;
 /**
@@ -176,9 +176,9 @@ declare const BackupRunStateSchema: z.ZodEnum<{
  * per-destination fan-out, `done` once terminal.
  */
 declare const BackupRunPhaseSchema: z.ZodEnum<{
-    queued: "queued";
-    done: "done";
     building: "building";
+    done: "done";
+    queued: "queued";
     uploading: "uploading";
 }>;
 /**
@@ -192,16 +192,16 @@ declare const BackupRunPhaseSchema: z.ZodEnum<{
 declare const BackupRunSchema: z.ZodObject<{
     id: z.ZodString;
     state: z.ZodEnum<{
+        cancelled: "cancelled";
+        failed: "failed";
         queued: "queued";
         running: "running";
-        failed: "failed";
-        cancelled: "cancelled";
         succeeded: "succeeded";
     }>;
     phase: z.ZodEnum<{
-        queued: "queued";
-        done: "done";
         building: "building";
+        done: "done";
+        queued: "queued";
         uploading: "uploading";
     }>;
     destinationIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
@@ -277,9 +277,9 @@ declare const BackupScheduleSchema: z.ZodObject<{
  * can replace it by registering the same capability.
  */
 export declare const backupCapability: {
-    readonly name: "backup";
-    readonly scope: "system";
-    readonly mode: "singleton";
+    readonly name: 'backup';
+    readonly scope: 'system';
+    readonly mode: 'singleton';
     readonly methods: {
         /**
          * Flat aggregate of every destination across every registered
@@ -351,16 +351,16 @@ export declare const backupCapability: {
         readonly listRuns: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             state: z.ZodEnum<{
+                cancelled: "cancelled";
+                failed: "failed";
                 queued: "queued";
                 running: "running";
-                failed: "failed";
-                cancelled: "cancelled";
                 succeeded: "succeeded";
             }>;
             phase: z.ZodEnum<{
-                queued: "queued";
-                done: "done";
                 building: "building";
+                done: "done";
+                queued: "queued";
                 uploading: "uploading";
             }>;
             destinationIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
@@ -433,8 +433,8 @@ export declare const backupCapability: {
             entries: z.ZodArray<z.ZodObject<{
                 path: z.ZodString;
                 kind: z.ZodEnum<{
-                    file: "file";
                     dir: "dir";
+                    file: "file";
                     symlink: "symlink";
                 }>;
                 sizeBytes: z.ZodNumber;