@camstack/types 1.2.129 → 1.2.131

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-D5821NGq.js");
+const require_sleep = require("./sleep-CqVyhcl-.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");
@@ -2267,6 +2267,20 @@ var RelocateJobSchema = zod.z.object({
 	* in its row, not in its name, so `MediaRelocateEngine` never reconciles one.
 	*/
 	rowsReconciled: zod.z.number().int().nonnegative().optional(),
+	/**
+	* Rows this run FORGOT because the file they name is not on disk.
+	*
+	* The mover derived the path from the row's own fields and `stat`ed it; an
+	* ENOENT there is a per-path confirmation that the segment is gone (D296),
+	* and the durable row is dropped through the same channel eviction uses. It
+	* is reported for the same reason `rowsReconciled` is: this is a durable
+	* mutation nobody asked for, and a migration that quietly erases hour rows is
+	* the same failure as one that quietly skips them (D295).
+	*
+	* The production drain of 2026-08-30 would have reported 11 074 here — the
+	* ledger claimed 5.65 GB of footage that no longer existed.
+	*/
+	rowsForgotten: zod.z.number().int().nonnegative().optional(),
 	startedAt: zod.z.number(),
 	finishedAt: zod.z.number().nullable(),
 	error: zod.z.string().nullable()
@@ -2662,6 +2676,92 @@ var RelocateResidueSchema = zod.z.object({
 	segments: zod.z.number().int().nonnegative(),
 	bytes: zod.z.number().int().nonnegative()
 }).nullable();
+/**
+* Ask one location whether its durable hour rows describe the disk — the walk
+* (D319).
+*
+* `apply` DEFAULTS TO FALSE and that default is the product: the operator's
+* missing tool is the question, and the dry run is how they sanity-check the
+* destructive run before authorising it.
+*/
+var LedgerWalkInputSchema = zod.z.object({
+	locationId: zod.z.string().min(1),
+	/** Forget the confirmed-absent rows, rather than only counting them. */
+	apply: zod.z.boolean().optional(),
+	/** Narrow to one camera. */
+	deviceId: zod.z.number().int().positive().optional(),
+	/** Narrow to these recording profiles; empty/absent = every profile. */
+	profiles: zod.z.array(zod.z.string().min(1)).optional()
+});
+/** Why a whole walk did nothing. Every one leaves the ledger untouched. */
+var LedgerWalkRefusalSchema = zod.z.enum([
+	"location-unknown",
+	"source-writable",
+	"no-ledger",
+	"archive-unreadable",
+	"anchor-absent",
+	"anchor-unreadable",
+	"anchor-moved"
+]);
+/** Why one hour was left exactly as it was found. */
+var LedgerWalkSkipReasonSchema = zod.z.enum([
+	"live-tail",
+	"listing-error",
+	"path-mismatch",
+	"durable-refused"
+]);
+/** Every skip reason, always present, always a number — so a reason that never
+*  fired reports as zero rather than absent and the report shape is constant
+*  between passes. Spelled out rather than `z.record` for exactly that. */
+var LedgerWalkSkipCountsSchema = zod.z.object({
+	"live-tail": zod.z.number().int().nonnegative(),
+	"listing-error": zod.z.number().int().nonnegative(),
+	"path-mismatch": zod.z.number().int().nonnegative(),
+	"durable-refused": zod.z.number().int().nonnegative()
+});
+/** One camera's share of a walk, so a report names cameras and not rows. */
+var LedgerWalkDeviceReportSchema = zod.z.object({
+	deviceId: zod.z.number().int(),
+	hoursWalked: zod.z.number().int().nonnegative(),
+	hoursMissing: zod.z.number().int().nonnegative(),
+	ghostSegments: zod.z.number().int().nonnegative(),
+	ghostBytes: zod.z.number().int().nonnegative(),
+	forgottenSegments: zod.z.number().int().nonnegative(),
+	orphanFiles: zod.z.number().int().nonnegative()
+});
+/**
+* What one walk claimed, listed, found and (only when armed) forgot.
+*
+* `archiveSegments` is the **M** and `segmentsClaimed` the **N** (D295), so a
+* walk that saw a fraction of the location is visible in its own report rather
+* than in the absence of one.
+*/
+var LedgerWalkReportSchema = zod.z.object({
+	locationId: zod.z.string(),
+	applied: zod.z.boolean(),
+	refused: LedgerWalkRefusalSchema.nullable(),
+	archiveSegments: zod.z.number().int().nonnegative().nullable(),
+	archiveBytes: zod.z.number().int().nonnegative().nullable(),
+	hoursClaimed: zod.z.number().int().nonnegative(),
+	hoursWalked: zod.z.number().int().nonnegative(),
+	hoursMissing: zod.z.number().int().nonnegative(),
+	/** `readdir` calls issued — the cost, stated in the unit that is paid. */
+	listings: zod.z.number().int().nonnegative(),
+	segmentsClaimed: zod.z.number().int().nonnegative(),
+	ghostSegments: zod.z.number().int().nonnegative(),
+	ghostBytes: zod.z.number().int().nonnegative(),
+	ghostHoursWhole: zod.z.number().int().nonnegative(),
+	forgottenSegments: zod.z.number().int().nonnegative(),
+	forgottenBytes: zod.z.number().int().nonnegative(),
+	/** Files under a claimed hour that no durable row names. Never deleted. */
+	orphanFiles: zod.z.number().int().nonnegative(),
+	orphanSample: zod.z.array(zod.z.string()).readonly(),
+	hoursSkipped: zod.z.number().int().nonnegative(),
+	skippedByReason: LedgerWalkSkipCountsSchema,
+	/** The walk stopped at its per-pass hour bound with claims unwalked. */
+	bounded: zod.z.boolean(),
+	byDevice: zod.z.array(LedgerWalkDeviceReportSchema).readonly()
+});
 /** How many rows a media pass would still act on against a given target — the
 *  media lane's denominator AND its residue, from ONE derivation so the two can
 *  never disagree. `null` = the count could not be taken. */
@@ -18566,13 +18666,15 @@ var ListGroupsPageSchema = zod.z.object({
 	groups: zod.z.array(AnalyticsGroupRecordSchema).readonly(),
 	nextCursor: zod.z.string().nullable()
 });
+var KEY_EVENTS_DEFAULT_LIMIT = 50;
+var KEY_EVENTS_MAX_LIMIT = 200;
 var KeyEventQueryInput = zod.z.object({
 	deviceId: zod.z.number(),
 	/** Window lower bound (track firstSeen ≥ since). */
 	since: zod.z.number(),
 	/** Window upper bound (track firstSeen ≤ until). */
 	until: zod.z.number(),
-	limit: zod.z.number().int().min(1).max(200).default(50),
+	limit: zod.z.number().int().min(1).max(KEY_EVENTS_MAX_LIMIT).default(KEY_EVENTS_DEFAULT_LIMIT),
 	/** Drop tracks scoring below this importance. */
 	minImportance: zod.z.number().min(0).max(1).optional(),
 	/** Restrict to a single class (e.g. 'person'). */
@@ -18594,6 +18696,32 @@ var KeyEventSchema = zod.z.object({
 	...TrackFlagFields,
 	...TrackRetrainFields
 });
+/** `getKeyEvents`' window and filters, asked of a SET of cameras at once. */
+var KeyEventBatchQueryInput = zod.z.object({
+	deviceIds: zod.z.array(zod.z.number()).min(1).max(200),
+	since: zod.z.number(),
+	until: zod.z.number(),
+	/** Applied PER CAMERA, exactly as `getKeyEvents.limit` is — never a total
+	*  across the set, which would let a busy camera starve a quiet one of its
+	*  rows and change what the merged feed contains. */
+	limit: zod.z.number().int().min(1).max(KEY_EVENTS_MAX_LIMIT).default(KEY_EVENTS_DEFAULT_LIMIT),
+	minImportance: zod.z.number().min(0).max(1).optional(),
+	classFilter: zod.z.string().optional()
+});
+/**
+* One camera's key events in a batch answer.
+*
+* The row exists for every requested id. `getKeyEvents` degrades to `[]` on
+* error rather than throwing, so a camera whose store read failed and one with
+* no events in the window were ALREADY indistinguishable per camera — the
+* batch does not make that worse, and the row keeps the deviceId the single
+* method's output never carried (the caller used to stamp it from the fan-out
+* key, which only worked because there was one query per camera).
+*/
+var KeyEventsForDeviceSchema = zod.z.object({
+	deviceId: zod.z.number(),
+	events: zod.z.array(KeyEventSchema).readonly()
+});
 var TrackedDetectionSchema = zod.z.object({
 	trackId: zod.z.string(),
 	className: zod.z.string(),
@@ -18813,6 +18941,47 @@ var RebuildStatusSchema = zod.z.object({
 	/** Present when the pass ended by throwing. */
 	error: zod.z.string().nullable()
 });
+/**
+* Acknowledgement that a debug-media reclaim STARTED.
+*
+* The pass is paced at ~2 MB/s over a standing 100 GB — tens of minutes — so
+* it runs detached and this returns immediately. Awaiting it is how the
+* `addons.custom` door hit the 60 s UDS deadline while the walk carried on
+* with no status. Poll {@link pipelineAnalyticsCapability.methods.getMediaReclaimStatus}.
+*/
+var MediaReclaimStartResultSchema = zod.z.object({
+	started: zod.z.boolean(),
+	/** True when a pass was already running; the new request is ignored. */
+	alreadyRunning: zod.z.boolean()
+});
+var MediaReclaimInputSchema = zod.z.object({
+	mode: zod.z.enum(["report", "reclaim"]).default("report"),
+	scopes: zod.z.array(zod.z.enum(["motion-still", "track-filmstrip"])).min(1).optional(),
+	deviceIds: zod.z.array(zod.z.number().int()).min(1).optional(),
+	restart: zod.z.boolean().optional(),
+	pageSize: zod.z.number().int().min(50).max(5e3).optional(),
+	maxRowsPerDevice: zod.z.number().int().min(1).max(5e5).optional(),
+	maxReclaimPerDevice: zod.z.number().int().min(1).max(5e5).optional(),
+	maxBytesPerRun: zod.z.number().int().min(1).optional(),
+	budgetMinutes: zod.z.number().int().min(1).max(720).optional(),
+	throttleBytesPerSec: zod.z.number().int().min(64 * 1024).optional(),
+	graceMinutes: zod.z.number().int().min(1).max(10080).optional()
+});
+var MediaReclaimStatusSchema = zod.z.object({
+	running: zod.z.boolean(),
+	mode: zod.z.enum(["report", "reclaim"]).nullable(),
+	totalExamined: zod.z.number(),
+	totalEligible: zod.z.number(),
+	totalReclaimed: zod.z.number(),
+	totalBytesReclaimed: zod.z.number(),
+	totalRefused: zod.z.number(),
+	/** Device+scope windows finished in this pass. */
+	devicesDone: zod.z.number(),
+	complete: zod.z.boolean().nullable(),
+	startedAtMs: zod.z.number().nullable(),
+	finishedAtMs: zod.z.number().nullable(),
+	error: zod.z.string().nullable()
+});
 var ReplayFrameInputSchema = zod.z.object({
 	timestamp: zod.z.number(),
 	frame: PipelineRunResultBridge
@@ -18943,6 +19112,21 @@ var pipelineAnalyticsCapability = {
 		* scored on-read (no write). Degrades to `[]` on error.
 		*/
 		getKeyEvents: require_sleep.method(KeyEventQueryInput, zod.z.array(KeyEventSchema).readonly()),
+		/**
+		* The same ranking, for a SET of cameras, in one round trip.
+		*
+		* The Detection Intelligence events feed asks this of every selected
+		* camera and re-asks on a 30s timer. Fanned out client-side that is N
+		* round trips — browser → hub → post-analysis — for N independent,
+		* already-indexed store queries. Batched, the queries are unchanged and
+		* run concurrently INSIDE the owner; only the transport collapses.
+		*
+		* Deliberately per-device rather than pre-merged: `limit` stays per
+		* camera (a total would let a busy camera starve a quiet one), and a
+		* caller that renders one camera's lane needs to know which camera a row
+		* came from. `getKeyEvents` stays for single-device callers.
+		*/
+		getKeyEventsBatch: require_sleep.method(KeyEventBatchQueryInput, zod.z.array(KeyEventsForDeviceSchema).readonly()),
 		/** Server-side bucketed event counts for the 24-hour timeline.
 		*  Returns one entry per non-empty bucket; empty buckets are omitted. */
 		getEventDensity: require_sleep.method(zod.z.object({
@@ -19221,6 +19405,20 @@ var pipelineAnalyticsCapability = {
 			auth: "admin"
 		}),
 		/**
+		* Reclaim the standing debug-media backlog (motion-visit stills + track
+		* filmstrips). DETACHED: returns `{ started }` immediately. The pass is
+		* tens of minutes; awaiting it is a timeout, not a verdict. Dry-run unless
+		* `mode: 'reclaim'`. Poll `getMediaReclaimStatus`.
+		*/
+		reclaimDebugMedia: require_sleep.method(MediaReclaimInputSchema, MediaReclaimStartResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getMediaReclaimStatus: require_sleep.method(zod.z.object({}), MediaReclaimStatusSchema, {
+			kind: "query",
+			auth: "admin"
+		}),
+		/**
 		* The CHEAP QUESTION, asked before any media moves: how big is the dataset
 		* the marked (`markForTrain`) tracks would produce?
 		*
@@ -31308,6 +31506,23 @@ var recordingCapability = {
 			kind: "query",
 			auth: "admin"
 		}),
+		/**
+		* Does this location's LEDGER tell the truth about its disk? (D319)
+		*
+		* One `readdir` per claimed hour, diffed both ways: durable rows whose file
+		* is not there, and files no durable row names. `apply` defaults to FALSE —
+		* the report is the product, and the dry run is how an operator
+		* sanity-checks the destructive run before authorising it.
+		*
+		* REFUSES a source that is still a write target: a listing of a live
+		* location is a lower bound, which is not the strong evidence that lets
+		* this pass forget without a budget. A live location is reconciled by the
+		* mover, under D318's bound.
+		*/
+		reconcileLedgerAgainstDisk: require_sleep.method(LedgerWalkInputSchema, LedgerWalkReportSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Cancel a running or queued relocate job. A queued job never runs. */
 		cancelRelocateJob: require_sleep.method(zod.z.object({ jobId: zod.z.string() }), zod.z.object({ cancelled: zod.z.boolean() }), {
 			kind: "mutation",
@@ -31809,6 +32024,25 @@ var SceneMonitorStatusSchema = zod.z.object({
 	monitors: zod.z.array(SceneMonitorSchema),
 	lastFetchedAt: zod.z.number()
 });
+/**
+* One camera's row in a `listScenesBatch` answer.
+*
+* `status` is NULLABLE and the nullability is the whole point. `scene-monitor`
+* is a `defaultActive` wrapper, so every camera is asked; a camera whose
+* provider is absent (pipeline-analytics not deployed, the post-processing node
+* down) cannot answer, and that is not the same fact as a camera with no scenes
+* configured. Fanned out per camera the difference was visible — one query
+* errored while the others resolved — and a batch that returned only the rows
+* it managed would have destroyed it, silently, by making an unreachable camera
+* indistinguishable from one that answered `monitors: []`.
+*
+* So: EVERY requested deviceId gets a row. `status: null` means "this camera
+* could not be read"; `status.monitors: []` means "read, and it has none".
+*/
+var SceneMonitorStatusForDeviceSchema = zod.z.object({
+	deviceId: zod.z.number(),
+	status: SceneMonitorStatusSchema.nullable()
+});
 var sceneMonitorCapability = {
 	name: "scene-monitor",
 	scope: "device",
@@ -31818,6 +32052,22 @@ var sceneMonitorCapability = {
 	deviceTypes: [require_sleep.DeviceType.Camera],
 	methods: {
 		listScenes: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), SceneMonitorStatusSchema),
+		/**
+		* The same answer, for a SET of cameras, in one round trip.
+		*
+		* `/scenes` renders every camera and re-reads them on a 30s safety-net
+		* poll behind the push slice. Fanned out client-side that was one query
+		* per camera — 29 round trips through the browser, the hub and the
+		* post-analysis runner every 30 seconds to read an in-memory map the
+		* owner had already merged. The work is unchanged (`statusFor` per
+		* device, all in-process at the owner); what collapses is the transport.
+		*
+		* A camera that cannot answer still gets a row, with `status: null` —
+		* see {@link SceneMonitorStatusForDeviceSchema}. Never fewer rows than
+		* ids: a caller that asked for twenty-nine and got twenty-seven cannot
+		* tell which two are missing, or that any are.
+		*/
+		listScenesBatch: require_sleep.method(zod.z.object({ deviceIds: zod.z.array(zod.z.number()).min(1).max(200) }), zod.z.array(SceneMonitorStatusForDeviceSchema).readonly()),
 		createScene: require_sleep.method(zod.z.object({
 			deviceId: zod.z.number(),
 			label: zod.z.string(),
@@ -34126,6 +34376,27 @@ var CameraOccupancySnapshotSchema = zod.z.object({
 	stationaryObjects: zod.z.array(StationaryObjectSchema).readonly().optional()
 });
 /**
+* One camera's row in a `getCurrentSnapshotBatch` answer.
+*
+* THREE outcomes, and the single-camera method could only express two of them
+* because `snapshot: null` was already spoken for:
+*
+*  - `read: 'read'`, `snapshot` present — the live occupancy reading.
+*  - `read: 'read'`, `snapshot: null`   — read, and this camera has no reading
+*    yet: no frame since boot, and no parked-object registry to hydrate from.
+*  - `read: 'unreadable'`               — the owner could not answer for this
+*    camera. `snapshot` is null, and it does NOT mean "nothing parked here".
+*
+* Collapsing the last two is the failure this field exists to prevent: a
+* hydration that threw would otherwise render as an empty Stationary section,
+* which is a definite claim about a camera nobody could read.
+*/
+var CameraOccupancySnapshotForDeviceSchema = zod.z.object({
+	deviceId: zod.z.number(),
+	read: zod.z.enum(["read", "unreadable"]),
+	snapshot: CameraOccupancySnapshotSchema.nullable()
+});
+/**
 * Time-series resolution. The history methods return one bucket per
 * step over the requested range. Smaller resolutions cost more
 * memory + bandwidth; bound to discrete steps so caller cannot ask
@@ -34182,6 +34453,20 @@ var zoneAnalyticsCapability = {
 		*  (no inference result emitted since boot or since binding was
 		*  activated). */
 		getCurrentSnapshot: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), CameraOccupancySnapshotSchema.nullable()),
+		/**
+		* The same snapshot, for a SET of cameras, in one round trip.
+		*
+		* The Events page's Stationary section polls this every 15s for every
+		* selected camera. Fanned out client-side that is one query per camera to
+		* read a `Map.get` at the owner — the answer costs nothing, the round trip
+		* costs everything. Batched, N transports become one and the per-device
+		* work is unchanged.
+		*
+		* Every requested deviceId gets a row, tagged `read` — see
+		* {@link CameraOccupancySnapshotForDeviceSchema}. A camera the owner could
+		* not answer for is `'unreadable'`, never an empty reading.
+		*/
+		getCurrentSnapshotBatch: require_sleep.method(zod.z.object({ deviceIds: zod.z.array(zod.z.number()).min(1).max(200) }), zod.z.array(CameraOccupancySnapshotForDeviceSchema).readonly()),
 		/** Time-series object count inside one zone. `className` optional —
 		*  omit to count every class in the zone. */
 		getZoneHistory: require_sleep.method(zod.z.object({
@@ -41619,6 +41904,18 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.getKeyEventsBatch": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"pipelineAnalytics.getMediaReclaimStatus": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.getMotionEvents": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -41793,6 +42090,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.reclaimDebugMedia": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.reconcileFromDisk": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -42795,6 +43098,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"recording.reconcileLedgerAgainstDisk": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"recording.refreshStorageLocationsForMigration": {
 		capName: "recording",
 		capScope: "system",
@@ -42921,6 +43230,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"sceneMonitor.listScenesBatch": {
+		capName: "scene-monitor",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"sceneMonitor.recheckNow": {
 		capName: "scene-monitor",
 		capScope: "device",
@@ -44277,6 +44592,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"zoneAnalytics.getCurrentSnapshotBatch": {
+		capName: "zone-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"zoneAnalytics.getUnzonedHistory": {
 		capName: "zone-analytics",
 		capScope: "device",
@@ -45544,6 +45865,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineAnalytics.getKeyEventsBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"pipelineAnalytics.getMotionEvents": [{
 		name: "deviceId",
 		form: "single",
@@ -45649,6 +45975,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: true
 	}],
+	"pipelineAnalytics.reclaimDebugMedia": [{
+		name: "deviceIds",
+		form: "array",
+		optional: true
+	}],
 	"pipelineAnalytics.reconcileFromDisk": [{
 		name: "deviceId",
 		form: "single",
@@ -45984,6 +46315,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"recording.reconcileLedgerAgainstDisk": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
 	"recording.relocateFootage": [{
 		name: "deviceId",
 		form: "single",
@@ -46049,6 +46385,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"sceneMonitor.listScenesBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"sceneMonitor.recheckNow": [{
 		name: "deviceId",
 		form: "single",
@@ -46310,6 +46651,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"zoneAnalytics.getCurrentSnapshotBatch": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"zoneAnalytics.getUnzonedHistory": [{
 		name: "deviceId",
 		form: "single",
@@ -46464,6 +46810,7 @@ var SYSTEM_SCOPE_DEVICE_METHODS = [
 	"recording.readGopBytes",
 	"recording.readSegmentBytes",
 	"recording.readWindowBytes",
+	"recording.reconcileLedgerAgainstDisk",
 	"recording.relocateFootage",
 	"recording.renderClip",
 	"recording.renderGif",
@@ -47394,6 +47741,7 @@ function createSystemProxy(api) {
 			relocateFootage: (input) => dispatch("recording", "relocateFootage", "mutation", input),
 			listRelocateJobs: (input) => dispatch("recording", "listRelocateJobs", "query", input),
 			getRelocateResidue: (input) => dispatch("recording", "getRelocateResidue", "query", input),
+			reconcileLedgerAgainstDisk: (input) => dispatch("recording", "reconcileLedgerAgainstDisk", "mutation", input),
 			cancelRelocateJob: (input) => dispatch("recording", "cancelRelocateJob", "mutation", input),
 			planStorageRebalance: (input) => dispatch("recording", "planStorageRebalance", "query", input),
 			startStorageRebalance: (input) => dispatch("recording", "startStorageRebalance", "mutation", input)
@@ -51644,6 +51992,7 @@ exports.CameraDetectionStatusSchema = CameraDetectionStatusSchema;
 exports.CameraMetricsSchema = CameraMetricsSchema;
 exports.CameraMetricsWithDeviceIdSchema = CameraMetricsWithDeviceIdSchema;
 exports.CameraMotionStatusSchema = CameraMotionStatusSchema;
+exports.CameraOccupancySnapshotForDeviceSchema = CameraOccupancySnapshotForDeviceSchema;
 exports.CameraRecordingModeSchema = CameraRecordingModeSchema;
 exports.CameraRecordingStatusSchema = CameraRecordingStatusSchema;
 exports.CameraSourceStatusSchema = CameraSourceStatusSchema;
@@ -51894,6 +52243,12 @@ exports.LabelDefinitionSchema = LabelDefinitionSchema;
 exports.LabelTierSchema = LabelTierSchema;
 exports.LawnMowerActivitySchema = LawnMowerActivitySchema;
 exports.LawnMowerControlStatusSchema = LawnMowerControlStatusSchema;
+exports.LedgerWalkDeviceReportSchema = LedgerWalkDeviceReportSchema;
+exports.LedgerWalkInputSchema = LedgerWalkInputSchema;
+exports.LedgerWalkRefusalSchema = LedgerWalkRefusalSchema;
+exports.LedgerWalkReportSchema = LedgerWalkReportSchema;
+exports.LedgerWalkSkipCountsSchema = LedgerWalkSkipCountsSchema;
+exports.LedgerWalkSkipReasonSchema = LedgerWalkSkipReasonSchema;
 exports.LinkedDeviceSchema = LinkedDeviceSchema;
 exports.LinkedDevicesModeSchema = LinkedDevicesModeSchema;
 exports.ListGroupsPageSchema = ListGroupsPageSchema;
@@ -52315,6 +52670,7 @@ exports.SceneConditionSchema = SceneConditionSchema;
 exports.SceneConfirmSchema = SceneConfirmSchema;
 exports.SceneMonitorSchema = SceneMonitorSchema;
 exports.SceneMonitorStateSchema = SceneMonitorStateSchema;
+exports.SceneMonitorStatusForDeviceSchema = SceneMonitorStatusForDeviceSchema;
 exports.SceneMonitorStatusSchema = SceneMonitorStatusSchema;
 exports.SceneReferenceSchema = SceneReferenceSchema;
 exports.SceneUnavailableSchema = SceneUnavailableSchema;