@camstack/types 1.2.130 → 1.2.132

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-DIg3xuEw.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");
@@ -2345,6 +2345,13 @@ var MediaRelocateModeSchema = zod.z.enum([
 ]);
 var RelocateMediaInputSchema = zod.z.object({
 	toLocationId: zod.z.string(),
+	/**
+	* Restrict the pass to rows currently on this location. Omitted / `'*'` =
+	* every row that is not already on `toLocationId` (the historical
+	* behaviour). A named source is what a from→to migration needs: without it
+	* "move events off disk 2" also emptied disk 1.
+	*/
+	fromLocationId: zod.z.string().optional(),
 	throttleMbps: zod.z.number().min(1).max(1e3).optional(),
 	/** Omitted = `move`, the pre-existing behaviour. */
 	mode: MediaRelocateModeSchema.optional()
@@ -2412,6 +2419,19 @@ var StorageMigrationDestinationsSchema = zod.z.object({
 	galleryMedia: zod.z.string().min(1).optional()
 }).refine((value) => Object.keys(value).length > 0, { message: "select at least one storage class" });
 /**
+* Optional named source per class. Omitted = the class's current default
+* (the historical behaviour). A named source that is NOT the default is a
+* drain of that disk: bytes move, the default stays, and the source is
+* disabled when the move finishes.
+*/
+var StorageMigrationSourcesSchema = zod.z.object({
+	recordings: zod.z.string().min(1).optional(),
+	recordingsLow: zod.z.string().min(1).optional(),
+	eventMedia: zod.z.string().min(1).optional(),
+	backups: zod.z.string().min(1).optional(),
+	galleryMedia: zod.z.string().min(1).optional()
+}).optional();
+/**
 * How a migration sequences the cutover against the byte move.
 *
 *  - `blocking`     — the historical order: pause, move every byte, repoint,
@@ -2433,6 +2453,8 @@ var StorageMigrationModeSchema = zod.z.enum(["blocking", "nonBlocking"]);
 /** Shared input for planning and starting an orchestrated storage migration. */
 var StorageMigrationInputSchema = zod.z.object({
 	destinations: StorageMigrationDestinationsSchema,
+	/** Omitted = each class's current default. */
+	sources: StorageMigrationSourcesSchema,
 	throttleMbps: zod.z.number().min(1).max(1e3).optional(),
 	/** Omitted = `blocking`, which stays the default. */
 	mode: StorageMigrationModeSchema.optional()
@@ -2512,6 +2534,13 @@ var StorageMigrationMoveSchema = zod.z.object({
 	storageClass: StorageMigrationClassSchema,
 	fromLocationId: zod.z.string(),
 	toLocationId: zod.z.string(),
+	/**
+	* True when `from` was NOT the class default at plan time. The move still
+	* copies bytes, but the default is left alone and the source is disabled
+	* once the copy verifies. Absent on jobs planned before this field existed
+	* — those jobs always repointed, which is `false`.
+	*/
+	freezeSource: zod.z.boolean().optional(),
 	moverJobId: zod.z.string().nullable(),
 	state: RelocateJobStateSchema.nullable(),
 	error: zod.z.string().nullable(),
@@ -2525,6 +2554,7 @@ var StorageMigrationJobSchema = zod.z.object({
 	*  can tell a seconds-long cutover from a thirty-hour one. */
 	mode: StorageMigrationModeSchema,
 	destinations: StorageMigrationDestinationsSchema,
+	sources: StorageMigrationSourcesSchema,
 	throttleMbps: zod.z.number(),
 	moves: zod.z.array(StorageMigrationMoveSchema),
 	pauseLeaseId: zod.z.string().nullable(),
@@ -2574,6 +2604,7 @@ var StorageMigrationFindingSchema = zod.z.object({
 });
 var StorageMigrationPlanSchema = zod.z.object({
 	destinations: StorageMigrationDestinationsSchema,
+	sources: StorageMigrationSourcesSchema,
 	/** The mode this plan was built for. A plan is only valid for its mode: the
 	*  `eventMedia` seal gate and the single-cardinality refusal both depend on
 	*  it. */
@@ -2581,7 +2612,8 @@ var StorageMigrationPlanSchema = zod.z.object({
 	moves: zod.z.array(zod.z.object({
 		storageClass: StorageMigrationClassSchema,
 		fromLocationId: zod.z.string(),
-		toLocationId: zod.z.string()
+		toLocationId: zod.z.string(),
+		freezeSource: zod.z.boolean().optional()
 	})),
 	findings: zod.z.array(StorageMigrationFindingSchema)
 });
@@ -2768,9 +2800,50 @@ var LedgerWalkReportSchema = zod.z.object({
 var RelocatableMediaCountSchema = zod.z.object({ rows: zod.z.number().int().nonnegative() }).nullable();
 var RelocatableMediaCountInputSchema = zod.z.object({
 	toLocationId: zod.z.string().min(1),
+	/** Restrict the count to one source; omitted / `'*'` = every non-target row. */
+	fromLocationId: zod.z.string().optional(),
 	/** Omitted = `move`. */
 	mode: MediaRelocateModeSchema.optional()
 });
+/**
+* Operator cleanup of leftover analytics rows, optional debug media, and
+* ghost ledger entries on frozen footage locations.
+*
+* A pass is tens of minutes on a standing backlog. The hub method RETURNS
+* `{ jobId }` immediately; progress is `cleanupStatus`. Awaiting the work
+* is how `addons.custom` hit the 60 s UDS deadline while reclaim continued
+* with no operator-visible status.
+*/
+var StorageCleanupPhaseSchema = zod.z.enum([
+	"orphans",
+	"debug-media",
+	"ghost-ledger",
+	"done",
+	"failed",
+	"cancelled"
+]);
+var StorageCleanupInputSchema = zod.z.object({ 
+/** Also walk motion stills / track filmstrips. Off by default. */
+includeDebugMedia: zod.z.boolean().optional() });
+var StorageCleanupJobSchema = zod.z.object({
+	jobId: zod.z.string(),
+	phase: StorageCleanupPhaseSchema,
+	includeDebugMedia: zod.z.boolean(),
+	orphansReclaimed: zod.z.number().int().nonnegative(),
+	orphanBytesReclaimed: zod.z.number().int().nonnegative(),
+	debugMediaReclaimed: zod.z.number().int().nonnegative(),
+	debugMediaBytesReclaimed: zod.z.number().int().nonnegative(),
+	ghostsForgotten: zod.z.number().int().nonnegative(),
+	ghostBytesForgotten: zod.z.number().int().nonnegative(),
+	/** Short operator-facing line: current collection, pass, or location. */
+	detail: zod.z.string().nullable(),
+	cancelRequested: zod.z.boolean(),
+	startedAt: zod.z.number(),
+	updatedAt: zod.z.number(),
+	finishedAt: zod.z.number().nullable(),
+	error: zod.z.string().nullable()
+});
+var StorageCleanupStatusInputSchema = zod.z.object({ jobId: zod.z.string().optional() });
 //#endregion
 //#region src/interfaces/server-analysis.ts
 var SUB_DETECTION_TYPES = ["face", "plate"];
@@ -2810,11 +2883,10 @@ var StorageLocationTypeSchema = zod.z.string().regex(/^[a-z][a-zA-Z0-9-]*$/);
 * The default location for a type uses `id === <type>:default` by
 * convention (the bare type ref like `'backups'` resolves to it).
 *
-* `isSystem: true` marks a location as orchestrator-seeded and
-* undeletable. The bootstrap-installed defaults (one per type) carry
-* this flag; operator-added locations don't. Editing the config of
-* a system location is allowed (path migration, provider swap) but
-* deleting it is rejected at the cap level.
+* `isSystem` is a legacy persisted flag. Seed still creates the initial
+* `<type>:default` locations; the flag is no longer a lock, a badge, or a
+* prune selector. New writes leave it false. Deletion is gated on uniqueness
+* / last-enabled, not on this bit.
 */
 var StorageLocationSchema = zod.z.object({
 	id: zod.z.string().regex(/^[a-z][a-zA-Z0-9-]*:[a-zA-Z0-9-]+$/),
@@ -18941,6 +19013,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
@@ -19364,6 +19477,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?
 		*
@@ -22593,7 +22720,23 @@ var storageMigrationCapability = {
 		drain: require_sleep.method(StorageMigrationDrainInputSchema, zod.z.object({ jobId: zod.z.string() }), {
 			kind: "mutation",
 			auth: "admin"
-		})
+		}),
+		/**
+		* One operator cleanup of leftover analytics (DB + blobs) and ghost
+		* ledger rows on frozen footage locations. Optional debug-media sweep.
+		* Returns immediately; poll {@link cleanupStatus}.
+		*/
+		cleanupStart: require_sleep.method(StorageCleanupInputSchema, zod.z.object({ jobId: zod.z.string() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		cleanupStatus: require_sleep.method(StorageCleanupStatusInputSchema, StorageCleanupJobSchema.nullable(), { auth: "admin" }),
+		cleanupCancel: require_sleep.method(zod.z.object({ jobId: zod.z.string() }), zod.z.object({ cancelled: zod.z.boolean() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Recent finished migration jobs, newest first. The live job is `status`. */
+		history: require_sleep.method(zod.z.object({}), zod.z.array(StorageMigrationJobSchema).readonly(), { auth: "admin" })
 	}
 };
 //#endregion
@@ -31130,6 +31273,33 @@ var RecordingRebalanceInputSchema = zod.z.object({
 	minMoveGb: zod.z.number().min(0).optional()
 });
 /**
+* Operator-facing placement of one camera onto a recordings location.
+*
+* `pinLocationId` is the operator instruction: a location id, or `null` for
+* Auto (the planner may move this camera). `locationId` is where high/mid
+* currently write — the plan, which may disagree with the pin when Auto.
+*/
+var RecordingDevicePlacementSchema = zod.z.object({
+	deviceId: zod.z.number().int(),
+	profile: zod.z.string(),
+	locationId: zod.z.string()
+});
+var RecordingDevicePinSchema = zod.z.object({
+	deviceId: zod.z.number().int(),
+	/** Recordings-class location this camera is pinned to. */
+	locationId: zod.z.string()
+});
+var RecordingPlacementViewSchema = zod.z.object({
+	assignments: zod.z.array(RecordingDevicePlacementSchema),
+	pins: zod.z.array(RecordingDevicePinSchema),
+	defaultLocations: zod.z.record(zod.z.string(), zod.z.string())
+});
+var RecordingSetDevicePlacementInputSchema = zod.z.object({
+	deviceId: zod.z.number().int(),
+	/** `null` = Auto. Otherwise a `recordings:*` location id. */
+	locationId: zod.z.string().nullable()
+});
+/**
 * Result of locating footage at a wall-clock instant for one device/profile.
 * `segment` carries the covering segment's window; `gap` reports the forward
 * nearest covered edge (`null` past the end of footage / when none exists)
@@ -31482,6 +31652,22 @@ var recordingCapability = {
 		startStorageRebalance: require_sleep.method(RecordingRebalanceInputSchema, RecordingRebalancePlanSchema, {
 			kind: "mutation",
 			auth: "admin"
+		}),
+		/**
+		* The placement plan in force plus operator pins. Drives the Locations
+		* admin page: Auto vs a named recordings location, per camera.
+		*/
+		getPlacement: require_sleep.method(zod.z.object({}), RecordingPlacementViewSchema, {
+			kind: "query",
+			auth: "admin"
+		}),
+		/**
+		* Pin a camera to a recordings location, or clear the pin (Auto). High and
+		* mid follow the pin; low stays with the recordingsLow planner.
+		*/
+		setDevicePlacement: require_sleep.method(RecordingSetDevicePlacementInputSchema, zod.z.object({ ok: zod.z.literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
 		})
 	}
 };
@@ -41855,6 +42041,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.getMediaReclaimStatus": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.getMotionEvents": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -42029,6 +42221,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",
@@ -42953,6 +43151,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"recording.getPlacement": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"recording.getPlaybackManifest": {
 		capName: "recording",
 		capScope: "system",
@@ -43079,6 +43283,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"recording.setDevicePlacement": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"recording.startStorageMigrationMove": {
 		capName: "recording",
 		capScope: "system",
@@ -43523,12 +43733,36 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"storageMigration.cleanupCancel": {
+		capName: "storage-migration",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"storageMigration.cleanupStart": {
+		capName: "storage-migration",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"storageMigration.cleanupStatus": {
+		capName: "storage-migration",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"storageMigration.drain": {
 		capName: "storage-migration",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"storageMigration.history": {
+		capName: "storage-migration",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"storageMigration.movers": {
 		capName: "storage-migration",
 		capScope: "system",
@@ -45908,6 +46142,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",
@@ -46273,6 +46512,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"recording.setDevicePlacement": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"recording.startStorageMigrationMove": [{
 		name: "deviceId",
 		form: "single",
@@ -46744,6 +46988,7 @@ var SYSTEM_SCOPE_DEVICE_METHODS = [
 	"recording.renderGif",
 	"recording.rescanStorage",
 	"recording.setDeviceConfig",
+	"recording.setDevicePlacement",
 	"recording.startStorageMigrationMove",
 	"recordingExport.createExport",
 	"recordingExport.listExports",
@@ -47672,7 +47917,9 @@ function createSystemProxy(api) {
 			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)
+			startStorageRebalance: (input) => dispatch("recording", "startStorageRebalance", "mutation", input),
+			getPlacement: (input) => dispatch("recording", "getPlacement", "query", input),
+			setDevicePlacement: (input) => dispatch("recording", "setDevicePlacement", "mutation", input)
 		},
 		recordingExport: {
 			createExport: (input) => dispatch("recordingExport", "createExport", "mutation", input),
@@ -47736,7 +47983,11 @@ function createSystemProxy(api) {
 			cancel: (input) => dispatch("storageMigration", "cancel", "mutation", input),
 			movers: (input) => dispatch("storageMigration", "movers", "query", input),
 			residue: (input) => dispatch("storageMigration", "residue", "query", input),
-			drain: (input) => dispatch("storageMigration", "drain", "mutation", input)
+			drain: (input) => dispatch("storageMigration", "drain", "mutation", input),
+			cleanupStart: (input) => dispatch("storageMigration", "cleanupStart", "mutation", input),
+			cleanupStatus: (input) => dispatch("storageMigration", "cleanupStatus", "query", input),
+			cleanupCancel: (input) => dispatch("storageMigration", "cleanupCancel", "mutation", input),
+			history: (input) => dispatch("storageMigration", "history", "query", input)
 		},
 		streamBroker: {
 			fetchEventMedia: (input) => dispatch("streamBroker", "fetchEventMedia", "mutation", input),
@@ -52643,6 +52894,10 @@ exports.StorageBeginDownloadInputSchema = BeginDownloadInputSchema;
 exports.StorageBeginDownloadResultSchema = BeginDownloadResultSchema;
 exports.StorageBeginUploadInputSchema = BeginUploadInputSchema;
 exports.StorageBeginUploadResultSchema = BeginUploadResultSchema;
+exports.StorageCleanupInputSchema = StorageCleanupInputSchema;
+exports.StorageCleanupJobSchema = StorageCleanupJobSchema;
+exports.StorageCleanupPhaseSchema = StorageCleanupPhaseSchema;
+exports.StorageCleanupStatusInputSchema = StorageCleanupStatusInputSchema;
 exports.StorageEndDownloadInputSchema = EndDownloadInputSchema;
 exports.StorageFinalizeUploadInputSchema = FinalizeUploadInputSchema;
 exports.StorageLocationDeclarationSchema = StorageLocationDeclarationSchema;
@@ -52668,6 +52923,7 @@ exports.StorageMigrationParticipantSchema = StorageMigrationParticipantSchema;
 exports.StorageMigrationPhaseSchema = StorageMigrationPhaseSchema;
 exports.StorageMigrationPlanSchema = StorageMigrationPlanSchema;
 exports.StorageMigrationResidueSchema = StorageMigrationResidueSchema;
+exports.StorageMigrationSourcesSchema = StorageMigrationSourcesSchema;
 exports.StorageProviderInfoSchema = ProviderInfoSchema;
 exports.StorageReadChunkInputSchema = ReadChunkInputSchema;
 exports.StorageTestLocationResultSchema = TestLocationResultSchema;