@camstack/types 1.2.421 → 1.2.423

package/dist/{composition-B3Hkb6v7.js → composition-CPRAP41h.js}

@@ -2232,6 +2232,544 @@ function sourcePickForAppliance() {
 	};
 }
 //#endregion
+//#region src/composition/helpers/energy.ts
+/**
+* Watts integrated over time, in kWh (D944).
+*
+* 1 kWh = 1 000 W × 3 600 000 ms. The history energy series uses the same
+* factor (`tw_sum / 3.6e9`), so a chart and an integral helper cannot diverge.
+*/
+var KWH_PER_WATT_MS = 1 / 36e8;
+function wattMillisecondsToKwh(wattMilliseconds) {
+	return wattMilliseconds * KWH_PER_WATT_MS;
+}
+//#endregion
+//#region src/composition/helpers/history-math.ts
+/**
+* Statistics and integrals over a history read (D944).
+*
+* Pure: the same points always give the same answer, so a restart recomputes
+* rather than trusting a buffer. A gauge mean is time-weighted (value × ms),
+* never the mean of the samples. A hole with no held value is not integrated
+* as zero. A truncated read is not published.
+*/
+var STATISTIC_STATS = [
+	"min",
+	"max",
+	"mean",
+	"sum",
+	"count",
+	"change"
+];
+var SERIES_KINDS = [
+	"gauge",
+	"counter",
+	"boolean"
+];
+function finite(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function pointValue(point) {
+	if (finite(point.value)) return point.value;
+	if (finite(point.last)) return point.last;
+	return null;
+}
+function stepCoverage(read) {
+	const points = read.points.filter((point) => point.t >= read.from && point.t < read.to);
+	const start = finite(read.before?.value) ? read.before.value : null;
+	let held = start;
+	let cursor = read.from;
+	let gaps = 0;
+	const segments = [];
+	if (held === null) {
+		const first = points.find((point) => pointValue(point) !== null);
+		if (first === void 0) return {
+			segments,
+			included: 0,
+			gaps: 1,
+			end: null,
+			start: null
+		};
+		if (first.t > read.from) gaps += 1;
+		cursor = first.t;
+		held = pointValue(first);
+	}
+	for (const point of points) {
+		const next = pointValue(point);
+		if (held !== null && point.t > cursor) segments.push({
+			value: held,
+			ms: point.t - cursor
+		});
+		if (next !== null) held = next;
+		if (point.t > cursor) cursor = point.t;
+	}
+	if (held !== null && read.to > cursor) segments.push({
+		value: held,
+		ms: read.to - cursor
+	});
+	const end = points.reduce((latest, point) => pointValue(point) ?? latest, held);
+	return {
+		segments,
+		included: points.length,
+		gaps,
+		end,
+		start
+	};
+}
+function rollupCoverage(read) {
+	const weighted = read.points.filter((point) => finite(point.twMean) && finite(point.twMs) && point.twMs > 0);
+	if (weighted.length === 0) return null;
+	const first = weighted[0];
+	const gaps = read.before === null && first !== void 0 && first.t > read.from ? 1 : 0;
+	const levels = read.points.flatMap((point) => finite(point.last) ? [point.last] : []);
+	const end = levels.length > 0 ? levels[levels.length - 1] ?? null : null;
+	return {
+		segments: weighted.flatMap((point) => finite(point.twMean) && finite(point.twMs) ? [{
+			value: point.twMean,
+			ms: point.twMs
+		}] : []),
+		included: weighted.length,
+		gaps,
+		end,
+		start: finite(read.before?.value) ? read.before.value : null
+	};
+}
+function coverageOf(read) {
+	if (read.tier !== "raw") {
+		const rolled = rollupCoverage(read);
+		if (rolled !== null) return rolled;
+	}
+	return stepCoverage(read);
+}
+function timeWeighted(segments) {
+	let ms = 0;
+	let sum = 0;
+	for (const segment of segments) {
+		ms += segment.ms;
+		sum += segment.value * segment.ms;
+	}
+	if (ms <= 0) return null;
+	return sum / ms;
+}
+function extremes(read, covered) {
+	const lows = [];
+	const highs = [];
+	for (const point of read.points) {
+		if (finite(point.min)) lows.push(point.min);
+		if (finite(point.max)) highs.push(point.max);
+	}
+	if (covered.start !== null) {
+		lows.push(covered.start);
+		highs.push(covered.start);
+	}
+	return {
+		min: lows.length === 0 ? null : Math.min(...lows),
+		max: highs.length === 0 ? null : Math.max(...highs)
+	};
+}
+function counterGrowth(read) {
+	const deltas = read.points.flatMap((point) => finite(point.delta) ? [point.delta] : []);
+	if (deltas.length === 0) return null;
+	return deltas.reduce((sum, delta) => sum + delta, 0);
+}
+function hold(reason) {
+	return {
+		write: "hold",
+		value: null,
+		included: 0,
+		excluded: 0,
+		reason
+	};
+}
+function gapValue(reason, included) {
+	return {
+		write: "null",
+		value: null,
+		included,
+		excluded: 1,
+		reason
+	};
+}
+function numberValue(value, included, gaps, reason) {
+	return {
+		write: "number",
+		value,
+		included,
+		excluded: gaps,
+		reason: gaps > 0 ? reason : null
+	};
+}
+var GAP_REASON = "history has a gap — that interval was not counted as zero";
+function evaluateStatistic(stat, read) {
+	if (read.truncated) return hold("the history query was truncated — the last statistic is kept");
+	if (stat === "sum" && read.kind !== "counter") return hold("a gauge has no sum — that is the integral template");
+	if (read.to <= read.from) return gapValue("the range is empty", 0);
+	const covered = coverageOf(read);
+	if (covered.segments.length === 0 && covered.start === null) return gapValue(GAP_REASON, covered.included);
+	if (stat === "count") return numberValue(covered.included, covered.included, covered.gaps, GAP_REASON);
+	if (stat === "sum" || stat === "change" && read.kind === "counter") {
+		const growth = counterGrowth(read);
+		if (growth === null) return gapValue("the counter has no growth in this range", covered.included);
+		return numberValue(growth, covered.included, covered.gaps, GAP_REASON);
+	}
+	if (stat === "change") {
+		if (covered.start === null || covered.end === null) return gapValue("the change has no value at the start of the range", covered.included);
+		return numberValue(covered.end - covered.start, covered.included, covered.gaps, GAP_REASON);
+	}
+	if (stat === "min" || stat === "max") {
+		const ends = extremes(read, covered);
+		const value = stat === "min" ? ends.min : ends.max;
+		if (value === null) return gapValue(GAP_REASON, covered.included);
+		return numberValue(value, covered.included, covered.gaps, GAP_REASON);
+	}
+	const mean = timeWeighted(covered.segments);
+	if (mean === null) return gapValue(GAP_REASON, covered.included);
+	return numberValue(mean, covered.included, covered.gaps, GAP_REASON);
+}
+function integrateReading(read, scale) {
+	if (read.truncated) return hold("the history query was truncated — the last total is kept");
+	if (read.kind === "counter") return hold("a counter is already a total — it is not integrated again");
+	if (read.to <= read.from) return gapValue("the range is empty", 0);
+	const covered = coverageOf(read);
+	if (covered.segments.length === 0) return {
+		write: "hold",
+		value: null,
+		included: covered.included,
+		excluded: covered.gaps,
+		reason: GAP_REASON
+	};
+	let unitMs = 0;
+	for (const segment of covered.segments) unitMs += segment.value * segment.ms;
+	return numberValue(scale === "energy-kwh" ? wattMillisecondsToKwh(unitMs) : unitMs / 1e3, covered.included, covered.gaps, GAP_REASON);
+}
+//#endregion
+//#region src/composition/helpers/history-window.ts
+/**
+* The range a statistics or integral helper asks history for (D944).
+*
+* Calendar edges are the hub's timezone, never UTC midnight: a day is 23, 24
+* or 25 hours across a DST change. A tier is eligible only when its retention
+* is strictly longer than the longest that range can be. Forever qualifies.
+* Equal to a tier's retention is a refusal, not a short answer.
+*/
+var MINUTE_MS = 6e4;
+var HOUR_MS = 60 * MINUTE_MS;
+var DAY_MS = 24 * HOUR_MS;
+var ROLLING_SPANS = [
+	"1h",
+	"24h",
+	"2d",
+	"7d",
+	"30d",
+	"custom"
+];
+var CALENDAR_PERIODS = [
+	"today",
+	"yesterday",
+	"this-week",
+	"this-month"
+];
+var HISTORY_TIERS = [
+	"raw",
+	"5m",
+	"1h",
+	"1d"
+];
+var RESET_PERIODS = [
+	"never",
+	"daily",
+	"weekly",
+	"monthly"
+];
+var MIN_CUSTOM_MINUTES = 5;
+/** Faster than this is not a history query. Rolling windows at most this often. */
+var HISTORY_FAST_MS = 6e4;
+var HISTORY_SLOW_MS = 5 * MINUTE_MS;
+var ROLLING_MS = {
+	"1h": HOUR_MS,
+	"24h": 24 * HOUR_MS,
+	"2d": 2 * DAY_MS,
+	"7d": 7 * DAY_MS,
+	"30d": 30 * DAY_MS
+};
+/** The device-history defaults: raw 7 d, 5 m 30 d, 1 h 365 d, 1 d forever. */
+var DEFAULT_HISTORY_RETENTION = {
+	rawMs: 7 * DAY_MS,
+	fiveMinuteMs: 30 * DAY_MS,
+	hourMs: 365 * DAY_MS,
+	dayMs: null
+};
+var rollingWindowObject = zod.z.object({
+	kind: zod.z.literal("rolling"),
+	span: zod.z.enum(ROLLING_SPANS),
+	customMinutes: zod.z.number().int().min(5).optional()
+}).check((payload) => {
+	if (payload.value.span === "custom" && payload.value.customMinutes === void 0) payload.issues.push({
+		code: "custom",
+		message: "a custom range needs a duration in minutes",
+		path: ["customMinutes"],
+		input: payload.value
+	});
+	if (payload.value.span !== "custom" && payload.value.customMinutes !== void 0) payload.issues.push({
+		code: "custom",
+		message: "only a custom range carries a duration",
+		path: ["customMinutes"],
+		input: payload.value
+	});
+});
+var RollingWindowSchema = rollingWindowObject;
+var calendarWindowObject = zod.z.object({
+	kind: zod.z.literal("calendar"),
+	period: zod.z.enum(CALENDAR_PERIODS)
+});
+var CalendarWindowSchema = calendarWindowObject;
+var StatisticWindowSchema = zod.z.discriminatedUnion("kind", [rollingWindowObject, calendarWindowObject]);
+var WEEKDAY_INDEX = {
+	Sun: 0,
+	Mon: 1,
+	Tue: 2,
+	Wed: 3,
+	Thu: 4,
+	Fri: 5,
+	Sat: 6
+};
+var FORMATTERS = /* @__PURE__ */ new Map();
+function formatterFor(timeZone) {
+	const held = FORMATTERS.get(timeZone);
+	if (held !== void 0) return held;
+	let made;
+	try {
+		made = new Intl.DateTimeFormat("en-US", {
+			timeZone,
+			weekday: "short",
+			year: "numeric",
+			month: "2-digit",
+			day: "2-digit",
+			hour: "2-digit",
+			minute: "2-digit",
+			second: "2-digit",
+			hourCycle: "h23"
+		});
+	} catch {
+		made = null;
+	}
+	FORMATTERS.set(timeZone, made);
+	return made;
+}
+function zonedClock(ms, timeZone) {
+	const formatter = formatterFor(timeZone);
+	if (formatter === null) return null;
+	const parts = formatter.formatToParts(new Date(ms));
+	const read = (type) => parts.find((part) => part.type === type)?.value;
+	const year = Number(read("year"));
+	const month = Number(read("month"));
+	const day = Number(read("day"));
+	const hourRaw = Number(read("hour"));
+	const minute = Number(read("minute"));
+	const second = Number(read("second"));
+	const weekday = WEEKDAY_INDEX[read("weekday") ?? ""];
+	if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day) || !Number.isInteger(hourRaw) || !Number.isInteger(minute) || !Number.isInteger(second) || weekday === void 0) return null;
+	return {
+		year,
+		month,
+		day,
+		hour: hourRaw === 24 ? 0 : hourRaw,
+		minute,
+		second,
+		weekday
+	};
+}
+function utcOf(clock, timeZone) {
+	const guess = Date.UTC(clock.year, clock.month - 1, clock.day, clock.hour, clock.minute, clock.second);
+	const first = zonedClock(guess, timeZone);
+	if (first === null) return null;
+	const offset = Date.UTC(first.year, first.month - 1, first.day, first.hour, first.minute, first.second) - guess;
+	const shifted = guess - offset;
+	const second = zonedClock(shifted, timeZone);
+	if (second === null) return null;
+	const offset2 = Date.UTC(second.year, second.month - 1, second.day, second.hour, second.minute, second.second) - shifted;
+	return offset2 === offset ? shifted : guess - offset2;
+}
+function midnightOf(ms, timeZone) {
+	const clock = zonedClock(ms, timeZone);
+	if (clock === null) return null;
+	return utcOf({
+		...clock,
+		hour: 0,
+		minute: 0,
+		second: 0
+	}, timeZone);
+}
+function monthStart(ms, timeZone) {
+	const clock = zonedClock(ms, timeZone);
+	if (clock === null) return null;
+	return utcOf({
+		...clock,
+		day: 1,
+		hour: 0,
+		minute: 0,
+		second: 0
+	}, timeZone);
+}
+function weekStart(ms, timeZone) {
+	const clock = zonedClock(ms, timeZone);
+	let cursor = midnightOf(ms, timeZone);
+	if (clock === null || cursor === null) return null;
+	const back = clock.weekday === 0 ? 6 : clock.weekday - 1;
+	for (let step = 0; step < back; step++) {
+		const previous = midnightOf(cursor - 1, timeZone);
+		if (previous === null) return null;
+		cursor = previous;
+	}
+	return cursor;
+}
+function keptLabel(ms) {
+	if (ms === null) return "forever";
+	if (ms % 864e5 === 0) return `${ms / DAY_MS} d`;
+	if (ms % 36e5 === 0) return `${ms / HOUR_MS} h`;
+	return `${ms / MINUTE_MS} min`;
+}
+function retentionSentence(retention) {
+	return `raw ${keptLabel(retention.rawMs)}, 5m ${keptLabel(retention.fiveMinuteMs)}, 1h ${keptLabel(retention.hourMs)}, 1d ${keptLabel(retention.dayMs)}`;
+}
+function tierFor(durationMs, retention) {
+	const rows = [
+		{
+			tier: "raw",
+			keptMs: retention.rawMs
+		},
+		{
+			tier: "5m",
+			keptMs: retention.fiveMinuteMs
+		},
+		{
+			tier: "1h",
+			keptMs: retention.hourMs
+		},
+		{
+			tier: "1d",
+			keptMs: retention.dayMs
+		}
+	];
+	for (const row of rows) if (row.keptMs === null || row.keptMs > durationMs) return {
+		ok: true,
+		tier: row.tier,
+		maxDurationMs: durationMs
+	};
+	return {
+		ok: false,
+		reason: `the range is ${keptLabel(durationMs)} and no history tier is kept strictly longer (${retentionSentence(retention)})`
+	};
+}
+function rollingDurationMs(window) {
+	if (window.span === "custom") return window.customMinutes === void 0 ? null : window.customMinutes * MINUTE_MS;
+	return ROLLING_MS[window.span];
+}
+/** Longest the window can be. Calendar periods use their full length, not the elapsed part. */
+function maxDurationMs(window) {
+	if (window.kind === "rolling") return rollingDurationMs(window);
+	switch (window.period) {
+		case "today":
+		case "yesterday": return 25 * HOUR_MS;
+		case "this-week": return 6084e5;
+		case "this-month": return 2682e6;
+	}
+}
+function planStatisticTier(window, retention) {
+	const duration = maxDurationMs(window);
+	if (duration === null) return {
+		ok: false,
+		reason: "a custom range needs a duration of at least 5 minutes"
+	};
+	return tierFor(duration, retention);
+}
+function planResetTier(reset, retention) {
+	switch (reset) {
+		case "never": return tierFor(Number.POSITIVE_INFINITY, retention);
+		case "daily": return tierFor(25 * HOUR_MS, retention);
+		case "weekly": return tierFor(6084e5, retention);
+		case "monthly": return tierFor(2682e6, retention);
+	}
+}
+function openStatistic(window, now, timeZone) {
+	if (window.kind === "rolling") {
+		const duration = rollingDurationMs(window);
+		if (duration === null) return null;
+		return {
+			from: now - duration,
+			to: now
+		};
+	}
+	const today = midnightOf(now, timeZone);
+	if (today === null) return null;
+	switch (window.period) {
+		case "today": return {
+			from: today,
+			to: now
+		};
+		case "yesterday": {
+			const start = midnightOf(today - 1, timeZone);
+			return start === null ? null : {
+				from: start,
+				to: today
+			};
+		}
+		case "this-week": {
+			const start = weekStart(now, timeZone);
+			return start === null ? null : {
+				from: start,
+				to: now
+			};
+		}
+		case "this-month": {
+			const start = monthStart(now, timeZone);
+			return start === null ? null : {
+				from: start,
+				to: now
+			};
+		}
+	}
+}
+function openReset(reset, now, timeZone) {
+	if (reset === "never") return {
+		from: 0,
+		to: now
+	};
+	const today = midnightOf(now, timeZone);
+	if (today === null) return null;
+	if (reset === "daily") return {
+		from: today,
+		to: now
+	};
+	if (reset === "weekly") {
+		const start = weekStart(now, timeZone);
+		return start === null ? null : {
+			from: start,
+			to: now
+		};
+	}
+	const start = monthStart(now, timeZone);
+	return start === null ? null : {
+		from: start,
+		to: now
+	};
+}
+/** The next hub-local midnight, strictly after `now`. Monday is one of these. */
+function nextLocalMidnight(now, timeZone) {
+	const today = midnightOf(now, timeZone);
+	if (today === null) return null;
+	return midnightOf(today + 26 * HOUR_MS, timeZone);
+}
+function statisticCadenceMs(window) {
+	if (window.kind === "calendar") return window.period === "today" ? HISTORY_FAST_MS : HISTORY_SLOW_MS;
+	const duration = rollingDurationMs(window);
+	if (duration !== null && duration <= 24 * 36e5) return HISTORY_FAST_MS;
+	return HISTORY_SLOW_MS;
+}
+function integralCadenceMs(tier) {
+	return tier === "raw" ? HISTORY_FAST_MS : HISTORY_SLOW_MS;
+}
+//#endregion
 //#region src/composition/source-ref.ts
 /**
 * A composition source identity: `(addonId, stableId)`, never a numeric device
@@ -2297,10 +2835,7 @@ var HelperMemberSchema = zod.z.object({
 	cap: zod.z.string().min(1),
 	fieldPath: zod.z.string().min(1)
 });
-/**
-* Phase 1a is groups only. Math, integral and statistics stay off this union
-* until the composer can run them — a control must not save a spec it cannot.
-*/
+/** A group, a statistic, or an integral (D944). The composer runs all three. */
 var GroupHelperSpecSchema = zod.z.object({
 	kind: zod.z.literal("group"),
 	templateId: GroupTemplateIdSchema,
@@ -2318,10 +2853,35 @@ var ApplianceHelperSpecSchema = zod.z.object({
 	stopDwellMs: zod.z.number().int().nonnegative(),
 	member: HelperMemberSchema
 });
-var HelperSpecSchema = zod.z.discriminatedUnion("kind", [GroupHelperSpecSchema, ApplianceHelperSpecSchema]);
-/** Every member a helper reads. An appliance has one. */
+var statisticHelperObject = zod.z.object({
+	kind: zod.z.literal("statistic"),
+	stat: zod.z.enum(STATISTIC_STATS),
+	window: StatisticWindowSchema,
+	source: HelperMemberSchema
+});
+var StatisticHelperSpecSchema = statisticHelperObject;
+var INTEGRAL_OUTPUTS = ["energy", "meter"];
+var integralHelperObject = zod.z.object({
+	kind: zod.z.literal("integral"),
+	reset: zod.z.enum(RESET_PERIODS),
+	output: zod.z.enum(INTEGRAL_OUTPUTS),
+	source: HelperMemberSchema
+});
+var IntegralHelperSpecSchema = integralHelperObject;
+var HelperSpecSchema = zod.z.discriminatedUnion("kind", [
+	GroupHelperSpecSchema,
+	ApplianceHelperSpecSchema,
+	statisticHelperObject,
+	integralHelperObject
+]);
+/** Every member a helper reads. A group has many; the others have one. */
 function helperMembers(spec) {
-	return spec.kind === "group" ? spec.members : [spec.member];
+	switch (spec.kind) {
+		case "group": return spec.members;
+		case "appliance": return [spec.member];
+		case "statistic":
+		case "integral": return [spec.source];
+	}
 }
 //#endregion
 //#region src/composition/composition.ts
@@ -2432,11 +2992,36 @@ var CompositionAggregateSourceSchema = zod.z.object({
 		"offline"
 	])
 });
+/**
+* `series`: a statistics or integral field. The composer writes it from a
+* history query. The live pass does not recompute it (D944).
+*/
+var CompositionSeriesSourceSchema = zod.z.object({
+	kind: zod.z.literal("series"),
+	read: CompositionFieldReadSchema,
+	/** `value` is the statistic or the integral. The others are the gap counts. */
+	publish: zod.z.enum([
+		"value",
+		"included",
+		"excluded",
+		"total"
+	]),
+	/**
+	* What an unanswered `value` does. Counts ignore this. `offline` leaves the
+	* device unseeded until history answers, so a restart cannot publish 0.
+	*/
+	empty: zod.z.enum([
+		"null",
+		"omit",
+		"offline"
+	])
+});
 var CompositionFieldSourceSchema = zod.z.discriminatedUnion("kind", [
 	CompositionFromSourceSchema,
 	CompositionExpressionSourceSchema,
 	CompositionCodeSourceSchema,
-	CompositionAggregateSourceSchema
+	CompositionAggregateSourceSchema,
+	CompositionSeriesSourceSchema
 ]);
 /** `forward`: RESERVED for slice 3. Argument mapping arrives there as an additive optional `args`. */
 var CompositionForwardCommandSchema = zod.z.object({
@@ -2556,6 +3141,7 @@ function fieldReads(source) {
 			fieldPath: binding.fieldPath
 		}] : []);
 		case "aggregate": return source.reads;
+		case "series": return [source.read];
 		case "code": return [];
 	}
 }
@@ -2642,6 +3228,12 @@ Object.defineProperty(exports, "BINARY_AGGREGATES", {
 		return BINARY_AGGREGATES;
 	}
 });
+Object.defineProperty(exports, "CALENDAR_PERIODS", {
+	enumerable: true,
+	get: function() {
+		return CALENDAR_PERIODS;
+	}
+});
 Object.defineProperty(exports, "COMPOSED_DEVICE_STABLE_ID_PREFIX", {
 	enumerable: true,
 	get: function() {
@@ -2672,6 +3264,12 @@ Object.defineProperty(exports, "CUSTOMIZATION_BLOCK_NAME_PREFIX", {
 		return CUSTOMIZATION_BLOCK_NAME_PREFIX;
 	}
 });
+Object.defineProperty(exports, "CalendarWindowSchema", {
+	enumerable: true,
+	get: function() {
+		return CalendarWindowSchema;
+	}
+});
 Object.defineProperty(exports, "CompositionAggregateSourceSchema", {
 	enumerable: true,
 	get: function() {
@@ -2774,6 +3372,12 @@ Object.defineProperty(exports, "CompositionSchema", {
 		return CompositionSchema;
 	}
 });
+Object.defineProperty(exports, "CompositionSeriesSourceSchema", {
+	enumerable: true,
+	get: function() {
+		return CompositionSeriesSourceSchema;
+	}
+});
 Object.defineProperty(exports, "CompositionSourceRefSchema", {
 	enumerable: true,
 	get: function() {
@@ -2786,12 +3390,24 @@ Object.defineProperty(exports, "CompositionTargetSchema", {
 		return CompositionTargetSchema;
 	}
 });
+Object.defineProperty(exports, "DAY_MS", {
+	enumerable: true,
+	get: function() {
+		return DAY_MS;
+	}
+});
 Object.defineProperty(exports, "DEFAULT_FIRST_SIGHTING_FRESHNESS_MS", {
 	enumerable: true,
 	get: function() {
 		return DEFAULT_FIRST_SIGHTING_FRESHNESS_MS;
 	}
 });
+Object.defineProperty(exports, "DEFAULT_HISTORY_RETENTION", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_HISTORY_RETENTION;
+	}
+});
 Object.defineProperty(exports, "EXPRESSION_BUILTINS", {
 	enumerable: true,
 	get: function() {
@@ -2870,6 +3486,30 @@ Object.defineProperty(exports, "GroupTemplateIdSchema", {
 		return GroupTemplateIdSchema;
 	}
 });
+Object.defineProperty(exports, "HISTORY_FAST_MS", {
+	enumerable: true,
+	get: function() {
+		return HISTORY_FAST_MS;
+	}
+});
+Object.defineProperty(exports, "HISTORY_SLOW_MS", {
+	enumerable: true,
+	get: function() {
+		return HISTORY_SLOW_MS;
+	}
+});
+Object.defineProperty(exports, "HISTORY_TIERS", {
+	enumerable: true,
+	get: function() {
+		return HISTORY_TIERS;
+	}
+});
+Object.defineProperty(exports, "HOUR_MS", {
+	enumerable: true,
+	get: function() {
+		return HOUR_MS;
+	}
+});
 Object.defineProperty(exports, "HelperMemberSchema", {
 	enumerable: true,
 	get: function() {
@@ -2882,6 +3522,24 @@ Object.defineProperty(exports, "HelperSpecSchema", {
 		return HelperSpecSchema;
 	}
 });
+Object.defineProperty(exports, "INTEGRAL_OUTPUTS", {
+	enumerable: true,
+	get: function() {
+		return INTEGRAL_OUTPUTS;
+	}
+});
+Object.defineProperty(exports, "IntegralHelperSpecSchema", {
+	enumerable: true,
+	get: function() {
+		return IntegralHelperSpecSchema;
+	}
+});
+Object.defineProperty(exports, "KWH_PER_WATT_MS", {
+	enumerable: true,
+	get: function() {
+		return KWH_PER_WATT_MS;
+	}
+});
 Object.defineProperty(exports, "MAX_COMPOSITION_CODE_LENGTH", {
 	enumerable: true,
 	get: function() {
@@ -2942,6 +3600,18 @@ Object.defineProperty(exports, "MAX_HELPER_MEMBERS", {
 		return MAX_HELPER_MEMBERS;
 	}
 });
+Object.defineProperty(exports, "MINUTE_MS", {
+	enumerable: true,
+	get: function() {
+		return MINUTE_MS;
+	}
+});
+Object.defineProperty(exports, "MIN_CUSTOM_MINUTES", {
+	enumerable: true,
+	get: function() {
+		return MIN_CUSTOM_MINUTES;
+	}
+});
 Object.defineProperty(exports, "NUMERIC_AGGREGATES", {
 	enumerable: true,
 	get: function() {
@@ -2954,6 +3624,30 @@ Object.defineProperty(exports, "RESERVED_BINDING_NAMES", {
 		return RESERVED_BINDING_NAMES;
 	}
 });
+Object.defineProperty(exports, "RESET_PERIODS", {
+	enumerable: true,
+	get: function() {
+		return RESET_PERIODS;
+	}
+});
+Object.defineProperty(exports, "ROLLING_SPANS", {
+	enumerable: true,
+	get: function() {
+		return ROLLING_SPANS;
+	}
+});
+Object.defineProperty(exports, "RollingWindowSchema", {
+	enumerable: true,
+	get: function() {
+		return RollingWindowSchema;
+	}
+});
+Object.defineProperty(exports, "SERIES_KINDS", {
+	enumerable: true,
+	get: function() {
+		return SERIES_KINDS;
+	}
+});
 Object.defineProperty(exports, "SOURCE_CAPS", {
 	enumerable: true,
 	get: function() {
@@ -2978,6 +3672,24 @@ Object.defineProperty(exports, "SOURCE_DEVICE_TYPES", {
 		return SOURCE_DEVICE_TYPES;
 	}
 });
+Object.defineProperty(exports, "STATISTIC_STATS", {
+	enumerable: true,
+	get: function() {
+		return STATISTIC_STATS;
+	}
+});
+Object.defineProperty(exports, "StatisticHelperSpecSchema", {
+	enumerable: true,
+	get: function() {
+		return StatisticHelperSpecSchema;
+	}
+});
+Object.defineProperty(exports, "StatisticWindowSchema", {
+	enumerable: true,
+	get: function() {
+		return StatisticWindowSchema;
+	}
+});
 Object.defineProperty(exports, "applianceDeviceType", {
 	enumerable: true,
 	get: function() {
@@ -3146,6 +3858,12 @@ Object.defineProperty(exports, "evaluateStatefulExpressionCall", {
 		return evaluateStatefulExpressionCall;
 	}
 });
+Object.defineProperty(exports, "evaluateStatistic", {
+	enumerable: true,
+	get: function() {
+		return evaluateStatistic;
+	}
+});
 Object.defineProperty(exports, "featureFieldEntries", {
 	enumerable: true,
 	get: function() {
@@ -3188,6 +3906,18 @@ Object.defineProperty(exports, "helperMembers", {
 		return helperMembers;
 	}
 });
+Object.defineProperty(exports, "integralCadenceMs", {
+	enumerable: true,
+	get: function() {
+		return integralCadenceMs;
+	}
+});
+Object.defineProperty(exports, "integrateReading", {
+	enumerable: true,
+	get: function() {
+		return integrateReading;
+	}
+});
 Object.defineProperty(exports, "invocationFromEncodeProfile", {
 	enumerable: true,
 	get: function() {
@@ -3224,6 +3954,30 @@ Object.defineProperty(exports, "logBannerArgs", {
 		return logBannerArgs;
 	}
 });
+Object.defineProperty(exports, "maxDurationMs", {
+	enumerable: true,
+	get: function() {
+		return maxDurationMs;
+	}
+});
+Object.defineProperty(exports, "nextLocalMidnight", {
+	enumerable: true,
+	get: function() {
+		return nextLocalMidnight;
+	}
+});
+Object.defineProperty(exports, "openReset", {
+	enumerable: true,
+	get: function() {
+		return openReset;
+	}
+});
+Object.defineProperty(exports, "openStatistic", {
+	enumerable: true,
+	get: function() {
+		return openStatistic;
+	}
+});
 Object.defineProperty(exports, "parseExpression", {
 	enumerable: true,
 	get: function() {
@@ -3236,12 +3990,30 @@ Object.defineProperty(exports, "pickVideoEncoder", {
 		return pickVideoEncoder;
 	}
 });
+Object.defineProperty(exports, "planResetTier", {
+	enumerable: true,
+	get: function() {
+		return planResetTier;
+	}
+});
+Object.defineProperty(exports, "planStatisticTier", {
+	enumerable: true,
+	get: function() {
+		return planStatisticTier;
+	}
+});
 Object.defineProperty(exports, "resolveStreamMaps", {
 	enumerable: true,
 	get: function() {
 		return resolveStreamMaps;
 	}
 });
+Object.defineProperty(exports, "rollingDurationMs", {
+	enumerable: true,
+	get: function() {
+		return rollingDurationMs;
+	}
+});
 Object.defineProperty(exports, "sliceActiveValue", {
 	enumerable: true,
 	get: function() {
@@ -3260,6 +4032,12 @@ Object.defineProperty(exports, "sourcePickForAppliance", {
 		return sourcePickForAppliance;
 	}
 });
+Object.defineProperty(exports, "statisticCadenceMs", {
+	enumerable: true,
+	get: function() {
+		return statisticCadenceMs;
+	}
+});
 Object.defineProperty(exports, "toExpressionValue", {
 	enumerable: true,
 	get: function() {
@@ -3278,3 +4056,9 @@ Object.defineProperty(exports, "validateExpressionSource", {
 		return validateExpressionSource;
 	}
 });
+Object.defineProperty(exports, "wattMillisecondsToKwh", {
+	enumerable: true,
+	get: function() {
+		return wattMillisecondsToKwh;
+	}
+});