@camstack/types 1.2.88 → 1.2.90

package/dist/capabilities/recording.cap.d.ts

@@ -60,6 +60,7 @@ export type RecordingDeviceUsage = z.infer<typeof RecordingDeviceUsageSchema>;
 export declare const RecordingLocationUsageSchema: z.ZodObject<{
     locationId: z.ZodNullable<z.ZodString>;
     locationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    root: z.ZodOptional<z.ZodString>;
     usedBytes: z.ZodNumber;
     availableBytes: z.ZodNullable<z.ZodNumber>;
     totalBytes: z.ZodNullable<z.ZodNumber>;
@@ -76,13 +77,14 @@ export declare const RecordingStorageUsageSchema: z.ZodObject<{
         usedBytes: z.ZodNumber;
         oldestMs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     }, z.core.$strip>>;
-    locations: z.ZodArray<z.ZodObject<{
+    locations: z.ZodOptional<z.ZodArray<z.ZodObject<{
         locationId: z.ZodNullable<z.ZodString>;
         locationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        root: z.ZodOptional<z.ZodString>;
         usedBytes: z.ZodNumber;
         availableBytes: z.ZodNullable<z.ZodNumber>;
         totalBytes: z.ZodNullable<z.ZodNumber>;
-    }, z.core.$strip>>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type RecordingStorageUsage = z.infer<typeof RecordingStorageUsageSchema>;
 /**
@@ -263,13 +265,14 @@ export declare const recordingCapability: {
                 usedBytes: z.ZodNumber;
                 oldestMs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
             }, z.core.$strip>>;
-            locations: z.ZodArray<z.ZodObject<{
+            locations: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 locationId: z.ZodNullable<z.ZodString>;
                 locationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                root: z.ZodOptional<z.ZodString>;
                 usedBytes: z.ZodNumber;
                 availableBytes: z.ZodNullable<z.ZodNumber>;
                 totalBytes: z.ZodNullable<z.ZodNumber>;
-            }, z.core.$strip>>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>, "query">;
         readonly getDeviceConfig: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;

package/dist/index.d.ts

@@ -194,6 +194,7 @@ export { audioIsFailClosed, audioLabelChoices, audioModeOf, audioOrDefaults, isA
 export { isBaseConditionKey, knownValues, NC_BASE_CONDITION_KEYS, type NcBaseConditionKey, pickerForCondition, type TaxonomyGroup, type TaxonomyOption, type TaxonomyPicker, } from './notification/condition-taxonomy.js';
 export { type PreparedAction, type PreparedAttachment, type PreparedNotification, prepareNotification, type ResolvedLevel, } from './notification/degrade-engine.js';
 export { htmlToText, markdownToHtmlLite, markdownToText, type NotificationFormat as NotificationBodyFormat, resolveFormat, textToHtml, transcodeBody, } from './notification/format-transcode.js';
+export { conditionExclusionReason, conditionVisibleForKind, defaultDeliveryForSection, droppedConditionsForKind, isAudioRule, isOccupancyRule, isSystemDelivery, NC_AUDIO_SEED, NC_OCCUPANCY_DEFAULTS, NC_RULE_EDITOR_SECTION_ORDER, NC_RULE_KIND_SPECS, NC_RULE_SECTIONS, NC_SYSTEM_DELIVERY, type NcDroppedCondition, type NcKindVisibilitySubject, type NcRuleEditorSection, type NcRuleEditorSectionKey, type NcRuleKind, type NcRuleKindSpec, type NcRuleOwningSectionKey, type NcRuleSection, type NcRuleSectionKey, type NcRuleSectionSubject, type NcRuleSeed, parseRuleSection, ruleEditorSectionsForKind, ruleKindOf, ruleKindSpec, ruleMatchesSection, ruleSection, ruleSectionOf, ruleSeedForSection, } from './notification/rule-kinds.js';
 export { isScheduleActive } from './notification/schedule.js';
 export { NC_SYSTEM_EVENT_FILTER_KEYS, type NcSystemEventFilterKey, systemEventFilterApplies, systemEventFilterAppliesToAnyKind, } from './notification/system-event-filters.js';
 export type { TimelapseCadencePair, TimelapsePreviewMode, TimelapseRule, TimelapseRuleInput, TimelapseRulePatch, TimelapseTemplate, } from './notification/timelapse-rule.js';

package/dist/index.js

@@ -27445,9 +27445,21 @@ var RecordingLocationUsageSchema = zod.z.object({
 	*  previously rendered as two identical "disks" with a nonsensical used
 	*  split — hydrate attribution across aliases is arbitrary by nature. */
 	locationIds: zod.z.array(zod.z.string()).optional(),
-	/** Bytes of recordings stored on this PHYSICAL volume (all aliases). */
+	/**
+	* Filesystem root of the physical volume this row accounts — the only
+	* operator-legible identity when a location has no `displayName` yet, and
+	* what a "which disk is full" alert has to name. OPTIONAL for the same
+	* train-skew reason as `oldestMs`: a recorder that predates the field omits
+	* it, and this schema must keep validating that older provider's payload.
+	*/
+	root: zod.z.string().optional(),
+	/** Bytes of recordings stored on this PHYSICAL volume (all aliases). This is
+	*  the footage's SHARE of the volume, not how full the volume is — the disk
+	*  also holds everything that is not recordings. Volume fill is
+	*  `(totalBytes - availableBytes) / totalBytes`. */
 	usedBytes: zod.z.number(),
-	/** Free bytes on the location's volume; null when capacity is unknown (remote). */
+	/** Free bytes on the location's volume; null when capacity is unknown
+	*  (remote/unstattable — the recorder logs the statfs failure with the root). */
 	availableBytes: zod.z.number().nullable(),
 	/** Total bytes of the location's volume; null when unknown. */
 	totalBytes: zod.z.number().nullable()
@@ -27459,7 +27471,15 @@ var RecordingStorageUsageSchema = zod.z.object({
 	nodeId: zod.z.string(),
 	totalUsedBytes: zod.z.number(),
 	devices: zod.z.array(RecordingDeviceUsageSchema),
-	locations: zod.z.array(RecordingLocationUsageSchema)
+	/**
+	* Per-physical-volume capacity. OPTIONAL, and consumers must render the rest
+	* of the payload without it: the hub serves this method through a BAKED
+	* router, so a hub whose framework train predates a change to this array
+	* strips it out of an answer a newer recorder happily produced. A UI that
+	* dereferences it unconditionally crashes the whole Storage page over a
+	* missing disk bar.
+	*/
+	locations: zod.z.array(RecordingLocationUsageSchema).optional()
 });
 /**
 * The OPERATOR-ARMED half of multi-location recordings (D116).
@@ -43560,6 +43580,340 @@ function prepareNotification(caps, n) {
 	};
 }
 //#endregion
+//#region src/notification/rule-kinds.ts
+/**
+* Reasons, written once. Each names the SUBJECT FIELD the engine reads and
+* finds absent — that is what makes the exclusion checkable against the engine
+* rather than an opinion about tidiness.
+*/
+var NO_SENSOR_KIND = "An occupancy edge is not a sensor event: it carries no sensor kind, so this condition can never match one.";
+var NO_EVENT_TOKEN = "An occupancy edge carries no device event-type token — that comes from an event-emitter slice, which a count crossing has none of.";
+var OCCUPANCY_SOURCE = "An occupancy edge is always produced by the pipeline, so any other source can never match and “pipeline” narrows nothing.";
+var AUDIO_SOURCE = "A confirmed sound window is always stamped as an audio subject, so any other source can never match.";
+var SOUND_NOT_A_PICTURE = "A sound rule fires on what the camera HEARD. Its subject carries no detection, so this condition can never match one — name the sounds in the Sound condition instead.";
+var SOUND_NO_CONFIDENCE = "A sound window’s evidence is a percentage of samples, not a detector score, so a confidence threshold can never be satisfied.";
+var SOUND_NO_GEOMETRY = "A sound has no position in the frame, so a zone or a drawn polygon can never match it.";
+var NC_RULE_KIND_SPECS = [
+	{
+		kind: "detection",
+		label: "Conditions",
+		excluded: {},
+		carriesMedia: true,
+		carriesSubjectCrop: true
+	},
+	{
+		kind: "sensor",
+		label: "Conditions",
+		/** Same argument as `detection`: `occupancy` converts, it does not confuse. */
+		excluded: {},
+		carriesMedia: true,
+		carriesSubjectCrop: true,
+		blurb: "A doorbell press or a linked sensor changing state. The picture comes from the camera the sensor is attributed to."
+	},
+	{
+		kind: "occupancy",
+		label: "Occupancy",
+		discriminator: "occupancy",
+		excluded: {
+			sensorKinds: NO_SENSOR_KIND,
+			eventTypeTokens: NO_EVENT_TOKEN,
+			source: OCCUPANCY_SOURCE
+		},
+		carriesMedia: true,
+		carriesSubjectCrop: true,
+		blurb: "Fires when the count in a camera frame or a zone crosses your threshold and holds. Pick the camera first — the zone list is that camera’s."
+	},
+	{
+		kind: "sound",
+		label: "Sound",
+		discriminator: "audio",
+		excluded: {
+			classes: SOUND_NOT_A_PICTURE,
+			classesExclude: SOUND_NOT_A_PICTURE,
+			minConfidence: SOUND_NO_CONFIDENCE,
+			zones: SOUND_NO_GEOMETRY,
+			zonesExclude: SOUND_NO_GEOMETRY,
+			customZones: SOUND_NO_GEOMETRY,
+			crossing: SOUND_NO_GEOMETRY,
+			labelEquals: SOUND_NOT_A_PICTURE,
+			identities: SOUND_NOT_A_PICTURE,
+			identitiesExclude: SOUND_NOT_A_PICTURE,
+			plates: SOUND_NOT_A_PICTURE,
+			source: AUDIO_SOURCE
+		},
+		carriesMedia: true,
+		carriesSubjectCrop: false,
+		blurb: "Fires on a confirmed sampling window of audio, never on a picture. Name the sounds and/or keep a level threshold — with neither it can never match.",
+		mediaBlurb: "A sound owns no frame, so the picture is a photograph of the camera taken at the moment of the match — the whole scene, never a crop. The GIF and the clip are cut around the same instant, from the camera."
+	},
+	{
+		kind: "system",
+		label: "Events",
+		discriminator: "systemEvent",
+		excluded: {},
+		carriesMedia: false,
+		carriesSubjectCrop: false,
+		blurb: "The installation itself: a camera or stream dropping, a node leaving, an update landing. There is no detection behind it and no frame to attach."
+	}
+];
+/** The spec for a kind. Total by construction — every member has an entry. */
+function ruleKindSpec(kind) {
+	return NC_RULE_KIND_SPECS.find((s) => s.kind === kind) ?? NC_RULE_KIND_SPECS[0];
+}
+/** The delivery a system rule rides — named once, compared everywhere. */
+var NC_SYSTEM_DELIVERY = "system-event";
+/**
+* Is this a SYSTEM rule — one about the installation rather than about anything
+* a camera saw? Takes a plain `string` so a rule carrying a delivery this build
+* has never heard of still gets an answer instead of a type error.
+*/
+function isSystemDelivery(delivery) {
+	return delivery === NC_SYSTEM_DELIVERY;
+}
+/**
+* Which kind of rule is this?
+*
+* The CONDITION wins over the delivery wherever the engine says it does, and
+* the order below is the engine's own: `evaluateRule` checks the system branch
+* first, then the occupancy and audio gates. Takes a plain `delivery` string so
+* a trigger this build does not know still classifies (as `detection`, which is
+* the read-only path's own fallback).
+*/
+function ruleKindOf(rule) {
+	if (isSystemDelivery(rule.delivery)) return "system";
+	if (rule.conditions.occupancy !== void 0 && rule.delivery === "device-event") return "occupancy";
+	if (rule.conditions.audio !== void 0 && rule.delivery === "immediate") return "sound";
+	if (rule.delivery === "device-event") return "sensor";
+	return "detection";
+}
+/**
+* Is this condition visible — and authorable — for a rule of this kind?
+*
+* The COMPOSITION, and the only function that decides it: `appliesTo` is the
+* server's answer about the trigger, the kind's `excluded` map is this build's
+* answer about the sub-type, and the discriminator overrides both (a sound rule
+* must be able to edit its sound even though `audio` is excluded for every
+* OTHER kind that rides `immediate`).
+*/
+function conditionVisibleForKind(descriptor, delivery, kind) {
+	const spec = ruleKindSpec(kind);
+	if (descriptor.id === spec.discriminator) return true;
+	if (!descriptor.appliesTo.includes(delivery)) return false;
+	return spec.excluded[descriptor.id] === void 0;
+}
+/** Why a condition is not offered for this kind, or `null` when it IS. */
+function conditionExclusionReason(descriptorId, kind) {
+	const spec = ruleKindSpec(kind);
+	if (descriptorId === spec.discriminator) return null;
+	return spec.excluded[descriptorId] ?? null;
+}
+function droppedConditionsForKind(conditions, kind) {
+	const spec = ruleKindSpec(kind);
+	const out = [];
+	for (const [conditionId, value] of Object.entries(conditions)) {
+		if (value === void 0) continue;
+		if (Array.isArray(value) && value.length === 0) continue;
+		const reason = spec.excluded[conditionId];
+		if (reason !== void 0) out.push({
+			conditionId,
+			reason
+		});
+	}
+	return out;
+}
+var NC_RULE_SECTIONS = [
+	{
+		key: "all",
+		label: "All rules",
+		blurb: "Every notification rule, whatever its trigger. Each rule picks a trigger, matches conditions and fans out to one or more delivery targets.",
+		newRuleLabel: "New rule",
+		emptyHint: "No notification rules yet. Create one to be told what your cameras see."
+	},
+	{
+		key: "detection",
+		label: "Detections & devices",
+		blurb: "Rules driven by what the cameras and sensors SEE — detections, tracks, doorbell presses and package events.",
+		newRuleLabel: "New detection rule",
+		emptyHint: "No detection rules yet. Create one to be told what your cameras see."
+	},
+	{
+		key: "audio",
+		label: "Sound",
+		blurb: "Rules on what the cameras HEAR: a sustained window of sound loud enough, or classified as one of the sounds you name. A sound rule fires only on a confirmed sampling window, never on a picture.",
+		newRuleLabel: "New sound rule",
+		emptyHint: "No sound rules yet. A new sound rule opens on the sound condition already filled in with a level threshold, so you only have to name the sounds and the targets."
+	},
+	{
+		key: "occupancy",
+		label: "Occupancy",
+		blurb: "Rules on how many objects are in a camera frame or a zone, and for how long: \"the driveway became occupied\", \"the garden emptied\".",
+		newRuleLabel: "New occupancy rule",
+		emptyHint: "No occupancy rules yet. A new occupancy rule opens on the occupancy condition; pick the camera first, then the zone and the count."
+	},
+	{
+		key: "system",
+		label: "System events",
+		blurb: "Rules about the installation itself: a camera or stream dropping, a node leaving the cluster, an addon or server update becoming available. These carry no image and are not tied to a detection.",
+		newRuleLabel: "New system rule",
+		emptyHint: "No system-event rules yet. These tell you when a camera drops, a node leaves or an update lands."
+	}
+];
+/** The section for a key, or `undefined` — the lookup behind every label. */
+function ruleSection(key) {
+	return NC_RULE_SECTIONS.find((s) => s.key === key) ?? NC_RULE_SECTIONS[0];
+}
+/** Narrow a raw section string back to a known key (no cast). */
+function parseRuleSection(value) {
+	return NC_RULE_SECTIONS.find((s) => s.key === value)?.key;
+}
+/** True for a rule whose sound condition makes it a SOUND rule. */
+function isAudioRule(subject) {
+	return subject.conditions.audio !== void 0;
+}
+/** True for a rule whose occupancy condition makes it an OCCUPANCY rule. */
+function isOccupancyRule(subject) {
+	return subject.conditions.occupancy !== void 0;
+}
+/**
+* Does a rule belong in this section?
+*
+* `all` always matches — a section that hides a rule is how an operator
+* concludes it was deleted. The other four PARTITION the list: sound and
+* occupancy are claimed by their condition, system by its trigger, and
+* everything left over — including a trigger this build has never heard of —
+* counts as a detection rule so it stays visible somewhere.
+*
+* Keyed on the CONDITION for two of them, because the trigger alone cannot
+* answer: a sound rule is `immediate` and an occupancy rule is `device-event`,
+* and in each case the condition is the discriminator the engine itself uses.
+* A section keyed on delivery would put both back in the pile they are
+* invisible in.
+*/
+function ruleMatchesSection(subject, section) {
+	if (section === "all") return true;
+	if (section === "system") return isSystemDelivery(subject.delivery);
+	if (section === "audio") return isAudioRule(subject);
+	if (section === "occupancy") return isOccupancyRule(subject);
+	return !isSystemDelivery(subject.delivery) && !isAudioRule(subject) && !isOccupancyRule(subject);
+}
+/**
+* Which section OWNS this rule — the counter behind a section strip.
+*
+* Derived from {@link ruleMatchesSection} rather than restated, so the strip's
+* counts and the strip's contents can never disagree.
+*/
+function ruleSectionOf(subject) {
+	if (ruleMatchesSection(subject, "system")) return "system";
+	if (ruleMatchesSection(subject, "audio")) return "audio";
+	if (ruleMatchesSection(subject, "occupancy")) return "occupancy";
+	return "detection";
+}
+/**
+* The occupancy schema's own defaults, in one place.
+*
+* Both the WIDGET (what an untouched sub-field shows) and the CREATION PRESET
+* (what "New occupancy rule" seeds) have to author exactly these numbers, and
+* two copies of a default is how a preset starts writing a rule that does not
+* match what the editor then displays. Mirrors `NcOccupancyConditionSchema`'s
+* `.default(...)` clauses, and the spec asserts the mirror.
+*/
+var NC_OCCUPANCY_DEFAULTS = {
+	op: "became-occupied",
+	count: 1,
+	sustainSeconds: 15
+};
+/**
+* The seeded sound condition.
+*
+* Carries a level floor rather than the bare defaults: with neither a level nor
+* a label the engine returns false for every window (`matchesAudio`), so a
+* preset without one would hand the operator a rule that can never fire. The
+* offered level is the same one the widget writes, so switching to SOUNDS
+* (label mode — the one that fires on the first labelled frame, D157) is one
+* tap on the mode picker.
+*
+* The seed cannot be a label rule instead: a labels-only condition with no
+* labels chosen yet is fail-closed too, and it would hand the operator the same
+* dead rule from the other side.
+*/
+var NC_AUDIO_SEED = {
+	hitPercent: NC_AUDIO_DEFAULTS.hitPercent,
+	samplingSeconds: NC_AUDIO_DEFAULTS.samplingSeconds,
+	dbThreshold: -55
+};
+function ruleSeedForSection(section) {
+	switch (section) {
+		case "system": return {
+			delivery: NC_SYSTEM_DELIVERY,
+			conditions: {}
+		};
+		case "audio": return {
+			delivery: "immediate",
+			conditions: { audio: NC_AUDIO_SEED }
+		};
+		case "occupancy": return {
+			delivery: "device-event",
+			conditions: { occupancy: NC_OCCUPANCY_DEFAULTS }
+		};
+		default: return {
+			delivery: "immediate",
+			conditions: {}
+		};
+	}
+}
+/** The trigger a "New rule" in this section should open on. */
+function defaultDeliveryForSection(section) {
+	return ruleSeedForSection(section).delivery;
+}
+var NC_RULE_EDITOR_SECTION_ORDER = [
+	"rule",
+	"devices",
+	"conditions",
+	"notification",
+	"actions",
+	"advanced"
+];
+/** The English fallback name of each section, before the kind renames one. */
+var EDITOR_SECTION_LABELS = {
+	rule: "Rule",
+	devices: "Cameras",
+	conditions: "Conditions",
+	notification: "Notification",
+	actions: "Actions",
+	advanced: "Advanced"
+};
+/**
+* The sections a rule of THIS kind actually shows.
+*
+* Two rules, both of them about a control that would decide nothing:
+*
+*  - a `system-event` rule has no device scope — `conditions.devices` is not
+*    evaluated for it and the input builder refuses to write it — so the
+*    Cameras section is DROPPED rather than shown and ignored;
+*  - a sound or occupancy rule is NAMED on its conditions section. Neither has
+*    a trigger of its own, so that section is the only place either feature
+*    exists, and a heading that never mentions sound is exactly why an operator
+*    with a working audio engine reported there was no way to create an audio
+*    rule.
+*
+* The NOTIFICATION section always survives: priority and the template still
+* matter even for a kind that carries no picture, and dropping the section to
+* hide the media controls would take the template with it. Whether the media
+* half renders is `carriesMedia` / `carriesSubjectCrop`, asked separately.
+*/
+function ruleEditorSectionsForKind(kind) {
+	const spec = ruleKindSpec(kind);
+	const sections = [];
+	for (const key of NC_RULE_EDITOR_SECTION_ORDER) {
+		if (key === "devices" && kind === "system") continue;
+		sections.push({
+			key,
+			label: key === "conditions" ? spec.label : EDITOR_SECTION_LABELS[key]
+		});
+	}
+	return sections;
+}
+//#endregion
 //#region src/notification/schedule.ts
 var WEEKDAY_TO_DAY = {
 	Sun: 0,
@@ -46772,6 +47126,7 @@ exports.NC_AUDIO_HIT_PERCENT_MAX = NC_AUDIO_HIT_PERCENT_MAX;
 exports.NC_AUDIO_HIT_PERCENT_MIN = NC_AUDIO_HIT_PERCENT_MIN;
 exports.NC_AUDIO_SAMPLING_MAX_SEC = NC_AUDIO_SAMPLING_MAX_SEC;
 exports.NC_AUDIO_SAMPLING_MIN_SEC = NC_AUDIO_SAMPLING_MIN_SEC;
+exports.NC_AUDIO_SEED = NC_AUDIO_SEED;
 exports.NC_AUTHORABLE_SYSTEM_EVENT_KINDS = NC_AUTHORABLE_SYSTEM_EVENT_KINDS;
 exports.NC_BASE_CONDITION_KEYS = NC_BASE_CONDITION_KEYS;
 exports.NC_CONDITION_CATALOG = NC_CONDITION_CATALOG;
@@ -46783,7 +47138,12 @@ exports.NC_DEFAULT_SNOOZE_MINUTES = NC_DEFAULT_SNOOZE_MINUTES;
 exports.NC_HISTORY_LIMIT_DEFAULT = NC_HISTORY_LIMIT_DEFAULT;
 exports.NC_HISTORY_LIMIT_MAX = NC_HISTORY_LIMIT_MAX;
 exports.NC_MAX_PER_TRACK_IMMEDIATE = NC_MAX_PER_TRACK_IMMEDIATE;
+exports.NC_OCCUPANCY_DEFAULTS = NC_OCCUPANCY_DEFAULTS;
+exports.NC_RULE_EDITOR_SECTION_ORDER = NC_RULE_EDITOR_SECTION_ORDER;
+exports.NC_RULE_KIND_SPECS = NC_RULE_KIND_SPECS;
+exports.NC_RULE_SECTIONS = NC_RULE_SECTIONS;
 exports.NC_SNOOZE_MAX_MINUTES = NC_SNOOZE_MAX_MINUTES;
+exports.NC_SYSTEM_DELIVERY = NC_SYSTEM_DELIVERY;
 exports.NC_SYSTEM_EVENT_FILTER_KEYS = NC_SYSTEM_EVENT_FILTER_KEYS;
 exports.NC_TAXONOMY = NC_TAXONOMY;
 exports.NativeCropBboxSchema = NativeCropBboxSchema;
@@ -47271,6 +47631,8 @@ exports.compileExpression = compileExpression;
 exports.compileExpressionSafe = compileExpressionSafe;
 exports.composeSwitchedOff = composeSwitchedOff;
 exports.conditionDepth = conditionDepth;
+exports.conditionExclusionReason = conditionExclusionReason;
+exports.conditionVisibleForKind = conditionVisibleForKind;
 exports.connectionTestCapability = connectionTestCapability;
 exports.connectivityCapability = connectivityCapability;
 exports.consumablesCapability = consumablesCapability;
@@ -47300,6 +47662,7 @@ exports.dayNightCapability = dayNightCapability;
 exports.declarationOwnerNodeId = declarationOwnerNodeId;
 exports.decodeVectorBase64 = decodeVectorBase64;
 exports.decoderCapability = decoderCapability;
+exports.defaultDeliveryForSection = defaultDeliveryForSection;
 exports.defaultDeviceFor = defaultDeviceFor;
 exports.defineCustomActions = defineCustomActions;
 exports.deriveBatteryPresence = deriveBatteryPresence;
@@ -47322,6 +47685,7 @@ exports.deviceSelectorMatches = deviceSelectorMatches;
 exports.deviceStateCapability = deviceStateCapability;
 exports.deviceStatusCapability = deviceStatusCapability;
 exports.doorbellCapability = doorbellCapability;
+exports.droppedConditionsForKind = droppedConditionsForKind;
 exports.egressTranscodeSharingKey = egressTranscodeSharingKey;
 exports.egressTransportFromRequest = egressTransportFromRequest;
 exports.embeddingEncoderCapability = embeddingEncoderCapability;
@@ -47373,6 +47737,7 @@ exports.invocationFromEncodeProfile = require_canonical_hash.invocationFromEncod
 exports.isAgentOnlyPlacement = isAgentOnlyPlacement;
 exports.isArrayOutputSchema = isArrayOutputSchema;
 exports.isAudioLabelSelected = isAudioLabelSelected;
+exports.isAudioRule = isAudioRule;
 exports.isBaseConditionKey = isBaseConditionKey;
 exports.isBatteryPresenceFault = isBatteryPresenceFault;
 exports.isCollectionArrayMethod = isCollectionArrayMethod;
@@ -47384,10 +47749,12 @@ exports.isEvent = require_sleep.isEvent;
 exports.isIsolatedBuiltin = isIsolatedBuiltin;
 exports.isNode = isNode;
 exports.isObjectInput = isObjectInput;
+exports.isOccupancyRule = isOccupancyRule;
 exports.isRestoredCap = isRestoredCap;
 exports.isSameAddonId = isSameAddonId;
 exports.isScheduleActive = isScheduleActive;
 exports.isSoftwareDecode = require_canonical_hash.isSoftwareDecode;
+exports.isSystemDelivery = isSystemDelivery;
 exports.isVoidInput = isVoidInput;
 exports.jobKindSchema = jobKindSchema;
 exports.kebabToCamel = kebabToCamel;
@@ -47451,6 +47818,7 @@ exports.parseJsonObject = require_sleep.parseJsonObject;
 exports.parseJsonUnknown = require_sleep.parseJsonUnknown;
 exports.parseProcStatus = parseProcStatus;
 exports.parseProfileBrokerId = require_sleep.parseProfileBrokerId;
+exports.parseRuleSection = parseRuleSection;
 exports.parseStreamParamsFormPatch = parseStreamParamsFormPatch;
 exports.patchAudio = patchAudio;
 exports.petFeederCapability = petFeederCapability;
@@ -47510,6 +47878,13 @@ exports.resolveScrubThumbnailGeometry = resolveScrubThumbnailGeometry;
 exports.resolveVariantModelId = resolveVariantModelId;
 exports.resolveViewableDeviceIds = resolveViewableDeviceIds;
 exports.roleSpec = roleSpec;
+exports.ruleEditorSectionsForKind = ruleEditorSectionsForKind;
+exports.ruleKindOf = ruleKindOf;
+exports.ruleKindSpec = ruleKindSpec;
+exports.ruleMatchesSection = ruleMatchesSection;
+exports.ruleSection = ruleSection;
+exports.ruleSectionOf = ruleSectionOf;
+exports.ruleSeedForSection = ruleSeedForSection;
 exports.runInferenceStep = runInferenceStep;
 exports.runtimeDevices = runtimeDevices;
 exports.runtimeStatePolicyFor = runtimeStatePolicyFor;