@camstack/types 0.1.14 → 0.1.16

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

@@ -0,0 +1,477 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+declare const RecordingModeSchema: z.ZodEnum<{
+    motion: "motion";
+    continuous: "continuous";
+    scheduled: "scheduled";
+    composite: "composite";
+}>;
+declare const RecordingPolicySchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    mode: z.ZodEnum<{
+        motion: "motion";
+        continuous: "continuous";
+        scheduled: "scheduled";
+        composite: "composite";
+    }>;
+    streams: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        streamId: z.ZodString;
+        mode: z.ZodEnum<{
+            inherit: "inherit";
+            always: "always";
+        }>;
+    }, z.core.$strip>>>;
+    enabled: z.ZodBoolean;
+    preBufferSec: z.ZodNumber;
+    postBufferSec: z.ZodNumber;
+    scheduleRules: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        days: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+        startTime: z.ZodString;
+        endTime: z.ZodString;
+        mode: z.ZodEnum<{
+            motion: "motion";
+            continuous: "continuous";
+        }>;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+declare const DataCategorySchema: z.ZodEnum<{
+    "recording:main": "recording:main";
+    "recording:mid": "recording:mid";
+    "recording:sub": "recording:sub";
+    "thumbnail:scrub": "thumbnail:scrub";
+    "thumbnail:event": "thumbnail:event";
+}>;
+declare const RecordingStorageConfigSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    dataCategory: z.ZodEnum<{
+        "recording:main": "recording:main";
+        "recording:mid": "recording:mid";
+        "recording:sub": "recording:sub";
+        "thumbnail:scrub": "thumbnail:scrub";
+        "thumbnail:event": "thumbnail:event";
+    }>;
+    storageName: z.ZodString;
+    subDirectory: z.ZodString;
+    retentionDays: z.ZodNullable<z.ZodNumber>;
+    retentionGb: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+declare const RecordingSegmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    deviceId: z.ZodNumber;
+    streamId: z.ZodString;
+    startTime: z.ZodNumber;
+    endTime: z.ZodNumber;
+    duration: z.ZodNumber;
+    path: z.ZodString;
+    storageName: z.ZodString;
+    subDirectory: z.ZodString;
+    sizeBytes: z.ZodNumber;
+    codec: z.ZodEnum<{
+        h264: "h264";
+        h265: "h265";
+    }>;
+    hasAudio: z.ZodBoolean;
+}, z.core.$strip>;
+declare const RecordingThumbnailSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    path: z.ZodString;
+    storageName: z.ZodString;
+    subDirectory: z.ZodString;
+    sizeBytes: z.ZodNumber;
+    category: z.ZodEnum<{
+        scrub: "scrub";
+        event: "event";
+    }>;
+}, z.core.$strip>;
+declare const AvailabilityRangeSchema: z.ZodObject<{
+    startTime: z.ZodNumber;
+    endTime: z.ZodNumber;
+    streams: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const StorageUsageSchema: z.ZodObject<{
+    totalBytes: z.ZodNumber;
+    segmentCount: z.ZodNumber;
+}, z.core.$strip>;
+declare const StorageEstimateSchema: z.ZodObject<{
+    perStream: z.ZodRecord<z.ZodString, z.ZodObject<{
+        bitrateKbps: z.ZodNumber;
+        retentionDays: z.ZodNullable<z.ZodNumber>;
+        retentionGb: z.ZodNullable<z.ZodNumber>;
+        estimatedGb: z.ZodNumber;
+        estimatedDaysAtCapacity: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    thumbnails: z.ZodObject<{
+        estimatedGb: z.ZodNumber;
+    }, z.core.$strip>;
+    totalEstimatedGb: z.ZodNumber;
+    motionEstimate: z.ZodOptional<z.ZodObject<{
+        avgEventsPerDay: z.ZodNumber;
+        avgDurationSec: z.ZodNumber;
+        dutyCyclePercent: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const MotionStatsSchema: z.ZodObject<{
+    totalEvents: z.ZodNumber;
+    avgDurationSec: z.ZodNumber;
+    avgEventsPerDay: z.ZodNumber;
+    dutyCyclePercent: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Recording engine — manages per-device recording lifecycle, policies,
+ * playlists, segments, thumbnails, and storage estimation.
+ *
+ * Implemented by the `recording` sub-addon inside `addon-analytics-suite`.
+ * Session 5 Sprint D expanded the cap from 1 method (`getStatus`) to the
+ * full 17-method contract, replacing the broken hand-written
+ * `recording.router.ts` that invoked non-existent methods on the addon.
+ *
+ * The provider implementation is a facade wrapping RecordingCoordinator,
+ * RecordingDb, PlaylistGenerator, StorageEstimator, and RetentionManager.
+ */
+export declare const recordingEngineCapability: {
+    readonly name: "recording-engine";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        readonly getStatus: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            activeRecordings: z.ZodNumber;
+            totalSegments: z.ZodNumber;
+            totalSizeMB: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly enable: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            policy: z.ZodObject<{
+                mode: z.ZodEnum<{
+                    motion: "motion";
+                    continuous: "continuous";
+                    scheduled: "scheduled";
+                    composite: "composite";
+                }>;
+                enabled: z.ZodBoolean;
+                preBufferSec: z.ZodNumber;
+                streams: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    streamId: z.ZodString;
+                    mode: z.ZodEnum<{
+                        inherit: "inherit";
+                        always: "always";
+                    }>;
+                }, z.core.$strip>>>;
+                postBufferSec: z.ZodNumber;
+                scheduleRules: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    days: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+                    startTime: z.ZodString;
+                    endTime: z.ZodString;
+                    mode: z.ZodEnum<{
+                        motion: "motion";
+                        continuous: "continuous";
+                    }>;
+                }, z.core.$strip>>>>;
+            }, z.core.$strip>;
+            storageOverrides: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                dataCategory: z.ZodEnum<{
+                    "recording:main": "recording:main";
+                    "recording:mid": "recording:mid";
+                    "recording:sub": "recording:sub";
+                    "thumbnail:scrub": "thumbnail:scrub";
+                    "thumbnail:event": "thumbnail:event";
+                }>;
+                storageName: z.ZodString;
+                subDirectory: z.ZodString;
+                retentionDays: z.ZodNullable<z.ZodNumber>;
+                retentionGb: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>>>;
+            ffmpegOverrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly disable: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly getConfig: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            mode: z.ZodEnum<{
+                motion: "motion";
+                continuous: "continuous";
+                scheduled: "scheduled";
+                composite: "composite";
+            }>;
+            streams: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                streamId: z.ZodString;
+                mode: z.ZodEnum<{
+                    inherit: "inherit";
+                    always: "always";
+                }>;
+            }, z.core.$strip>>>;
+            enabled: z.ZodBoolean;
+            preBufferSec: z.ZodNumber;
+            postBufferSec: z.ZodNumber;
+            scheduleRules: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                days: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+                startTime: z.ZodString;
+                endTime: z.ZodString;
+                mode: z.ZodEnum<{
+                    motion: "motion";
+                    continuous: "continuous";
+                }>;
+            }, z.core.$strip>>>>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly updateConfig: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            policy: z.ZodObject<{
+                mode: z.ZodEnum<{
+                    motion: "motion";
+                    continuous: "continuous";
+                    scheduled: "scheduled";
+                    composite: "composite";
+                }>;
+                enabled: z.ZodBoolean;
+                preBufferSec: z.ZodNumber;
+                streams: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    streamId: z.ZodString;
+                    mode: z.ZodEnum<{
+                        inherit: "inherit";
+                        always: "always";
+                    }>;
+                }, z.core.$strip>>>;
+                postBufferSec: z.ZodNumber;
+                scheduleRules: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    days: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+                    startTime: z.ZodString;
+                    endTime: z.ZodString;
+                    mode: z.ZodEnum<{
+                        motion: "motion";
+                        continuous: "continuous";
+                    }>;
+                }, z.core.$strip>>>>;
+            }, z.core.$strip>;
+            ffmpegOverrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly getPlaylist: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            streamId: z.ZodString;
+            startTime: z.ZodNumber;
+            endTime: z.ZodNumber;
+            live: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodString, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getThumbnail: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            timestamp: z.ZodNumber;
+            category: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            timestamp: z.ZodNumber;
+            path: z.ZodString;
+            storageName: z.ZodString;
+            subDirectory: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            category: z.ZodEnum<{
+                scrub: "scrub";
+                event: "event";
+            }>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getSegments: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            streamId: z.ZodString;
+            startTime: z.ZodNumber;
+            endTime: z.ZodNumber;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            deviceId: z.ZodNumber;
+            streamId: z.ZodString;
+            startTime: z.ZodNumber;
+            endTime: z.ZodNumber;
+            duration: z.ZodNumber;
+            path: z.ZodString;
+            storageName: z.ZodString;
+            subDirectory: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            codec: z.ZodEnum<{
+                h264: "h264";
+                h265: "h265";
+            }>;
+            hasAudio: z.ZodBoolean;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getAvailability: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            startTime: z.ZodNumber;
+            endTime: z.ZodNumber;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            startTime: z.ZodNumber;
+            endTime: z.ZodNumber;
+            streams: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly estimateStorage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            motionInput: z.ZodOptional<z.ZodObject<{
+                avgEventsPerDay: z.ZodNumber;
+                avgDurationSec: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            perStream: z.ZodRecord<z.ZodString, z.ZodObject<{
+                bitrateKbps: z.ZodNumber;
+                retentionDays: z.ZodNullable<z.ZodNumber>;
+                retentionGb: z.ZodNullable<z.ZodNumber>;
+                estimatedGb: z.ZodNumber;
+                estimatedDaysAtCapacity: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>;
+            thumbnails: z.ZodObject<{
+                estimatedGb: z.ZodNumber;
+            }, z.core.$strip>;
+            totalEstimatedGb: z.ZodNumber;
+            motionEstimate: z.ZodOptional<z.ZodObject<{
+                avgEventsPerDay: z.ZodNumber;
+                avgDurationSec: z.ZodNumber;
+                dutyCyclePercent: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly estimateGlobalStorage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            perStream: z.ZodRecord<z.ZodString, z.ZodObject<{
+                bitrateKbps: z.ZodNumber;
+                retentionDays: z.ZodNullable<z.ZodNumber>;
+                retentionGb: z.ZodNullable<z.ZodNumber>;
+                estimatedGb: z.ZodNumber;
+                estimatedDaysAtCapacity: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>;
+            thumbnails: z.ZodObject<{
+                estimatedGb: z.ZodNumber;
+            }, z.core.$strip>;
+            totalEstimatedGb: z.ZodNumber;
+            motionEstimate: z.ZodOptional<z.ZodObject<{
+                avgEventsPerDay: z.ZodNumber;
+                avgDurationSec: z.ZodNumber;
+                dutyCyclePercent: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getStorageUsage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            streamId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            totalBytes: z.ZodNumber;
+            segmentCount: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly setPolicy: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            policy: z.ZodObject<{
+                mode: z.ZodEnum<{
+                    motion: "motion";
+                    continuous: "continuous";
+                    scheduled: "scheduled";
+                    composite: "composite";
+                }>;
+                enabled: z.ZodBoolean;
+                preBufferSec: z.ZodNumber;
+                streams: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    streamId: z.ZodString;
+                    mode: z.ZodEnum<{
+                        inherit: "inherit";
+                        always: "always";
+                    }>;
+                }, z.core.$strip>>>;
+                postBufferSec: z.ZodNumber;
+                scheduleRules: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    days: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+                    startTime: z.ZodString;
+                    endTime: z.ZodString;
+                    mode: z.ZodEnum<{
+                        motion: "motion";
+                        continuous: "continuous";
+                    }>;
+                }, z.core.$strip>>>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly getPolicy: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            mode: z.ZodEnum<{
+                motion: "motion";
+                continuous: "continuous";
+                scheduled: "scheduled";
+                composite: "composite";
+            }>;
+            streams: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                streamId: z.ZodString;
+                mode: z.ZodEnum<{
+                    inherit: "inherit";
+                    always: "always";
+                }>;
+            }, z.core.$strip>>>;
+            enabled: z.ZodBoolean;
+            preBufferSec: z.ZodNumber;
+            postBufferSec: z.ZodNumber;
+            scheduleRules: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                days: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
+                startTime: z.ZodString;
+                endTime: z.ZodString;
+                mode: z.ZodEnum<{
+                    motion: "motion";
+                    continuous: "continuous";
+                }>;
+            }, z.core.$strip>>>>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getPolicyStatus: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            enabled: z.ZodBoolean;
+            mode: z.ZodEnum<{
+                motion: "motion";
+                continuous: "continuous";
+                scheduled: "scheduled";
+                composite: "composite";
+            }>;
+            activeStreams: z.ZodNumber;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getRetentionConfig: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            dataCategory: z.ZodEnum<{
+                "recording:main": "recording:main";
+                "recording:mid": "recording:mid";
+                "recording:sub": "recording:sub";
+                "thumbnail:scrub": "thumbnail:scrub";
+                "thumbnail:event": "thumbnail:event";
+            }>;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            dataCategory: z.ZodEnum<{
+                "recording:main": "recording:main";
+                "recording:mid": "recording:mid";
+                "recording:sub": "recording:sub";
+                "thumbnail:scrub": "thumbnail:scrub";
+                "thumbnail:event": "thumbnail:event";
+            }>;
+            storageName: z.ZodString;
+            subDirectory: z.ZodString;
+            retentionDays: z.ZodNullable<z.ZodNumber>;
+            retentionGb: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly updateRetentionConfig: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            dataCategory: z.ZodEnum<{
+                "recording:main": "recording:main";
+                "recording:mid": "recording:mid";
+                "recording:sub": "recording:sub";
+                "thumbnail:scrub": "thumbnail:scrub";
+                "thumbnail:event": "thumbnail:event";
+            }>;
+            storageName: z.ZodString;
+            subDirectory: z.ZodString;
+            retentionDays: z.ZodNullable<z.ZodNumber>;
+            retentionGb: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        readonly getMotionStats: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            startTime: z.ZodNumber;
+            endTime: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            totalEvents: z.ZodNumber;
+            avgDurationSec: z.ZodNumber;
+            avgEventsPerDay: z.ZodNumber;
+            dutyCyclePercent: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IRecordingEngineProvider = InferProvider<typeof recordingEngineCapability>;
+export { RecordingPolicySchema, RecordingSegmentSchema, RecordingThumbnailSchema, RecordingStorageConfigSchema, AvailabilityRangeSchema, StorageUsageSchema, StorageEstimateSchema, MotionStatsSchema, RecordingModeSchema, DataCategorySchema, };
+//# sourceMappingURL=recording-engine.cap.d.ts.map

package/dist/capabilities/recording-engine.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recording-engine.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/recording-engine.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAIlG,QAAA,MAAM,mBAAmB;;;;;EAA6D,CAAA;AActF,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQzB,CAAA;AAEF,QAAA,MAAM,kBAAkB;;;;;;EAGtB,CAAA;AAEF,QAAA,MAAM,4BAA4B;;;;;;;;;;;;;iBAOhC,CAAA;AAEF,QAAA,MAAM,sBAAsB;;;;;;;;;;;;;;;;iBAa1B,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;;;;;;;iBAQ5B,CAAA;AAEF,QAAA,MAAM,uBAAuB;;;;iBAI3B,CAAA;AAEF,QAAA,MAAM,kBAAkB;;;iBAGtB,CAAA;AAUF,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;iBASzB,CAAA;AAEF,QAAA,MAAM,iBAAiB;;;;;iBAKrB,CAAA;AAuEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDG,CAAA;AAEzC,MAAM,MAAM,wBAAwB,GAAG,aAAa,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAEtF,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,wBAAwB,EACxB,4BAA4B,EAC5B,uBAAuB,EACvB,kBAAkB,EAClB,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,GACnB,CAAA"}

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

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+declare const SegmentSchema: z.ZodObject<{
+    id: z.ZodString;
+    startTs: z.ZodNumber;
+    endTs: z.ZodNumber;
+    durationSec: z.ZodNumber;
+    sizeBytes: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const recordingCapability: {
+    readonly name: "recording";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly methods: {
+        readonly getSegments: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            from: z.ZodOptional<z.ZodNumber>;
+            to: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            startTs: z.ZodNumber;
+            endTs: z.ZodNumber;
+            durationSec: z.ZodNumber;
+            sizeBytes: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getPlaybackUrl: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            segmentId: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodString>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getThumbnailAt: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            timestamp: z.ZodNumber;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            base64: z.ZodString;
+            contentType: z.ZodString;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IRecordingProvider = InferProvider<typeof recordingCapability>;
+export { SegmentSchema };
+//# sourceMappingURL=recording.cap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recording.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/recording.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,QAAA,MAAM,aAAa;;;;;;iBAMjB,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBS,CAAA;AAEzC,MAAM,MAAM,kBAAkB,GAAG,aAAa,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC1E,OAAO,EAAE,aAAa,EAAE,CAAA"}

package/dist/capabilities/remote-access.cap.d.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+declare const RemoteAccessEndpointSchema: z.ZodObject<{
+    url: z.ZodString;
+    hostname: z.ZodString;
+    port: z.ZodNumber;
+    protocol: z.ZodEnum<{
+        http: "http";
+        https: "https";
+    }>;
+}, z.core.$strip>;
+/**
+ * Remote-access provider summary, surfaced to the admin UI's
+ * "Remote Access" page. One row per registered `network-access`
+ * provider (Cloudflare Tunnel, ngrok, Tailscale, etc.).
+ */
+declare const RemoteAccessProviderInfoSchema: z.ZodObject<{
+    addonId: z.ZodString;
+    displayName: z.ZodString;
+    kind: z.ZodEnum<{
+        other: "other";
+        tailscale: "tailscale";
+        "cloudflare-tunnel": "cloudflare-tunnel";
+        ngrok: "ngrok";
+    }>;
+    enabled: z.ZodBoolean;
+    connected: z.ZodBoolean;
+    endpoint: z.ZodNullable<z.ZodObject<{
+        url: z.ZodString;
+        hostname: z.ZodString;
+        port: z.ZodNumber;
+        protocol: z.ZodEnum<{
+            http: "http";
+            https: "https";
+        }>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RemoteAccessProviderInfo = z.infer<typeof RemoteAccessProviderInfoSchema>;
+/**
+ * `remote-access` — singleton facade over the `network-access`
+ * collection. Consumed by the admin UI's Remote Access page so an
+ * operator can see at a glance which providers are configured, which
+ * are connected, and which public endpoint each exposes.
+ *
+ * Mirrors the `authentication` / `turn-orchestrator` patterns: the
+ * UI talks to the singleton, the singleton walks the collection.
+ */
+export declare const remoteAccessCapability: {
+    readonly name: "remote-access";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        /** All registered remote-access providers + their live status. */
+        readonly listProviders: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            addonId: z.ZodString;
+            displayName: z.ZodString;
+            kind: z.ZodEnum<{
+                other: "other";
+                tailscale: "tailscale";
+                "cloudflare-tunnel": "cloudflare-tunnel";
+                ngrok: "ngrok";
+            }>;
+            enabled: z.ZodBoolean;
+            connected: z.ZodBoolean;
+            endpoint: z.ZodNullable<z.ZodObject<{
+                url: z.ZodString;
+                hostname: z.ZodString;
+                port: z.ZodNumber;
+                protocol: z.ZodEnum<{
+                    http: "http";
+                    https: "https";
+                }>;
+            }, z.core.$strip>>;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Start a specific provider's tunnel. Per-provider config still
+         * lives on the addon's settings panel; this is just the on/off
+         * trigger so the admin UI can manage the lifecycle from one place.
+         */
+        readonly startProvider: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addonId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            url: z.ZodString;
+            hostname: z.ZodString;
+            port: z.ZodNumber;
+            protocol: z.ZodEnum<{
+                http: "http";
+                https: "https";
+            }>;
+        }, z.core.$strip>, "mutation">;
+        /** Stop a specific provider's tunnel (idempotent on already-stopped). */
+        readonly stopProvider: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            addonId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+    };
+};
+export type IRemoteAccessOrchestrator = InferProvider<typeof remoteAccessCapability>;
+export { RemoteAccessEndpointSchema, RemoteAccessProviderInfoSchema };
+//# sourceMappingURL=remote-access.cap.d.ts.map

package/dist/capabilities/remote-access.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-access.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/remote-access.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG,QAAA,MAAM,0BAA0B;;;;;;;;iBAK9B,CAAA;AAEF;;;;GAIG;AACH,QAAA,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;iBAqBlC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAErF;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB;;;;;QAK/B,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;QAElE;;;;WAIG;;;;;;;;;;;;QAMH,yEAAyE;;;;;;;CAOpC,CAAA;AAEzC,MAAM,MAAM,yBAAyB,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAEpF,OAAO,EAAE,0BAA0B,EAAE,8BAA8B,EAAE,CAAA"}