@camstack/types 1.2.367 → 1.2.369

package/dist/index.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-NZlEFYGX.js");
+const require_sleep = require("./sleep-CXlc9YJ5.js");
 const require_event_category = require("./event-category-T43rdQWR.js");
 const require_composition = require("./composition-DCYnv4I6.js");
 const require_node_color = require("./node-color.js");
@@ -13877,6 +13877,243 @@ var keychainCapability = {
 	}
 };
 //#endregion
+//#region src/capabilities/device-history.cap.ts
+/**
+* device-history — the ONE mechanism for numeric history (D850).
+*
+* A device value is recorded because its capability says so (the `history`
+* block of a `*.cap.ts`, captured hub-side from `DeviceStateChanged`); any
+* other series is DECLARED by the addon that produces it and fed with points
+* (`record`) or closed five-minute buckets (`recordBuckets`). Rollups 5m / 1h /
+* 1d are computed here and nowhere else. Storage is `history.db` (D851).
+*
+* Who the PRODUCER is: `declareSeries`, `record` and `recordBuckets` are owner
+* checked against the `callerAddonId` the transport stamps into a call that
+* crossed a process (never in an input schema, so a session cannot supply it).
+* A call with no stamp is refused `not-owner`. The methods are `admin` so a
+* non-admin session never reaches them; an addon's `ctx.api` call bypasses the
+* tier by design.
+*/
+/** Whose history: a real device, or a cluster node (load, memory). */
+var DeviceHistorySubjectSchema = zod.z.discriminatedUnion("kind", [zod.z.object({
+	kind: zod.z.literal("device"),
+	deviceId: zod.z.number().int()
+}), zod.z.object({
+	kind: zod.z.literal("node"),
+	nodeId: zod.z.string().min(1)
+})]);
+var DeviceHistoryKindSchema = zod.z.enum([
+	"gauge",
+	"counter",
+	"boolean"
+]);
+var DeviceHistoryResolutionSchema = zod.z.enum([
+	"raw",
+	"5m",
+	"1h",
+	"1d"
+]);
+/** Why a producer's point or bucket was not stored. Counted, never silent (D391). */
+var DeviceHistoryRefusalReasonSchema = zod.z.enum([
+	"undeclared",
+	"not-owner",
+	"opted-out",
+	"not-a-real-device",
+	"rate",
+	"ingest-mismatch",
+	"out-of-range"
+]);
+var RefusalSchema = zod.z.object({
+	key: zod.z.string(),
+	reason: DeviceHistoryRefusalReasonSchema,
+	count: zod.z.number().int()
+});
+var IngestResultSchema = zod.z.object({
+	accepted: zod.z.number().int(),
+	refused: zod.z.array(RefusalSchema).readonly()
+});
+var SeriesInfoSchema = zod.z.object({
+	key: zod.z.string(),
+	scope: zod.z.string(),
+	kind: DeviceHistoryKindSchema,
+	/** `null` is unknown (a `unitFrom` series whose device does not state a unit right now), never a guess. */
+	unit: zod.z.string().nullable(),
+	displayName: zod.z.string(),
+	source: zod.z.enum(["cap", "addon"]),
+	firstTs: zod.z.number(),
+	lastTs: zod.z.number()
+});
+var QueryPointSchema = zod.z.object({
+	/** Raw: the point's time. Rollup: the bucket start. */
+	t: zod.z.number(),
+	samples: zod.z.number().int(),
+	/** `sum / samples`. */
+	mean: zod.z.number().nullable(),
+	/** Time-weighted mean (`tw_sum / tw_ms`); `null` for bucket-ingested series. For a boolean: the fraction of time true. */
+	twMean: zod.z.number().nullable(),
+	min: zod.z.number(),
+	max: zod.z.number(),
+	/** `null` is unknown, never zero (D393). */
+	last: zod.z.number().nullable()
+});
+var QuerySeriesSchema = zod.z.object({
+	scope: zod.z.string(),
+	/** The last point STRICTLY BEFORE `from` in the chosen tier, so a step chart can start at the held value. */
+	before: zod.z.object({
+		t: zod.z.number(),
+		value: zod.z.number().nullable()
+	}).nullable(),
+	points: zod.z.array(QueryPointSchema).readonly()
+});
+/** The window part of a query, shared by the device and node forms. */
+var QueryWindowShape = {
+	key: zod.z.string(),
+	scope: zod.z.string().optional(),
+	from: zod.z.number(),
+	to: zod.z.number(),
+	resolution: zod.z.union([DeviceHistoryResolutionSchema, zod.z.literal("auto")]).default("auto"),
+	maxPoints: zod.z.number().int().positive().max(5e3).default(1e3)
+};
+var QueryResultSchema = zod.z.object({
+	resolution: DeviceHistoryResolutionSchema,
+	series: zod.z.array(QuerySeriesSchema).readonly(),
+	truncated: zod.z.boolean()
+});
+var TierStatusSchema = zod.z.object({
+	tier: DeviceHistoryResolutionSchema,
+	/** `null` until the first background count answered. */
+	rows: zod.z.number().int().nullable(),
+	/** `rows` times a fixed per-row estimate — approximate, labelled so. */
+	approxBytes: zod.z.number().nullable(),
+	countedAt: zod.z.number().nullable()
+});
+/** Operator/diagnostic view: rows per tier, last runs, refusals and drops since boot. */
+var DeviceHistoryStatusSchema = zod.z.object({
+	startedAt: zod.z.number(),
+	/** The store is declared, series loaded and the first reconcile has answered. */
+	ready: zod.z.boolean(),
+	series: zod.z.number().int(),
+	metrics: zod.z.number().int(),
+	optedOutDevices: zod.z.number().int(),
+	tiers: zod.z.array(TierStatusSchema).readonly(),
+	capture: zod.z.object({
+		eventsSeen: zod.z.number().int(),
+		pointsEmitted: zod.z.number().int(),
+		pointsWritten: zod.z.number().int(),
+		pointsDropped: zod.z.number().int(),
+		bufferDepth: zod.z.number().int(),
+		trailingEmitted: zod.z.number().int(),
+		reconciledPoints: zod.z.number().int(),
+		reconcileRuns: zod.z.number().int(),
+		reconcileFailures: zod.z.number().int(),
+		lastReconcileAt: zod.z.number().nullable(),
+		lastFlushAt: zod.z.number().nullable(),
+		flushFailures: zod.z.number().int(),
+		skipped: zod.z.record(zod.z.string(), zod.z.number().int())
+	}),
+	ingest: zod.z.object({
+		accepted: zod.z.number().int(),
+		refused: zod.z.record(zod.z.string(), zod.z.number().int())
+	}),
+	rollup: zod.z.object({
+		last5mAt: zod.z.number().nullable(),
+		last1hAt: zod.z.number().nullable(),
+		last1dAt: zod.z.number().nullable(),
+		errors: zod.z.number().int(),
+		dirty5m: zod.z.number().int(),
+		dirty1h: zod.z.number().int(),
+		dirty1d: zod.z.number().int()
+	}),
+	retention: zod.z.object({
+		lastRunAt: zod.z.number().nullable(),
+		deleted: zod.z.record(zod.z.string(), zod.z.number().int()),
+		purgedSeries: zod.z.number().int()
+	}),
+	directory: zod.z.object({
+		devices: zod.z.number().int(),
+		lastRefreshAt: zod.z.number().nullable()
+	})
+});
+var deviceHistoryCapability = {
+	name: "device-history",
+	scope: "system",
+	mode: "singleton",
+	methods: {
+		/**
+		* The series a DEVICE has, and their span. `deviceId` is a flat top-level field
+		* on purpose: the generated device selector (and so the scope gate) only sees
+		* top-level ids, and a nested `subject.deviceId` would let a principal limited
+		* to one device read another's history. Node series are the admin-only
+		* `listNodeSeries` / `queryNode`.
+		*/
+		listSeries: require_sleep.method(zod.z.object({ deviceId: zod.z.number().int() }), zod.z.array(SeriesInfoSchema).readonly()),
+		listNodeSeries: require_sleep.method(zod.z.object({ nodeId: zod.z.string().min(1) }), zod.z.array(SeriesInfoSchema).readonly(), { auth: "admin" }),
+		/**
+		* One series (or every scope of it) at one resolution. `auto` picks the
+		* finest tier whose retention covers `from` and whose point count fits
+		* `maxPoints`; when even the coarsest tier does not fit, the newest
+		* `maxPoints` points are returned and `truncated` is true.
+		*/
+		query: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number().int(),
+			...QueryWindowShape
+		}), QueryResultSchema),
+		queryNode: require_sleep.method(zod.z.object({
+			nodeId: zod.z.string().min(1),
+			...QueryWindowShape
+		}), QueryResultSchema, { auth: "admin" }),
+		/** Producer: declare (idempotent) a series key this addon owns: `addon:<callerAddonId>/<name>`. */
+		declareSeries: require_sleep.method(zod.z.object({
+			name: zod.z.string().regex(/^[a-z0-9-]+$/),
+			subjectKind: zod.z.enum(["device", "node"]),
+			kind: DeviceHistoryKindSchema,
+			unit: zod.z.string().optional(),
+			displayName: zod.z.string().min(1),
+			ingest: zod.z.enum(["points", "buckets"])
+		}), zod.z.object({ key: zod.z.string() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Producer: points. Low rate: at most one per 10 s per series, sustained. */
+		record: require_sleep.method(zod.z.object({ points: zod.z.array(zod.z.object({
+			key: zod.z.string(),
+			subject: DeviceHistorySubjectSchema,
+			scope: zod.z.string().default(""),
+			ts: zod.z.number(),
+			value: zod.z.number()
+		})).max(5e3) }), IngestResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Producer: CLOSED five-minute buckets. Idempotent upsert keyed (series, bucketStart). */
+		recordBuckets: require_sleep.method(zod.z.object({ buckets: zod.z.array(zod.z.object({
+			key: zod.z.string(),
+			subject: DeviceHistorySubjectSchema,
+			scope: zod.z.string().default(""),
+			bucketStart: zod.z.number(),
+			samples: zod.z.number().int().positive(),
+			sum: zod.z.number(),
+			min: zod.z.number(),
+			max: zod.z.number(),
+			last: zod.z.number().nullable(),
+			lastTs: zod.z.number().nullable()
+		})).max(5e3) }), IngestResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Per-device opt-out. This addon IS the authority: the switch stores nothing elsewhere (D62). */
+		getDeviceEnabled: require_sleep.method(zod.z.object({ deviceId: zod.z.number().int() }), zod.z.object({ enabled: zod.z.boolean() })),
+		setDeviceEnabled: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number().int(),
+			enabled: zod.z.boolean()
+		}), zod.z.object({ enabled: zod.z.boolean() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getStatus: require_sleep.method(zod.z.object({}), DeviceHistoryStatusSchema, { auth: "admin" })
+	}
+};
+//#endregion
 //#region src/capabilities/device-credentials.cap.ts
 var DeviceCaStatusSchema = zod.z.discriminatedUnion("state", [
 	zod.z.object({ state: zod.z.literal("absent") }),
@@ -14077,6 +14314,16 @@ var nodeCertificatesCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* The hub unpairs this node (D857): it erases its mesh material, goes back to the
+		* unpaired state and advertises itself again. The call is answered first; the wire
+		* goes down right after, so the hub revokes the node's certificates BEFORE this
+		* connection drops, never after.
+		*/
+		forgetHub: require_sleep.method(zod.z.object({}), zod.z.object({ ok: zod.z.literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Install the hub-signed HTTPS leaf and hot-swap the serving context (no restart). */
 		installHttpsCertificate: require_sleep.method(zod.z.object({
 			certPem: zod.z.string().min(1),
@@ -38173,6 +38420,23 @@ var HUB_MDNS_TXT_KEYS = {
 	url: "url"
 };
 var HUB_MDNS_ROLE = "hub";
+/**
+* How a hub finds agents to pair (D857): every agent publishes ONE mDNS service for its API
+* port, paired or not. The TXT record carries only public facts. Finding an agent grants
+* nothing: pairing still needs the six-digit code confirmed on both screens.
+*/
+var AGENT_MDNS_SERVICE_TYPE = "camstack-agent";
+/** The fully-qualified name a hub browses for. */
+var AGENT_MDNS_QUERY_NAME = "_camstack-agent._tcp.local";
+/** The TXT keys of the agent advertisement. Every value is public. */
+var AGENT_MDNS_TXT_KEYS = {
+	nodeId: "nodeId",
+	version: "version",
+	/** `unpaired` | `pending` | `paired`. */
+	state: "state",
+	/** First 16 hex chars of the SHA-256 of the agent's mesh leaf; present once paired. */
+	keyFingerprint: "fp"
+};
 //#endregion
 //#region src/capabilities/ai-cap-timeouts.ts
 /**
@@ -77465,6 +77729,66 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceHistory.declareSeries": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"deviceHistory.getDeviceEnabled": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceHistory.getStatus": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceHistory.listNodeSeries": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceHistory.listSeries": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceHistory.query": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceHistory.queryNode": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"deviceHistory.record": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"deviceHistory.recordBuckets": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"deviceHistory.setDeviceEnabled": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"deviceManager.addLocation": {
 		capName: "device-manager",
 		capScope: "system",
@@ -79529,6 +79853,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"nodeCertificates.forgetHub": {
+		capName: "node-certificates",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"nodeCertificates.getCertificates": {
 		capName: "node-certificates",
 		capScope: "system",
@@ -83846,6 +84176,7 @@ var KNOWN_CAP_NAMES = [
 	"device-discovery",
 	"device-export",
 	"device-extension",
+	"device-history",
 	"device-manager",
 	"device-ops",
 	"device-provider",
@@ -84084,6 +84415,7 @@ var SYSTEM_CAP_NAMES = [
 	"device-adoption",
 	"device-credentials",
 	"device-export",
+	"device-history",
 	"device-manager",
 	"device-provider",
 	"device-state",
@@ -86114,6 +86446,7 @@ var CAPABILITY_NAMES = {
 	deviceDiscovery: "device-discovery",
 	deviceExport: "device-export",
 	deviceExtension: "device-extension",
+	deviceHistory: "device-history",
 	deviceManager: "device-manager",
 	deviceOps: "device-ops",
 	deviceProvider: "device-provider",
@@ -86451,6 +86784,10 @@ var CAPABILITY_ROUTER_KEYS = [
 		key: "deviceExtension",
 		name: "device-extension"
 	},
+	{
+		key: "deviceHistory",
+		name: "device-history"
+	},
 	{
 		key: "deviceManager",
 		name: "device-manager"
@@ -86988,6 +87325,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	deviceDiscoveryCapability,
 	deviceExportCapability,
 	deviceExtensionCapability,
+	deviceHistoryCapability,
 	deviceManagerCapability,
 	require_sleep.deviceOpsCapability,
 	deviceProviderCapability,
@@ -87573,6 +87911,26 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"deviceHistory.getDeviceEnabled": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceHistory.listSeries": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceHistory.query": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"deviceHistory.setDeviceEnabled": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"deviceManager.adoptionRelease": [{
 		name: "camDeviceId",
 		form: "single",
@@ -89755,6 +90113,10 @@ var SYSTEM_SCOPE_DEVICE_METHODS = [
 	"deviceExport.applyDeviceSettingsPatch",
 	"deviceExport.getDeviceLiveContribution",
 	"deviceExport.getDeviceSettingsContribution",
+	"deviceHistory.getDeviceEnabled",
+	"deviceHistory.listSeries",
+	"deviceHistory.query",
+	"deviceHistory.setDeviceEnabled",
 	"deviceManager.adoptionRelease",
 	"deviceManager.adoptionResync",
 	"deviceManager.applyInitialMeta",
@@ -90289,6 +90651,107 @@ var RESTORED_CAP_NAMES = [
 	"zones"
 ];
 //#endregion
+//#region src/history/bucket-accumulator.ts
+/** Width of a bucket the history store accepts. */
+var HISTORY_BUCKET_MS = 5 * 6e4;
+/** One hour of failed deliveries per series is retried; older buckets are dropped. */
+var MAX_REQUEUED_BUCKETS_PER_SERIES = 12;
+function bucketStartOf(at) {
+	return Math.floor(at / HISTORY_BUCKET_MS) * HISTORY_BUCKET_MS;
+}
+function subjectId(subject) {
+	return subject.kind === "device" ? `d:${subject.deviceId}` : `n:${subject.nodeId}`;
+}
+function seriesIdentity(key, subject, scope) {
+	return `${key}\u0000${subjectId(subject)}\u0000${scope}`;
+}
+function toClosed(b) {
+	return {
+		key: b.key,
+		subject: b.subject,
+		scope: b.scope,
+		bucketStart: b.bucketStart,
+		samples: b.samples,
+		sum: b.sum,
+		min: b.min,
+		max: b.max,
+		last: b.last,
+		lastTs: b.lastTs
+	};
+}
+var BucketAccumulator = class {
+	open = /* @__PURE__ */ new Map();
+	requeued = /* @__PURE__ */ new Map();
+	/** Add one observation. A non-finite value or timestamp is ignored (never counted as 0). */
+	note(key, subject, scope, value, at) {
+		if (!Number.isFinite(value) || !Number.isFinite(at)) return;
+		const bucketStart = bucketStartOf(at);
+		const id = `${seriesIdentity(key, subject, scope)}\u0000${bucketStart}`;
+		const existing = this.open.get(id);
+		if (existing === void 0) {
+			this.open.set(id, {
+				key,
+				subject,
+				scope,
+				bucketStart,
+				samples: 1,
+				sum: value,
+				min: value,
+				max: value,
+				last: value,
+				lastTs: at
+			});
+			return;
+		}
+		existing.samples += 1;
+		existing.sum += value;
+		if (value < existing.min) existing.min = value;
+		if (value > existing.max) existing.max = value;
+		if (at >= existing.lastTs) {
+			existing.last = value;
+			existing.lastTs = at;
+		}
+	}
+	/**
+	* Buckets whose window ended at or before `now`, oldest first, requeued ones
+	* included. They leave the accumulator: delivery is the caller's.
+	*/
+	takeClosed(now) {
+		const out = [];
+		for (const [id, bucket] of this.open) if (bucket.bucketStart + 3e5 <= now) {
+			out.push(toClosed(bucket));
+			this.open.delete(id);
+		}
+		for (const list of this.requeued.values()) out.push(...list);
+		this.requeued.clear();
+		return out.toSorted((a, b) => a.bucketStart - b.bucketStart);
+	}
+	/**
+	* Put undelivered buckets back for the next `takeClosed`. Keeps the newest
+	* {@link MAX_REQUEUED_BUCKETS_PER_SERIES} per series and returns the buckets
+	* it dropped (empty when none).
+	*/
+	requeue(buckets) {
+		const dropped = [];
+		for (const bucket of buckets) {
+			const id = seriesIdentity(bucket.key, bucket.subject, bucket.scope);
+			const list = [...this.requeued.get(id) ?? [], bucket].toSorted((a, b) => a.bucketStart - b.bucketStart);
+			while (list.length > 12) {
+				const oldest = list.shift();
+				if (oldest !== void 0) dropped.push(oldest);
+			}
+			this.requeued.set(id, list);
+		}
+		return dropped;
+	}
+	/** Buckets currently held (open plus requeued) — for a gauge in the producer's own status. */
+	pendingBucketCount() {
+		let n = this.open.size;
+		for (const list of this.requeued.values()) n += list.length;
+		return n;
+	}
+};
+//#endregion
 //#region src/generated/history-catalog.ts
 /**
 * Cap history catalog, projected from every `*.cap.ts` `history` block.
@@ -90878,6 +91341,14 @@ function createSystemProxy(api) {
 			exposeDevice: (input) => dispatch("deviceExport", "exposeDevice", "mutation", input),
 			unexposeDevice: (input) => dispatch("deviceExport", "unexposeDevice", "mutation", input)
 		},
+		deviceHistory: {
+			listNodeSeries: (input) => dispatch("deviceHistory", "listNodeSeries", "query", input),
+			queryNode: (input) => dispatch("deviceHistory", "queryNode", "query", input),
+			declareSeries: (input) => dispatch("deviceHistory", "declareSeries", "mutation", input),
+			record: (input) => dispatch("deviceHistory", "record", "mutation", input),
+			recordBuckets: (input) => dispatch("deviceHistory", "recordBuckets", "mutation", input),
+			getStatus: (input) => dispatch("deviceHistory", "getStatus", "query", input)
+		},
 		deviceManager: {
 			allocateDeviceId: (input) => dispatch("deviceManager", "allocateDeviceId", "mutation", input),
 			migrateDevice: (input) => dispatch("deviceManager", "migrateDevice", "mutation", input),
@@ -99917,6 +100388,9 @@ function enumerateInferenceDevices(hw) {
 //#endregion
 exports.ACCESSORY_LABEL = ACCESSORY_LABEL;
 exports.ACCESS_ROLES = ACCESS_ROLES;
+exports.AGENT_MDNS_QUERY_NAME = AGENT_MDNS_QUERY_NAME;
+exports.AGENT_MDNS_SERVICE_TYPE = AGENT_MDNS_SERVICE_TYPE;
+exports.AGENT_MDNS_TXT_KEYS = AGENT_MDNS_TXT_KEYS;
 exports.ALEXA_EGRESS_PROFILE = ALEXA_EGRESS_PROFILE;
 exports.ALL_CAPABILITY_DEFINITIONS = ALL_CAPABILITY_DEFINITIONS;
 exports.APPEARANCE_BIN_COUNT = APPEARANCE_BIN_COUNT;
@@ -100068,6 +100542,7 @@ exports.BrokerSubscribeInputSchema = SubscribeInputSchema;
 exports.BrokerSubscribeResultSchema = SubscribeResultSchema;
 exports.BrokerTestConnectionResultSchema = TestConnectionResultSchema;
 exports.BrokerUnsubscribeInputSchema = UnsubscribeInputSchema;
+exports.BucketAccumulator = BucketAccumulator;
 exports.BulkRecordSchema = BulkRecordSchema;
 exports.CAMERA_SENSORS_NOT_LOADED = CAMERA_SENSORS_NOT_LOADED;
 exports.CAMERA_SENSORS_SETTINGS_KEY = CAMERA_SENSORS_SETTINGS_KEY;
@@ -100397,6 +100872,11 @@ exports.DeviceExportExposeInputSchema = ExposeInputSchema;
 exports.DeviceExportStatusSchema = DeviceExportStatusSchema;
 exports.DeviceExportUnexposeInputSchema = UnexposeInputSchema;
 exports.DeviceFeature = require_err_msg.DeviceFeature;
+exports.DeviceHistoryKindSchema = DeviceHistoryKindSchema;
+exports.DeviceHistoryRefusalReasonSchema = DeviceHistoryRefusalReasonSchema;
+exports.DeviceHistoryResolutionSchema = DeviceHistoryResolutionSchema;
+exports.DeviceHistoryStatusSchema = DeviceHistoryStatusSchema;
+exports.DeviceHistorySubjectSchema = DeviceHistorySubjectSchema;
 exports.DeviceInfoSchema = DeviceInfoSchema;
 exports.DeviceModelChoiceSchema = DeviceModelChoiceSchema;
 exports.DeviceNetworkStatsSchema = DeviceNetworkStatsSchema;
@@ -100558,6 +101038,7 @@ exports.HAP_AUDIO_VBV_KBITS = HAP_AUDIO_VBV_KBITS;
 exports.HAP_KEYFRAME_INTERVAL_SEC = HAP_KEYFRAME_INTERVAL_SEC;
 exports.HF_BASE_URL = require_sleep.HF_BASE_URL;
 exports.HF_REPO = require_sleep.HF_REPO;
+exports.HISTORY_BUCKET_MS = HISTORY_BUCKET_MS;
 exports.HISTORY_CATALOG = HISTORY_CATALOG;
 exports.HISTORY_DEFAULT_MIN_INTERVAL_MS = require_sleep.HISTORY_DEFAULT_MIN_INTERVAL_MS;
 exports.HISTORY_NONE_CAPS = HISTORY_NONE_CAPS;
@@ -100732,6 +101213,7 @@ exports.MAX_EXPRESSION_EVAL_STEPS = require_composition.MAX_EXPRESSION_EVAL_STEP
 exports.MAX_EXPRESSION_SOURCE_LENGTH = require_composition.MAX_EXPRESSION_SOURCE_LENGTH;
 exports.MAX_KEYS = MAX_KEYS;
 exports.MAX_REASONS_PER_KEY = MAX_REASONS_PER_KEY;
+exports.MAX_REQUEUED_BUCKETS_PER_SERIES = MAX_REQUEUED_BUCKETS_PER_SERIES;
 exports.MAX_SENSOR_TRIGGER_DEVICES = MAX_SENSOR_TRIGGER_DEVICES;
 exports.MAX_TRACK_DEBUG_NOTE_LEN = MAX_TRACK_DEBUG_NOTE_LEN;
 exports.MAX_TRACK_PURITIES = MAX_TRACK_PURITIES;
@@ -101734,6 +102216,7 @@ exports.binaryCapability = binaryCapability;
 exports.bindAddonActions = bindAddonActions;
 exports.brightnessCapability = brightnessCapability;
 exports.brokerCapability = brokerCapability;
+exports.bucketStartOf = bucketStartOf;
 exports.buildAddonRouteProvider = buildAddonRouteProvider;
 exports.buildAudioArgs = require_composition.buildAudioArgs;
 exports.buildBenchStepTree = buildBenchStepTree;
@@ -101901,6 +102384,7 @@ exports.deviceDiscoveryCapability = deviceDiscoveryCapability;
 exports.deviceDoFamily = deviceDoFamily;
 exports.deviceExportCapability = deviceExportCapability;
 exports.deviceExtensionCapability = deviceExtensionCapability;
+exports.deviceHistoryCapability = deviceHistoryCapability;
 exports.deviceManagerCapability = deviceManagerCapability;
 exports.deviceMatchesProfile = deviceMatchesProfile;
 exports.deviceOpsCapability = require_sleep.deviceOpsCapability;