@camstack/types 1.2.162 → 1.2.164

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

@@ -29,10 +29,20 @@ declare const BeginUploadInputSchema: z.ZodObject<{
         nodeId: z.ZodOptional<z.ZodString>;
         isSystem: z.ZodDefault<z.ZodBoolean>;
         enabled: z.ZodOptional<z.ZodBoolean>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            readonly: "readonly";
+            active: "active";
+            drain: "drain";
+            disabled: "disabled";
+        }>>;
         capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
             totalBytes: z.ZodNumber;
             availableBytes: z.ZodNumber;
         }, z.core.$strip>>>;
+        owned: z.ZodOptional<z.ZodObject<{
+            bytes: z.ZodNumber;
+            measuredAtMs: z.ZodNumber;
+        }, z.core.$strip>>;
         createdAt: z.ZodNumber;
         updatedAt: z.ZodNumber;
     }, z.core.$strip>;
@@ -63,10 +73,20 @@ declare const BeginDownloadInputSchema: z.ZodObject<{
         nodeId: z.ZodOptional<z.ZodString>;
         isSystem: z.ZodDefault<z.ZodBoolean>;
         enabled: z.ZodOptional<z.ZodBoolean>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            readonly: "readonly";
+            active: "active";
+            drain: "drain";
+            disabled: "disabled";
+        }>>;
         capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
             totalBytes: z.ZodNumber;
             availableBytes: z.ZodNumber;
         }, z.core.$strip>>>;
+        owned: z.ZodOptional<z.ZodObject<{
+            bytes: z.ZodNumber;
+            measuredAtMs: z.ZodNumber;
+        }, z.core.$strip>>;
         createdAt: z.ZodNumber;
         updatedAt: z.ZodNumber;
     }, z.core.$strip>;
@@ -158,10 +178,20 @@ export declare const storageProviderCapability: {
                 nodeId: z.ZodOptional<z.ZodString>;
                 isSystem: z.ZodDefault<z.ZodBoolean>;
                 enabled: z.ZodOptional<z.ZodBoolean>;
+                mode: z.ZodOptional<z.ZodEnum<{
+                    readonly: "readonly";
+                    active: "active";
+                    drain: "drain";
+                    disabled: "disabled";
+                }>>;
                 capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                     totalBytes: z.ZodNumber;
                     availableBytes: z.ZodNumber;
                 }, z.core.$strip>>>;
+                owned: z.ZodOptional<z.ZodObject<{
+                    bytes: z.ZodNumber;
+                    measuredAtMs: z.ZodNumber;
+                }, z.core.$strip>>;
                 createdAt: z.ZodNumber;
                 updatedAt: z.ZodNumber;
             }, z.core.$strip>;
@@ -177,10 +207,20 @@ export declare const storageProviderCapability: {
                 nodeId: z.ZodOptional<z.ZodString>;
                 isSystem: z.ZodDefault<z.ZodBoolean>;
                 enabled: z.ZodOptional<z.ZodBoolean>;
+                mode: z.ZodOptional<z.ZodEnum<{
+                    readonly: "readonly";
+                    active: "active";
+                    drain: "drain";
+                    disabled: "disabled";
+                }>>;
                 capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                     totalBytes: z.ZodNumber;
                     availableBytes: z.ZodNumber;
                 }, z.core.$strip>>>;
+                owned: z.ZodOptional<z.ZodObject<{
+                    bytes: z.ZodNumber;
+                    measuredAtMs: z.ZodNumber;
+                }, z.core.$strip>>;
                 createdAt: z.ZodNumber;
                 updatedAt: z.ZodNumber;
             }, z.core.$strip>;
@@ -197,10 +237,20 @@ export declare const storageProviderCapability: {
                 nodeId: z.ZodOptional<z.ZodString>;
                 isSystem: z.ZodDefault<z.ZodBoolean>;
                 enabled: z.ZodOptional<z.ZodBoolean>;
+                mode: z.ZodOptional<z.ZodEnum<{
+                    readonly: "readonly";
+                    active: "active";
+                    drain: "drain";
+                    disabled: "disabled";
+                }>>;
                 capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                     totalBytes: z.ZodNumber;
                     availableBytes: z.ZodNumber;
                 }, z.core.$strip>>>;
+                owned: z.ZodOptional<z.ZodObject<{
+                    bytes: z.ZodNumber;
+                    measuredAtMs: z.ZodNumber;
+                }, z.core.$strip>>;
                 createdAt: z.ZodNumber;
                 updatedAt: z.ZodNumber;
             }, z.core.$strip>;
@@ -216,10 +266,20 @@ export declare const storageProviderCapability: {
                 nodeId: z.ZodOptional<z.ZodString>;
                 isSystem: z.ZodDefault<z.ZodBoolean>;
                 enabled: z.ZodOptional<z.ZodBoolean>;
+                mode: z.ZodOptional<z.ZodEnum<{
+                    readonly: "readonly";
+                    active: "active";
+                    drain: "drain";
+                    disabled: "disabled";
+                }>>;
                 capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                     totalBytes: z.ZodNumber;
                     availableBytes: z.ZodNumber;
                 }, z.core.$strip>>>;
+                owned: z.ZodOptional<z.ZodObject<{
+                    bytes: z.ZodNumber;
+                    measuredAtMs: z.ZodNumber;
+                }, z.core.$strip>>;
                 createdAt: z.ZodNumber;
                 updatedAt: z.ZodNumber;
             }, z.core.$strip>;
@@ -235,10 +295,20 @@ export declare const storageProviderCapability: {
                 nodeId: z.ZodOptional<z.ZodString>;
                 isSystem: z.ZodDefault<z.ZodBoolean>;
                 enabled: z.ZodOptional<z.ZodBoolean>;
+                mode: z.ZodOptional<z.ZodEnum<{
+                    readonly: "readonly";
+                    active: "active";
+                    drain: "drain";
+                    disabled: "disabled";
+                }>>;
                 capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                     totalBytes: z.ZodNumber;
                     availableBytes: z.ZodNumber;
                 }, z.core.$strip>>>;
+                owned: z.ZodOptional<z.ZodObject<{
+                    bytes: z.ZodNumber;
+                    measuredAtMs: z.ZodNumber;
+                }, z.core.$strip>>;
                 createdAt: z.ZodNumber;
                 updatedAt: z.ZodNumber;
             }, z.core.$strip>;
@@ -254,10 +324,20 @@ export declare const storageProviderCapability: {
                 nodeId: z.ZodOptional<z.ZodString>;
                 isSystem: z.ZodDefault<z.ZodBoolean>;
                 enabled: z.ZodOptional<z.ZodBoolean>;
+                mode: z.ZodOptional<z.ZodEnum<{
+                    readonly: "readonly";
+                    active: "active";
+                    drain: "drain";
+                    disabled: "disabled";
+                }>>;
                 capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                     totalBytes: z.ZodNumber;
                     availableBytes: z.ZodNumber;
                 }, z.core.$strip>>>;
+                owned: z.ZodOptional<z.ZodObject<{
+                    bytes: z.ZodNumber;
+                    measuredAtMs: z.ZodNumber;
+                }, z.core.$strip>>;
                 createdAt: z.ZodNumber;
                 updatedAt: z.ZodNumber;
             }, z.core.$strip>;
@@ -273,10 +353,20 @@ export declare const storageProviderCapability: {
                 nodeId: z.ZodOptional<z.ZodString>;
                 isSystem: z.ZodDefault<z.ZodBoolean>;
                 enabled: z.ZodOptional<z.ZodBoolean>;
+                mode: z.ZodOptional<z.ZodEnum<{
+                    readonly: "readonly";
+                    active: "active";
+                    drain: "drain";
+                    disabled: "disabled";
+                }>>;
                 capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                     totalBytes: z.ZodNumber;
                     availableBytes: z.ZodNumber;
                 }, z.core.$strip>>>;
+                owned: z.ZodOptional<z.ZodObject<{
+                    bytes: z.ZodNumber;
+                    measuredAtMs: z.ZodNumber;
+                }, z.core.$strip>>;
                 createdAt: z.ZodNumber;
                 updatedAt: z.ZodNumber;
             }, z.core.$strip>;
@@ -291,10 +381,20 @@ export declare const storageProviderCapability: {
                 nodeId: z.ZodOptional<z.ZodString>;
                 isSystem: z.ZodDefault<z.ZodBoolean>;
                 enabled: z.ZodOptional<z.ZodBoolean>;
+                mode: z.ZodOptional<z.ZodEnum<{
+                    readonly: "readonly";
+                    active: "active";
+                    drain: "drain";
+                    disabled: "disabled";
+                }>>;
                 capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                     totalBytes: z.ZodNumber;
                     availableBytes: z.ZodNumber;
                 }, z.core.$strip>>>;
+                owned: z.ZodOptional<z.ZodObject<{
+                    bytes: z.ZodNumber;
+                    measuredAtMs: z.ZodNumber;
+                }, z.core.$strip>>;
                 createdAt: z.ZodNumber;
                 updatedAt: z.ZodNumber;
             }, z.core.$strip>;
@@ -324,10 +424,20 @@ export declare const storageProviderCapability: {
                 nodeId: z.ZodOptional<z.ZodString>;
                 isSystem: z.ZodDefault<z.ZodBoolean>;
                 enabled: z.ZodOptional<z.ZodBoolean>;
+                mode: z.ZodOptional<z.ZodEnum<{
+                    readonly: "readonly";
+                    active: "active";
+                    drain: "drain";
+                    disabled: "disabled";
+                }>>;
                 capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                     totalBytes: z.ZodNumber;
                     availableBytes: z.ZodNumber;
                 }, z.core.$strip>>>;
+                owned: z.ZodOptional<z.ZodObject<{
+                    bytes: z.ZodNumber;
+                    measuredAtMs: z.ZodNumber;
+                }, z.core.$strip>>;
                 createdAt: z.ZodNumber;
                 updatedAt: z.ZodNumber;
             }, z.core.$strip>;

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

@@ -96,10 +96,20 @@ export declare const storageCapability: {
             nodeId: z.ZodOptional<z.ZodString>;
             isSystem: z.ZodDefault<z.ZodBoolean>;
             enabled: z.ZodOptional<z.ZodBoolean>;
+            mode: z.ZodOptional<z.ZodEnum<{
+                readonly: "readonly";
+                active: "active";
+                drain: "drain";
+                disabled: "disabled";
+            }>>;
             capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                 totalBytes: z.ZodNumber;
                 availableBytes: z.ZodNumber;
             }, z.core.$strip>>>;
+            owned: z.ZodOptional<z.ZodObject<{
+                bytes: z.ZodNumber;
+                measuredAtMs: z.ZodNumber;
+            }, z.core.$strip>>;
             createdAt: z.ZodNumber;
             updatedAt: z.ZodNumber;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
@@ -131,10 +141,20 @@ export declare const storageCapability: {
             providerId: z.ZodString;
             config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
             isSystem: z.ZodDefault<z.ZodBoolean>;
+            mode: z.ZodOptional<z.ZodEnum<{
+                readonly: "readonly";
+                active: "active";
+                drain: "drain";
+                disabled: "disabled";
+            }>>;
             capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                 totalBytes: z.ZodNumber;
                 availableBytes: z.ZodNumber;
             }, z.core.$strip>>>;
+            owned: z.ZodOptional<z.ZodObject<{
+                bytes: z.ZodNumber;
+                measuredAtMs: z.ZodNumber;
+            }, z.core.$strip>>;
         }, z.core.$strip>, z.ZodObject<{
             id: z.ZodString;
             type: z.ZodString;
@@ -144,10 +164,20 @@ export declare const storageCapability: {
             nodeId: z.ZodOptional<z.ZodString>;
             isSystem: z.ZodDefault<z.ZodBoolean>;
             enabled: z.ZodOptional<z.ZodBoolean>;
+            mode: z.ZodOptional<z.ZodEnum<{
+                readonly: "readonly";
+                active: "active";
+                drain: "drain";
+                disabled: "disabled";
+            }>>;
             capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                 totalBytes: z.ZodNumber;
                 availableBytes: z.ZodNumber;
             }, z.core.$strip>>>;
+            owned: z.ZodOptional<z.ZodObject<{
+                bytes: z.ZodNumber;
+                measuredAtMs: z.ZodNumber;
+            }, z.core.$strip>>;
             createdAt: z.ZodNumber;
             updatedAt: z.ZodNumber;
         }, z.core.$strip>, "mutation">;
@@ -169,6 +199,19 @@ export declare const storageCapability: {
             id: z.ZodString;
             force: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /**
+         * How far each draining location has got (D386). A pure READ of what the
+         * last pressure sweep computed — it starts no work, and a location that is
+         * not draining simply does not appear.
+         */
+        readonly listDrainProgress: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            locationId: z.ZodString;
+            startedAtMs: z.ZodNumber;
+            startBytes: z.ZodNumber;
+            bytesRemaining: z.ZodNumber;
+            drained: z.ZodBoolean;
+            estimatedEmptyAtMs: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         readonly testLocation: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             id: z.ZodString;
         }, z.core.$strip>, z.ZodObject<{

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

@@ -294,10 +294,10 @@ export type BrokerDecodedClient = z.infer<typeof BrokerDecodedClientSchema>;
 export type BrokerAudioClient = z.infer<typeof BrokerAudioClientSchema>;
 export type BrokerClients = z.infer<typeof BrokerClientsSchema>;
 export declare const PlaceholderReasonSchema: z.ZodEnum<{
+    disabled: "disabled";
     sleeping: "sleeping";
     reconnecting: "reconnecting";
     offline: "offline";
-    disabled: "disabled";
     waking: "waking";
 }>;
 export type PlaceholderReason = z.infer<typeof PlaceholderReasonSchema>;

package/dist/device/device-profile.d.ts

@@ -105,7 +105,7 @@ export interface DeviceProfileDefaults {
      *  explicitly to enable SW motion). PIR-sourced motion currently
      *  flows through `'onboard'` because Reolink's accessory PIRs feed
      *  the parent camera's firmware motion event channel. */
-    readonly motionSources?: readonly ('onboard' | 'analyzer')[];
+    readonly motionSources?: import('../capabilities/pipeline-runner.cap.js').MotionSources;
     readonly audioMode?: PipelinePhaseMode;
     readonly detectionMode?: PipelinePhaseMode;
 }

package/dist/enums/event-category.d.ts

@@ -192,6 +192,19 @@ export declare enum EventCategory {
     ProcessCrashed = "process.crashed",
     ProcessRestartScheduled = "process.restart_scheduled",
     ProcessRestarted = "process.restarted",
+    /**
+     * The SET of storage locations changed — one was created, edited, enabled,
+     * disabled or deleted through `storage.upsertLocation` / `deleteLocation`.
+     *
+     * Telemetry, not a transaction (D8/D11): every consumer that re-resolves on
+     * it must also converge on its own periodic path, because a dropped event
+     * must not leave a node writing to yesterday's disk set forever. It exists
+     * because there was NO signal at all — an operator who added a second
+     * recordings disk in the admin UI got nothing, and the recorder kept its
+     * resolved locations until something else happened to re-resolve them
+     * (D387). Payload `StorageLocationsChangedPayload`.
+     */
+    StorageLocationsChanged = "storage.locations-changed",
     RecordingStarted = "recording.started",
     RecordingStopped = "recording.stopped",
     RecordingError = "recording.error",

package/dist/enums.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_event_category = require("./event-category-b8kBSOTT.js");
+const require_event_category = require("./event-category-BVo6ta6_.js");
 //#region src/enums/event-source-type.ts
 var EventSourceType = /* @__PURE__ */ function(EventSourceType) {
 	EventSourceType["Addon"] = "addon";

package/dist/enums.mjs

@@ -1,4 +1,4 @@
-import { t as EventCategory } from "./event-category-zAv7pMUz.mjs";
+import { t as EventCategory } from "./event-category-CnLqLOKs.mjs";
 //#region src/enums/event-source-type.ts
 var EventSourceType = /* @__PURE__ */ function(EventSourceType) {
 	EventSourceType["Addon"] = "addon";

package/dist/{event-category-b8kBSOTT.js → event-category-BVo6ta6_.js}

@@ -193,6 +193,19 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["ProcessCrashed"] = "process.crashed";
 	EventCategory["ProcessRestartScheduled"] = "process.restart_scheduled";
 	EventCategory["ProcessRestarted"] = "process.restarted";
+	/**
+	* The SET of storage locations changed — one was created, edited, enabled,
+	* disabled or deleted through `storage.upsertLocation` / `deleteLocation`.
+	*
+	* Telemetry, not a transaction (D8/D11): every consumer that re-resolves on
+	* it must also converge on its own periodic path, because a dropped event
+	* must not leave a node writing to yesterday's disk set forever. It exists
+	* because there was NO signal at all — an operator who added a second
+	* recordings disk in the admin UI got nothing, and the recorder kept its
+	* resolved locations until something else happened to re-resolve them
+	* (D387). Payload `StorageLocationsChangedPayload`.
+	*/
+	EventCategory["StorageLocationsChanged"] = "storage.locations-changed";
 	EventCategory["RecordingStarted"] = "recording.started";
 	EventCategory["RecordingStopped"] = "recording.stopped";
 	EventCategory["RecordingError"] = "recording.error";

package/dist/{event-category-zAv7pMUz.mjs → event-category-CnLqLOKs.mjs}

@@ -193,6 +193,19 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["ProcessCrashed"] = "process.crashed";
 	EventCategory["ProcessRestartScheduled"] = "process.restart_scheduled";
 	EventCategory["ProcessRestarted"] = "process.restarted";
+	/**
+	* The SET of storage locations changed — one was created, edited, enabled,
+	* disabled or deleted through `storage.upsertLocation` / `deleteLocation`.
+	*
+	* Telemetry, not a transaction (D8/D11): every consumer that re-resolves on
+	* it must also converge on its own periodic path, because a dropped event
+	* must not leave a node writing to yesterday's disk set forever. It exists
+	* because there was NO signal at all — an operator who added a second
+	* recordings disk in the admin UI got nothing, and the recorder kept its
+	* resolved locations until something else happened to re-resolve them
+	* (D387). Payload `StorageLocationsChangedPayload`.
+	*/
+	EventCategory["StorageLocationsChanged"] = "storage.locations-changed";
 	EventCategory["RecordingStarted"] = "recording.started";
 	EventCategory["RecordingStopped"] = "recording.stopped";
 	EventCategory["RecordingError"] = "recording.error";

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

@@ -104,6 +104,7 @@ import type { snapshotCapability } from '../capabilities/snapshot.cap.js';
 import type { ssoBridgeCapability } from '../capabilities/sso-bridge.cap.js';
 import type { storageEvictableCapability } from '../capabilities/storage-evictable.cap.js';
 import type { storageMigrationCapability } from '../capabilities/storage-migration.cap.js';
+import type { storageOccupancyCapability } from '../capabilities/storage-occupancy.cap.js';
 import type { storageProviderCapability } from '../capabilities/storage-provider.cap.js';
 import type { storageCapability } from '../capabilities/storage.cap.js';
 import type { streamBrokerCapability } from '../capabilities/stream-broker.cap.js';
@@ -7415,6 +7416,13 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof storageCapability.methods.deleteLocation.output>;
             meta: object;
         }>;
+        listDrainProgress: TRPCQueryProcedure<{
+            input: {
+                nodeId?: string | undefined;
+            } | undefined;
+            output: z.infer<typeof storageCapability.methods.listDrainProgress.output>;
+            meta: object;
+        }>;
         testLocation: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
@@ -7542,6 +7550,20 @@ export type AppRouter = TrpcCoreRouter<{
             meta: object;
         }>;
     }>>;
+    storageOccupancy: TRPCBuiltRouter<{
+        ctx: TrpcContext;
+        meta: object;
+        errorShape: AugmentedErrorShape;
+        transformer: true;
+    }, TRPCDecorateCreateRouterOptions<{
+        getOccupancy: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof storageOccupancyCapability.methods.getOccupancy.input>;
+            output: z.infer<typeof storageOccupancyCapability.methods.getOccupancy.output>;
+            meta: object;
+        }>;
+    }>>;
     storageProvider: TRPCBuiltRouter<{
         ctx: TrpcContext;
         meta: object;

package/dist/generated/capability-router-map.d.ts

@@ -127,6 +127,7 @@ export { ssoBridgeCapability } from '../capabilities/sso-bridge.cap.js';
 export { storageCapability } from '../capabilities/storage.cap.js';
 export { storageEvictableCapability } from '../capabilities/storage-evictable.cap.js';
 export { storageMigrationCapability } from '../capabilities/storage-migration.cap.js';
+export { storageOccupancyCapability } from '../capabilities/storage-occupancy.cap.js';
 export { storageProviderCapability } from '../capabilities/storage-provider.cap.js';
 export { streamBrokerCapability } from '../capabilities/stream-broker.cap.js';
 export { streamCatalogCapability } from '../capabilities/stream-catalog.cap.js';
@@ -283,6 +284,7 @@ export declare const CAPABILITY_NAMES: {
     readonly storage: "storage";
     readonly storageEvictable: "storage-evictable";
     readonly storageMigration: "storage-migration";
+    readonly storageOccupancy: "storage-occupancy";
     readonly storageProvider: "storage-provider";
     readonly streamBroker: "stream-broker";
     readonly streamCatalog: "stream-catalog";
@@ -452,6 +454,7 @@ export interface CapabilityRouterMap<TRouter = unknown> {
     readonly storage: TRouter;
     readonly storageEvictable: TRouter;
     readonly storageMigration: TRouter;
+    readonly storageOccupancy: TRouter;
     readonly storageProvider: TRouter;
     readonly streamBroker: TRouter;
     readonly streamCatalog: TRouter;
@@ -483,8 +486,8 @@ export interface CapabilityRouterMap<TRouter = unknown> {
 export declare const SINGLETON_CAPABILITY_NAMES: readonly ["accessories", "addon-pages", "addon-settings", "addon-widgets", "addons", "admin-ui", "air-quality-sensor", "alarm-panel", "alerts", "ambient-light-sensor", "audio-analysis", "audio-analyzer", "audio-codec", "audio-metrics", "automation-control", "backup", "battery", "binary", "brightness", "button", "camera-credentials", "camera-pipeline-config", "camera-streams", "carbon-monoxide", "climate-control", "color", "connectivity", "consumables", "contact", "control", "core-blocks", "cover", "day-night", "decoder", "detection-pipeline", "device-adoption", "device-discovery", "device-manager", "device-ops", "device-state", "device-status", "doorbell", "enum-sensor", "event-emitter", "events", "face-gallery", "fan-control", "feature-probe", "filesystem-browse", "flood", "gas", "humidifier", "humidity-sensor", "image", "image-settings", "integrations", "intercom", "lawn-mower-control", "llm-runtime", "local-network", "lock-control", "media-player", "metrics-provider", "model-convert", "model-distributor", "motion", "motion-detection", "motion-trigger", "motion-zones", "native-object-detection", "navigation", "network-link", "network-quality", "nodes", "notification-rules", "notifier", "numeric-sensor", "osd", "osd-manager", "pet-feeder", "pipeline-analytics", "pipeline-executor", "pipeline-orchestrator", "pipeline-runner", "plate-gallery", "platform-probe", "power-meter", "presence", "pressure-sensor", "privacy-mask", "ptz", "ptz-autotrack", "reboot", "recording", "recording-export", "recording-signal", "scene-monitor", "script-runner", "server-management", "settings-store", "smoke", "snapshot", "sso-bridge", "storage", "storage-migration", "stream-broker", "stream-catalog", "stream-params", "switch", "system", "tamper", "temperature-sensor", "terminal-session", "toast", "update", "user-management", "vacuum-control", "valve", "vector-store", "vibration", "videoclips", "viewer-ui", "water-heater", "weather", "webrtc-session", "zone-analytics", "zone-rules", "zones"];
 /** Union of singleton capability names (literal string union). */
 export type SingletonCapabilityName = typeof SINGLETON_CAPABILITY_NAMES[number];
-/** Capability names whose mode is `collection` (27 caps). */
-export declare const COLLECTION_CAPABILITY_NAMES: readonly ["addon-pages-source", "addon-routes", "addon-widgets-source", "auth-provider", "broker", "connection-test", "custom-model-registry", "data-store-provider", "device-export", "device-provider", "embedding-encoder", "failure-contribution", "llm", "load-contribution", "log-channels", "log-destination", "login-method", "mesh-network", "mqtt-broker", "network-access", "notification-output", "oauth-integration", "smtp-provider", "storage-evictable", "storage-provider", "turn-provider", "user-passkeys"];
+/** Capability names whose mode is `collection` (28 caps). */
+export declare const COLLECTION_CAPABILITY_NAMES: readonly ["addon-pages-source", "addon-routes", "addon-widgets-source", "auth-provider", "broker", "connection-test", "custom-model-registry", "data-store-provider", "device-export", "device-provider", "embedding-encoder", "failure-contribution", "llm", "load-contribution", "log-channels", "log-destination", "login-method", "mesh-network", "mqtt-broker", "network-access", "notification-output", "oauth-integration", "smtp-provider", "storage-evictable", "storage-occupancy", "storage-provider", "turn-provider", "user-passkeys"];
 /** Union of collection capability names (literal string union). */
 export type CollectionCapabilityName = typeof COLLECTION_CAPABILITY_NAMES[number];
 /** Capability mode lookup at runtime — mirrors the `.cap.ts` definitions. */

package/dist/generated/collection-array-methods.d.ts

@@ -8,7 +8,7 @@
  * barrel (`ALL_CAPABILITY_DEFINITIONS`), which would cost ~144MB RSS per
  * forked runner. See docs/decisions/adr-0028.md.
  *
- * Coverage: 20 collection caps, 33 array methods.
+ * Coverage: 21 collection caps, 34 array methods.
  */
 export declare const COLLECTION_ARRAY_METHODS: Readonly<Record<string, readonly string[]>>;
 /**

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

@@ -6,7 +6,7 @@
  * scope+access check inside `protectedProcedure` (see
  * `server/backend/src/api/trpc/trpc.middleware.ts`).
  *
- * Coverage: 1019 method paths across 128 capabilities.
+ * Coverage: 1021 method paths across 129 capabilities.
  */
 import type { CapabilityMethodAccess } from '../capabilities/capability-definition.js';
 export interface MethodAccessRecord {

package/dist/generated/system-proxy.d.ts

@@ -91,7 +91,7 @@ export interface SystemProxy {
     readonly recordingExport: Pick<InferProvider<typeof recordingExportCapability>, 'createExport' | 'getExport' | 'cancelExport' | 'deleteExport' | 'getDownloadUrl' | 'readExportBytes'>;
     readonly serverManagement: Pick<InferProvider<typeof serverManagementCapability>, 'getServerPackageStatus' | 'checkServerUpdate' | 'applyServerUpdate' | 'rollbackServerUpdate' | 'restartServer'>;
     readonly settingsStore: Pick<InferProvider<typeof settingsStoreCapability>, 'get' | 'set' | 'query' | 'insert' | 'insertMany' | 'update' | 'delete' | 'deleteWhere' | 'updateWhere' | 'count' | 'aggregate' | 'histogram' | 'isEmpty' | 'declareCollection'>;
-    readonly storage: Pick<InferProvider<typeof storageCapability>, 'resolve' | 'write' | 'read' | 'exists' | 'list' | 'delete' | 'getAvailableSpace' | 'beginUpload' | 'writeChunk' | 'finalizeUpload' | 'abortUpload' | 'beginDownload' | 'readChunk' | 'endDownload' | 'listLocations' | 'listLocationDeclarations' | 'upsertLocation' | 'deleteLocation' | 'testLocation' | 'listProviders' | 'testConfig'>;
+    readonly storage: Pick<InferProvider<typeof storageCapability>, 'resolve' | 'write' | 'read' | 'exists' | 'list' | 'delete' | 'getAvailableSpace' | 'beginUpload' | 'writeChunk' | 'finalizeUpload' | 'abortUpload' | 'beginDownload' | 'readChunk' | 'endDownload' | 'listLocations' | 'listLocationDeclarations' | 'upsertLocation' | 'deleteLocation' | 'listDrainProgress' | 'testLocation' | 'listProviders' | 'testConfig'>;
     readonly storageMigration: Pick<InferProvider<typeof storageMigrationCapability>, 'plan' | 'start' | 'status' | 'cancel' | 'movers' | 'residue' | 'drain' | 'cleanupStart' | 'cleanupStatus' | 'cleanupCancel' | 'history'>;
     readonly streamBroker: Pick<InferProvider<typeof streamBrokerCapability>, 'fetchEventMedia' | 'listAllCameraStreams' | 'listAllProfileSlots' | 'getBrokerStats' | 'probeStream' | 'listClients' | 'killClient' | 'getStreamUrl' | 'getStreamWithCodec' | 'releaseStreamWithCodec' | 'acquireEgressTranscode' | 'releaseEgressTranscode' | 'subscribeAudioChunks' | 'pullAudioChunks' | 'unsubscribeAudioChunks' | 'subscribeFrames' | 'pullFrameHandles' | 'unsubscribeFrames' | 'setPreBufferDuration' | 'getPreBufferInfo' | 'getRtspPort' | 'getAllRtspEntries' | 'getRtspEntry' | 'regenerateRtspToken' | 'setRtspEnabled' | 'isRtspEnabled'>;
     readonly system: Pick<InferProvider<typeof systemCapability>, 'info' | 'health' | 'featureFlags' | 'networkAddresses' | 'getRetentionConfig' | 'setRetentionConfig' | 'forceRetentionCleanup' | 'getSiteLocation' | 'setSiteLocation' | 'detectSiteLocation' | 'getRequestCensus' | 'getLoadContributions' | 'getFailureContributions' | 'getLoggingSettings' | 'setLoggingSettings'>;

package/dist/index.d.ts

@@ -86,10 +86,12 @@ export type * from './interfaces/server-analysis.js';
 export * from './interfaces/server-analysis.js';
 export type * from './interfaces/server-network.js';
 export type * from './interfaces/storage.js';
-export type { LegacyStorageLocationDefault, StorageLocation, StorageLocationRef, } from './interfaces/storage-location.js';
-export { isLocationEnabled, LegacyStorageLocationDefaultSchema, StorageLocationRefSchema, StorageLocationSchema, StorageLocationTypeSchema, } from './interfaces/storage-location.js';
+export type { LegacyStorageLocationDefault, StorageDrainProgress, StorageLocation, StorageLocationRef, } from './interfaces/storage-location.js';
+export { gbToBytes, isLocationEnabled, LegacyStorageLocationDefaultSchema, STORAGE_BYTES_PER_GB, StorageDrainProgressSchema, StorageLocationRefSchema, StorageLocationSchema, StorageLocationTypeSchema, } from './interfaces/storage-location.js';
 export type { StorageAccess, StorageLocationDeclaration, } from './interfaces/storage-location-declaration.js';
 export { STORAGE_ACCESS_FALLBACK, StorageAccessSchema, StorageLocationDeclarationSchema, } from './interfaces/storage-location-declaration.js';
+export type { StorageEvictionPolicy, StorageLocationMode, StorageLocationModePatch, StorageLocationStateSource, } from './interfaces/storage-location-mode.js';
+export { evictionPolicyForMode, evictionPolicyOfLocation, isStorageLocationMode, LEGACY_READ_ONLY_CONFIG_KEY, legacyModeOf, mayReadLocation, mayWriteToLocation, modeMayRead, modeMayWrite, resolveLocationMode, STORAGE_LOCATION_MODES, StorageEvictionPolicySchema, StorageLocationModeSchema, strippedOfLegacyReadOnly, withLocationMode, } from './interfaces/storage-location-mode.js';
 export * from './interfaces/stream-broker.js';
 export type * from './interfaces/task-handler.js';
 export type { Timezone, TimezoneDstRule, Weekday } from './interfaces/timezones.js';