@camstack/types 1.2.336 → 1.2.338

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

@@ -27,10 +27,10 @@ export type DoorbellPressEvent = z.infer<typeof DoorbellPressEventSchema>;
  * The DeviceEventPropagator re-emits `onPressed` on the camera parent.
  */
 export declare const doorbellCapability: {
-    readonly name: "doorbell";
-    readonly scope: "device";
+    readonly name: 'doorbell';
+    readonly scope: 'device';
     readonly deviceNative: true;
-    readonly mode: "singleton";
+    readonly mode: 'singleton';
     readonly deviceTypes: readonly [DeviceType.Button, DeviceType.Camera];
     readonly methods: {};
     readonly events: {
@@ -45,8 +45,8 @@ export declare const doorbellCapability: {
                 timestamp: z.ZodNumber;
             }, z.core.$strip>;
             readonly fromState: {
-                readonly field: "lastPressedAt";
-                readonly on: "advance";
+                readonly field: 'lastPressedAt';
+                readonly on: 'advance';
             };
         };
     };
@@ -55,7 +55,7 @@ export declare const doorbellCapability: {
             lastPressedAt: z.ZodNullable<z.ZodNumber>;
             pressCountSinceStart: z.ZodNumber;
         }, z.core.$strip>;
-        readonly kind: "push";
+        readonly kind: 'push';
     };
     /**
      * Runtime-state slice — last press timestamp + lifetime press count.
@@ -73,6 +73,6 @@ export declare const doorbellCapability: {
      * See `RuntimeStateDurability`. Enforced by
      * `scripts/check-runtime-state-durability.ts`.
      */
-    readonly durability: "restored";
+    readonly durability: 'restored';
 };
 export type IDoorbellProvider = InferProvider<typeof doorbellCapability>;

package/dist/capabilities/embedding-encoder.cap.d.ts

@@ -111,8 +111,8 @@ export declare const EMBEDDING_REQUIREMENTS_UNAVAILABLE = "embedding-requirement
 export declare const EMBEDDING_REQUIREMENTS_FAILED = "embedding-requirements-failed";
 export declare const EmbeddingRefusalCodeSchema: z.ZodEnum<{
     "embedding-model-failed": "embedding-model-failed";
-    "embedding-requirements-unavailable": "embedding-requirements-unavailable";
     "embedding-requirements-failed": "embedding-requirements-failed";
+    "embedding-requirements-unavailable": "embedding-requirements-unavailable";
 }>;
 export type EmbeddingRefusalCode = z.infer<typeof EmbeddingRefusalCodeSchema>;
 /** What every token names: enough to count a refusal and to point at the reset. */
@@ -149,9 +149,9 @@ export declare function embeddingModelFailedOf(err: unknown): EmbeddingModelFail
  * UNKNOWN to the reader, never "no failures" (D315).
  */
 export declare const embeddingEncoderCapability: {
-    readonly name: "embedding-encoder";
-    readonly scope: "system";
-    readonly mode: "collection";
+    readonly name: 'embedding-encoder';
+    readonly scope: 'system';
+    readonly mode: 'collection';
     readonly internal: true;
     readonly methods: {
         /**

package/dist/capabilities/enum-sensor.cap.d.ts

@@ -12,45 +12,45 @@ import { DeviceType } from '../device/device-type.js';
 /** Locale-render shape for an ISO `value` carried by a `DateTimeSensor`-role
  *  enum sensor: `date` (date-only), `time` (time-only), `datetime` (both). */
 export declare const EnumSensorDateTimeFormatSchema: z.ZodEnum<{
-    datetime: "datetime";
     date: "date";
+    datetime: "datetime";
     time: "time";
 }>;
 export type EnumSensorDateTimeFormat = z.infer<typeof EnumSensorDateTimeFormatSchema>;
 export declare const EnumSensorStatusSchema: z.ZodObject<{
     value: z.ZodString;
     format: z.ZodOptional<z.ZodEnum<{
-        datetime: "datetime";
         date: "date";
+        datetime: "datetime";
         time: "time";
     }>>;
     lastFetchedAt: z.ZodNumber;
 }, z.core.$strip>;
 export type EnumSensorStatus = z.infer<typeof EnumSensorStatusSchema>;
 export declare const enumSensorCapability: {
-    readonly name: "enum-sensor";
-    readonly scope: "device";
+    readonly name: 'enum-sensor';
+    readonly scope: 'device';
     readonly deviceNative: true;
-    readonly mode: "singleton";
+    readonly mode: 'singleton';
     readonly deviceTypes: readonly [DeviceType.Sensor];
     readonly methods: {};
     readonly status: {
         readonly schema: z.ZodObject<{
             value: z.ZodString;
             format: z.ZodOptional<z.ZodEnum<{
-                datetime: "datetime";
                 date: "date";
+                datetime: "datetime";
                 time: "time";
             }>>;
             lastFetchedAt: z.ZodNumber;
         }, z.core.$strip>;
-        readonly kind: "push";
+        readonly kind: 'push';
     };
     readonly runtimeState: z.ZodObject<{
         value: z.ZodString;
         format: z.ZodOptional<z.ZodEnum<{
-            datetime: "datetime";
             date: "date";
+            datetime: "datetime";
             time: "time";
         }>>;
         lastFetchedAt: z.ZodNumber;
@@ -61,7 +61,7 @@ export declare const enumSensorCapability: {
      * 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/event-emitter.cap.d.ts

@@ -32,10 +32,10 @@ export declare const EventEmitterStatusSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type EventEmitterStatus = z.infer<typeof EventEmitterStatusSchema>;
 export declare const eventEmitterCapability: {
-    readonly name: "event-emitter";
-    readonly scope: "device";
+    readonly name: 'event-emitter';
+    readonly scope: 'device';
     readonly deviceNative: true;
-    readonly mode: "singleton";
+    readonly mode: 'singleton';
     readonly deviceTypes: readonly [DeviceType.EventEmitter];
     readonly methods: {};
     readonly events: {
@@ -61,7 +61,7 @@ export declare const eventEmitterCapability: {
             }, z.core.$strip>>;
             eventCountSinceStart: z.ZodNumber;
         }, z.core.$strip>;
-        readonly kind: "push";
+        readonly kind: 'push';
     };
     readonly runtimeState: z.ZodObject<{
         eventTypes: z.ZodArray<z.ZodString>;
@@ -80,6 +80,6 @@ export declare const eventEmitterCapability: {
      * See `RuntimeStateDurability`. Enforced by
      * `scripts/check-runtime-state-durability.ts`.
      */
-    readonly durability: "session";
+    readonly durability: 'session';
 };
 export type IEventEmitterProvider = InferProvider<typeof eventEmitterCapability>;

package/dist/capabilities/face-gallery.cap.d.ts

@@ -119,8 +119,8 @@ export type FaceInfo = z.infer<typeof FaceInfoSchema>;
  * backend's NULL-collation accident.
  */
 declare const FaceSortFieldEnum: z.ZodEnum<{
-    timestamp: "timestamp";
     suggestionConfidence: "suggestionConfidence";
+    timestamp: "timestamp";
 }>;
 export type FaceSortField = z.infer<typeof FaceSortFieldEnum>;
 declare const FaceSortDirectionEnum: z.ZodEnum<{
@@ -138,9 +138,9 @@ declare const FaceClusterSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type FaceCluster = z.infer<typeof FaceClusterSchema>;
 export declare const faceGalleryCapability: {
-    readonly name: "face-gallery";
-    readonly scope: "system";
-    readonly mode: "singleton";
+    readonly name: 'face-gallery';
+    readonly scope: 'system';
+    readonly mode: 'singleton';
     readonly methods: {
         readonly listIdentities: import("./capability-definition.js").CapabilityMethodSchema<z.ZodOptional<z.ZodObject<{
             includeCrops: z.ZodOptional<z.ZodBoolean>;
@@ -230,15 +230,15 @@ export declare const faceGalleryCapability: {
             limit: z.ZodOptional<z.ZodNumber>;
             filter: z.ZodOptional<z.ZodEnum<{
                 all: "all";
-                unassigned: "unassigned";
-                recognized: "recognized";
                 identified: "identified";
+                recognized: "recognized";
+                unassigned: "unassigned";
             }>>;
             since: z.ZodOptional<z.ZodNumber>;
             until: z.ZodOptional<z.ZodNumber>;
             sortBy: z.ZodOptional<z.ZodEnum<{
-                timestamp: "timestamp";
                 suggestionConfidence: "suggestionConfidence";
+                timestamp: "timestamp";
             }>>;
             sortDirection: z.ZodOptional<z.ZodEnum<{
                 asc: "asc";

package/dist/capabilities/failure-contribution.cap.d.ts

@@ -73,9 +73,9 @@ declare const FailureContributionSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type FailureContribution = z.infer<typeof FailureContributionSchema>;
 export declare const failureContributionCapability: {
-    readonly name: "failure-contribution";
-    readonly scope: "system";
-    readonly mode: "collection";
+    readonly name: 'failure-contribution';
+    readonly scope: 'system';
+    readonly mode: 'collection';
     readonly internal: true;
     readonly methods: {
         /**
@@ -104,7 +104,7 @@ export declare const failureContributionCapability: {
     };
     /** In-process only — enumerated through `addons.listCapabilityProviders`. */
     readonly mount: {
-        readonly kind: "skip";
+        readonly kind: 'skip';
     };
 };
 export type IFailureContributionProvider = InferProvider<typeof failureContributionCapability>;

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

@@ -20,8 +20,8 @@ import { DeviceType } from '../device/device-type.js';
  *   - `FanOscillating` — oscillation toggle
  */
 export declare const FanDirectionSchema: z.ZodEnum<{
-    reverse: "reverse";
     forward: "forward";
+    reverse: "reverse";
 }>;
 export type FanDirection = z.infer<typeof FanDirectionSchema>;
 export declare const FanControlStatusSchema: z.ZodObject<{
@@ -30,18 +30,18 @@ export declare const FanControlStatusSchema: z.ZodObject<{
     preset: z.ZodString;
     availablePresets: z.ZodArray<z.ZodString>;
     direction: z.ZodNullable<z.ZodEnum<{
-        reverse: "reverse";
         forward: "forward";
+        reverse: "reverse";
     }>>;
     oscillating: z.ZodNullable<z.ZodBoolean>;
     lastChangedAt: z.ZodNumber;
 }, z.core.$strip>;
 export type FanControlStatus = z.infer<typeof FanControlStatusSchema>;
 export declare const fanControlCapability: {
-    readonly name: "fan-control";
-    readonly scope: "device";
+    readonly name: 'fan-control';
+    readonly scope: 'device';
     readonly deviceNative: true;
-    readonly mode: "singleton";
+    readonly mode: 'singleton';
     readonly deviceTypes: readonly [DeviceType.Fan];
     readonly methods: {
         readonly setPercentage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
@@ -55,8 +55,8 @@ export declare const fanControlCapability: {
         readonly setDirection: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
             direction: z.ZodEnum<{
-                reverse: "reverse";
                 forward: "forward";
+                reverse: "reverse";
             }>;
         }, z.core.$strip>, z.ZodVoid, "mutation">;
         readonly setOscillating: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
@@ -71,13 +71,13 @@ export declare const fanControlCapability: {
             preset: z.ZodString;
             availablePresets: z.ZodArray<z.ZodString>;
             direction: z.ZodNullable<z.ZodEnum<{
-                reverse: "reverse";
                 forward: "forward";
+                reverse: "reverse";
             }>>;
             oscillating: z.ZodNullable<z.ZodBoolean>;
             lastChangedAt: z.ZodNumber;
         }, z.core.$strip>;
-        readonly kind: "push";
+        readonly kind: 'push';
     };
     /**
      * Runtime-state slice — mirrored by the kernel. UI fan speed
@@ -89,8 +89,8 @@ export declare const fanControlCapability: {
         preset: z.ZodString;
         availablePresets: z.ZodArray<z.ZodString>;
         direction: z.ZodNullable<z.ZodEnum<{
-            reverse: "reverse";
             forward: "forward";
+            reverse: "reverse";
         }>>;
         oscillating: z.ZodNullable<z.ZodBoolean>;
         lastChangedAt: z.ZodNumber;
@@ -101,6 +101,6 @@ export declare const fanControlCapability: {
      * See `RuntimeStateDurability`. Enforced by
      * `scripts/check-runtime-state-durability.ts`.
      */
-    readonly durability: "session";
+    readonly durability: 'session';
 };
 export type IFanControlProvider = InferProvider<typeof fanControlCapability>;

package/dist/capabilities/feature-probe.cap.d.ts

@@ -34,10 +34,10 @@ export declare const FeatureProbeStatusSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type FeatureProbeStatus = z.infer<typeof FeatureProbeStatusSchema>;
 export declare const featureProbeCapability: {
-    readonly name: "feature-probe";
-    readonly scope: "device";
+    readonly name: 'feature-probe';
+    readonly scope: 'device';
     readonly deviceNative: true;
-    readonly mode: "singleton";
+    readonly mode: 'singleton';
     readonly methods: {};
     readonly events: {
         /** Fires whenever a fresh probe completes (kernel-driven `reprobe()`
@@ -65,7 +65,7 @@ export declare const featureProbeCapability: {
             lastProbedAt: z.ZodNumber;
             lastFetchedAt: z.ZodNumber;
         }, z.core.$strip>;
-        readonly kind: "push";
+        readonly kind: 'push';
     };
     readonly runtimeState: z.ZodObject<{
         flags: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -81,6 +81,6 @@ export declare const featureProbeCapability: {
      * See `RuntimeStateDurability`. Enforced by
      * `scripts/check-runtime-state-durability.ts`.
      */
-    readonly durability: "session";
+    readonly durability: 'session';
 };
 export type IFeatureProbeProvider = InferProvider<typeof featureProbeCapability>;

package/dist/capabilities/filesystem-browse.cap.d.ts

@@ -9,9 +9,9 @@
 import { z } from 'zod';
 import { type InferProvider } from './capability-definition.js';
 export declare const filesystemBrowseCapability: {
-    readonly name: "filesystem-browse";
-    readonly scope: "system";
-    readonly mode: "singleton";
+    readonly name: 'filesystem-browse';
+    readonly scope: 'system';
+    readonly mode: 'singleton';
     readonly internal: true;
     readonly methods: {
         /** The roots `createDir` is sandboxed to on this node. Browsing is not confined to them. */

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

@@ -15,10 +15,10 @@ export declare const FloodStatusSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type FloodStatus = z.infer<typeof FloodStatusSchema>;
 export declare const floodCapability: {
-    readonly name: "flood";
-    readonly scope: "device";
+    readonly name: 'flood';
+    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 floodCapability: {
             flooded: z.ZodBoolean;
             lastChangedAt: z.ZodNumber;
         }, z.core.$strip>;
-        readonly kind: "push";
+        readonly kind: 'push';
     };
     readonly runtimeState: z.ZodObject<{
         flooded: z.ZodBoolean;
@@ -38,7 +38,7 @@ export declare const floodCapability: {
      * 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/gas.cap.d.ts

@@ -12,10 +12,10 @@ export declare const GasStatusSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type GasStatus = z.infer<typeof GasStatusSchema>;
 export declare const gasCapability: {
-    readonly name: "gas";
-    readonly scope: "device";
+    readonly name: 'gas';
+    readonly scope: 'device';
     readonly deviceNative: true;
-    readonly mode: "singleton";
+    readonly mode: 'singleton';
     readonly deviceTypes: readonly [DeviceType.Sensor];
     readonly methods: {};
     readonly status: {
@@ -23,7 +23,7 @@ export declare const gasCapability: {
             detected: z.ZodBoolean;
             lastChangedAt: z.ZodNumber;
         }, z.core.$strip>;
-        readonly kind: "push";
+        readonly kind: 'push';
     };
     readonly runtimeState: z.ZodObject<{
         detected: z.ZodBoolean;
@@ -35,7 +35,7 @@ export declare const gasCapability: {
      * 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/hub-address.d.ts

@@ -38,7 +38,7 @@
  */
 import type { z } from 'zod';
 import type { ConnectionEndpoint, HubAddressRoleSchema } from './local-network.cap.js';
-export declare const HUB_ADDRESS_ROLES: readonly ["appConnections", "notificationTaps", "internal", "publicEndpoint"];
+export declare const HUB_ADDRESS_ROLES: readonly ['appConnections', 'notificationTaps', 'internal', 'publicEndpoint'];
 export type HubAddressRole = z.infer<typeof HubAddressRoleSchema>;
 /** The roles at most one address carries. */
 export type SingleHubAddressRole = Exclude<HubAddressRole, 'appConnections'>;

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

@@ -29,10 +29,10 @@ export declare const HumidifierStatusSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type HumidifierStatus = z.infer<typeof HumidifierStatusSchema>;
 export declare const humidifierCapability: {
-    readonly name: "humidifier";
-    readonly scope: "device";
+    readonly name: 'humidifier';
+    readonly scope: 'device';
     readonly deviceNative: true;
-    readonly mode: "singleton";
+    readonly mode: 'singleton';
     readonly deviceTypes: readonly [DeviceType.Humidifier];
     readonly methods: {
         readonly setOn: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
@@ -60,7 +60,7 @@ export declare const humidifierCapability: {
             maxHumidity: z.ZodNullable<z.ZodNumber>;
             lastChangedAt: z.ZodNumber;
         }, z.core.$strip>;
-        readonly kind: "push";
+        readonly kind: 'push';
     };
     /**
      * Runtime-state slice — mirrored by the kernel. UI controls watch the
@@ -83,6 +83,6 @@ export declare const humidifierCapability: {
      * See `RuntimeStateDurability`. Enforced by
      * `scripts/check-runtime-state-durability.ts`.
      */
-    readonly durability: "session";
+    readonly durability: 'session';
 };
 export type IHumidifierProvider = InferProvider<typeof humidifierCapability>;

package/dist/capabilities/humidity-sensor.cap.d.ts

@@ -17,10 +17,10 @@ export declare const HumiditySensorStatusSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type HumiditySensorStatus = z.infer<typeof HumiditySensorStatusSchema>;
 export declare const humiditySensorCapability: {
-    readonly name: "humidity-sensor";
-    readonly scope: "device";
+    readonly name: 'humidity-sensor';
+    readonly scope: 'device';
     readonly deviceNative: true;
-    readonly mode: "singleton";
+    readonly mode: 'singleton';
     readonly deviceTypes: readonly [DeviceType.Sensor, DeviceType.Thermostat];
     readonly methods: {};
     readonly status: {
@@ -30,7 +30,7 @@ export declare const humiditySensorCapability: {
             unit: z.ZodOptional<z.ZodString>;
             precision: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>;
-        readonly kind: "push";
+        readonly kind: 'push';
     };
     readonly runtimeState: z.ZodObject<{
         percent: z.ZodNumber;
@@ -44,7 +44,7 @@ export declare const humiditySensorCapability: {
      * 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"];