@camstack/types 0.1.40 → 0.1.42

package/dist/capabilities/settings-store.cap.d.ts

@@ -147,6 +147,31 @@ export declare const settingsStoreCapability: {
                 offset: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>;
         }, z.core.$strip>, z.ZodNumber, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Grouped counts per ((field-origin)/bucketSize) bucket, filtered. */
+        readonly histogram: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+            collection: z.ZodString;
+            field: z.ZodString;
+            bucketSize: z.ZodNumber;
+            origin: z.ZodNumber;
+            filter: z.ZodOptional<z.ZodObject<{
+                where: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                whereIn: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnknown>>>;
+                whereBetween: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodTuple<[z.ZodUnknown, z.ZodUnknown], null>>>;
+                orderBy: z.ZodOptional<z.ZodObject<{
+                    field: z.ZodString;
+                    direction: z.ZodEnum<{
+                        asc: "asc";
+                        desc: "desc";
+                    }>;
+                }, z.core.$strip>>;
+                limit: z.ZodOptional<z.ZodNumber>;
+                offset: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            bucket: z.ZodNumber;
+            count: z.ZodNumber;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         /** Check if a collection is empty. */
         readonly isEmpty: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             namespace: z.ZodOptional<z.ZodString>;

package/dist/capabilities/settings-store.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"settings-store.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/settings-store.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;GAEG;AACH,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;iBAUrB,CAAA;AAEF,8CAA8C;AAC9C,QAAA,MAAM,oBAAoB;;;iBAGxB,CAAA;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,sBAAsB;;;;;;;;;;;;iBAM1B,CAAA;AAEF,QAAA,MAAM,qBAAqB;;;;iBAIzB,CAAA;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,uBAAuB;;;;;QAKhC,mDAAmD;;;;;;QAMnD,mDAAmD;;;;;;;QAOnD,mDAAmD;;;;;;;;;;;;;;;;;;;;;;QAMnD,2BAA2B;;;;;;;;;QAO3B,uCAAuC;;;;;;;QAOvC,iCAAiC;;;;;;QAOjC,0DAA0D;;;;;;;;;;;;;;;;;;;QAM1D,sCAAsC;;;;;QAMtC;;;;;;;;;;;;;;WAcG;;;;;;;;;;;;;;;;;;;;;;;;CAYkC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAElF;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,2BAA2B,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAA;AAE/F,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,CAAA;AAEjG,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA"}
+{"version":3,"file":"settings-store.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/settings-store.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;GAEG;AACH,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;iBAUrB,CAAA;AAEF,8CAA8C;AAC9C,QAAA,MAAM,oBAAoB;;;iBAGxB,CAAA;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,sBAAsB;;;;;;;;;;;;iBAM1B,CAAA;AAEF,QAAA,MAAM,qBAAqB;;;;iBAIzB,CAAA;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,uBAAuB;;;;;QAKhC,mDAAmD;;;;;;QAMnD,mDAAmD;;;;;;;QAOnD,mDAAmD;;;;;;;;;;;;;;;;;;;;;;QAMnD,2BAA2B;;;;;;;;;QAO3B,uCAAuC;;;;;;;QAOvC,iCAAiC;;;;;;QAOjC,0DAA0D;;;;;;;;;;;;;;;;;;;QAM1D,uEAAuE;;;;;;;;;;;;;;;;;;;;;;;;;QAUvE,sCAAsC;;;;;QAMtC;;;;;;;;;;;;;;WAcG;;;;;;;;;;;;;;;;;;;;;;;;CAYkC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAElF;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,2BAA2B,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAA;AAE/F,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,CAAA;AAEjG,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA"}

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

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Smoke alarm sensor — boolean "is smoke currently detected" with
+ * timestamp of the last transition. Drives Home Assistant
+ * `binary_sensor` entries with `device_class: smoke`.
+ *
+ * Push-driven: a smoke event is critical, so the slice updates
+ * immediately on the upstream signal. Auto-clearing back to false is
+ * provider-controlled (some alarms latch until manually reset).
+ */
+export declare const SmokeStatusSchema: z.ZodObject<{
+    detected: z.ZodBoolean;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type SmokeStatus = z.infer<typeof SmokeStatusSchema>;
+export declare const smokeCapability: {
+    readonly name: "smoke";
+    readonly scope: "device";
+    readonly deviceNative: true;
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Sensor];
+    readonly methods: {};
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            detected: z.ZodBoolean;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    readonly runtimeState: z.ZodObject<{
+        detected: z.ZodBoolean;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type ISmokeProvider = InferProvider<typeof smokeCapability>;
+//# sourceMappingURL=smoke.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smoke.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/smoke.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB;;;iBAI5B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;CAYa,CAAA;AAEzC,MAAM,MAAM,cAAc,GAAG,aAAa,CAAC,OAAO,eAAe,CAAC,CAAA"}

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

@@ -3,7 +3,7 @@ import { type InferProvider } from './capability-definition.js';
 /**
  * snapshot-provider — collection of native snapshot implementations.
  *
- * Device provider addons (ONVIF, Frigate, Scrypted, etc.) register here
+ * Device provider addons (ONVIF, Frigate, etc.) register here
  * when they can capture frames through a protocol-native path (e.g.
  * ONVIF GetSnapshotUri, Frigate /api/<cam>/latest.jpg). The `snapshot`
  * singleton orchestrator iterates over the collection, asking each

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

@@ -47,6 +47,7 @@ declare const SnapshotStatusSchema: z.ZodObject<{
 export declare const snapshotCapability: {
     readonly name: "snapshot";
     readonly scope: "device";
+    readonly deviceNative: true;
     readonly mode: "singleton";
     readonly kind: "wrapper";
     readonly defaultActive: true;

package/dist/capabilities/snapshot.cap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"snapshot.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/snapshot.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;GAMG;AACH,QAAA,MAAM,mBAAmB;;;iBAGvB,CAAA;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH;;;;;GAKG;AACH,QAAA,MAAM,oBAAoB;;;;;iBASxB,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCU,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE5E,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,CAAA"}
+{"version":3,"file":"snapshot.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/snapshot.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;GAMG;AACH,QAAA,MAAM,mBAAmB;;;iBAGvB,CAAA;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH;;;;;GAKG;AACH,QAAA,MAAM,oBAAoB;;;;;iBASxB,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCU,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE5E,OAAO,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,CAAA"}

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

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * `storage-evictable` — implemented by any addon that owns evictable data on a
+ * storage location (recordings, event clips, thumbnails, …).
+ *
+ * The core `StoragePressureManager` (in storage-orchestrator) owns the TRIGGER:
+ * it monitors free space per location and, on breach of a location's
+ * `minFreePercent`, asks each evictable provider to free a share of the deficit.
+ * The provider decides WHAT is expendable and does the deletion itself — core
+ * never deletes data it doesn't understand. This inverts control so disk-space
+ * arbitration is one cross-consumer concern, not re-implemented per addon.
+ *
+ * `internal: true` — consumed only by the orchestrator's pressure manager, never
+ * a public client surface.
+ */
+declare const EvictableUsageSchema: z.ZodObject<{
+    bytes: z.ZodNumber;
+}, z.core.$strip>;
+export type EvictableUsage = z.infer<typeof EvictableUsageSchema>;
+declare const EvictResultSchema: z.ZodObject<{
+    reclaimedBytes: z.ZodNumber;
+    exhausted: z.ZodBoolean;
+}, z.core.$strip>;
+export type EvictResult = z.infer<typeof EvictResultSchema>;
+export declare const storageEvictableCapability: {
+    readonly name: "storage-evictable";
+    readonly scope: "system";
+    readonly mode: "collection";
+    readonly internal: true;
+    readonly methods: {
+        /** Bytes this provider holds on the given location — drives proportional fan-out. */
+        readonly getEvictableUsage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            locationId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            bytes: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Free approximately `targetBytes` of this provider's OWN least-valuable
+         * data on the location (oldest footage, expired clips, …). Returns what it
+         * actually reclaimed + whether it is now exhausted.
+         */
+        readonly evict: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            locationId: z.ZodString;
+            targetBytes: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            reclaimedBytes: z.ZodNumber;
+            exhausted: z.ZodBoolean;
+        }, z.core.$strip>, "mutation">;
+    };
+};
+export type IStorageEvictableProvider = InferProvider<typeof storageEvictableCapability>;
+export {};
+//# sourceMappingURL=storage-evictable.cap.d.ts.map

package/dist/capabilities/storage-evictable.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-evictable.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/storage-evictable.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG;;;;;;;;;;;;;GAaG;AAEH,QAAA,MAAM,oBAAoB;;iBAGxB,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,QAAA,MAAM,iBAAiB;;;iBAKrB,CAAA;AACF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,eAAO,MAAM,0BAA0B;;;;;;QAMnC,qFAAqF;;;;;;QAKrF;;;;WAIG;;;;;;;;;CAOkC,CAAA;AAEzC,MAAM,MAAM,yBAAyB,GAAG,aAAa,CAAC,OAAO,0BAA0B,CAAC,CAAA"}

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

@@ -1,24 +1,20 @@
 import { z } from 'zod';
 import { type InferProvider } from './capability-definition.js';
-declare const ProviderInfoSchema: z.ZodObject<{
+declare const ProviderInfoSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     providerId: z.ZodString;
     displayName: z.ZodString;
-    supportedLocationTypes: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-        data: "data";
-        media: "media";
-        recordings: "recordings";
-        cache: "cache";
-        logs: "logs";
-        models: "models";
-        "recordings-high": "recordings-high";
-        "recordings-low": "recordings-low";
-        "recordings-clips": "recordings-clips";
-        "event-images": "event-images";
-        "addons-data": "addons-data";
-        backups: "backups";
-    }>>>;
     configSchema: z.ZodUnknown;
-}, z.core.$strip>;
+    nodeLocal: z.ZodBoolean;
+    shouldSaveDiskSpace: z.ZodLiteral<true>;
+    minFreePercent: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    providerId: z.ZodString;
+    displayName: z.ZodString;
+    configSchema: z.ZodUnknown;
+    nodeLocal: z.ZodBoolean;
+    shouldSaveDiskSpace: z.ZodLiteral<false>;
+    minFreePercent: z.ZodLiteral<null>;
+}, z.core.$strip>], "shouldSaveDiskSpace">;
 declare const TestLocationResultSchema: z.ZodObject<{
     ok: z.ZodBoolean;
     error: z.ZodOptional<z.ZodString>;
@@ -26,23 +22,11 @@ declare const TestLocationResultSchema: z.ZodObject<{
 declare const BeginUploadInputSchema: z.ZodObject<{
     location: z.ZodObject<{
         id: z.ZodString;
-        type: z.ZodEnum<{
-            data: "data";
-            media: "media";
-            recordings: "recordings";
-            cache: "cache";
-            logs: "logs";
-            models: "models";
-            "recordings-high": "recordings-high";
-            "recordings-low": "recordings-low";
-            "recordings-clips": "recordings-clips";
-            "event-images": "event-images";
-            "addons-data": "addons-data";
-            backups: "backups";
-        }>;
+        type: z.ZodString;
         displayName: z.ZodString;
         providerId: z.ZodString;
         config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        nodeId: z.ZodOptional<z.ZodString>;
         isDefault: z.ZodDefault<z.ZodBoolean>;
         isSystem: z.ZodDefault<z.ZodBoolean>;
         createdAt: z.ZodNumber;
@@ -68,23 +52,11 @@ declare const AbortUploadInputSchema: z.ZodObject<{
 declare const BeginDownloadInputSchema: z.ZodObject<{
     location: z.ZodObject<{
         id: z.ZodString;
-        type: z.ZodEnum<{
-            data: "data";
-            media: "media";
-            recordings: "recordings";
-            cache: "cache";
-            logs: "logs";
-            models: "models";
-            "recordings-high": "recordings-high";
-            "recordings-low": "recordings-low";
-            "recordings-clips": "recordings-clips";
-            "event-images": "event-images";
-            "addons-data": "addons-data";
-            backups: "backups";
-        }>;
+        type: z.ZodString;
         displayName: z.ZodString;
         providerId: z.ZodString;
         config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        nodeId: z.ZodOptional<z.ZodString>;
         isDefault: z.ZodDefault<z.ZodBoolean>;
         isSystem: z.ZodDefault<z.ZodBoolean>;
         createdAt: z.ZodNumber;
@@ -131,25 +103,21 @@ export declare const storageProviderCapability: {
     readonly internal: true;
     readonly methods: {
         /** Self-description for the "Add location" wizard. */
-        readonly getProviderInfo: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+        readonly getProviderInfo: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodDiscriminatedUnion<[z.ZodObject<{
             providerId: z.ZodString;
             displayName: z.ZodString;
-            supportedLocationTypes: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
-                data: "data";
-                media: "media";
-                recordings: "recordings";
-                cache: "cache";
-                logs: "logs";
-                models: "models";
-                "recordings-high": "recordings-high";
-                "recordings-low": "recordings-low";
-                "recordings-clips": "recordings-clips";
-                "event-images": "event-images";
-                "addons-data": "addons-data";
-                backups: "backups";
-            }>>>;
             configSchema: z.ZodUnknown;
-        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+            nodeLocal: z.ZodBoolean;
+            shouldSaveDiskSpace: z.ZodLiteral<true>;
+            minFreePercent: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            providerId: z.ZodString;
+            displayName: z.ZodString;
+            configSchema: z.ZodUnknown;
+            nodeLocal: z.ZodBoolean;
+            shouldSaveDiskSpace: z.ZodLiteral<false>;
+            minFreePercent: z.ZodLiteral<null>;
+        }, z.core.$strip>], "shouldSaveDiskSpace">, import("./capability-definition.js").CapabilityMethodKind>;
         /** Validate config + probe connectivity. Called on add and on edit. */
         readonly testLocation: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -160,23 +128,11 @@ export declare const storageProviderCapability: {
         readonly resolve: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             location: z.ZodObject<{
                 id: z.ZodString;
-                type: z.ZodEnum<{
-                    data: "data";
-                    media: "media";
-                    recordings: "recordings";
-                    cache: "cache";
-                    logs: "logs";
-                    models: "models";
-                    "recordings-high": "recordings-high";
-                    "recordings-low": "recordings-low";
-                    "recordings-clips": "recordings-clips";
-                    "event-images": "event-images";
-                    "addons-data": "addons-data";
-                    backups: "backups";
-                }>;
+                type: z.ZodString;
                 displayName: z.ZodString;
                 providerId: z.ZodString;
                 config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                nodeId: z.ZodOptional<z.ZodString>;
                 isDefault: z.ZodDefault<z.ZodBoolean>;
                 isSystem: z.ZodDefault<z.ZodBoolean>;
                 createdAt: z.ZodNumber;
@@ -187,23 +143,11 @@ export declare const storageProviderCapability: {
         readonly write: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             location: z.ZodObject<{
                 id: z.ZodString;
-                type: z.ZodEnum<{
-                    data: "data";
-                    media: "media";
-                    recordings: "recordings";
-                    cache: "cache";
-                    logs: "logs";
-                    models: "models";
-                    "recordings-high": "recordings-high";
-                    "recordings-low": "recordings-low";
-                    "recordings-clips": "recordings-clips";
-                    "event-images": "event-images";
-                    "addons-data": "addons-data";
-                    backups: "backups";
-                }>;
+                type: z.ZodString;
                 displayName: z.ZodString;
                 providerId: z.ZodString;
                 config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                nodeId: z.ZodOptional<z.ZodString>;
                 isDefault: z.ZodDefault<z.ZodBoolean>;
                 isSystem: z.ZodDefault<z.ZodBoolean>;
                 createdAt: z.ZodNumber;
@@ -215,23 +159,11 @@ export declare const storageProviderCapability: {
         readonly read: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             location: z.ZodObject<{
                 id: z.ZodString;
-                type: z.ZodEnum<{
-                    data: "data";
-                    media: "media";
-                    recordings: "recordings";
-                    cache: "cache";
-                    logs: "logs";
-                    models: "models";
-                    "recordings-high": "recordings-high";
-                    "recordings-low": "recordings-low";
-                    "recordings-clips": "recordings-clips";
-                    "event-images": "event-images";
-                    "addons-data": "addons-data";
-                    backups: "backups";
-                }>;
+                type: z.ZodString;
                 displayName: z.ZodString;
                 providerId: z.ZodString;
                 config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                nodeId: z.ZodOptional<z.ZodString>;
                 isDefault: z.ZodDefault<z.ZodBoolean>;
                 isSystem: z.ZodDefault<z.ZodBoolean>;
                 createdAt: z.ZodNumber;
@@ -242,23 +174,11 @@ export declare const storageProviderCapability: {
         readonly exists: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             location: z.ZodObject<{
                 id: z.ZodString;
-                type: z.ZodEnum<{
-                    data: "data";
-                    media: "media";
-                    recordings: "recordings";
-                    cache: "cache";
-                    logs: "logs";
-                    models: "models";
-                    "recordings-high": "recordings-high";
-                    "recordings-low": "recordings-low";
-                    "recordings-clips": "recordings-clips";
-                    "event-images": "event-images";
-                    "addons-data": "addons-data";
-                    backups: "backups";
-                }>;
+                type: z.ZodString;
                 displayName: z.ZodString;
                 providerId: z.ZodString;
                 config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                nodeId: z.ZodOptional<z.ZodString>;
                 isDefault: z.ZodDefault<z.ZodBoolean>;
                 isSystem: z.ZodDefault<z.ZodBoolean>;
                 createdAt: z.ZodNumber;
@@ -269,23 +189,11 @@ export declare const storageProviderCapability: {
         readonly list: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             location: z.ZodObject<{
                 id: z.ZodString;
-                type: z.ZodEnum<{
-                    data: "data";
-                    media: "media";
-                    recordings: "recordings";
-                    cache: "cache";
-                    logs: "logs";
-                    models: "models";
-                    "recordings-high": "recordings-high";
-                    "recordings-low": "recordings-low";
-                    "recordings-clips": "recordings-clips";
-                    "event-images": "event-images";
-                    "addons-data": "addons-data";
-                    backups: "backups";
-                }>;
+                type: z.ZodString;
                 displayName: z.ZodString;
                 providerId: z.ZodString;
                 config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                nodeId: z.ZodOptional<z.ZodString>;
                 isDefault: z.ZodDefault<z.ZodBoolean>;
                 isSystem: z.ZodDefault<z.ZodBoolean>;
                 createdAt: z.ZodNumber;
@@ -296,23 +204,11 @@ export declare const storageProviderCapability: {
         readonly delete: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             location: z.ZodObject<{
                 id: z.ZodString;
-                type: z.ZodEnum<{
-                    data: "data";
-                    media: "media";
-                    recordings: "recordings";
-                    cache: "cache";
-                    logs: "logs";
-                    models: "models";
-                    "recordings-high": "recordings-high";
-                    "recordings-low": "recordings-low";
-                    "recordings-clips": "recordings-clips";
-                    "event-images": "event-images";
-                    "addons-data": "addons-data";
-                    backups: "backups";
-                }>;
+                type: z.ZodString;
                 displayName: z.ZodString;
                 providerId: z.ZodString;
                 config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                nodeId: z.ZodOptional<z.ZodString>;
                 isDefault: z.ZodDefault<z.ZodBoolean>;
                 isSystem: z.ZodDefault<z.ZodBoolean>;
                 createdAt: z.ZodNumber;
@@ -323,23 +219,11 @@ export declare const storageProviderCapability: {
         readonly getAvailableSpace: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             location: z.ZodObject<{
                 id: z.ZodString;
-                type: z.ZodEnum<{
-                    data: "data";
-                    media: "media";
-                    recordings: "recordings";
-                    cache: "cache";
-                    logs: "logs";
-                    models: "models";
-                    "recordings-high": "recordings-high";
-                    "recordings-low": "recordings-low";
-                    "recordings-clips": "recordings-clips";
-                    "event-images": "event-images";
-                    "addons-data": "addons-data";
-                    backups: "backups";
-                }>;
+                type: z.ZodString;
                 displayName: z.ZodString;
                 providerId: z.ZodString;
                 config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                nodeId: z.ZodOptional<z.ZodString>;
                 isDefault: z.ZodDefault<z.ZodBoolean>;
                 isSystem: z.ZodDefault<z.ZodBoolean>;
                 createdAt: z.ZodNumber;
@@ -349,23 +233,11 @@ export declare const storageProviderCapability: {
         readonly beginUpload: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             location: z.ZodObject<{
                 id: z.ZodString;
-                type: z.ZodEnum<{
-                    data: "data";
-                    media: "media";
-                    recordings: "recordings";
-                    cache: "cache";
-                    logs: "logs";
-                    models: "models";
-                    "recordings-high": "recordings-high";
-                    "recordings-low": "recordings-low";
-                    "recordings-clips": "recordings-clips";
-                    "event-images": "event-images";
-                    "addons-data": "addons-data";
-                    backups: "backups";
-                }>;
+                type: z.ZodString;
                 displayName: z.ZodString;
                 providerId: z.ZodString;
                 config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                nodeId: z.ZodOptional<z.ZodString>;
                 isDefault: z.ZodDefault<z.ZodBoolean>;
                 isSystem: z.ZodDefault<z.ZodBoolean>;
                 createdAt: z.ZodNumber;
@@ -390,23 +262,11 @@ export declare const storageProviderCapability: {
         readonly beginDownload: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             location: z.ZodObject<{
                 id: z.ZodString;
-                type: z.ZodEnum<{
-                    data: "data";
-                    media: "media";
-                    recordings: "recordings";
-                    cache: "cache";
-                    logs: "logs";
-                    models: "models";
-                    "recordings-high": "recordings-high";
-                    "recordings-low": "recordings-low";
-                    "recordings-clips": "recordings-clips";
-                    "event-images": "event-images";
-                    "addons-data": "addons-data";
-                    backups: "backups";
-                }>;
+                type: z.ZodString;
                 displayName: z.ZodString;
                 providerId: z.ZodString;
                 config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                nodeId: z.ZodOptional<z.ZodString>;
                 isDefault: z.ZodDefault<z.ZodBoolean>;
                 isSystem: z.ZodDefault<z.ZodBoolean>;
                 createdAt: z.ZodNumber;

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

@@ -1 +1 @@
-{"version":3,"file":"storage-provider.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/storage-provider.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAgBlG,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;iBAKtB,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;iBAG5B,CAAA;AAcF,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI1B,CAAA;AACF,QAAA,MAAM,uBAAuB;;iBAAqC,CAAA;AAClE,QAAA,MAAM,qBAAqB;;;;iBAIzB,CAAA;AACF,QAAA,MAAM,yBAAyB;;iBAAqC,CAAA;AACpE,QAAA,MAAM,sBAAsB;;iBAAqC,CAAA;AAMjE,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG5B,CAAA;AACF,QAAA,MAAM,yBAAyB;;;iBAG7B,CAAA;AACF,QAAA,MAAM,oBAAoB;;;;iBAIxB,CAAA;AACF,QAAA,MAAM,sBAAsB;;iBAAuC,CAAA;AAEnE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,yBAAyB;;;;;;QAMlC,sDAAsD;;;;;;;;;;;;;;;;;;;;QAGtD,uEAAuE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDlC,CAAA;AAEzC,MAAM,MAAM,oBAAoB,GAAG,aAAa,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAElF,OAAO,EACL,kBAAkB,EAClB,wBAAwB,EACxB,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,EACrB,yBAAyB,EACzB,sBAAsB,EACtB,wBAAwB,EACxB,yBAAyB,EACzB,oBAAoB,EACpB,sBAAsB,GACvB,CAAA"}
+{"version":3,"file":"storage-provider.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/storage-provider.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAsBlG,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;0CAyBtB,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;iBAG5B,CAAA;AAcF,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;iBAI1B,CAAA;AACF,QAAA,MAAM,uBAAuB;;iBAAqC,CAAA;AAClE,QAAA,MAAM,qBAAqB;;;;iBAIzB,CAAA;AACF,QAAA,MAAM,yBAAyB;;iBAAqC,CAAA;AACpE,QAAA,MAAM,sBAAsB;;iBAAqC,CAAA;AAMjE,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;iBAG5B,CAAA;AACF,QAAA,MAAM,yBAAyB;;;iBAG7B,CAAA;AACF,QAAA,MAAM,oBAAoB;;;;iBAIxB,CAAA;AACF,QAAA,MAAM,sBAAsB;;iBAAuC,CAAA;AAEnE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,yBAAyB;;;;;;QAMlC,sDAAsD;;;;;;;;;;;;;;;;QAGtD,uEAAuE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDlC,CAAA;AAEzC,MAAM,MAAM,oBAAoB,GAAG,aAAa,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAElF,OAAO,EACL,kBAAkB,EAClB,wBAAwB,EACxB,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,EACrB,yBAAyB,EACzB,sBAAsB,EACtB,wBAAwB,EACxB,yBAAyB,EACzB,oBAAoB,EACpB,sBAAsB,GACvB,CAAA"}