@camstack/types 1.2.65 → 1.2.67

package/dist/capabilities/pet-feeder.cap.d.ts

@@ -181,5 +181,12 @@ export declare const petFeederCapability: {
         volume: z.ZodNumber;
         lastFetchedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — live appliance state re-published on connect.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type IPetFeederProvider = InferProvider<typeof petFeederCapability>;

package/dist/capabilities/power-meter.cap.d.ts

@@ -60,5 +60,15 @@ export declare const powerMeterCapability: {
         unit: z.ZodOptional<z.ZodString>;
         precision: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — as `numeric-sensor`; `kwhTotal` is an accumulator whose restored value is the baseline.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastFetchedAt"];
 };
 export type IPowerMeterProvider = InferProvider<typeof powerMeterCapability>;

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

@@ -73,6 +73,16 @@ export declare const presenceCapability: {
         batteryPercent: z.ZodNullable<z.ZodNumber>;
         lastChangedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — occupancy-relevant: the restored state is what an occupancy rule compares the first post-restart observation against.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastChangedAt"];
 };
 export type IPresenceProvider = InferProvider<typeof presenceCapability>;
 export {};

package/dist/capabilities/pressure-sensor.cap.d.ts

@@ -38,5 +38,15 @@ export declare const pressureSensorCapability: {
         unit: z.ZodOptional<z.ZodString>;
         precision: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — as `numeric-sensor`.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastFetchedAt"];
 };
 export type IPressureSensorProvider = InferProvider<typeof pressureSensorCapability>;

package/dist/capabilities/privacy-mask.cap.d.ts

@@ -243,6 +243,16 @@ export declare const privacyMaskCapability: {
         audioEnabled: z.ZodNullable<z.ZodBoolean>;
         lastFetchedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — operator-drawn regions, zero real churn — 22 writes in 25 minutes, every one of them the clock.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastFetchedAt"];
 };
 export type IPrivacyMaskProvider = InferNativeProvider<typeof privacyMaskCapability>;
 /**

package/dist/capabilities/ptz-autotrack.cap.d.ts

@@ -194,5 +194,12 @@ export declare const ptzAutotrackCapability: {
         }, z.core.$strip>>;
         lastFetchedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — mirrors the camera's own autotrack config, re-read on connect.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type IPtzAutotrackProvider = InferProvider<typeof ptzAutotrackCapability>;

package/dist/capabilities/scene-monitor.cap.d.ts

@@ -479,5 +479,12 @@ export declare const sceneMonitorCapability: {
         }, z.core.$strip>>;
         lastFetchedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — re-derived from the current scene on the next evaluation.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type ISceneMonitorProvider = InferNativeProvider<typeof sceneMonitorCapability>;

package/dist/capabilities/script-runner.cap.d.ts

@@ -57,5 +57,12 @@ export declare const scriptRunnerCapability: {
         lastError: z.ZodNullable<z.ZodString>;
         lastChangedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — a restored `isRunning: true` describes a process that died with the previous hub.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type IScriptRunnerProvider = InferProvider<typeof scriptRunnerCapability>;

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

@@ -33,5 +33,15 @@ export declare const smokeCapability: {
         detected: z.ZodBoolean;
         lastChangedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — a safety sensor must not read "clear" merely because the hub restarted.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastChangedAt"];
 };
 export type ISmokeProvider = InferProvider<typeof smokeCapability>;

package/dist/capabilities/stream-params.cap.d.ts

@@ -481,6 +481,16 @@ export declare const streamParamsCapability: {
         }, z.core.$strip>>;
         lastFetchedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — operator-set encoder profile; mutation-driven.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastFetchedAt"];
 };
 export type IStreamParamsProvider = InferNativeProvider<typeof streamParamsCapability>;
 export { StreamProfileConfigSchema, StreamProfileOptionsSchema };

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

@@ -50,6 +50,16 @@ export declare const switchCapability: {
         on: z.ZodBoolean;
         lastChangedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — device state an operator reads as authoritative; 55 devices, transition-driven.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastChangedAt"];
     readonly settings: {
         readonly bindings: readonly [{
             readonly kind: "scalar";

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

@@ -28,5 +28,15 @@ export declare const tamperCapability: {
         tampered: z.ZodBoolean;
         lastChangedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — as `smoke`.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastChangedAt"];
 };
 export type ITamperProvider = InferProvider<typeof tamperCapability>;

package/dist/capabilities/temperature-sensor.cap.d.ts

@@ -46,5 +46,15 @@ export declare const temperatureSensorCapability: {
         unit: z.ZodOptional<z.ZodString>;
         precision: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — as `numeric-sensor` (69 of 125 writes were the clock alone).
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastFetchedAt"];
 };
 export type ITemperatureSensorProvider = InferProvider<typeof temperatureSensorCapability>;

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

@@ -44,5 +44,12 @@ export declare const updateCapability: {
         state: z.ZodNullable<z.ZodString>;
         inProgress: z.ZodBoolean;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — a restored `inProgress: true` describes an update that is no longer running; versions are re-probed at boot.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type IUpdateProvider = InferProvider<typeof updateCapability>;

package/dist/capabilities/vacuum-control.cap.d.ts

@@ -237,5 +237,12 @@ export declare const vacuumControlCapability: {
         errorLabel: z.ZodNullable<z.ZodString>;
         lastChangedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — as `media-player` — a restored `state: cleaning` is a robot that is not cleaning.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type IVacuumControlProvider = InferProvider<typeof vacuumControlCapability>;

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

@@ -88,5 +88,12 @@ export declare const valveCapability: {
         position: z.ZodNullable<z.ZodNumber>;
         lastChangedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — as `brightness`.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type IValveProvider = InferProvider<typeof valveCapability>;

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

@@ -28,5 +28,15 @@ export declare const vibrationCapability: {
         detected: z.ZodBoolean;
         lastChangedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — as `smoke`.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastChangedAt"];
 };
 export type IVibrationProvider = InferProvider<typeof vibrationCapability>;

package/dist/capabilities/water-heater.cap.d.ts

@@ -73,5 +73,12 @@ export declare const waterHeaterCapability: {
         maxTemp: z.ZodNullable<z.ZodNumber>;
         lastChangedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — as `climate-control`.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type IWaterHeaterProvider = InferProvider<typeof waterHeaterCapability>;

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

@@ -71,5 +71,12 @@ export declare const weatherCapability: {
         windBearing: z.ZodNullable<z.ZodNumber>;
         lastFetchedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — a forecast is stale the moment the hub is down; the provider re-fetches on connect.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type IWeatherProvider = InferProvider<typeof weatherCapability>;

package/dist/capabilities/zone-analytics.cap.d.ts

@@ -284,6 +284,13 @@ export declare const zoneAnalyticsCapability: {
             keyFrameMediaKey: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>>;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — per-frame analytics; with `audio-metrics` it is ~90 % of the offered write rate. Re-derived on the next frame.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type IZoneAnalyticsProvider = InferProvider<typeof zoneAnalyticsCapability>;
 export { CameraOccupancySnapshotSchema as _CameraOccupancySnapshotSchema, StationaryObjectSchema, HistoryResolutionEnum, HistoryPointSchema, HistoryRangeSchema, ZoneScopeBreakdownSchema, PerScopeBreakdownSchema, };

package/dist/capabilities/zone-rules.cap.d.ts

@@ -149,5 +149,12 @@ export declare const zoneRulesCapability: {
             enabled: z.ZodDefault<z.ZodBoolean>;
         }, z.core.$strip>>>;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — operator intent, mutation-only, same argument as `zones`.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
 };
 export type IZoneRulesProvider = InferProvider<typeof zoneRulesCapability>;

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

@@ -146,5 +146,12 @@ export declare const zonesCapability: {
             color: z.ZodDefault<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — written only on operator mutation, so a camera that never had one has nothing to re-derive from. This is the slice `zone-mirror-hydration.ts` exists to paper over.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
 };
 export type IZonesProvider = InferProvider<typeof zonesCapability>;

package/dist/catalogs/coco-classmap.d.ts

@@ -1,4 +1,25 @@
 import type { LabelDefinition, ClassMapDefinition } from '../types/labels.js';
 export declare const COCO_80_LABELS: readonly LabelDefinition[];
 export declare const MACRO_LABELS: readonly LabelDefinition[];
+/**
+ * The class names a per-class COUNT can ever be keyed on — the macro ids, and
+ * only those.
+ *
+ * `preserveOriginal: false` below is the whole reason this set exists: the
+ * executor maps each raw COCO label onto its macro and DROPS everything else,
+ * so a tracked detection's `className` is always one of {@link MACRO_LABELS}.
+ * Any surface that indexes counts by class name — the ZoneAnalytics occupancy
+ * snapshot's `byClass`, and therefore every occupancy rule — can match nothing
+ * else. Derived from the catalog, never hand-listed, so a new macro joins it by
+ * being declared once.
+ *
+ * Cost of not having it, 2026-08-12: the notification rule editor offered the
+ * full taxonomy for an occupancy class (occupancy is the one condition that
+ * does not go through the engine's macro-expanding `expandClassSelector`), two
+ * live rules were authored on `car`, and both counters read 0 forever.
+ */
+export declare const DETECTION_MACRO_CLASSES: ReadonlySet<string>;
+/** True when `className` is a macro the detector can actually emit (and hence a
+ *  class a count can be keyed on) — see {@link DETECTION_MACRO_CLASSES}. */
+export declare function isDetectionMacroClass(className: string): boolean;
 export declare const COCO_TO_MACRO: ClassMapDefinition;

package/dist/device/system-mirror.d.ts

@@ -54,9 +54,24 @@ import { type SliceHandleApi } from './device-state-handle.js';
  */
 export interface SystemMirrorApi extends SliceHandleApi {
     readonly deviceManager: {
+        /**
+         * Whole-fleet binding dump. WARM BOOT ONLY — 903 ms and 373 KB on a
+         * 524-device hub. Anything on the event path uses `getBindings`.
+         */
         readonly getAllBindings: {
             query(input: Record<string, never>): Promise<ReadonlyArray<DeviceBinding>>;
         };
+        /**
+         * Single-device binding read. Required — `refreshBinding` runs once
+         * per `capability.binding-changed` and once per `device.registered`,
+         * and a full-fleet fetch there is what turned a 20-device Home
+         * Assistant adoption into 166 fleet sweeps (see `refreshBinding`).
+         */
+        readonly getBindings: {
+            query(input: {
+                deviceId: number;
+            }): Promise<DeviceBinding>;
+        };
         readonly listAll: {
             query(input: {
                 addonId?: string;
@@ -327,6 +342,28 @@ export declare class SystemMirror {
     private subscribeBus;
     private applyStateUpdate;
     private applyDeviceRemoval;
+    /**
+     * ONE device's bindings, not the fleet's.
+     *
+     * This runs on every `capability.binding-changed` AND on every
+     * `device.registered`, per mirror. It used to answer that with
+     * `getAllBindings` and `.find()` the one row — measured on the live
+     * hub (524 devices): 903 ms and 373 KB per call, against 21 ms and
+     * 613 bytes for `getBindings({deviceId})`.
+     *
+     * Adopting 20 Home Assistant devices registers 166 devices (parents +
+     * accessories), so an operator with the admin UI open bought 166
+     * full-fleet binding sweeps: ~150 s of hub main-thread time inside a
+     * 219 s adoption, with every other RPC — including the adoption's own —
+     * queued behind them. Same defect, same fix, as `refreshDeviceMetadata`
+     * below (`listAll` → `getDevice`).
+     *
+     * Removal is the destructive direction (every proxy handle a consumer
+     * holds goes inert), and an EMPTY binding list is not a claim that the
+     * device is gone — a device can legitimately bind nothing. So it needs
+     * a second read to agree (D49); `device.unregistered` remains the
+     * primary removal path.
+     */
     private refreshBinding;
     private refreshDeviceMetadata;
 }

package/dist/generated/runtime-state-durability.d.ts

@@ -0,0 +1,31 @@
+import type { RuntimeStateDurability } from '../capabilities/capability-definition.js';
+/** The persistence policy one capability declares for its runtime-state slice. */
+export interface RuntimeStatePolicy {
+    /** `'restored'` slices reach disk; `'session'` slices stay in the RAM mirror. */
+    readonly durability: RuntimeStateDurability;
+    /**
+     * Clock fields — persisted, but ignored by the equality test that decides
+     * whether a write is worth a SQLite commit. Declared by the cap.
+     */
+    readonly volatileFields: readonly string[];
+}
+/**
+ * Per-cap runtime-state policy, projected from every `*.cap.ts` that declares
+ * `runtimeState`. 62 caps: 33 `restored`, 29 `session`.
+ *
+ * A cap absent from this map has no runtime-state slice at all. A cap PRESENT
+ * with `durability: 'session'` has one and has decided not to keep it.
+ */
+export declare const RUNTIME_STATE_POLICY: Readonly<Record<string, RuntimeStatePolicy>>;
+/**
+ * The policy for `capName`. An UNKNOWN cap resolves to `'session'` — an
+ * addon-private slice the codegen has never seen is not persisted until its
+ * capability says so, which is the safe direction: the cost of a lost session
+ * value is a cold window, the cost of an unasked-for persist is a commit per
+ * second on the fleet's busiest write path.
+ */
+export declare function runtimeStatePolicyFor(capName: string): RuntimeStatePolicy;
+/** True when this cap's slice is written to disk. */
+export declare function isRestoredCap(capName: string): boolean;
+/** Cap names whose slice survives a restart, sorted. */
+export declare const RESTORED_CAP_NAMES: readonly string[];

package/dist/index.d.ts

@@ -119,7 +119,7 @@ export { AutomationActionSchema, AutomationConditionOperatorSchema, AutomationCo
 export * from './cap-call-context.js';
 export * from './capabilities/index.js';
 export { APPLE_SA_TO_MACRO, AUDIO_MACRO_LABELS, getAudioMacroClassIds, mapAudioLabelToMacro, YAMNET_TO_MACRO, } from './catalogs/audio-classmap.js';
-export { COCO_80_LABELS, COCO_TO_MACRO, MACRO_LABELS, } from './catalogs/coco-classmap.js';
+export { COCO_80_LABELS, COCO_TO_MACRO, DETECTION_MACRO_CLASSES, isDetectionMacroClass, MACRO_LABELS, } from './catalogs/coco-classmap.js';
 export { DEVICE_STATE_READERS, readDeviceStateFrom, stateVocabularyFor, } from './catalogs/device-state-vocabulary.js';
 export { colorForKind, DEFAULT_EVENT_COLOR, EVENT_TAXONOMY, type EventTaxonomyCategory, type EventTaxonomyEntry, type EventTaxonomyLevel, getTaxonomyEntry, subKindsOf, TAXONOMY_COLORS, } from './catalogs/event-taxonomy.js';
 export { buildNcTaxonomy, NC_TAXONOMY, type NcTaxonomy, type NcTaxonomyEntry, NcTaxonomyEntrySchema, NcTaxonomySchema, } from './catalogs/nc-taxonomy.js';
@@ -176,6 +176,8 @@ export { DEVICE_SCOPED_CAPS, isDeviceScopedCap } from './generated/device-scoped
 export type { MethodAccessRecord } from './generated/method-access-map.js';
 export { DEVICE_CAP_NAMES, KNOWN_CAP_NAMES, METHOD_ACCESS_MAP, SYSTEM_CAP_NAMES, } from './generated/method-access-map.js';
 export { CAP_PROVIDER_KIND_MAP, getCapsByProviderKind, PROVIDER_KIND_CAP_NAMES, } from './generated/provider-kind-map.js';
+export type { RuntimeStatePolicy } from './generated/runtime-state-durability.js';
+export { isRestoredCap, RESTORED_CAP_NAMES, RUNTIME_STATE_POLICY, runtimeStatePolicyFor, } from './generated/runtime-state-durability.js';
 export type { ScopePresetId, ScopePresetSpec } from './generated/scope-presets.js';
 export { SCOPE_PRESETS } from './generated/scope-presets.js';
 export type { SystemProxy } from './generated/system-proxy.js';
@@ -184,6 +186,7 @@ export type { AudioCodecInfo, AudioDecodeSessionConfig, AudioEncodedChunk, Audio
 export type { StreamQuality } from './interfaces/device-capabilities/camera.js';
 export { STREAM_QUALITY_LABELS, streamQualityLabel, } from './interfaces/device-capabilities/camera.js';
 export * from './lifecycle/index.js';
+export { audioIsFailClosed, audioLabelChoices, audioOrDefaults, isAudioLabelSelected, NC_AUDIO_DB_MAX, NC_AUDIO_DB_MIN, NC_AUDIO_DB_OFFERED, NC_AUDIO_DB_STEP, NC_AUDIO_DEFAULTS, NC_AUDIO_HIT_PERCENT_MAX, NC_AUDIO_HIT_PERCENT_MIN, NC_AUDIO_SAMPLING_MAX_SEC, NC_AUDIO_SAMPLING_MIN_SEC, type NcAudioLabelChoice, type NcAudioPatch, normalizeAudioLabel, patchAudio, toggleAudioLabel, } from './notification/audio-condition.js';
 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';