@camstack/types 1.2.134 → 1.2.136

package/dist/index.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_event_category = require("./event-category-BaEgqJNv.js");
-const require_sleep = require("./sleep-DkBAyPva.js");
+const require_sleep = require("./sleep-BwGJ_wL_.js");
 const require_canonical_hash = require("./canonical-hash-DNV8S5ET.js");
 const require_enums = require("./enums.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
@@ -1832,7 +1832,8 @@ var OpsLogReasonSchema = zod.z.enum([
 	"quota",
 	"manual",
 	"operator",
-	"maintenance"
+	"maintenance",
+	"orphaned-device"
 ]);
 /** One audit row, shared verbatim by both domains. */
 var OpsLogEntrySchema = zod.z.object({
@@ -10311,6 +10312,29 @@ var DevicePersistConfigPayloadSchema = zod.z.object({
 	deviceId: zod.z.number(),
 	data: zod.z.record(zod.z.string(), zod.z.unknown())
 });
+/** What a migration actually did, per switch. `unreachable` is a first-class
+*  answer: a camera that could not be asked is not a camera that was silenced. */
+var MigrateSwitchOutcomeSchema = zod.z.enum([
+	"off",
+	"on",
+	"not-offered",
+	"unreachable"
+]);
+var MigrateSwitchReportSchema = zod.z.object({
+	deviceId: zod.z.number(),
+	switchId: CameraSwitchIdSchema,
+	outcome: MigrateSwitchOutcomeSchema,
+	detail: zod.z.string().optional()
+});
+var MigrateDeviceResultSchema = zod.z.object({
+	sourceId: zod.z.number(),
+	targetId: zod.z.number(),
+	switches: zod.z.array(MigrateSwitchReportSchema).readonly(),
+	/** Switches that could NOT be turned off on the source. Empty is the only
+	*  value meaning the replaced hardware is quiet. */
+	sourceStillLive: zod.z.array(CameraSwitchIdSchema).readonly(),
+	swapped: zod.z.boolean()
+});
 var deviceManagerCapability = {
 	name: "device-manager",
 	scope: "system",
@@ -10325,6 +10349,33 @@ var deviceManagerCapability = {
 			addonId: zod.z.string(),
 			stableId: zod.z.string()
 		}), zod.z.object({ id: zod.z.number() }), { kind: "mutation" }),
+		/**
+		* Replace a camera: the new hardware inherits the number the system knows.
+		*
+		* Everything general about a camera is keyed on the numeric id and nothing
+		* else — the recording path on disk, the hour ledger, the media store, zone
+		* ownership, and all four ecosystem exports. So a replacement moves the
+		* NUMBER rather than the work, and the operator keeps their footage, their
+		* rules and their integrations.
+		*
+		* Both cameras are switched off first, then the identities are exchanged
+		* (children follow their parent), then the target — now answering on the
+		* inherited number — is switched back on.
+		*
+		* **A switch that could not be written is REPORTED, not swallowed.** The
+		* source is characteristically broken, and two of the eight switches write
+		* the camera itself, so on a dead one they cannot be written at all.
+		* `sourceStillLive` names what stayed live; empty is the only value that
+		* means the old hardware is quiet. The migration proceeds either way —
+		* refusing would refuse the case this exists for.
+		*/
+		migrateDevice: require_sleep.method(zod.z.object({
+			sourceId: zod.z.number(),
+			targetId: zod.z.number()
+		}), MigrateDeviceResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Register a device in the DB + in-memory registry. Called by DeviceManagerApi.register(). */
 		registerDevice: require_sleep.method(DeviceRegisterPayloadSchema, zod.z.void(), { kind: "mutation" }),
 		/** Remove a device from the DB + in-memory registry. Called by DeviceManagerApi.remove(). */
@@ -18777,6 +18828,49 @@ var KeyEventsForDeviceSchema = zod.z.object({
 	deviceId: zod.z.number(),
 	events: zod.z.array(KeyEventSchema).readonly()
 });
+/** One non-empty bucket of the timeline histogram. */
+var EventDensityBucketSchema = zod.z.object({
+	bucketStart: zod.z.number(),
+	motion: zod.z.number().int(),
+	object: zod.z.number().int(),
+	audio: zod.z.number().int()
+});
+/**
+* Most cameras one `getEventDensityBatch` may name.
+*
+* The same ceiling the sibling batches on this cap already carry
+* (`listEventKindsBatch`, `getKeyEventsBatch`): a tablet grid is tens of
+* cameras, never hundreds, and one call's answer is N × (window / bucketMs)
+* buckets crossing a process boundary.
+*
+* The ceiling is on the SCHEMA, not only on the caller. An over-eager ask is
+* REFUSED — never truncated to the first {@link EVENT_DENSITY_BATCH_MAX} ids,
+* because that answer is indistinguishable from a complete one and the caller
+* would never learn it asked too much. A caller with more cameras sends
+* ⌈n/max⌉ calls.
+*/
+var EVENT_DENSITY_BATCH_MAX = 200;
+/**
+* One camera's row in a `getEventDensityBatch` answer.
+*
+* TWO facts, and the timeline draws them differently:
+*
+*  - `read: 'read'` — the histogram for this camera. `buckets: []` is a real
+*    claim: read, and nothing happened in the window.
+*  - `read: 'unreadable'` — nobody could answer for this camera. `buckets` is
+*    empty and that emptiness means NOTHING; the timeline must render unknown,
+*    not quiet.
+*
+* Fanned out per camera the difference was free — one query rejected while the
+* others resolved — and collapsing to a batch is the exact moment it is lost
+* silently. Every requested id gets a row: a caller that asked for twelve and
+* got eleven cannot tell which one is missing, or that any is.
+*/
+var EventDensityForDeviceSchema = zod.z.object({
+	deviceId: zod.z.number(),
+	read: zod.z.enum(["read", "unreadable"]),
+	buckets: zod.z.array(EventDensityBucketSchema).readonly()
+});
 var TrackedDetectionSchema = zod.z.object({
 	trackId: zod.z.string(),
 	className: zod.z.string(),
@@ -19177,12 +19271,31 @@ var pipelineAnalyticsCapability = {
 			since: zod.z.number(),
 			until: zod.z.number(),
 			bucketMs: zod.z.number().int().positive()
-		}), zod.z.array(zod.z.object({
-			bucketStart: zod.z.number(),
-			motion: zod.z.number().int(),
-			object: zod.z.number().int(),
-			audio: zod.z.number().int()
-		})).readonly()),
+		}), zod.z.array(EventDensityBucketSchema).readonly()),
+		/**
+		* The same histogram, for a SET of cameras, in one round trip.
+		*
+		* A multi-camera timeline (the tablet grid) re-asks this of every camera in
+		* the grid on every day change — N browser → hub → post-analysis round
+		* trips for N independent, already-indexed store queries. The queries are
+		* unchanged and still run per camera (`densityByKind`, one per deviceId,
+		* concurrently INSIDE the owner); only the transport collapses.
+		*
+		* Deliberately per-device rather than pre-merged: a timeline lane belongs
+		* to a camera, and a caller that merged would have to un-merge.
+		* `getEventDensity` stays for single-camera callers.
+		*
+		* Every requested id gets a row, marked — see
+		* {@link EventDensityForDeviceSchema}. `deviceIds` is capped at
+		* {@link EVENT_DENSITY_BATCH_MAX}, and an over-cap ask is refused rather
+		* than truncated.
+		*/
+		getEventDensityBatch: require_sleep.method(zod.z.object({
+			deviceIds: zod.z.array(zod.z.number()).min(1).max(200),
+			since: zod.z.number(),
+			until: zod.z.number(),
+			bucketMs: zod.z.number().int().positive()
+		}), zod.z.array(EventDensityForDeviceSchema).readonly()),
 		/**
 		* @deprecated Prefer `pruneTracksBefore` — the track is the ROOT of the
 		* analytics model and retention must cascade from it (design §5.1). This
@@ -31113,6 +31226,54 @@ var RecordingDaysSchema = zod.z.object({
 	/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
 	days: zod.z.array(zod.z.number())
 });
+/**
+* Most cameras one `getAvailabilityBatch` / `getDaysWithRecordingsBatch` may
+* name.
+*
+* Matches the ceiling the per-camera batches elsewhere in the system carry
+* (`pipelineAnalytics.getKeyEventsBatch`, `sceneMonitor.listScenesBatch`): a
+* grid is tens of cameras, never hundreds, and each id costs the recorder one
+* calendar walk whose answer crosses a process boundary.
+*
+* The ceiling is on the SCHEMA. An over-eager ask is REFUSED, never truncated
+* to the first {@link RECORDING_TIMELINE_BATCH_MAX} ids — a truncated answer
+* looks exactly like a complete one, and the caller would draw an empty
+* timeline for the cameras it never learned were dropped.
+*/
+var RECORDING_TIMELINE_BATCH_MAX = 200;
+/**
+* One camera's row in a `getAvailabilityBatch` answer.
+*
+* `ranges` is EXACTLY what `getAvailability` returns for that camera — the
+* batch collapses the transport, not the work — plus the one thing the singular
+* method never had to say:
+*
+*  - `read: 'read'` — answered. `ranges: []` means "read, and this camera has
+*    no footage in the window", which is a real claim.
+*  - `read: 'unreadable'` — the recorder could not answer for this camera (its
+*    calendar rung threw, its location is unmounted). `ranges` is empty and
+*    that emptiness means NOTHING.
+*
+* A timeline that renders the second as the first tells an operator there is no
+* footage when the truth is that nobody looked.
+*/
+var RecordingAvailabilityForDeviceSchema = zod.z.object({
+	deviceId: zod.z.number(),
+	read: zod.z.enum(["read", "unreadable"]),
+	ranges: zod.z.array(RecordingRangeSchema).readonly()
+});
+/**
+* One camera's row in a `getDaysWithRecordingsBatch` answer. Same rule as
+* {@link RecordingAvailabilityForDeviceSchema}: `days: []` on a `'read'` row is
+* "no footage in this month", `read: 'unreadable'` is "nobody could look", and
+* the date-picker's day dots must not spell them the same.
+*/
+var RecordingDaysForDeviceSchema = zod.z.object({
+	deviceId: zod.z.number(),
+	read: zod.z.enum(["read", "unreadable"]),
+	/** Local-midnight epochs (UTC ms) of days that have ≥1 recorded segment. */
+	days: zod.z.array(zod.z.number()).readonly()
+});
 var RecordingManifestSchema = zod.z.object({
 	deviceId: zod.z.number(),
 	/** Local filesystem path to the master playlist; null when no recording exists for the requested range. */
@@ -31358,6 +31519,32 @@ var recordingCapability = {
 			kind: "query",
 			auth: "protected"
 		}),
+		/**
+		* `getAvailability` for a SET of cameras, in one round trip.
+		*
+		* A multi-camera timeline re-asks availability for every camera in the grid
+		* on every day change; fanned out that is one request per camera for N
+		* independent calendar walks. The per-camera work is IDENTICAL (the same
+		* `availabilityProfileFor` + `rangesIn`, run concurrently inside the
+		* recorder) — only the transport collapses.
+		*
+		* `protected` for the same reason the singular method is: every id in
+		* `deviceIds` is a device reference, so the F1 #3 gate refuses any camera
+		* outside the caller's scope — one id out of scope refuses the CALL, it
+		* does not quietly drop a row.
+		*
+		* Every requested id gets a row, marked — see
+		* {@link RecordingAvailabilityForDeviceSchema}. `deviceIds` is capped at
+		* {@link RECORDING_TIMELINE_BATCH_MAX} and an over-cap ask is refused.
+		*/
+		getAvailabilityBatch: require_sleep.method(zod.z.object({
+			deviceIds: zod.z.array(zod.z.number()).min(1).max(200),
+			fromMs: zod.z.number(),
+			toMs: zod.z.number()
+		}), zod.z.array(RecordingAvailabilityForDeviceSchema).readonly(), {
+			kind: "query",
+			auth: "protected"
+		}),
 		/** Which calendar days in [fromMs,toMs) have ≥1 recorded segment, bucketed by
 		*  the client's local day (`tzOffsetMinutes` = minutes to add to UTC). Drives
 		*  the theater date-picker's day dots. */
@@ -31370,6 +31557,26 @@ var recordingCapability = {
 			kind: "query",
 			auth: "protected"
 		}),
+		/**
+		* `getDaysWithRecordings` for a SET of cameras, in one round trip.
+		*
+		* The cheapest question in the product, asked once per camera per month
+		* change. One directory read per day per camera at the owner, unchanged;
+		* what collapses is the N requests it took to ask.
+		*
+		* Every requested id gets a row, marked — see
+		* {@link RecordingDaysForDeviceSchema}. `deviceIds` is capped at
+		* {@link RECORDING_TIMELINE_BATCH_MAX} and an over-cap ask is refused.
+		*/
+		getDaysWithRecordingsBatch: require_sleep.method(zod.z.object({
+			deviceIds: zod.z.array(zod.z.number()).min(1).max(200),
+			fromMs: zod.z.number(),
+			toMs: zod.z.number(),
+			tzOffsetMinutes: zod.z.number()
+		}), zod.z.array(RecordingDaysForDeviceSchema).readonly(), {
+			kind: "query",
+			auth: "protected"
+		}),
 		getPlaybackManifest: require_sleep.method(zod.z.object({
 			deviceId: zod.z.number(),
 			fromMs: zod.z.number(),
@@ -40248,6 +40455,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"deviceManager.migrateDevice": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"deviceManager.persistConfig": {
 		capName: "device-manager",
 		capScope: "system",
@@ -41982,6 +42195,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.getEventDensityBatch": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.getEventMedia": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -43104,12 +43323,24 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"recording.getAvailabilityBatch": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"recording.getDaysWithRecordings": {
 		capName: "recording",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
+	"recording.getDaysWithRecordingsBatch": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"recording.getDeviceConfig": {
 		capName: "recording",
 		capScope: "system",
@@ -45977,6 +46208,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineAnalytics.getEventDensityBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"pipelineAnalytics.getEventMedia": [{
 		name: "deviceId",
 		form: "single",
@@ -46392,11 +46628,21 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"recording.getAvailabilityBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"recording.getDaysWithRecordings": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
+	"recording.getDaysWithRecordingsBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"recording.getDeviceConfig": [{
 		name: "deviceId",
 		form: "single",
@@ -46928,7 +47174,9 @@ var SYSTEM_SCOPE_DEVICE_METHODS = [
 	"plateGallery.listPlates",
 	"recording.deleteFootprint",
 	"recording.getAvailability",
+	"recording.getAvailabilityBatch",
 	"recording.getDaysWithRecordings",
+	"recording.getDaysWithRecordingsBatch",
 	"recording.getDeviceConfig",
 	"recording.getPlaybackManifest",
 	"recording.listOpsLog",
@@ -47571,6 +47819,7 @@ function createSystemProxy(api) {
 		},
 		deviceManager: {
 			allocateDeviceId: (input) => dispatch("deviceManager", "allocateDeviceId", "mutation", input),
+			migrateDevice: (input) => dispatch("deviceManager", "migrateDevice", "mutation", input),
 			registerDevice: (input) => dispatch("deviceManager", "registerDevice", "mutation", input),
 			removeDevice: (input) => dispatch("deviceManager", "removeDevice", "mutation", input),
 			persistConfig: (input) => dispatch("deviceManager", "persistConfig", "mutation", input),
@@ -47859,6 +48108,8 @@ function createSystemProxy(api) {
 			unassignPlates: (input) => dispatch("plateGallery", "unassignPlates", "mutation", input)
 		},
 		recording: {
+			getAvailabilityBatch: (input) => dispatch("recording", "getAvailabilityBatch", "query", input),
+			getDaysWithRecordingsBatch: (input) => dispatch("recording", "getDaysWithRecordingsBatch", "query", input),
 			getStorageUsage: (input) => dispatch("recording", "getStorageUsage", "query", input),
 			listOpsLog: (input) => dispatch("recording", "listOpsLog", "query", input),
 			pauseForStorageMigration: (input) => dispatch("recording", "pauseForStorageMigration", "mutation", input),
@@ -52260,6 +52511,7 @@ exports.DisposerChain = require_sleep.DisposerChain;
 exports.DoorbellPressEventSchema = DoorbellPressEventSchema;
 exports.DoorbellStatusSchema = DoorbellStatusSchema;
 exports.EVENTFUL_CAP_NAMES = EVENTFUL_CAP_NAMES;
+exports.EVENT_DENSITY_BATCH_MAX = EVENT_DENSITY_BATCH_MAX;
 exports.EVENT_KIND_BY_CAP = EVENT_KIND_BY_CAP;
 exports.EVENT_PAD_MS = EVENT_PAD_MS;
 exports.EVENT_TAXONOMY = EVENT_TAXONOMY;
@@ -52282,6 +52534,8 @@ exports.EnrichedWidgetMetadataSchema = EnrichedWidgetMetadataSchema;
 exports.EnumSensorDateTimeFormatSchema = EnumSensorDateTimeFormatSchema;
 exports.EnumSensorStatusSchema = EnumSensorStatusSchema;
 exports.EventCategory = require_event_category.EventCategory;
+exports.EventDensityBucketSchema = EventDensityBucketSchema;
+exports.EventDensityForDeviceSchema = EventDensityForDeviceSchema;
 exports.EventEmitterStatusSchema = EventEmitterStatusSchema;
 exports.EventFireSchema = EventFireSchema;
 exports.EventItemSchema = EventItemSchema;
@@ -52691,6 +52945,7 @@ exports.REACHABILITY_POLL_INTERVAL_MS = REACHABILITY_POLL_INTERVAL_MS;
 exports.REACHABILITY_PROBE_TIMEOUT_MS = REACHABILITY_PROBE_TIMEOUT_MS;
 exports.RECOGNITION_TYPES = RECOGNITION_TYPES;
 exports.RECORDING_EXPORT_MAX_READ_BYTES = RECORDING_EXPORT_MAX_READ_BYTES;
+exports.RECORDING_TIMELINE_BATCH_MAX = RECORDING_TIMELINE_BATCH_MAX;
 exports.REDACTED_SECRET = REDACTED_SECRET;
 exports.RESERVED_BINDING_NAMES = RESERVED_BINDING_NAMES;
 exports.RESTORED_CAP_NAMES = RESTORED_CAP_NAMES;
@@ -52707,11 +52962,13 @@ exports.ReadinessRegistry = require_sleep.ReadinessRegistry;
 exports.ReadinessTimeoutError = require_sleep.ReadinessTimeoutError;
 exports.RecentTracksPageSchema = RecentTracksPageSchema;
 exports.RecentTracksQueryInput = RecentTracksQueryInput;
+exports.RecordingAvailabilityForDeviceSchema = RecordingAvailabilityForDeviceSchema;
 exports.RecordingAvailabilitySchema = RecordingAvailabilitySchema;
 exports.RecordingBandModeSchema = RecordingBandModeSchema;
 exports.RecordingBandSchema = RecordingBandSchema;
 exports.RecordingBandTriggersSchema = RecordingBandTriggersSchema;
 exports.RecordingConfigSchema = RecordingConfigSchema;
+exports.RecordingDaysForDeviceSchema = RecordingDaysForDeviceSchema;
 exports.RecordingDaysSchema = RecordingDaysSchema;
 exports.RecordingDeviceUsageSchema = RecordingDeviceUsageSchema;
 exports.RecordingLocationUsageSchema = RecordingLocationUsageSchema;