@camstack/addon-post-analysis 1.2.271 → 1.2.273

package/dist/{dist-K6zDULiD.mjs → dist-PZVHV70g.mjs}

@@ -5359,7 +5359,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-CiR4z7r9.mjs
+//#region ../types/dist/sleep-CaB_hL5g.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -7585,6 +7585,8 @@ var EVENT_OWNER_TYPES = [
 * nothing failing until a caller asked.
 */
 var EventOwnerTypeSchema = _enum(EVENT_OWNER_TYPES);
+/** The same list as a Zod enum, for the cap input that carries it. */
+var MediaPresenceOwnerKindSchema = _enum([...EVENT_OWNER_TYPES, "track"]);
 var EVENT_OWNER_TYPE_SET = new Set(EVENT_OWNER_TYPES);
 /** True when this key's owner is one of the three event tables. */
 function isEventOwnerType(ownerType) {
@@ -8457,24 +8459,6 @@ var DetectionCatalogClassMapSchema = object({
 	preserveOriginal: boolean()
 });
 /**
-* THE canonical event-clip pad: the time window a single-timestamp analytics
-* event expands to when joined with footage (clip window = `[timestamp - preMs,
-* timestamp + postMs]`). Matches the admin-ui clip window (−5s/+10s).
-*
-* Every consumer derives from this ONE constant so event↔footage boundaries
-* agree everywhere (C1): today that is the `videoclips` default provider
-* (addon-post-analysis), which pads its clip windows with it. The recorder used
-* to pad in-RAM playback markers with it too; those markers had no reader
-* anywhere in the repo and were deleted on 2026-08-29.
-*
-* NOTE: this is a UI/JOIN convention, NOT the `events`-band keep/discard gate —
-* that uses the per-device `preBufferSec`/`postBufferSec` config.
-*/
-var EVENT_PAD_MS = {
-	preMs: 5e3,
-	postMs: 1e4
-};
-/**
 * Numeric day-of-week: 0 = Sunday … 6 = Saturday (matches `Date.getDay`).
 * Named `RecordingWeekday` to avoid collision with the string-union
 * `Weekday` exported from `interfaces/timezones.ts`.
@@ -8627,20 +8611,7 @@ var RecordingBandSchema = object({
 	preBufferSec: number().min(0).optional(),
 	postBufferSec: number().min(0).optional()
 });
-/**
-* Adjacent recorded ranges closer than this belong to the SAME videoclip visit.
-*
-* This is NOT the recorder calendar merge (`RANGE_MERGE_GAP_MS = 5s`). That
-* threshold is for the timeline bar, which must show exact holes — including
-* the ~8s GOP/keyframe rolls measured on events-mode cameras (dispensa 1438,
-* 2026-08-16). A videoclip is the events-mode keep-window (writer session),
-* whose idle bound is `postBufferSec`. Using that default (30s) glues those
-* intra-visit holes without joining visits hours apart.
-*
-* Segments stay the source of truth on disk (`startMs-durMs-bytes.m4s`); a
-* visit is derived, not a second copy of the files.
-*/
-var VISIT_MERGE_GAP_MS = { postBufferSec: 30 }.postBufferSec * 1e3;
+({ postBufferSec: 30 }).postBufferSec * 1e3;
 /**
 * Per-device retention overrides. Every field is optional; an unset or `0`
 * value inherits the node-wide recorder default. Only footage-lifetime limits
@@ -23210,6 +23181,35 @@ var pipelineAnalyticsCapability = {
 			deviceId: number()
 		}), array(MediaFileInfoSchema).readonly()),
 		/**
+		* Which of `ownerIds` hold at least ONE media row — an INDEX read, never a
+		* blob read, and the LICENCE `videoclips` needs to publish a `thumbnail`.
+		*
+		* The event-media URL is stamped from a template for every event in the
+		* system, so "the plane is up" was being served as "there are bytes": 64 of
+		* one camera's 179 clips pointed at a 404 (device 3836, 2026-08-17). This
+		* is the question that turns the stamp into a claim.
+		*
+		* It is on the WIRE because the clip source is registered by the addon that
+		* owns the FOOTAGE, not by this one (D560) — the probe used to be an
+		* in-process `MediaStore` read. One call per OWNER KIND, never one per
+		* owner: that N+1 is what `MediaStore.ownersWithMedia` was written to
+		* prevent, and crossing a process boundary makes it worse, not better.
+		* `ownerIds` is bounded at the same 5 000 the annotation fetch is bounded
+		* at, so one pathological camera-day cannot mint an unbounded request.
+		*
+		* THROWS rather than answering partially. A probe that quietly
+		* under-reports reads as "these owners have nothing" and the caller drops
+		* thumbnails that exist — the opposite failure to the one above, and
+		* equally invisible.
+		*
+		* `deviceId` is the authorization subject, exactly as on `getEventMedia`.
+		*/
+		ownersWithMedia: method(object({
+			deviceId: number(),
+			ownerKind: MediaPresenceOwnerKindSchema,
+			ownerIds: array(string()).max(5e3)
+		}), array(string()).readonly()),
+		/**
 		* Search object events by text query using CLIP cosine similarity.
 		* Encodes `text` via the `embedding-encoder` cap, queries the
 		* `ObjectEmbeddingStore` with optional prefilters, ranks all matching
@@ -26283,6 +26283,18 @@ method(VectorDeclareIndexInputSchema, _void(), {
 	kind: "mutation",
 	auth: "admin"
 }), method(VectorStatsInputSchema, VectorStatsResultSchema, { auth: "admin" });
+_enum([
+	"queue-full",
+	"camera-backoff",
+	"sleeping",
+	"camera-refused",
+	"no-keyframe",
+	"no-catalog-row",
+	"unsupported",
+	"unknown-device",
+	"uid-missing"
+]);
+_enum(["deferred", "final"]);
 var ClipSchema = object({
 	/** Opaque, provider-namespaced id. The default provider encodes the time
 	*  window so `getClipPlayback` is self-contained (no event re-query). */
@@ -26357,44 +26369,244 @@ var ClipSchema = object({
 	holes: array(object({
 		startMs: number(),
 		endMs: number()
-	})).optional()
+	})).optional(),
+	/**
+	* A URL that MAY produce this clip's still, asked only for rows actually on
+	* screen. The opposite of {@link ClipSchema.thumbnail}: that one is VOUCHED
+	* (a JPEG is already on disk), this one is an offer. The route answers 200
+	* with the image, or 204 with `x-camstack-reason` when it could not mint one
+	* — a surface latches that refusal to the instant rather than retrying.
+	*
+	* Never both: a clip with a vouched `thumbnail` needs no mint.
+	*/
+	thumbnailMint: string().optional(),
+	/**
+	* Why no still will be produced for this clip RIGHT NOW — set when the
+	* provider already knows, so the surface draws the glyph and the reason
+	* instead of firing a mint that cannot succeed.
+	*
+	* `sleeping` — a standalone battery camera; a read would be a wake (D549 4).
+	* `camera-refused` — the camera answered the CoverPreview with a refusal.
+	* `no-keyframe` — the window holds no decodable I-frame (an event that sits
+	*   inside no file is the measured case).
+	* `unsupported` — this source cannot mint stills at all.
+	*/
+	thumbnailUnavailable: object({ reason: _enum([
+		"sleeping",
+		"camera-refused",
+		"no-keyframe",
+		"unsupported"
+	]) }).optional(),
+	/**
+	* When the catalog this row came from was last CONFIRMED against the device.
+	* Absent means "this row was read live". A persisted catalog served while a
+	* camera sleeps carries the age it really has — a cached list is never drawn
+	* as current (D549 13).
+	*/
+	catalogAsOf: number().optional(),
+	/**
+	* The camera's OWN type strings for this clip, all of them, unmapped
+	* (`md`, `people`, `dog_cat`, `sched`, …). Kept beside {@link labels}
+	* because a firmware inventing a type must not vanish: the mapping into our
+	* filter vocabulary is lossy on purpose and this is the lossless copy
+	* (D549 20).
+	*/
+	nativeTypes: array(string()).optional(),
+	/**
+	* What the subject DID — `crossline`, `intrude`, `loitering`. A behaviour
+	* travels BESIDE a class, never instead of one, and the class filter ignores
+	* it: "a person crossed a line" is still a person (D549 20).
+	*/
+	behaviours: array(string()).optional(),
+	/**
+	* The same recording as two files — the sub twin (what the row and its
+	* thumbnail are) and its main twin, matched at listing time so a quality
+	* change never re-searches the camera (D549 15). `getClipPlayback`'s
+	* `profile` picks between them: `low | mid` → sub, `high` → main.
+	*/
+	streams: object({
+		sub: object({
+			id: string(),
+			bytes: number().optional()
+		}).optional(),
+		main: object({
+			id: string(),
+			bytes: number().optional()
+		}).optional()
+	}).optional(),
+	/** The camera says it holds a sub-stream copy of this recording. */
+	supportSub: boolean().optional(),
+	/**
+	* Whether this row has bytes behind it. ABSENT means yes — every clip that
+	* IS a file is playable, and only a source that lists EVENTS can produce a
+	* row with nothing to play (the measured case: 1 of 29 hub events on 3628
+	* fell inside no file). Such a row is shown, never dropped and never offered
+	* as playable-then-failing (D549 19).
+	*/
+	playable: boolean().optional(),
+	/** Why {@link playable} is false, verbatim (`no-file-for-window`). */
+	unplayableReason: string().optional(),
+	/**
+	* This clip is STILL BEING WRITTEN, so {@link ClipSchema.timeRange}`.endMs`
+	* is not its end.
+	*
+	* Absent — the common case — means the row is closed and its `endMs` is the
+	* end of the recording. Present and `true` means the source told us the file
+	* has no end yet, and the `endMs` we carry is whatever the camera's index
+	* entry happened to hold: on a Reolink E1 Outdoor PoE (592, measured
+	* 2026-09-20) the newest file `…_192927_000000_…_0.mp4` reported an `endTime`
+	* of 19:29:56 and STILL reported it eight minutes later, while the file went
+	* on growing. A surface that drew 29 s there was lying about a clip that
+	* plays for minutes, on the one row the operator looks at first.
+	*
+	* `endMs` is deliberately still a number: it is the best bound anything has
+	* for a mint window or a byte fetch, and every consumer already requires it.
+	* This flag says what it is WORTH, and a duration is not drawn from it.
+	*/
+	inProgress: boolean().optional()
 });
 var ClipPlaybackSchema = object({
-	/** HLS master URL through the hub data-plane (Range + token in path). */
+	/**
+	* A media URL through the hub data-plane. {@link ClipPlaybackSchema.format}
+	* says what kind — an HLS master playlist for a recording-derived clip, a
+	* progressive MP4 for a native file the vendor addon muxed and serves with
+	* `Range`. The URL is NOT a credential: both planes are registered
+	* `access: 'authenticated'` and the hub's `/addon/<id>/<prefix>` proxy takes
+	* the session cookie, so nothing is appended to it (D549 22).
+	*/
 	playbackUrl: string(),
+	/**
+	* How to play {@link playbackUrl}. Absent means `hls` — the shape every
+	* existing consumer already assumes. A player that branches on this is the
+	* one change a native clip needs; a player that ignores it will hand an MP4
+	* to hls.js and fail parsing it as a manifest.
+	*/
+	format: _enum(["hls", "mp4"]).optional(),
+	/**
+	* Which twin was actually served. A clip that holds only one stream answers
+	* with the one it has, and the surface SAYS so — a missing main twin is
+	* never served silently as if it were the asked-for quality (D549 15).
+	*/
+	served: CamProfileSchema.optional(),
 	/** Optional LAN/remote alternates for the same clip. */
 	playbackEndpoints: array(string()).optional(),
 	token: string().optional()
 });
-var videoclipsCapability = {
-	name: "videoclips",
-	scope: "device",
-	mode: "singleton",
-	kind: "wrapper",
-	defaultActive: true,
-	/** A clip is a window over a camera's footage — the cap is meaningless on a
-	*  sensor, a button or an event emitter, and the `defaultActive` auto-bind
-	*  reads this to decide which devices it may claim. */
-	deviceTypes: [DeviceType.Camera],
-	methods: {
-		listClips: method(object({
-			deviceId: number(),
-			since: number(),
-			until: number(),
-			limit: number().int().positive().optional()
-		}), array(ClipSchema).readonly(), {
-			kind: "query",
-			auth: "admin"
-		}),
-		getClipPlayback: method(object({
-			deviceId: number(),
-			clipId: string()
-		}), ClipPlaybackSchema, {
-			kind: "query",
-			auth: "admin"
-		})
-	}
-};
+/**
+* Why a source cannot answer right now — per SOURCE, never fleet-wide.
+*
+* `ok` is the only state whose clip list may be read as complete. The other
+* three exist because an empty list from a sleeping camera reads as "this
+* camera has no recordings", which is the defect this whole line of work is
+* about: a battery camera nobody woke (`sleeping`), a camera that could not be
+* reached at all (`unreachable`, also what a provider that THREW reports), a
+* camera whose SD card is not mounted (`no-storage`, measured on 640 —
+* `HddInfo mount 0`, honestly nothing to list rather than "no clips"), and a
+* camera whose OWN index disagrees with its OWN calendar (`index-empty`,
+* measured on 618: the calendar marks 3–20 September, days 6–20 list zero
+* files on both streams and both filters, with 177 GB free). That last one is
+* a defect ON THE CAMERA, and the only honest thing a provider can do is say
+* which days it asked for and got nothing — "no clips" would be a lie about a
+* card that is full of them.
+*/
+var ClipSourceAvailabilitySchema = object({
+	state: _enum([
+		"ok",
+		"sleeping",
+		"unreachable",
+		"no-storage",
+		"index-empty"
+	]),
+	/** Free text, shown verbatim. Names the camera's own refusal when there is one. */
+	reason: string().optional(),
+	/** When this source's catalog was last CONFIRMED. A cached list is never
+	*  drawn as current: the surface shows the age whenever it is older than the
+	*  refresh interval. */
+	catalogAsOf: number().optional()
+});
+/**
+* One SOURCE of clips for a camera — a row of the picker, and the namespace
+* every clip id from it is prefixed with (`analytics`,
+* `native:reolink:onboard`, `hksv`, …).
+*
+* A provider lists the sources IT serves for that device, and answers for each
+* of them whether it can answer at all. A provider with nothing to offer on a
+* camera returns `[]` — it is not that camera's business.
+*/
+var ClipSourceSchema = object({
+	/** The value this source stamps on {@link ClipSchema.source}, and the prefix
+	*  of every clip id it mints. `getClipPlayback` routes on it. */
+	source: string(),
+	/** Operator-facing name of the source ("CamStack recordings", "SD card"). */
+	label: string(),
+	/**
+	* The addon that SERVES this row.
+	*
+	* A surface cannot otherwise resolve a source to who answers it, and the
+	* alternative — a `native:reolink:* → provider-reolink` table inside the
+	* widget — is a second authority on provider identity living in the one
+	* package with no business knowing it, wrong the day a third source appears
+	* (D557). One addon may serve SEVERAL sources, which is why the per-device
+	* switch is keyed by SOURCE and not by this (D555) — `addon-provider-reolink`
+	* served a hub child two of them until the two views were measured to be one
+	* store read twice (D555) and then read ONE way (D565).
+	*
+	* Optional for version skew only. The collection dispatcher stamps it from
+	* the registry, so a row that travelled through the fan-out carries the
+	* authoritative id whatever the provider filled in.
+	*/
+	addonId: string().optional(),
+	availability: ClipSourceAvailabilitySchema
+});
+DeviceType.Camera, method(object({
+	deviceId: number(),
+	since: number(),
+	until: number(),
+	limit: number().int().positive().optional(),
+	/**
+	* WHICH provider to ask — the `addonId` a {@link ClipSourceSchema} row
+	* carries, never a source id and never a list.
+	*
+	* Absent means the device's BOUND provider, which is CamStack on every
+	* camera today because that is what `deviceManager.getBindings`
+	* answers with. A provider the device is not bound to is refused by
+	* name rather than answered by another one (D552's
+	* `rejectUnresolvedAddonPin` rule).
+	*
+	* It replaced `sources?: string[]`, a VIEW filter over source ids that
+	* assumed the answer was a fan-out over everything a camera has. The
+	* operator settled otherwise on 2026-09-20 — *"il get videoclips
+	* prendere un provider opzionale, di default va su camstack"*,
+	* *"l'utilizzatore è uno solo"* — so the list is asked of one provider
+	* at a time and there is nothing to filter out of it.
+	*/
+	provider: string().optional()
+}), array(ClipSchema).readonly(), {
+	kind: "query",
+	auth: "protected"
+}), method(object({ deviceId: number() }), array(ClipSourceSchema).readonly(), {
+	kind: "query",
+	auth: "protected"
+}), method(object({
+	deviceId: number(),
+	clipId: string(),
+	/**
+	* Which twin to serve, on the ONE quality scale the system already has
+	* (`CamProfileSchema`). `low | mid` → the sub file, `high` → the main
+	* twin; both ids are already on the row so this never re-searches the
+	* camera. Absent means the provider's own default (the sub file, which
+	* every source is measured to hold).
+	*
+	* `auto` is deliberately NOT accepted here: a stored file has no
+	* broker session, so the adaptive tier cannot be resolved for it. The
+	* viewer resolves `auto` to a profile the same way live does, before
+	* it calls (D549 15).
+	*/
+	profile: CamProfileSchema.optional()
+}), ClipPlaybackSchema, {
+	kind: "query",
+	auth: "protected"
+});
 /**
 * Optional client-side hints sent at session creation to help the provider
 * pick the best native source. All fields optional — a viewer that knows
@@ -41699,6 +41911,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.ownersWithMedia": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.pauseForStorageMigration": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -44291,6 +44509,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"videoclips.listSources": {
+		capName: "videoclips",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"viewerUi.getStaticDir": {
 		capName: "viewer-ui",
 		capScope: "system",
@@ -45593,6 +45817,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineAnalytics.ownersWithMedia": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineAnalytics.proposeRetrainAnnotations": [{
 		name: "deviceId",
 		form: "single",
@@ -46299,6 +46528,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"videoclips.listSources": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"waterHeater.setAway": [{
 		name: "deviceId",
 		form: "single",
@@ -47580,4 +47814,4 @@ function vectorDimFromBase64(encoded) {
 	return Math.floor(Buffer.from(encoded, "base64").byteLength / 4);
 }
 //#endregion
-export { TimelapseRuleSchema as $, array as $t, NcConditionDescriptorSchema as A, readDeviceStateFrom as At, NcTaxonomySchema as B, zoneAnalyticsCapability as Bt, MOTION_CLOSE_AFTER_MS as C, mayWriteToLocation as Ct, NC_DEFAULT_SNOOZE_MINUTES as D, pickClusterStepModels as Dt, NC_CONDITION_CATALOG as E, parseProcStatus as Et, NcScheduleSchema as F, storageOccupancyCapability as Ft, SCENE_CONFIRM_DEFAULT_TIMEOUT_MS as G, createEvent as Gt, PoolMemoryWatchdog as H, BaseAddon as Ht, NcSnoozeInputSchema as I, subKindsOf as It, SCENE_DIVERGED as J, hydrateSchema as Jt, SCENE_DEFAULT_ANCHOR_THRESHOLD as K, customAction as Kt, NcSnoozeSchema as L, systemEventFilterApplies as Lt, NcRulePatchSchema as M, resolveLocationMode as Mt, NcRuleSchema as N, resolvePoolMemoryPolicy as Nt, NC_SNOOZE_MAX_MINUTES as O, pipelineAnalyticsCapability as Ot, NcRuleTargetSchema as P, sceneMonitorCapability as Pt, TimelapseRulePatchSchema as Q, _enum as Qt, NcSnoozeSuppressedSchema as R, vectorDimFromBase64 as Rt, MAX_BIRTH_LATENCY_PROXY_MS as S, kebabToCamel as St, NC_ALARM_SYSTEM_EVENT_KINDS as T, occupancyScope as Tt, RECORDING_EXPORT_MAX_READ_BYTES as U, CamProfileSchema as Ut, OpsLogEntrySchema as V, errMsg as Vt, RetrainStatusSchema as W, DeviceType as Wt, TIMELAPSE_DENSE_FLOOR_SEC as X, nodePin as Xt, SceneMonitorSchema as Y, isDeviceScopedCap as Yt, TimelapseRuleInputSchema as Z, sleep as Zt, FULL_IMAGE_BBOX as _, isDetectionMacroClass as _t, CLUSTER_MODEL_SCOPED_STEPS as a, partialRecord as an, audioMetricsCapability as at, MAX_ARCHIVED_DEBUG_NOTES as b, isScheduleActive as bt, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as c, unknown as cn, cosineSimilarity as ct, DETECTION_PIPELINE_CAP_NAME as d, encodeVectorBase64 as dt, boolean as en, TrackSourceSchema as et, DeclaredDevices as f, evaluateSensorEdge as ft, FIRST_LEVEL_MACRO_CLASSES as g, hfModelUrl as gt, EVENT_PAD_MS as h, failureContributionCapability as ht, BirthDecisionRecordSchema as i, object as in, assertTimelapseCadences as it, NcRuleInputSchema as j, readTimelapseGeneratedAt as jt, NC_TAXONOMY as k, plateGalleryCapability as kt, DEFAULT_TIMELAPSE_PREVIEW_TEXT as l, EventCategory as ln, deriveRecordingMode as lt, EVENT_OWNER_TYPES as m, faceGalleryCapability as mt, ArchivedDebugNoteSchema as n, literal as nn, addonWidgetsSourceCapability as nt, COCO_TO_MACRO as o, record as on, audioModeOf as ot, EVENT_KIND_BY_CAP as p, evictionPolicyOfLocation as pt, SCENE_DEFAULT_UNCOVERED_POLICY as q, defineCustomActions as qt, BaseDevice as r, number as rn, alarmPanelCapability as rt, DEFAULT_EVENT_COLOR as s, string as sn, buildEventKindDescriptor as st, AUDIO_MACRO_LABELS as t, discriminatedUnion as tn, VISIT_MERGE_GAP_MS as tt, DETECTION_MACRO_CLASSES as u, embeddingEncoderCapability as ut, FailureCounters as v, isEventOwnerType as vt, MediaFileKindEnum as w, notificationRulesCapability as wt, MAX_BIRTH_DECISION_RECORDS as x, isSourceCap as xt, LabelAttributionSchema as y, isMediaOwnerType as yt, NcSystemEventKindSchema as z, videoclipsCapability as zt };
+export { TrackSourceSchema as $, literal as $t, NcRuleInputSchema as A, resolveLocationMode as At, OpsLogEntrySchema as B, CamProfileSchema as Bt, MediaFileKindEnum as C, occupancyScope as Ct, NC_SNOOZE_MAX_MINUTES as D, plateGalleryCapability as Dt, NC_DEFAULT_SNOOZE_MINUTES as E, pipelineAnalyticsCapability as Et, NcSnoozeInputSchema as F, systemEventFilterApplies as Ft, SCENE_DEFAULT_ANCHOR_THRESHOLD as G, hydrateSchema as Gt, RECORDING_EXPORT_MAX_READ_BYTES as H, createEvent as Ht, NcSnoozeSchema as I, vectorDimFromBase64 as It, SceneMonitorSchema as J, sleep as Jt, SCENE_DEFAULT_UNCOVERED_POLICY as K, isDeviceScopedCap as Kt, NcSnoozeSuppressedSchema as L, zoneAnalyticsCapability as Lt, NcRuleSchema as M, sceneMonitorCapability as Mt, NcRuleTargetSchema as N, storageOccupancyCapability as Nt, NC_TAXONOMY as O, readDeviceStateFrom as Ot, NcScheduleSchema as P, subKindsOf as Pt, TimelapseRuleSchema as Q, discriminatedUnion as Qt, NcSystemEventKindSchema as R, errMsg as Rt, MOTION_CLOSE_AFTER_MS as S, notificationRulesCapability as St, NC_CONDITION_CATALOG as T, pickClusterStepModels as Tt, RetrainStatusSchema as U, customAction as Ut, PoolMemoryWatchdog as V, DeviceType as Vt, SCENE_CONFIRM_DEFAULT_TIMEOUT_MS as W, defineCustomActions as Wt, TimelapseRuleInputSchema as X, array as Xt, TIMELAPSE_DENSE_FLOOR_SEC as Y, _enum as Yt, TimelapseRulePatchSchema as Z, boolean as Zt, FailureCounters as _, isMediaOwnerType as _t, CLUSTER_MODEL_SCOPED_STEPS as a, unknown as an, buildEventKindDescriptor as at, MAX_BIRTH_DECISION_RECORDS as b, kebabToCamel as bt, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as c, embeddingEncoderCapability as ct, DETECTION_PIPELINE_CAP_NAME as d, evictionPolicyOfLocation as dt, number as en, addonWidgetsSourceCapability as et, DeclaredDevices as f, faceGalleryCapability as ft, FULL_IMAGE_BBOX as g, isEventOwnerType as gt, FIRST_LEVEL_MACRO_CLASSES as h, isDetectionMacroClass as ht, BirthDecisionRecordSchema as i, string as in, audioModeOf as it, NcRulePatchSchema as j, resolvePoolMemoryPolicy as jt, NcConditionDescriptorSchema as k, readTimelapseGeneratedAt as kt, DEFAULT_TIMELAPSE_PREVIEW_TEXT as l, encodeVectorBase64 as lt, EVENT_OWNER_TYPES as m, hfModelUrl as mt, ArchivedDebugNoteSchema as n, partialRecord as nn, assertTimelapseCadences as nt, COCO_TO_MACRO as o, EventCategory as on, cosineSimilarity as ot, EVENT_KIND_BY_CAP as p, failureContributionCapability as pt, SCENE_DIVERGED as q, nodePin as qt, BaseDevice as r, record as rn, audioMetricsCapability as rt, DEFAULT_EVENT_COLOR as s, deriveRecordingMode as st, AUDIO_MACRO_LABELS as t, object as tn, alarmPanelCapability as tt, DETECTION_MACRO_CLASSES as u, evaluateSensorEdge as ut, LabelAttributionSchema as v, isScheduleActive as vt, NC_ALARM_SYSTEM_EVENT_KINDS as w, parseProcStatus as wt, MAX_BIRTH_LATENCY_PROXY_MS as x, mayWriteToLocation as xt, MAX_ARCHIVED_DEBUG_NOTES as y, isSourceCap as yt, NcTaxonomySchema as z, BaseAddon as zt };