@camstack/types 1.2.422 → 1.2.424

package/dist/client.js

@@ -23833,7 +23833,20 @@ var NcRuleInputSchema = zod.z.object({
 	* save by the hub's grouping guard). `.optional()`, never `.default()`: the addon cap
 	* path does not run Zod defaults.
 	*/
-	groupingSec: zod.z.number().int().min(5).max(60).optional()
+	groupingSec: zod.z.number().int().min(5).max(60).optional(),
+	/**
+	* ASK ME TO CONFIRM DETECTIONS (#243): a DETECTION notification of this rule
+	* carries "Correct" / "Wrong" buttons (and, where the channel has room, a
+	* "Wrong, it is a <class>" choice). A tap marks the track for retraining, the
+	* same mark the Library writes, and records whose notification it was and
+	* when. A channel with no buttons gets the same two choices as links.
+	*
+	* `.optional()`, never `.default()` (a Zod default does not run on the addon
+	* cap path): absent and `false` both mean off, which is what every rule
+	* authored before this field meant. An editor turns it off by writing
+	* `false`, so it needs no `clear` key.
+	*/
+	askVerdict: zod.z.boolean().optional()
 });
 /**
 * Partial patch for `updateRule` — any subset of the input fields, plus the
@@ -26834,6 +26847,7 @@ function createDeviceProxy(api, binding, opts) {
 	const featureProbeInterface = { getStatus: (input) => dispatch("feature-probe", "featureProbe", "getStatus", "query", input) };
 	const floodInterface = { getStatus: (input) => dispatch("flood", "flood", "getStatus", "query", input) };
 	const gasInterface = { getStatus: (input) => dispatch("gas", "gas", "getStatus", "query", input) };
+	const groupActiveInterface = { getStatus: (input) => dispatch("group-active", "groupActive", "getStatus", "query", input) };
 	const groupCommandsInterface = { getStatus: (input) => dispatch("group-commands", "groupCommands", "getStatus", "query", input) };
 	const groupStatusInterface = { getStatus: (input) => dispatch("group-status", "groupStatus", "getStatus", "query", input) };
 	const heatingValveInterface = { getStatus: (input) => dispatch("heating-valve", "heatingValve", "getStatus", "query", input) };
@@ -27391,6 +27405,7 @@ function createDeviceProxy(api, binding, opts) {
 			featureProbe: createSliceHandle(stateSource, binding.deviceId, "feature-probe"),
 			flood: createSliceHandle(stateSource, binding.deviceId, "flood"),
 			gas: createSliceHandle(stateSource, binding.deviceId, "gas"),
+			groupActive: createSliceHandle(stateSource, binding.deviceId, "group-active"),
 			groupCommands: createSliceHandle(stateSource, binding.deviceId, "group-commands"),
 			groupStatus: createSliceHandle(stateSource, binding.deviceId, "group-status"),
 			heatingValve: createSliceHandle(stateSource, binding.deviceId, "heating-valve"),
@@ -27477,6 +27492,7 @@ function createDeviceProxy(api, binding, opts) {
 		...bound("feature-probe") ? { featureProbe: featureProbeInterface } : {},
 		...bound("flood") ? { flood: floodInterface } : {},
 		...bound("gas") ? { gas: gasInterface } : {},
+		...bound("group-active") ? { groupActive: groupActiveInterface } : {},
 		...bound("group-commands") ? { groupCommands: groupCommandsInterface } : {},
 		...bound("group-status") ? { groupStatus: groupStatusInterface } : {},
 		...bound("heating-valve") ? { heatingValve: heatingValveInterface } : {},

package/dist/client.mjs

@@ -23832,7 +23832,20 @@ var NcRuleInputSchema = z.object({
 	* save by the hub's grouping guard). `.optional()`, never `.default()`: the addon cap
 	* path does not run Zod defaults.
 	*/
-	groupingSec: z.number().int().min(5).max(60).optional()
+	groupingSec: z.number().int().min(5).max(60).optional(),
+	/**
+	* ASK ME TO CONFIRM DETECTIONS (#243): a DETECTION notification of this rule
+	* carries "Correct" / "Wrong" buttons (and, where the channel has room, a
+	* "Wrong, it is a <class>" choice). A tap marks the track for retraining, the
+	* same mark the Library writes, and records whose notification it was and
+	* when. A channel with no buttons gets the same two choices as links.
+	*
+	* `.optional()`, never `.default()` (a Zod default does not run on the addon
+	* cap path): absent and `false` both mean off, which is what every rule
+	* authored before this field meant. An editor turns it off by writing
+	* `false`, so it needs no `clear` key.
+	*/
+	askVerdict: z.boolean().optional()
 });
 /**
 * Partial patch for `updateRule` — any subset of the input fields, plus the
@@ -26833,6 +26846,7 @@ function createDeviceProxy(api, binding, opts) {
 	const featureProbeInterface = { getStatus: (input) => dispatch("feature-probe", "featureProbe", "getStatus", "query", input) };
 	const floodInterface = { getStatus: (input) => dispatch("flood", "flood", "getStatus", "query", input) };
 	const gasInterface = { getStatus: (input) => dispatch("gas", "gas", "getStatus", "query", input) };
+	const groupActiveInterface = { getStatus: (input) => dispatch("group-active", "groupActive", "getStatus", "query", input) };
 	const groupCommandsInterface = { getStatus: (input) => dispatch("group-commands", "groupCommands", "getStatus", "query", input) };
 	const groupStatusInterface = { getStatus: (input) => dispatch("group-status", "groupStatus", "getStatus", "query", input) };
 	const heatingValveInterface = { getStatus: (input) => dispatch("heating-valve", "heatingValve", "getStatus", "query", input) };
@@ -27390,6 +27404,7 @@ function createDeviceProxy(api, binding, opts) {
 			featureProbe: createSliceHandle(stateSource, binding.deviceId, "feature-probe"),
 			flood: createSliceHandle(stateSource, binding.deviceId, "flood"),
 			gas: createSliceHandle(stateSource, binding.deviceId, "gas"),
+			groupActive: createSliceHandle(stateSource, binding.deviceId, "group-active"),
 			groupCommands: createSliceHandle(stateSource, binding.deviceId, "group-commands"),
 			groupStatus: createSliceHandle(stateSource, binding.deviceId, "group-status"),
 			heatingValve: createSliceHandle(stateSource, binding.deviceId, "heating-valve"),
@@ -27476,6 +27491,7 @@ function createDeviceProxy(api, binding, opts) {
 		...bound("feature-probe") ? { featureProbe: featureProbeInterface } : {},
 		...bound("flood") ? { flood: floodInterface } : {},
 		...bound("gas") ? { gas: gasInterface } : {},
+		...bound("group-active") ? { groupActive: groupActiveInterface } : {},
 		...bound("group-commands") ? { groupCommands: groupCommandsInterface } : {},
 		...bound("group-status") ? { groupStatus: groupStatusInterface } : {},
 		...bound("heating-valve") ? { heatingValve: heatingValveInterface } : {},

package/dist/composition/composition-report.d.ts

@@ -183,6 +183,7 @@ export declare const CompositionFieldPlanSchema: z.ZodObject<{
             cap: z.ZodString;
             fieldPath: z.ZodString;
         }, z.core.$strip>>;
+        activeWhen: z.ZodOptional<z.ZodArray<z.ZodString>>;
         publish: z.ZodEnum<{
             excluded: "excluded";
             included: "included";
@@ -361,6 +362,7 @@ export declare const CompositionValidationSchema: z.ZodObject<{
                 cap: z.ZodString;
                 fieldPath: z.ZodString;
             }, z.core.$strip>>;
+            activeWhen: z.ZodOptional<z.ZodArray<z.ZodString>>;
             publish: z.ZodEnum<{
                 excluded: "excluded";
                 included: "included";

package/dist/composition/composition.d.ts

@@ -128,6 +128,7 @@ export declare const CompositionAggregateSourceSchema: z.ZodObject<{
         cap: z.ZodString;
         fieldPath: z.ZodString;
     }, z.core.$strip>>;
+    activeWhen: z.ZodOptional<z.ZodArray<z.ZodString>>;
     publish: z.ZodEnum<{
         excluded: "excluded";
         included: "included";
@@ -213,6 +214,7 @@ export declare const CompositionFieldSourceSchema: z.ZodDiscriminatedUnion<[z.Zo
         cap: z.ZodString;
         fieldPath: z.ZodString;
     }, z.core.$strip>>;
+    activeWhen: z.ZodOptional<z.ZodArray<z.ZodString>>;
     publish: z.ZodEnum<{
         excluded: "excluded";
         included: "included";
@@ -328,6 +330,7 @@ export declare const CompositionItemEntrySchema: z.ZodObject<{
             cap: z.ZodString;
             fieldPath: z.ZodString;
         }, z.core.$strip>>;
+        activeWhen: z.ZodOptional<z.ZodArray<z.ZodString>>;
         publish: z.ZodEnum<{
             excluded: "excluded";
             included: "included";
@@ -412,6 +415,7 @@ export declare const CompositionFieldsFeatureSchema: z.ZodObject<{
             cap: z.ZodString;
             fieldPath: z.ZodString;
         }, z.core.$strip>>;
+        activeWhen: z.ZodOptional<z.ZodArray<z.ZodString>>;
         publish: z.ZodEnum<{
             excluded: "excluded";
             included: "included";
@@ -492,6 +496,7 @@ export declare const CompositionFieldsFeatureSchema: z.ZodObject<{
                 cap: z.ZodString;
                 fieldPath: z.ZodString;
             }, z.core.$strip>>;
+            activeWhen: z.ZodOptional<z.ZodArray<z.ZodString>>;
             publish: z.ZodEnum<{
                 excluded: "excluded";
                 included: "included";
@@ -600,6 +605,7 @@ export declare const CompositionFeatureSchema: z.ZodDiscriminatedUnion<[z.ZodObj
             cap: z.ZodString;
             fieldPath: z.ZodString;
         }, z.core.$strip>>;
+        activeWhen: z.ZodOptional<z.ZodArray<z.ZodString>>;
         publish: z.ZodEnum<{
             excluded: "excluded";
             included: "included";
@@ -680,6 +686,7 @@ export declare const CompositionFeatureSchema: z.ZodDiscriminatedUnion<[z.ZodObj
                 cap: z.ZodString;
                 fieldPath: z.ZodString;
             }, z.core.$strip>>;
+            activeWhen: z.ZodOptional<z.ZodArray<z.ZodString>>;
             publish: z.ZodEnum<{
                 excluded: "excluded";
                 included: "included";
@@ -830,6 +837,7 @@ export declare const CompositionSchema: z.ZodObject<{
                 cap: z.ZodString;
                 fieldPath: z.ZodString;
             }, z.core.$strip>>;
+            activeWhen: z.ZodOptional<z.ZodArray<z.ZodString>>;
             publish: z.ZodEnum<{
                 excluded: "excluded";
                 included: "included";
@@ -910,6 +918,7 @@ export declare const CompositionSchema: z.ZodObject<{
                     cap: z.ZodString;
                     fieldPath: z.ZodString;
                 }, z.core.$strip>>;
+                activeWhen: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 publish: z.ZodEnum<{
                     excluded: "excluded";
                     included: "included";

package/dist/composition/helpers/actuator-methods.d.ts

@@ -0,0 +1,39 @@
+/**
+ * One method table per actuator type (D944). A group offers a method only
+ * when every member can take it, so a command never reaches a member that
+ * lacks the surface: the cap must be bound by every member (the primary cap of
+ * the type is the exception — a member that lacks it is simply not commanded),
+ * and a row that names a device feature needs every member to advertise it.
+ * Offline does not remove a method: capability is the binding, not liveness.
+ */
+import { DeviceFeature } from '../../device/device-type.js';
+export declare const ACTUATOR_TEMPLATE_IDS: readonly ['switch', 'light', 'fan', 'cover', 'valve', 'lock', 'media-player', 'climate'];
+export type ActuatorTemplateId = (typeof ACTUATOR_TEMPLATE_IDS)[number];
+export interface ActuatorMethodRow {
+    readonly cap: string;
+    readonly method: string;
+    /** Every member must advertise this feature for the row to be shared. */
+    readonly requires: DeviceFeature | null;
+    /** The call must say `confirm: true`; the group refuses it otherwise. */
+    readonly confirm: boolean;
+}
+/** The first row's cap is the type's own: always offered, members without it are skipped. */
+export declare const ACTUATOR_METHODS: Readonly<Record<ActuatorTemplateId, readonly ActuatorMethodRow[]>>;
+export interface ActuatorMemberSurface {
+    readonly caps: readonly string[];
+    readonly features: readonly string[];
+}
+export declare function actuatorMethodRow(templateId: ActuatorTemplateId, cap: string, method: string): ActuatorMethodRow | null;
+/**
+ * The rows every member can take. An empty member list shares nothing; the
+ * caller passes a surface for every member it could read, or none at all.
+ */
+export declare function sharedActuatorMethods(templateId: ActuatorTemplateId, members: readonly ActuatorMemberSurface[]): readonly ActuatorMethodRow[];
+/** The device features every member has, among those the table gates on, in table order. */
+export declare function sharedActuatorFeatures(templateId: ActuatorTemplateId, featureLists: readonly (readonly string[])[]): readonly DeviceFeature[];
+export declare const UNLOCK_CONFIRMATION: string;
+/**
+ * Why a call must not be fanned out, or null. Only a confirmed row passes
+ * without `confirm: true`; anything else is the caller's to refuse by name.
+ */
+export declare function methodRefusal(method: ActuatorMethodRow | null, args: Readonly<Record<string, unknown>>): string | null;

package/dist/composition/helpers/aggregate.d.ts

@@ -20,6 +20,8 @@ export interface AggregateCounts {
 export type AggregatePublish = 'value' | 'included' | 'excluded' | 'total';
 export type AggregateEmpty = 'null' | 'omit' | 'offline';
 export interface EvaluateAggregateInput {
+    /** Enum states that count as active, for a reducer over states instead of booleans. */
+    readonly activeWhen?: readonly string[];
     readonly reducer: AggregateReducer;
     readonly members: readonly AggregateReadResult[];
     readonly publish: AggregatePublish;

package/dist/composition/helpers/catalog.d.ts

@@ -20,8 +20,14 @@ export interface GroupTemplate {
     readonly summary: string;
     readonly deviceType: DeviceType;
     readonly role: DeviceRole | undefined;
-    /** Members are this one device type. */
+    /** Members are this one device type — or, for a climate group, one of a few. */
     readonly memberDeviceType: DeviceType;
+    readonly memberDeviceTypes: readonly DeviceType[];
+    /**
+     * Enum states of the member field that count as active. Set when the member
+     * field is a state rather than a yes/no (a cover is `open`, a lock `locked`).
+     */
+    readonly activeWhen: readonly string[] | undefined;
     readonly outputCap: string;
     readonly outputField: string;
     /**

package/dist/composition/helpers/compile-history.d.ts

@@ -1,12 +1,27 @@
 import type { CompositionProblem } from '../composition-report.js';
 import type { SeriesKind } from './history-math.js';
 import { type HistoryRetention } from './history-window.js';
-import type { HelperMember, IntegralHelperSpec, StatisticHelperSpec } from './spec.js';
+import type { DerivativeHelperSpec, HelperMember, IntegralHelperSpec, StatisticHelperSpec } from './spec.js';
+/**
+ * The unit of a rate: the source series' unit per second, minute or hour
+ * (`°C/h`). A source with no unit of its own (a generic number) has none to
+ * borrow, so the label is null and the chart shows the bare number.
+ */
+export declare function derivativeUnitLabel(spec: DerivativeHelperSpec): string | null;
 export declare function declaredSeriesKind(member: HelperMember): SeriesKind | 'enum' | null;
 export declare function statisticDraft(spec: StatisticHelperSpec, retention?: HistoryRetention): {
     readonly draft: unknown;
     readonly problems: readonly CompositionProblem[];
 };
+/**
+ * A derivative reads a gauge or a counter and publishes its rate per second,
+ * minute or hour. The output is a plain number: a rate of a temperature is not
+ * a temperature, so the chart carries no inherited unit.
+ */
+export declare function derivativeDraft(spec: DerivativeHelperSpec, retention?: HistoryRetention): {
+    readonly draft: unknown;
+    readonly problems: readonly CompositionProblem[];
+};
 export declare function integralDraft(spec: IntegralHelperSpec, retention?: HistoryRetention): {
     readonly draft: unknown;
     readonly problems: readonly CompositionProblem[];

package/dist/composition/helpers/compile-math.d.ts

@@ -0,0 +1,9 @@
+import type { CompositionProblem } from '../composition-report.js';
+import type { ArithmeticHelperSpec, ExpressionHelperSpec, ThresholdHelperSpec } from './spec.js';
+export interface MathDraft {
+    readonly draft: unknown;
+    readonly problems: readonly CompositionProblem[];
+}
+export declare function thresholdDraft(spec: ThresholdHelperSpec): MathDraft;
+export declare function arithmeticDraft(spec: ArithmeticHelperSpec): MathDraft;
+export declare function expressionDraft(spec: ExpressionHelperSpec): MathDraft;

package/dist/composition/helpers/history-math.d.ts

@@ -37,3 +37,11 @@ export interface HistoryValue {
 export declare function evaluateStatistic(stat: StatisticStat, read: SeriesRead): HistoryValue;
 export type IntegralScale = 'energy-kwh' | 'per-second';
 export declare function integrateReading(read: SeriesRead, scale: IntegralScale): HistoryValue;
+/**
+ * Rate of change over a window, per `perMs`. The slope is taken between the
+ * first and the last measured sample, so a hole inside the window neither
+ * counts as zero nor stretches the elapsed time. A gauge that reported
+ * nothing after the value held at the start is flat (rate 0); fewer than two
+ * samples and no held value is a known gap (D393).
+ */
+export declare function evaluateDerivative(read: SeriesRead, perMs: number): HistoryValue;

package/dist/composition/helpers/index.d.ts

@@ -1,12 +1,14 @@
+export { ACTUATOR_METHODS, ACTUATOR_TEMPLATE_IDS, type ActuatorMemberSurface, type ActuatorMethodRow, type ActuatorTemplateId, actuatorMethodRow, methodRefusal, sharedActuatorFeatures, sharedActuatorMethods, UNLOCK_CONFIRMATION, } from './actuator-methods.js';
 export { FAN_OUT_CONCURRENCY, LIGHT_SHARED_CAPS, type FanOutCall, type FanOutFailed, type FanOutMember, type FanOutMemberResult, type FanOutOk, type LightSharedCap, activeForReducer, fanOutTargets, reducerForActive, runFanOut, sharedColorModes, sharedLightCaps, } from './actuator.js';
 export { type AggregateCounts, type AggregateEmpty, type AggregateOutcome, type AggregatePublish, type AggregateReadResult, type AggregateUnavailable, type AggregateValue, type EvaluateAggregateInput, evaluateAggregate, } from './aggregate.js';
 export { APPLIANCE_DEFAULTS, APPLIANCE_KINDS, APPLIANCE_TEMPLATE_ID, type ApplianceDefaults, type ApplianceKind, applianceDeviceType, isApplianceKind, sourcePickForAppliance, } from './appliance.js';
 export { type GroupTemplate, type HelperAccept, type HelperCompanion, GROUP_TEMPLATES, groupTemplate, } from './catalog.js';
 export { type HelperCompileResult, type HelperCompiled, type HelperRefused, compileHelper, sameHelperBody, templateDeviceType, } from './compile.js';
-export { declaredSeriesKind, integralDraft, statisticDraft } from './compile-history.js';
+export { declaredSeriesKind, derivativeDraft, derivativeUnitLabel, integralDraft, statisticDraft, } from './compile-history.js';
+export { arithmeticDraft, expressionDraft, thresholdDraft } from './compile-math.js';
 export { KWH_PER_WATT_MS, wattMillisecondsToKwh } from './energy.js';
-export { type HistoryValue, type IntegralScale, type SeriesBefore, type SeriesKind, type SeriesPoint, type SeriesRead, STATISTIC_STATS, SERIES_KINDS, evaluateStatistic, integrateReading, } from './history-math.js';
+export { type HistoryValue, type IntegralScale, type SeriesBefore, type SeriesKind, type SeriesPoint, type SeriesRead, STATISTIC_STATS, SERIES_KINDS, evaluateDerivative, evaluateStatistic, integrateReading, } from './history-math.js';
 export { type CalendarPeriod, type CalendarWindow, type HistoryRetention, type HistoryTier, type HistoryTierPlan, type OpenRange, type ResetPeriod, type RollingSpan, type RollingWindow, type StatisticWindow, CALENDAR_PERIODS, CalendarWindowSchema, DAY_MS, DEFAULT_HISTORY_RETENTION, HISTORY_FAST_MS, HISTORY_SLOW_MS, HISTORY_TIERS, HOUR_MS, MINUTE_MS, MIN_CUSTOM_MINUTES, RESET_PERIODS, ROLLING_SPANS, RollingWindowSchema, StatisticWindowSchema, integralCadenceMs, maxDurationMs, nextLocalMidnight, openReset, openStatistic, planResetTier, planStatisticTier, rollingDurationMs, statisticCadenceMs, } from './history-window.js';
 export { type HelperMemberFact, helperSaveProblems, } from './save.js';
-export { type SourcePick, type SourcePickAccept, type SourcePickHistory, type SourcePickRequest, sourcePickForHistory, sourcePickForTemplate, } from './source-pick.js';
-export { ACTIVE_CRITERIA, AGGREGATE_REDUCERS, ActiveCriterionSchema, AggregateReducerSchema, BINARY_AGGREGATES, GROUP_TEMPLATE_IDS, ApplianceHelperSpecSchema, GroupHelperSpecSchema, GroupTemplateIdSchema, HelperMemberSchema, HelperSpecSchema, INTEGRAL_OUTPUTS, IntegralHelperSpecSchema, MAX_HELPER_MEMBERS, helperMembers, NUMERIC_AGGREGATES, StatisticHelperSpecSchema, type ActiveCriterion, type AggregateReducer, type BinaryAggregate, type ApplianceHelperSpec, type GroupHelperSpec, type GroupTemplateId, type HelperMember, type HelperSpec, type IntegralHelperSpec, type IntegralOutput, type NumericAggregate, type StatisticHelperSpec, type StatisticStat, } from './spec.js';
+export { type SourcePick, type SourcePickAccept, type SourcePickHistory, type SourcePickRequest, type MathSourceKind, sourcePickForHistory, sourcePickForMath, sourcePickForTemplate, } from './source-pick.js';
+export { ACTIVE_CRITERIA, AGGREGATE_REDUCERS, ActiveCriterionSchema, AggregateReducerSchema, BINARY_AGGREGATES, GROUP_TEMPLATE_IDS, ApplianceHelperSpecSchema, ARITHMETIC_OPS, ArithmeticHelperSpecSchema, DERIVATIVE_UNITS, DerivativeHelperSpecSchema, EXPRESSION_OUTPUTS, ExpressionHelperSpecSchema, ThresholdHelperSpecSchema, GroupHelperSpecSchema, GroupTemplateIdSchema, HelperMemberSchema, HelperSpecSchema, INTEGRAL_OUTPUTS, IntegralHelperSpecSchema, MAX_HELPER_MEMBERS, helperMembers, isHistoryHelper, NUMERIC_AGGREGATES, StatisticHelperSpecSchema, type ActiveCriterion, type AggregateReducer, type BinaryAggregate, type ApplianceHelperSpec, type ArithmeticHelperSpec, type ArithmeticOp, type DerivativeHelperSpec, type DerivativeUnit, type ExpressionHelperSpec, type ExpressionInput, type ExpressionOutput, type ThresholdHelperSpec, type GroupHelperSpec, type GroupTemplateId, type HelperMember, type HelperSpec, type HistoryHelperSpec, type IntegralHelperSpec, type IntegralOutput, type NumericAggregate, type StatisticHelperSpec, type StatisticStat, } from './spec.js';

package/dist/composition/helpers/source-pick.d.ts

@@ -9,7 +9,7 @@ import type { GroupTemplate } from './catalog.js';
 export interface SourcePickAccept {
     readonly cap: string;
     readonly fieldPath: string;
-    readonly valueKind: 'number' | 'boolean';
+    readonly valueKind: 'number' | 'boolean' | 'state';
 }
 export interface SourcePickHistory {
     readonly required: boolean;
@@ -40,3 +40,10 @@ export interface SourcePick {
 export declare function sourcePickForTemplate(template: GroupTemplate): SourcePickRequest;
 /** A statistic or integral reads one field that declares history. */
 export declare function sourcePickForHistory(kind: 'statistic' | 'integral'): SourcePickRequest;
+export type MathSourceKind = 'threshold' | 'sum' | 'difference' | 'ratio' | 'expression' | 'derivative';
+/**
+ * What the input step asks the selector for a math helper. A threshold reads
+ * one number, a difference or a ratio two, a sum and an expression several.
+ * A derivative reads one historised number.
+ */
+export declare function sourcePickForMath(kind: MathSourceKind): SourcePickRequest;

package/dist/composition/helpers/spec.d.ts

@@ -5,11 +5,11 @@
 import { z } from 'zod';
 import { APPLIANCE_TEMPLATE_ID } from './appliance.js';
 import { STATISTIC_STATS } from './history-math.js';
-import { type ResetPeriod, type StatisticWindow } from './history-window.js';
+import { type ResetPeriod, type RollingWindow, type StatisticWindow } from './history-window.js';
 import { CompositionSourceRefSchema } from '../source-ref.js';
 /** A group may name more members than an expression call (the 16-arg cap). */
 export declare const MAX_HELPER_MEMBERS: number;
-export declare const GROUP_TEMPLATE_IDS: readonly ['temperature', 'humidity', 'pressure', 'illuminance', 'power', 'energy', 'battery', 'numeric', 'motion', 'contact', 'leak', 'smoke', 'occupancy', 'binary', 'switch', 'light'];
+export declare const GROUP_TEMPLATE_IDS: readonly ['temperature', 'humidity', 'pressure', 'illuminance', 'power', 'energy', 'battery', 'numeric', 'motion', 'contact', 'leak', 'smoke', 'occupancy', 'binary', 'switch', 'light', 'fan', 'cover', 'valve', 'lock', 'media-player', 'climate'];
 export type GroupTemplateId = (typeof GROUP_TEMPLATE_IDS)[number];
 export declare const NUMERIC_AGGREGATES: readonly ['mean', 'median', 'min', 'max', 'sum'];
 export type NumericAggregate = (typeof NUMERIC_AGGREGATES)[number];
@@ -70,7 +70,53 @@ export type IntegralHelperSpec = {
     readonly source: HelperMember;
 };
 export declare const IntegralHelperSpecSchema: z.ZodType<IntegralHelperSpec>;
-export type HelperSpec = GroupHelperSpec | ApplianceHelperSpec | StatisticHelperSpec | IntegralHelperSpec;
+/** Math (D944 phase 3). A reading in, a reading or a yes/no out. */
+export type ThresholdHelperSpec = {
+    readonly kind: 'threshold';
+    readonly source: HelperMember;
+    /** The output turns on once the reading is at or above this. */
+    readonly high: number;
+    /** The output turns off once the reading is at or below this. `low <= high`. */
+    readonly low: number;
+    readonly onForMs: number;
+    readonly offForMs: number;
+};
+export declare const ThresholdHelperSpecSchema: z.ZodType<ThresholdHelperSpec>;
+export declare const ARITHMETIC_OPS: readonly ['sum', 'difference', 'ratio'];
+export type ArithmeticOp = (typeof ARITHMETIC_OPS)[number];
+export type ArithmeticHelperSpec = {
+    readonly kind: 'arithmetic';
+    readonly op: ArithmeticOp;
+    /** Sum: two or more. Difference and ratio: exactly two, first minus / over second. */
+    readonly inputs: readonly HelperMember[];
+};
+export declare const ArithmeticHelperSpecSchema: z.ZodType<ArithmeticHelperSpec>;
+export declare const EXPRESSION_OUTPUTS: readonly ['number', 'boolean'];
+export type ExpressionOutput = (typeof EXPRESSION_OUTPUTS)[number];
+export interface ExpressionInput {
+    readonly name: string;
+    readonly member: HelperMember;
+}
+export type ExpressionHelperSpec = {
+    readonly kind: 'expression';
+    readonly expr: string;
+    readonly inputs: readonly ExpressionInput[];
+    readonly output: ExpressionOutput;
+};
+export declare const ExpressionHelperSpecSchema: z.ZodType<ExpressionHelperSpec>;
+export declare const DERIVATIVE_UNITS: readonly ['second', 'minute', 'hour'];
+export type DerivativeUnit = (typeof DERIVATIVE_UNITS)[number];
+export type DerivativeHelperSpec = {
+    readonly kind: 'derivative';
+    readonly window: RollingWindow;
+    readonly per: DerivativeUnit;
+    readonly source: HelperMember;
+};
+export declare const DerivativeHelperSpecSchema: z.ZodType<DerivativeHelperSpec>;
+export type HelperSpec = GroupHelperSpec | ApplianceHelperSpec | StatisticHelperSpec | IntegralHelperSpec | ThresholdHelperSpec | ArithmeticHelperSpec | ExpressionHelperSpec | DerivativeHelperSpec;
 export declare const HelperSpecSchema: z.ZodType<HelperSpec>;
+/** The kinds the composer runs from device history, on a schedule. */
+export type HistoryHelperSpec = StatisticHelperSpec | IntegralHelperSpec | DerivativeHelperSpec;
+export declare function isHistoryHelper(spec: HelperSpec): spec is HistoryHelperSpec;
 /** Every member a helper reads. A group has many; the others have one. */
 export declare function helperMembers(spec: HelperSpec): readonly HelperMember[];