@camstack/types 1.1.48 → 1.1.50

package/dist/index.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-BoTIF1d4.js");
-const require_event_category = require("./event-category-AkBNxg_X.js");
+const require_sleep = require("./sleep-CF-UWPp0.js");
+const require_event_category = require("./event-category-CGj9fI4L.js");
 const require_enums = require("./enums.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
 let zod = require("zod");
@@ -1048,6 +1048,71 @@ function migrateConfigToBands(config) {
 	return schedules.map((schedule) => bandFromSchedule(schedule, bandMode, config));
 }
 //#endregion
+//#region src/interfaces/ops-log.ts
+/**
+* Ops-log — the durable, append-only operations audit shared by the
+* recordings and events management surfaces.
+*
+* ONE row shape is reused for both domains so a single "Activity" view can
+* merge the recorder's DurableState ring (recordings ops-log) and the
+* pipeline-analytics SQLite collection (events ops-log). Each row records a
+* management operation, WHY it ran (reason), and its measurable effect
+* (itemsAffected + bytesReclaimed). Writes are best-effort — a failed log must
+* never fail the operation it records.
+*/
+/** Which management domain the operation belongs to. */
+var OpsLogDomainSchema = zod.z.enum(["recording", "events"]);
+/** The kind of management operation performed. */
+var OpsLogOpSchema = zod.z.enum([
+	"prune",
+	"manual-delete",
+	"rescan",
+	"retention-run"
+]);
+/** Why the operation ran. */
+var OpsLogReasonSchema = zod.z.enum([
+	"retention",
+	"quota",
+	"manual",
+	"operator"
+]);
+/** One audit row, shared verbatim by both domains. */
+var OpsLogEntrySchema = zod.z.object({
+	/** Unique row id. */
+	id: zod.z.string(),
+	/** Epoch ms the operation completed. */
+	at: zod.z.number(),
+	domain: OpsLogDomainSchema,
+	op: OpsLogOpSchema,
+	reason: OpsLogReasonSchema,
+	/** The camera the op targeted; null for a cluster/global op. */
+	deviceId: zod.z.number().nullable(),
+	/** Node that performed the op (the log carries nodeId — no cross-node aggregation). */
+	nodeId: zod.z.string(),
+	/** Buckets / rows deleted (op-specific unit). */
+	itemsAffected: zod.z.number(),
+	/** Bytes reclaimed by the op (0 when not measurable). */
+	bytesReclaimed: zod.z.number(),
+	/** Free-text detail (e.g. "floor moved to <ts>"); null when none. */
+	detail: zod.z.string().nullable(),
+	/** Who/what triggered the op. */
+	actor: zod.z.string()
+});
+/** Shared query input for the per-domain `listOpsLog` cap methods. */
+var OpsLogQueryInputSchema = zod.z.object({
+	/** Restrict to a single camera; omit for every row. */
+	deviceId: zod.z.number().optional(),
+	/** Max rows returned, newest-first. */
+	limit: zod.z.number().int().min(1).max(1e3).optional()
+});
+/**
+* Default cap on the recorder's DurableState ops-log ring — the newest N rows
+* survive; older ones are evicted on append.
+*/
+var OPS_LOG_RING_DEFAULT_MAX = 500;
+/** Default page size for a `listOpsLog` query when the caller omits `limit`. */
+var OPS_LOG_DEFAULT_LIMIT = 200;
+//#endregion
 //#region src/interfaces/storage-location.ts
 /**
 * `StorageLocationType` — an addon-declared id that identifies the *kind* of
@@ -2271,6 +2336,10 @@ var MACRO_LABELS = [
 	{
 		id: "animal",
 		name: "Animal"
+	},
+	{
+		id: "package",
+		name: "Package"
 	}
 ];
 var COCO_TO_MACRO = {
@@ -2293,7 +2362,10 @@ var COCO_TO_MACRO = {
 		elephant: "animal",
 		bear: "animal",
 		zebra: "animal",
-		giraffe: "animal"
+		giraffe: "animal",
+		suitcase: "package",
+		backpack: "package",
+		handbag: "package"
 	},
 	preserveOriginal: false
 };
@@ -11001,7 +11073,11 @@ var ZoneRulesArraySchema = zod.z.array(ZoneRuleSchema).readonly();
 * Extend the enum here when a new gating consumer comes online (audio
 * gating, alert filtering, …) — no other surface needs to change.
 */
-var ZoneRuleStageEnum = zod.z.enum(["motion", "detection"]);
+var ZoneRuleStageEnum = zod.z.enum([
+	"motion",
+	"detection",
+	"package"
+]);
 /**
 * Zone rules capability — per-camera CRUD over the {@link ZoneRule}
 * arrays that decide how each pipeline stage uses the polygon zones.
@@ -11045,16 +11121,25 @@ var zoneRulesCapability = {
 		})
 	},
 	/**
-	* Runtime-state slice — both stages mirrored together so consumers
+	* Runtime-state slice — every stage mirrored together so consumers
 	* see one reactive handle (`device.state.zoneRules.value`) instead
-	* of two. Bulk-replace mutations on either stage write the full
-	* `{motion, detection}` shape, so subscribers always get the
+	* of one per stage. Bulk-replace mutations on any stage write the full
+	* `{motion, detection, package}` shape, so subscribers always get the
 	* complete current set. Consumers that only care about one stage
 	* just read the matching property.
+	*
+	* `package` backs the package-drop detector — a package zone is a
+	* `ZoneRule` on the `'package'` stage referencing drawn polygons
+	* (see docs/superpowers/specs/2026-07-17-package-zones-design.md §3.1).
+	* The orchestrator provider writes this stage as a first-class slice
+	* (Phase 4): every mutation mirrors the full `{motion, detection,
+	* package}` shape, so consumers read the current package rules directly
+	* off `device.state.zoneRules.value.package`.
 	*/
 	runtimeState: zod.z.object({
 		motion: zod.z.array(ZoneRuleSchema).readonly(),
-		detection: zod.z.array(ZoneRuleSchema).readonly()
+		detection: zod.z.array(ZoneRuleSchema).readonly(),
+		package: zod.z.array(ZoneRuleSchema).readonly()
 	})
 };
 //#endregion
@@ -13054,7 +13139,16 @@ function createSystemProxy(api) {
 			assignPlates: (input) => dispatch("plateGallery", "assignPlates", "mutation", input),
 			unassignPlates: (input) => dispatch("plateGallery", "unassignPlates", "mutation", input)
 		},
-		recording: { getStorageUsage: (input) => dispatch("recording", "getStorageUsage", "query", input) },
+		recording: {
+			getStorageUsage: (input) => dispatch("recording", "getStorageUsage", "query", input),
+			listOpsLog: (input) => dispatch("recording", "listOpsLog", "query", input)
+		},
+		recordingExport: {
+			getExport: (input) => dispatch("recordingExport", "getExport", "query", input),
+			cancelExport: (input) => dispatch("recordingExport", "cancelExport", "mutation", input),
+			deleteExport: (input) => dispatch("recordingExport", "deleteExport", "mutation", input),
+			getDownloadUrl: (input) => dispatch("recordingExport", "getDownloadUrl", "query", input)
+		},
 		serverManagement: {
 			getServerPackageStatus: (input) => dispatch("serverManagement", "getServerPackageStatus", "query", input),
 			checkServerUpdate: (input) => dispatch("serverManagement", "checkServerUpdate", "mutation", input),
@@ -18319,6 +18413,7 @@ var EventKindIconSchema = zod.z.enum([
 	"smoke",
 	"water",
 	"button",
+	"package",
 	"generic"
 ]);
 var EventKindCategorySchema = zod.z.enum([
@@ -18326,7 +18421,8 @@ var EventKindCategorySchema = zod.z.enum([
 	"audio",
 	"detection",
 	"sensor",
-	"custom"
+	"custom",
+	"package"
 ]);
 var EventKindDescriptorSchema = zod.z.object({
 	/** Stable kind id (e.g. 'motion', 'person', 'contact'). */
@@ -18667,6 +18763,26 @@ var TrackCascadeCountsSchema = zod.z.object({
 	/** Per-track CLIP search vectors removed (best-effort). */
 	embeddings: zod.z.number().int()
 });
+/** Event-store footprint for one camera. */
+var EventStoreDeviceFootprintSchema = zod.z.object({
+	deviceId: zod.z.number(),
+	/** Persisted event rows (motion + object + audio) for the camera. */
+	rows: zod.z.number().int(),
+	/** Event-owned media bytes on disk for the camera. */
+	bytes: zod.z.number().int()
+});
+/** Aggregate event-store footprint: global totals + per-camera breakdown. */
+var EventStoreFootprintSchema = zod.z.object({
+	totalRows: zod.z.number().int(),
+	totalBytes: zod.z.number().int(),
+	devices: zod.z.array(EventStoreDeviceFootprintSchema).readonly()
+});
+/** Per-kind counts returned by the event-prune / device-delete mutations. */
+var EventPruneCountsSchema = zod.z.object({
+	motion: zod.z.number().int(),
+	object: zod.z.number().int(),
+	audio: zod.z.number().int()
+});
 var pipelineAnalyticsCapability = {
 	name: "pipeline-analytics",
 	scope: "device",
@@ -18828,6 +18944,45 @@ var pipelineAnalyticsCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Durable event-store footprint for the management UI: event rows
+		* (motion + object + audio) counted per camera + total, plus the
+		* event-owned media bytes on disk per camera + total. Stat/count-based,
+		* computed on demand.
+		*/
+		getEventStoreFootprint: require_sleep.method(zod.z.object({}), EventStoreFootprintSchema, {
+			kind: "query",
+			auth: "admin"
+		}),
+		/**
+		* Cluster-wide prune of events older than `olderThanMs` (exclusive) across
+		* every camera, deleting each event's media in lockstep. Logged to the
+		* events ops-log with `reason` (default `'retention'`). Returns the summed
+		* per-kind deleted counts.
+		*/
+		pruneEvents: require_sleep.method(zod.z.object({
+			olderThanMs: zod.z.number(),
+			reason: OpsLogReasonSchema.optional()
+		}), EventPruneCountsSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Manually delete EVERY event (motion + object + audio) for one camera and
+		* its event-owned media in lockstep. Logged to the events ops-log as
+		* `op:'manual-delete', reason:'manual'`. Destructive — the admin UI guards
+		* it behind a confirm.
+		*/
+		deleteDeviceEvents: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), EventPruneCountsSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** The events ops-log rows (newest-first), optionally scoped to one camera.
+		*  Backed by a declared pipeline-analytics SQLite collection. */
+		listOpsLog: require_sleep.method(OpsLogQueryInputSchema, zod.z.array(OpsLogEntrySchema).readonly(), {
+			kind: "query",
+			auth: "admin"
+		}),
 		getEventMedia: require_sleep.method(zod.z.object({
 			eventId: zod.z.string(),
 			kind: MediaFileKindEnum.optional()
@@ -23565,14 +23720,164 @@ var recordingCapability = {
 			auth: "admin"
 		}),
 		/** Apply this device's retention policy to footage now; returns the oldest
-		*  surviving footage start (the retention floor) or null if no footage. */
-		pruneFootage: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), zod.z.object({
+		*  surviving footage start (the retention floor) or null if no footage. The
+		*  prune is logged to the recordings ops-log with `reason` (default
+		*  `'retention'` — the policy-driven prune; `'quota'` when disk-pressure
+		*  triggered). */
+		pruneFootage: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			reason: OpsLogReasonSchema.optional()
+		}), zod.z.object({
 			floorMs: zod.z.number().nullable(),
 			deletedBuckets: zod.z.number().int(),
 			reclaimedBytes: zod.z.number().int()
 		}), {
 			kind: "mutation",
 			auth: "admin"
+		}),
+		/**
+		* Manually delete a camera's footage — the whole footprint, or a
+		* `[fromMs, toMs)` window when either bound is given. Logged to the
+		* recordings ops-log as `op:'manual-delete', reason:'manual'`. Destructive:
+		* the admin UI guards it behind a confirm.
+		*/
+		deleteFootprint: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			fromMs: zod.z.number().optional(),
+			toMs: zod.z.number().optional()
+		}), zod.z.object({
+			deletedBuckets: zod.z.number().int(),
+			reclaimedBytes: zod.z.number().int()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** The recordings ops-log rows (newest-first), optionally scoped to one
+		*  camera. Backed by the recorder's bounded DurableState ring. */
+		listOpsLog: require_sleep.method(OpsLogQueryInputSchema, zod.z.array(OpsLogEntrySchema).readonly(), {
+			kind: "query",
+			auth: "admin"
+		})
+	}
+};
+//#endregion
+//#region src/capabilities/recording-export.cap.ts
+/**
+* `recordingExport` cap — render a footage time range into a single downloadable
+* MP4 (regular / accelerated / decelerated / timelapse, ± audio), kept for a
+* bounded lifetime with a durable history, auto-expiry, and optional
+* delete-after-download.
+*
+* Like `recording` this is a `scope:'system', mode:'singleton'` cap: the
+* recorder self-gates so exactly ONE node (the designated `recordingNodeId`,
+* default `hub`) registers it. Device-scoped methods carry `deviceId` in their
+* input and dispatch to that single provider; the render runs on the node that
+* owns the footage (no cross-node segment transfer). Download rides the
+* framework addon data-plane. State persists in a DurableState blob (NOT
+* SQLite); history rows survive file deletion for audit.
+*/
+/** Playback-speed multiplier for the render (1 = realtime). */
+var ExportSpeedSchema = zod.z.number().min(.25).max(32);
+/** Timelapse cadence — sample one source frame per `everyMs`, output at `outputFps`. */
+var ExportTimelapseSchema = zod.z.object({
+	everyMs: zod.z.number().int().positive(),
+	outputFps: zod.z.number().int().min(1).max(60).optional()
+});
+/**
+* Render options. `speed` and `timelapse` are mutually exclusive. `includeAudio`
+* is honoured only for a realtime-ish speed (0.5–2×); timelapse is always
+* silent. `maxLifeMs` bounds how long the finished file is kept;
+* `deleteAfterDownload` removes it shortly after the first complete download.
+*/
+var ExportOptionsSchema = zod.z.object({
+	speed: ExportSpeedSchema.optional(),
+	timelapse: ExportTimelapseSchema.optional(),
+	includeAudio: zod.z.boolean(),
+	maxLifeMs: zod.z.number().int().positive(),
+	deleteAfterDownload: zod.z.boolean(),
+	title: zod.z.string().max(200).optional()
+}).superRefine((v, ctx) => {
+	if (v.speed !== void 0 && v.timelapse !== void 0) ctx.addIssue({
+		code: zod.z.ZodIssueCode.custom,
+		message: "speed and timelapse are mutually exclusive",
+		path: ["timelapse"]
+	});
+});
+var ExportStateSchema = zod.z.enum([
+	"queued",
+	"rendering",
+	"ready",
+	"failed",
+	"expired",
+	"deleted"
+]);
+/** One export job / history row. */
+var ExportRecordSchema = zod.z.object({
+	id: zod.z.string(),
+	deviceId: zod.z.number(),
+	profile: zod.z.string(),
+	fromMs: zod.z.number(),
+	toMs: zod.z.number(),
+	options: ExportOptionsSchema,
+	state: ExportStateSchema,
+	/** 0–100 while rendering; null otherwise. */
+	progressPct: zod.z.number().nullable(),
+	/** File size once ready; null before. */
+	fileBytes: zod.z.number().nullable(),
+	expiresAt: zod.z.number(),
+	deleteAfterDownload: zod.z.boolean(),
+	/** Epoch of the first complete download; null until then. */
+	downloadedAt: zod.z.number().nullable(),
+	createdAt: zod.z.number(),
+	/** User id/name that requested the export. */
+	createdBy: zod.z.string(),
+	/** Failure reason when state is 'failed'; null otherwise. */
+	error: zod.z.string().nullable()
+});
+/** Candidate download URLs (LAN first, then operator extra hosts). */
+var ExportDownloadSchema = zod.z.object({
+	url: zod.z.string(),
+	endpoints: zod.z.array(zod.z.string())
+});
+var recordingExportCapability = {
+	name: "recordingExport",
+	scope: "system",
+	mode: "singleton",
+	methods: {
+		/** Queue a render of `[fromMs,toMs)` for `deviceId`/`profile`. Fails fast
+		*  when no footage covers the range. Returns the queued record. */
+		createExport: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			profile: zod.z.string(),
+			fromMs: zod.z.number(),
+			toMs: zod.z.number(),
+			options: ExportOptionsSchema
+		}), ExportRecordSchema, {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		/** All export rows (history included), optionally scoped to one device. */
+		listExports: require_sleep.method(zod.z.object({ deviceId: zod.z.number().optional() }), zod.z.array(ExportRecordSchema), {
+			kind: "query",
+			auth: "protected"
+		}),
+		getExport: require_sleep.method(zod.z.object({ exportId: zod.z.string() }), ExportRecordSchema, {
+			kind: "query",
+			auth: "protected"
+		}),
+		/** Abort a queued/rendering export; the partial file is removed. */
+		cancelExport: require_sleep.method(zod.z.object({ exportId: zod.z.string() }), ExportRecordSchema, {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		/** Remove the file but keep the history row (state → 'deleted'). */
+		deleteExport: require_sleep.method(zod.z.object({ exportId: zod.z.string() }), ExportRecordSchema, {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		getDownloadUrl: require_sleep.method(zod.z.object({ exportId: zod.z.string() }), ExportDownloadSchema, {
+			kind: "query",
+			auth: "protected"
 		})
 	}
 };
@@ -24368,6 +24673,7 @@ var CAPABILITY_NAMES = {
 	ptzAutotrack: "ptz-autotrack",
 	reboot: "reboot",
 	recording: "recording",
+	recordingExport: "recordingExport",
 	sceneMonitor: "scene-monitor",
 	scriptRunner: "script-runner",
 	serverManagement: "server-management",
@@ -24833,6 +25139,10 @@ var CAPABILITY_ROUTER_KEYS = [
 		key: "recording",
 		name: "recording"
 	},
+	{
+		key: "recordingExport",
+		name: "recordingExport"
+	},
 	{
 		key: "sceneMonitor",
 		name: "scene-monitor"
@@ -25087,6 +25397,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	ptzAutotrackCapability,
 	rebootCapability,
 	recordingCapability,
+	recordingExportCapability,
 	sceneMonitorCapability,
 	scriptRunnerCapability,
 	serverManagementCapability,
@@ -27908,6 +28219,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"pipelineAnalytics.deleteDeviceEvents": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "delete"
+	},
 	"pipelineAnalytics.deleteTracks": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -27938,6 +28255,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.getEventStoreFootprint": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.getKeyEvents": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -27980,6 +28303,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.listOpsLog": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.listRecentTracks": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -27992,6 +28321,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.pruneEvents": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.pruneEventsBefore": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -28754,6 +29089,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"recording.deleteFootprint": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"recording.getAvailability": {
 		capName: "recording",
 		capScope: "system",
@@ -28784,6 +29125,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"recording.listOpsLog": {
+		capName: "recording",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"recording.locateSegment": {
 		capName: "recording",
 		capScope: "system",
@@ -28814,6 +29161,42 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"recordingExport.cancelExport": {
+		capName: "recordingExport",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"recordingExport.createExport": {
+		capName: "recordingExport",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"recordingExport.deleteExport": {
+		capName: "recordingExport",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
+	"recordingExport.getDownloadUrl": {
+		capName: "recordingExport",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"recordingExport.getExport": {
+		capName: "recordingExport",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"recordingExport.listExports": {
+		capName: "recordingExport",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"sceneMonitor.captureReference": {
 		capName: "scene-monitor",
 		capScope: "device",
@@ -30025,6 +30408,7 @@ var KNOWN_CAP_NAMES = [
 	"ptz-autotrack",
 	"reboot",
 	"recording",
+	"recordingExport",
 	"scene-monitor",
 	"script-runner",
 	"server-management",
@@ -30161,6 +30545,7 @@ var SYSTEM_CAP_NAMES = [
 	"plate-gallery",
 	"platform-probe",
 	"recording",
+	"recordingExport",
 	"server-management",
 	"settings-store",
 	"smtp-provider",
@@ -30970,8 +31355,14 @@ exports.EventKindDescriptorSchema = EventKindDescriptorSchema;
 exports.EventKindIconSchema = EventKindIconSchema;
 exports.EventKindSchema = EventKindSchema;
 exports.EventSourceType = require_enums.EventSourceType$1;
+exports.ExportDownloadSchema = ExportDownloadSchema;
+exports.ExportOptionsSchema = ExportOptionsSchema;
+exports.ExportRecordSchema = ExportRecordSchema;
 exports.ExportSetupFieldSchema = ExportSetupFieldSchema;
 exports.ExportSetupSchema = ExportSetupSchema;
+exports.ExportSpeedSchema = ExportSpeedSchema;
+exports.ExportStateSchema = ExportStateSchema;
+exports.ExportTimelapseSchema = ExportTimelapseSchema;
 exports.ExposedDeviceSchema = ExposedDeviceSchema;
 exports.ExposureModeSchema = ExposureModeSchema;
 exports.ExpressionEvalError = ExpressionEvalError;
@@ -31105,8 +31496,15 @@ exports.NotificationRuleSchema = NotificationRuleSchema;
 exports.NotificationSchema = NotificationSchema;
 exports.NotifierStatusSchema = NotifierStatusSchema;
 exports.NumericSensorStatusSchema = NumericSensorStatusSchema;
+exports.OPS_LOG_DEFAULT_LIMIT = OPS_LOG_DEFAULT_LIMIT;
+exports.OPS_LOG_RING_DEFAULT_MAX = OPS_LOG_RING_DEFAULT_MAX;
 exports.OauthIntegrationDescriptorSchema = OauthIntegrationDescriptorSchema;
 exports.ObjectEventSchema = ObjectEventSchema;
+exports.OpsLogDomainSchema = OpsLogDomainSchema;
+exports.OpsLogEntrySchema = OpsLogEntrySchema;
+exports.OpsLogOpSchema = OpsLogOpSchema;
+exports.OpsLogQueryInputSchema = OpsLogQueryInputSchema;
+exports.OpsLogReasonSchema = OpsLogReasonSchema;
 exports.OrchestratorMetricsSchema = OrchestratorMetricsSchema;
 exports.OsdOverlayKindEnum = OsdOverlayKindEnum;
 exports.OsdOverlayPatchSchema = OsdOverlayPatchSchema;
@@ -31549,6 +31947,7 @@ exports.readNodePin = readNodePin;
 exports.readinessKey = require_sleep.readinessKey;
 exports.rebootCapability = rebootCapability;
 exports.recordingCapability = recordingCapability;
+exports.recordingExportCapability = recordingExportCapability;
 exports.rectsToCells = rectsToCells;
 exports.requiresPython = requiresPython;
 exports.resolveAddonExecution = resolveAddonExecution;