@camstack/types 1.2.365 → 1.2.367

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

@@ -250,5 +250,9 @@ export declare const intercomCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): none — talk sessions are a ledger concern, not a trend.
+     */
+    readonly history: 'none';
 };
 export type IIntercomProvider = InferProvider<typeof intercomCapability>;

package/dist/capabilities/lawn-mower-control.cap.d.ts

@@ -116,5 +116,17 @@ export declare const lawnMowerControlCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): recorded series.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly batteryLevel: {
+                readonly kind: 'gauge';
+                readonly unit: '%';
+                readonly deadband: 2;
+            };
+        };
+    };
 };
 export type ILawnMowerControlProvider = InferProvider<typeof lawnMowerControlCapability>;

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

@@ -94,6 +94,10 @@ export declare const lockControlCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): none — enum state; lock events belong in the events ledger.
+     */
+    readonly history: 'none';
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastChangedAt"];

package/dist/capabilities/media-player.cap.d.ts

@@ -202,6 +202,10 @@ export declare const mediaPlayerCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): none — `positionMs` moves continuously while playing; volume is transient.
+     */
+    readonly history: 'none';
 };
 export type IMediaPlayerProvider = InferProvider<typeof mediaPlayerCapability>;
 export {};

package/dist/capabilities/motion-trigger.cap.d.ts

@@ -81,5 +81,9 @@ export declare const motionTriggerCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): none — configuration switch.
+     */
+    readonly history: 'none';
 };
 export type IMotionTriggerProvider = InferProvider<typeof motionTriggerCapability>;

package/dist/capabilities/motion-zones.cap.d.ts

@@ -167,6 +167,10 @@ export declare const motionZonesCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): none — configuration.
+     */
+    readonly history: 'none';
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastFetchedAt"];

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

@@ -168,5 +168,16 @@ export declare const motionCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): recorded series. A PIR sensor is a series; a camera is not (its motion is an addon series and a ledger).
+     */
+    readonly history: {
+        readonly fields: {
+            readonly detected: {
+                readonly kind: 'boolean';
+                readonly excludeDeviceTypes: readonly [DeviceType.Camera];
+            };
+        };
+    };
 };
 export type IMotionProvider = InferProvider<typeof motionCapability>;

package/dist/capabilities/native-object-detection.cap.d.ts

@@ -268,6 +268,10 @@ export declare const nativeObjectDetectionCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): none — event-like and nested per class; detections live in the objects ledger.
+     */
+    readonly history: 'none';
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastFetchedAt"];

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

@@ -459,5 +459,9 @@ export declare const navigationCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): none — control state of a robotic camera, configuration-like.
+     */
+    readonly history: 'none';
 };
 export type INavigationProvider = InferProvider<typeof navigationCapability>;

package/dist/capabilities/network-link.cap.d.ts

@@ -128,6 +128,25 @@ export declare const networkLinkCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): recorded series.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly signalPercent: {
+                readonly kind: 'gauge';
+                readonly unit: '%';
+                readonly deadband: 3;
+                readonly minIntervalMs: 60000;
+            };
+            readonly rssiDbm: {
+                readonly kind: 'gauge';
+                readonly unit: 'dBm';
+                readonly deadband: 2;
+                readonly minIntervalMs: 60000;
+            };
+        };
+    };
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastUpdated"];

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

@@ -174,6 +174,10 @@ export declare const notifierCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): none — `queueDepth` is outbox operational state, not a device trend.
+     */
+    readonly history: 'none';
 };
 export type INotifierProvider = InferProvider<typeof notifierCapability>;
 export {};

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

@@ -54,6 +54,18 @@ export declare const numericSensorCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): recorded series. The unit is per device, read from the sibling `unit` field.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly value: {
+                readonly kind: 'gauge';
+                readonly unitFrom: 'unit';
+                readonly minIntervalMs: 30000;
+            };
+        };
+    };
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastFetchedAt"];

package/dist/capabilities/pet-feeder.cap.d.ts

@@ -188,5 +188,30 @@ export declare const petFeederCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): recorded series.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly foodLevel: {
+                readonly kind: 'gauge';
+            };
+            readonly food1: {
+                readonly kind: 'gauge';
+            };
+            readonly food2: {
+                readonly kind: 'gauge';
+            };
+            readonly batteryPower: {
+                readonly kind: 'gauge';
+                readonly unit: '%';
+                readonly deadband: 2;
+            };
+            readonly desiccantLeftDays: {
+                readonly kind: 'gauge';
+                readonly unit: 'days';
+            };
+        };
+    };
 };
 export type IPetFeederProvider = InferProvider<typeof petFeederCapability>;

package/dist/capabilities/power-meter.cap.d.ts

@@ -67,6 +67,49 @@ export declare const powerMeterCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): recorded series. Gauges are floored at 30 s; `kwhTotal` is the one monotonic meter (counter).
+     */
+    readonly history: {
+        readonly fields: {
+            readonly watts: {
+                readonly kind: 'gauge';
+                readonly unit: 'W';
+                readonly deadband: 1;
+                readonly minIntervalMs: 30000;
+            };
+            readonly kwhTotal: {
+                readonly kind: 'counter';
+                readonly unit: 'kWh';
+                readonly deadband: 0.01;
+                readonly minIntervalMs: 60000;
+            };
+            readonly volts: {
+                readonly kind: 'gauge';
+                readonly unit: 'V';
+                readonly deadband: 1;
+                readonly minIntervalMs: 30000;
+            };
+            readonly amps: {
+                readonly kind: 'gauge';
+                readonly unit: 'A';
+                readonly deadband: 0.05;
+                readonly minIntervalMs: 30000;
+            };
+            readonly va: {
+                readonly kind: 'gauge';
+                readonly unit: 'VA';
+                readonly deadband: 1;
+                readonly minIntervalMs: 30000;
+            };
+            readonly powerFactor: {
+                readonly kind: 'gauge';
+                readonly unit: 'ratio';
+                readonly deadband: 0.01;
+                readonly minIntervalMs: 60000;
+            };
+        };
+    };
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastFetchedAt"];

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

@@ -80,6 +80,18 @@ export declare const presenceCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): recorded series.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly batteryPercent: {
+                readonly kind: 'gauge';
+                readonly unit: '%';
+                readonly deadband: 1;
+            };
+        };
+    };
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastChangedAt"];

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

@@ -45,6 +45,18 @@ export declare const pressureSensorCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): recorded series.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly hpa: {
+                readonly kind: 'gauge';
+                readonly unit: 'hPa';
+                readonly deadband: 0.1;
+            };
+        };
+    };
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastFetchedAt"];

package/dist/capabilities/privacy-mask.cap.d.ts

@@ -250,6 +250,10 @@ export declare const privacyMaskCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): none — configuration.
+     */
+    readonly history: 'none';
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastFetchedAt"];

package/dist/capabilities/ptz-autotrack.cap.d.ts

@@ -219,5 +219,9 @@ export declare const ptzAutotrackCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): none — configuration and capability.
+     */
+    readonly history: 'none';
 };
 export type IPtzAutotrackProvider = InferProvider<typeof ptzAutotrackCapability>;

package/dist/capabilities/recording-onboard.cap.d.ts

@@ -697,6 +697,10 @@ export declare const recordingOnboardCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): none — SD-card configuration and window inventory; arrays.
+     */
+    readonly history: 'none';
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastFetchedAt"];

package/dist/capabilities/recording-signal.cap.d.ts

@@ -87,5 +87,9 @@ export declare const recordingSignalCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): none — recording intent is already in the recordings ledger.
+     */
+    readonly history: 'none';
 };
 export type IRecordingSignalProvider = InferProvider<typeof recordingSignalCapability>;

package/dist/capabilities/scene-monitor.cap.d.ts

@@ -1125,5 +1125,9 @@ export declare const sceneMonitorCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): none — nested configuration.
+     */
+    readonly history: 'none';
 };
 export type ISceneMonitorProvider = InferNativeProvider<typeof sceneMonitorCapability>;

package/dist/capabilities/script-runner.cap.d.ts

@@ -64,5 +64,9 @@ export declare const scriptRunnerCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): none — transient; run results belong in a ledger.
+     */
+    readonly history: 'none';
 };
 export type IScriptRunnerProvider = InferProvider<typeof scriptRunnerCapability>;

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

@@ -40,6 +40,16 @@ export declare const smokeCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): recorded series.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly detected: {
+                readonly kind: 'boolean';
+            };
+        };
+    };
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastChangedAt"];

package/dist/capabilities/stream-catalog.cap.d.ts

@@ -191,6 +191,10 @@ export declare const streamCatalogCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): none — stream inventory.
+     */
+    readonly history: 'none';
     /** Clock field: written, but excluded from the compare that decides whether
      *  persisting is worth a SQLite commit — the descriptors are the value. */
     readonly volatileStateFields: readonly ["lastFetchedAt"];

package/dist/capabilities/stream-params.cap.d.ts

@@ -488,6 +488,10 @@ export declare const streamParamsCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): none — encoder configuration.
+     */
+    readonly history: 'none';
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastFetchedAt"];

package/dist/capabilities/stream-signals.cap.d.ts

@@ -79,6 +79,10 @@ export declare const streamSignalsCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): none — array state.
+     */
+    readonly history: 'none';
     readonly methods: {
         /**
          * What this device can emit. Empty is a valid and common answer — most

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

@@ -57,6 +57,16 @@ export declare const switchCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): recorded series.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly on: {
+                readonly kind: 'boolean';
+            };
+        };
+    };
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastChangedAt"];

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

@@ -35,6 +35,16 @@ export declare const tamperCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): recorded series.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly tampered: {
+                readonly kind: 'boolean';
+            };
+        };
+    };
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastChangedAt"];

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

@@ -53,6 +53,18 @@ export declare const temperatureSensorCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): recorded series.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly celsius: {
+                readonly kind: 'gauge';
+                readonly unit: '°C';
+                readonly deadband: 0.1;
+            };
+        };
+    };
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastFetchedAt"];

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

@@ -51,5 +51,9 @@ export declare const updateCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): none — text and state.
+     */
+    readonly history: 'none';
 };
 export type IUpdateProvider = InferProvider<typeof updateCapability>;

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

@@ -244,5 +244,37 @@ export declare const vacuumControlCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): recorded series. Tank levels are fixed-object paths (`cleanWater.level`, ...).
+     */
+    readonly history: {
+        readonly fields: {
+            readonly batteryLevel: {
+                readonly kind: 'gauge';
+                readonly unit: '%';
+                readonly deadband: 2;
+            };
+            readonly 'cleanWater.level': {
+                readonly kind: 'gauge';
+                readonly unit: '%';
+                readonly deadband: 2;
+            };
+            readonly 'dirtyWater.level': {
+                readonly kind: 'gauge';
+                readonly unit: '%';
+                readonly deadband: 2;
+            };
+            readonly 'detergent.level': {
+                readonly kind: 'gauge';
+                readonly unit: '%';
+                readonly deadband: 2;
+            };
+            readonly 'dustBin.level': {
+                readonly kind: 'gauge';
+                readonly unit: '%';
+                readonly deadband: 2;
+            };
+        };
+    };
 };
 export type IVacuumControlProvider = InferProvider<typeof vacuumControlCapability>;

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

@@ -95,5 +95,17 @@ export declare const valveCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): recorded series. Actuator tier: position keeps every change.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly position: {
+                readonly kind: 'gauge';
+                readonly unit: '%';
+                readonly minIntervalMs: 0;
+            };
+        };
+    };
 };
 export type IValveProvider = InferProvider<typeof valveCapability>;

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

@@ -35,6 +35,16 @@ export declare const vibrationCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): recorded series.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly detected: {
+                readonly kind: 'boolean';
+            };
+        };
+    };
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastChangedAt"];

package/dist/capabilities/water-heater.cap.d.ts

@@ -80,5 +80,22 @@ export declare const waterHeaterCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): recorded series. The schema carries no unit; providers publish Celsius. Setpoint keeps every change.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly currentTemp: {
+                readonly kind: 'gauge';
+                readonly unit: '°C';
+                readonly deadband: 0.5;
+            };
+            readonly targetTemp: {
+                readonly kind: 'gauge';
+                readonly unit: '°C';
+                readonly minIntervalMs: 0;
+            };
+        };
+    };
 };
 export type IWaterHeaterProvider = InferProvider<typeof waterHeaterCapability>;

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

@@ -78,5 +78,32 @@ export declare const weatherCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): recorded series. Units follow the sibling `*Unit` fields.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly temperature: {
+                readonly kind: 'gauge';
+                readonly unitFrom: 'temperatureUnit';
+                readonly deadband: 0.2;
+            };
+            readonly humidity: {
+                readonly kind: 'gauge';
+                readonly unit: '%';
+                readonly deadband: 1;
+            };
+            readonly pressure: {
+                readonly kind: 'gauge';
+                readonly unitFrom: 'pressureUnit';
+                readonly deadband: 0.5;
+            };
+            readonly windSpeed: {
+                readonly kind: 'gauge';
+                readonly unitFrom: 'windSpeedUnit';
+                readonly deadband: 0.5;
+            };
+        };
+    };
 };
 export type IWeatherProvider = InferProvider<typeof weatherCapability>;

package/dist/capabilities/zone-analytics.cap.d.ts

@@ -462,6 +462,10 @@ export declare const zoneAnalyticsCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): none — occupancy is the addon series `pipeline-analytics/occupancy`; the rest is per-zone arrays keyed by runtime ids.
+     */
+    readonly history: 'none';
 };
 export type IZoneAnalyticsProvider = InferProvider<typeof zoneAnalyticsCapability>;
 export { CameraOccupancySnapshotSchema as _CameraOccupancySnapshotSchema, HistoryPointSchema, HistoryRangeSchema, HistoryResolutionEnum, PerScopeBreakdownSchema, StationaryObjectSchema, ZoneScopeBreakdownSchema, };

package/dist/capabilities/zone-rules.cap.d.ts

@@ -156,5 +156,9 @@ export declare const zoneRulesCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): none — configuration arrays.
+     */
+    readonly history: 'none';
 };
 export type IZoneRulesProvider = InferProvider<typeof zoneRulesCapability>;

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

@@ -153,5 +153,9 @@ export declare const zonesCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): none — configuration arrays.
+     */
+    readonly history: 'none';
 };
 export type IZonesProvider = InferProvider<typeof zonesCapability>;