@camstack/types 1.2.305 → 1.2.306

package/dist/capabilities/custom-model-registry.cap.d.ts

@@ -169,6 +169,15 @@ export declare const CustomModelDescriptorSchema: z.ZodObject<{
             }>>;
             preserveOriginal: z.ZodBoolean;
         }, z.core.$strip>>;
+        fillsClassifierEffects: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            stepId: z.ZodEnum<{
+                "animal-classifier": "animal-classifier";
+                "vehicle-classifier": "vehicle-classifier";
+                "package-detection": "package-detection";
+            }>;
+            labelToEffect: z.ZodRecord<z.ZodString, z.ZodString>;
+            uncovered: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>>;
         clip: z.ZodOptional<z.ZodObject<{
             textModelId: z.ZodString;
             embeddingDim: z.ZodNumber;
@@ -348,6 +357,15 @@ export declare const customModelRegistryCapability: {
                     }>>;
                     preserveOriginal: z.ZodBoolean;
                 }, z.core.$strip>>;
+                fillsClassifierEffects: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    stepId: z.ZodEnum<{
+                        "animal-classifier": "animal-classifier";
+                        "vehicle-classifier": "vehicle-classifier";
+                        "package-detection": "package-detection";
+                    }>;
+                    labelToEffect: z.ZodRecord<z.ZodString, z.ZodString>;
+                    uncovered: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>>>;
                 clip: z.ZodOptional<z.ZodObject<{
                     textModelId: z.ZodString;
                     embeddingDim: z.ZodNumber;

package/dist/capabilities/device-manager.cap.d.ts

@@ -781,6 +781,8 @@ export declare const deviceManagerCapability: {
             locationKey: z.ZodString;
             icon: z.ZodEnum<{
                 package: "package";
+                car: "car";
+                umbrella: "umbrella";
                 "map-pin": "map-pin";
                 house: "house";
                 "door-open": "door-open";
@@ -789,11 +791,9 @@ export declare const deviceManagerCapability: {
                 "bed-double": "bed-double";
                 bath: "bath";
                 briefcase: "briefcase";
-                car: "car";
                 "circle-parking": "circle-parking";
                 route: "route";
                 trees: "trees";
-                umbrella: "umbrella";
                 "waves-ladder": "waves-ladder";
                 fence: "fence";
                 warehouse: "warehouse";
@@ -815,6 +815,8 @@ export declare const deviceManagerCapability: {
             location: z.ZodString;
             icon: z.ZodNullable<z.ZodEnum<{
                 package: "package";
+                car: "car";
+                umbrella: "umbrella";
                 "map-pin": "map-pin";
                 house: "house";
                 "door-open": "door-open";
@@ -823,11 +825,9 @@ export declare const deviceManagerCapability: {
                 "bed-double": "bed-double";
                 bath: "bath";
                 briefcase: "briefcase";
-                car: "car";
                 "circle-parking": "circle-parking";
                 route: "route";
                 trees: "trees";
-                umbrella: "umbrella";
                 "waves-ladder": "waves-ladder";
                 fence: "fence";
                 warehouse: "warehouse";
@@ -882,6 +882,8 @@ export declare const deviceManagerCapability: {
             label: z.ZodString;
             icon: z.ZodNullable<z.ZodEnum<{
                 package: "package";
+                car: "car";
+                umbrella: "umbrella";
                 "map-pin": "map-pin";
                 house: "house";
                 "door-open": "door-open";
@@ -890,11 +892,9 @@ export declare const deviceManagerCapability: {
                 "bed-double": "bed-double";
                 bath: "bath";
                 briefcase: "briefcase";
-                car: "car";
                 "circle-parking": "circle-parking";
                 route: "route";
                 trees: "trees";
-                umbrella: "umbrella";
                 "waves-ladder": "waves-ladder";
                 fence: "fence";
                 warehouse: "warehouse";
@@ -915,6 +915,8 @@ export declare const deviceManagerCapability: {
             name: z.ZodString;
             icon: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
                 package: "package";
+                car: "car";
+                umbrella: "umbrella";
                 "map-pin": "map-pin";
                 house: "house";
                 "door-open": "door-open";
@@ -923,11 +925,9 @@ export declare const deviceManagerCapability: {
                 "bed-double": "bed-double";
                 bath: "bath";
                 briefcase: "briefcase";
-                car: "car";
                 "circle-parking": "circle-parking";
                 route: "route";
                 trees: "trees";
-                umbrella: "umbrella";
                 "waves-ladder": "waves-ladder";
                 fence: "fence";
                 warehouse: "warehouse";

package/dist/capabilities/model-convert.cap.d.ts

@@ -279,6 +279,15 @@ export declare const modelConvertCapability: {
                     }>>;
                     preserveOriginal: z.ZodBoolean;
                 }, z.core.$strip>>;
+                fillsClassifierEffects: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    stepId: z.ZodEnum<{
+                        "animal-classifier": "animal-classifier";
+                        "vehicle-classifier": "vehicle-classifier";
+                        "package-detection": "package-detection";
+                    }>;
+                    labelToEffect: z.ZodRecord<z.ZodString, z.ZodString>;
+                    uncovered: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>>>;
                 clip: z.ZodOptional<z.ZodObject<{
                     textModelId: z.ZodString;
                     embeddingDim: z.ZodNumber;

package/dist/capabilities/model-distributor.cap.d.ts

@@ -177,6 +177,15 @@ export declare const ModelDistributeInputSchema: z.ZodObject<{
             }>>;
             preserveOriginal: z.ZodBoolean;
         }, z.core.$strip>>;
+        fillsClassifierEffects: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            stepId: z.ZodEnum<{
+                "animal-classifier": "animal-classifier";
+                "vehicle-classifier": "vehicle-classifier";
+                "package-detection": "package-detection";
+            }>;
+            labelToEffect: z.ZodRecord<z.ZodString, z.ZodString>;
+            uncovered: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>>;
         clip: z.ZodOptional<z.ZodObject<{
             textModelId: z.ZodString;
             embeddingDim: z.ZodNumber;
@@ -361,6 +370,15 @@ export declare const modelDistributorCapability: {
                     }>>;
                     preserveOriginal: z.ZodBoolean;
                 }, z.core.$strip>>;
+                fillsClassifierEffects: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    stepId: z.ZodEnum<{
+                        "animal-classifier": "animal-classifier";
+                        "vehicle-classifier": "vehicle-classifier";
+                        "package-detection": "package-detection";
+                    }>;
+                    labelToEffect: z.ZodRecord<z.ZodString, z.ZodString>;
+                    uncovered: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>>>;
                 clip: z.ZodOptional<z.ZodObject<{
                     textModelId: z.ZodString;
                     embeddingDim: z.ZodNumber;

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

@@ -740,8 +740,6 @@ export declare const NcLegacyRuleActionSequenceSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type NcLegacyRuleActionSequence = z.infer<typeof NcLegacyRuleActionSequenceSchema>;
 /** @deprecated Alias kept for call sites mid-migration; prefer {@link NcSharedSequence}. */
-export type NcRuleActionSequence = NcLegacyRuleActionSequence;
-/** @deprecated */
 export declare const NcRuleActionSequenceSchema: z.ZodObject<{
     name: z.ZodString;
     enabled: z.ZodBoolean;
@@ -757,6 +755,8 @@ export declare const NcRuleActionSequenceSchema: z.ZodObject<{
         args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>], "kind">>;
 }, z.core.$strip>;
+/** @deprecated */
+export type NcRuleActionSequence = z.infer<typeof NcRuleActionSequenceSchema>;
 /**
  * "This rule applies only while `deviceId` is in one of `states`."
  *

package/dist/capabilities/pipeline-executor.cap.d.ts

@@ -204,6 +204,15 @@ declare const PipelineModelOptionSchema: z.ZodObject<{
         scrypted: "scrypted";
     }>>;
     defaultConfidence: z.ZodOptional<z.ZodNumber>;
+    fillsClassifierEffects: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        stepId: z.ZodEnum<{
+            "animal-classifier": "animal-classifier";
+            "vehicle-classifier": "vehicle-classifier";
+            "package-detection": "package-detection";
+        }>;
+        labelToEffect: z.ZodRecord<z.ZodString, z.ZodString>;
+        uncovered: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>>;
 }, z.core.$strip>;
 declare const PipelineAddonSchemaSchema: z.ZodObject<{
     id: z.ZodString;
@@ -252,6 +261,15 @@ declare const PipelineAddonSchemaSchema: z.ZodObject<{
             scrypted: "scrypted";
         }>>;
         defaultConfidence: z.ZodOptional<z.ZodNumber>;
+        fillsClassifierEffects: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            stepId: z.ZodEnum<{
+                "animal-classifier": "animal-classifier";
+                "vehicle-classifier": "vehicle-classifier";
+                "package-detection": "package-detection";
+            }>;
+            labelToEffect: z.ZodRecord<z.ZodString, z.ZodString>;
+            uncovered: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>>;
     }, z.core.$strip>>>;
     defaultModelId: z.ZodString;
     defaultModelIdByFormat: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -325,6 +343,15 @@ declare const PipelineSlotSchemaSchema: z.ZodObject<{
                 scrypted: "scrypted";
             }>>;
             defaultConfidence: z.ZodOptional<z.ZodNumber>;
+            fillsClassifierEffects: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                stepId: z.ZodEnum<{
+                    "animal-classifier": "animal-classifier";
+                    "vehicle-classifier": "vehicle-classifier";
+                    "package-detection": "package-detection";
+                }>;
+                labelToEffect: z.ZodRecord<z.ZodString, z.ZodString>;
+                uncovered: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>>;
         }, z.core.$strip>>>;
         defaultModelId: z.ZodString;
         defaultModelIdByFormat: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -434,6 +461,15 @@ declare const PipelineSchemaSchema: z.ZodObject<{
                     scrypted: "scrypted";
                 }>>;
                 defaultConfidence: z.ZodOptional<z.ZodNumber>;
+                fillsClassifierEffects: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    stepId: z.ZodEnum<{
+                        "animal-classifier": "animal-classifier";
+                        "vehicle-classifier": "vehicle-classifier";
+                        "package-detection": "package-detection";
+                    }>;
+                    labelToEffect: z.ZodRecord<z.ZodString, z.ZodString>;
+                    uncovered: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>>>;
             }, z.core.$strip>>>;
             defaultModelId: z.ZodString;
             defaultModelIdByFormat: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -789,6 +825,15 @@ export declare const pipelineExecutorCapability: {
                             scrypted: "scrypted";
                         }>>;
                         defaultConfidence: z.ZodOptional<z.ZodNumber>;
+                        fillsClassifierEffects: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                            stepId: z.ZodEnum<{
+                                "animal-classifier": "animal-classifier";
+                                "vehicle-classifier": "vehicle-classifier";
+                                "package-detection": "package-detection";
+                            }>;
+                            labelToEffect: z.ZodRecord<z.ZodString, z.ZodString>;
+                            uncovered: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>>>>;
                     }, z.core.$strip>>>;
                     defaultModelId: z.ZodString;
                     defaultModelIdByFormat: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;

package/dist/catalogs/classifier-fill.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Detector ↔ step label link — the ONE place that says which pipeline steps a
+ * root detector can stand in for, in whose vocabulary, and who writes tier 1.
+ *
+ * A Frigate+ detector already emits `deer`, `car`, `package`: the effect
+ * `animal-classifier`, `vehicle-classifier` and `package-detection` exist to
+ * produce. The model DECLARES that (`ModelCatalogEntry.fillsClassifierEffects`,
+ * derived here from its labelmap), and the step's own `labelLink` policy says
+ * whether the declaration is honoured. Pure — no I/O, no clock.
+ */
+import type { FillsClassifierEffect, ModelCatalogEntry } from '../types/models.js';
+/** Steps a root detector may declare it fills. */
+export declare const FILLABLE_STEP_IDS: readonly ["animal-classifier", "vehicle-classifier", "package-detection"];
+export type FillableStepId = (typeof FILLABLE_STEP_IDS)[number];
+/** Narrow a step id to a fillable one — type guard, not a cast. */
+export declare function isFillableStepId(value: string): value is FillableStepId;
+/**
+ * The EFFECT vocabulary of each fillable step: exactly the strings the step
+ * itself emits, in its own spelling. A linked label is one of these and nothing
+ * else, so a tier-1 value means the same thing whichever writer produced it.
+ *
+ * - `animal-classifier`: the PRIMARY model's `-labels.json` (Open Images V7,
+ *   8 classes) — also the species allow-list the step offers.
+ * - `vehicle-classifier`: `vehicle-type-v1-labels.json`, capitalised as the
+ *   model emits them (the classifier writes `winner.class` verbatim).
+ * - `package-detection`: its one output class.
+ *
+ * `scripts/check-label-link-vocabulary.ts` fails the build if a model entry's
+ * `labelToEffect` names anything outside this table.
+ */
+export declare const FILLABLE_STEP_VOCABULARIES: Readonly<Record<FillableStepId, readonly string[]>>;
+/** The macro a detection must carry for the step to apply to it. */
+export declare const FILLABLE_STEP_MACRO: Readonly<Record<FillableStepId, string>>;
+/** The policy values of a step's `labelLink` setting. */
+export declare const LABEL_LINK_POLICIES: readonly ["run", "skip-when-filled"];
+export type LabelLinkPolicy = (typeof LABEL_LINK_POLICIES)[number];
+/** Absent setting ⇒ this. It changes nothing unless the root model declares a fill. */
+export declare const DEFAULT_LABEL_LINK_POLICY: LabelLinkPolicy;
+/** The step-settings key the policy is stored under (DeviceStepConfig.settings). */
+export declare const LABEL_LINK_SETTING_KEY = "labelLink";
+/** One fill a root model declares — the catalog schema's own type. */
+export type ClassifierFillDeclaration = FillsClassifierEffect;
+/** `ScoredLabel.stepId` prefix of a label the detector wrote for a step. */
+export declare const LINKED_LABEL_STEP_PREFIX = "detector-link:";
+/** `detector-link:<stepId>` — the attribution of a linked label. */
+export declare function linkedLabelStepId(stepId: FillableStepId): string;
+/** The step a linked label stands in for, or `undefined` for any other attribution. */
+export declare function linkedStepOf(attributionStepId: string | undefined): FillableStepId | undefined;
+/**
+ * A labelmap is COCO when it carries at least half of the COCO-80 classes. A
+ * COCO detector NEVER fills a step (operator decision, D715): its `dog` / `car`
+ * is the generic class the classifier exists to refine, and its six animal
+ * classes would otherwise read as "fills animal-classifier 6/8". Frigate+
+ * shares about a dozen COCO names; a COCO-80 or COCO-91 labelmap carries ~80.
+ */
+export declare function isCocoLabelmap(labels: readonly string[]): boolean;
+/**
+ * Which steps a root detector fills, from its labelmap and classMap. A label
+ * counts for a step only when the model's classMap sends it to that step's
+ * macro AND it names a vocabulary entry. A step none of the labels reach is
+ * not declared; a COCO labelmap declares nothing.
+ */
+export declare function deriveClassifierFills(labels: readonly string[], classMap: {
+    readonly mapping: Readonly<Record<string, string>>;
+} | undefined): readonly ClassifierFillDeclaration[];
+/** The fill a model declares for one step, if any. */
+export declare function fillFor(entry: Pick<ModelCatalogEntry, 'fillsClassifierEffects'> | undefined, stepId: FillableStepId): ClassifierFillDeclaration | undefined;
+/** Read the `labelLink` policy off a step's settings bag; anything else ⇒ the default. */
+export declare function readLabelLinkPolicy(settings: Readonly<Record<string, unknown>> | undefined): LabelLinkPolicy;
+/** The configured step the decision is about, as the attach tree carries it. */
+export interface LinkedStepState {
+    readonly enabled: boolean;
+    readonly settings?: Readonly<Record<string, unknown>>;
+}
+/** Who writes the step's effect for this camera. */
+export interface LabelLinkDecision {
+    /**
+     * The detector is the ONE writer of this effect: its linked label carries
+     * the detection's score. Otherwise it is written at score 0, a fallback any
+     * scored answer of the step outranks.
+     */
+    readonly authoritative: boolean;
+    /** The step is configured to run and must NOT be dispatched. */
+    readonly skip: boolean;
+    readonly policy: LabelLinkPolicy;
+    /**
+     * Vocabulary entries the detector cannot produce that the step's
+     * `enabledClasses` still asks for (empty allow-list = all). The skip waits
+     * until the operator switches every one of them off.
+     */
+    readonly openGaps: readonly string[];
+}
+/**
+ * Decide the writer of one filled effect for one camera.
+ *
+ * - The step is not running (disabled, or not in the camera's tree): the
+ *   detector is the only writer — authoritative, nothing to skip.
+ * - The step runs, the policy is `skip-when-filled` and every coverage gap is
+ *   switched off in `enabledClasses`: the detector is authoritative and the
+ *   step is skipped.
+ * - Otherwise the step runs and is the writer; the linked label is a score-0
+ *   fallback.
+ */
+export declare function resolveLabelLink(fill: ClassifierFillDeclaration, step: LinkedStepState | undefined): LabelLinkDecision;

package/dist/catalogs/frigate-plus-classmap.d.ts

@@ -0,0 +1,49 @@
+import { CLASS_MAP_MACRO_TARGETS, type DetectionCatalogClassMap } from '../types/labels.js';
+import { type ClassifierFillDeclaration } from './classifier-fill.js';
+/** A macro a detection catalog classMap may resolve to. */
+export type ClassMapMacroTarget = (typeof CLASS_MAP_MACRO_TARGETS)[number];
+/**
+ * Raw Frigate+ label → detection macro. Every label of the documented
+ * Frigate+ base set (docs.frigate.video/plus, verified 2026-08-21) is either
+ * here or in {@link FRIGATE_PLUS_UNMAPPED_LABELS}, with the reason it is not.
+ *
+ * Why this exists: a Frigate+ import used to carry NO classMap, so it inherited
+ * the step's `COCO_TO_MACRO` (`preserveOriginal: false`) and the executor
+ * dropped every label COCO does not name — deer, raccoon, fox, squirrel, goat,
+ * rabbit, skunk, kangaroo, possum, rodent, school_bus, garbage_truck and even
+ * `package` vanished as `class-filter` discards. The executor keeps the raw
+ * label as `originalClass` whenever the map resolves it, so the fine identity
+ * survives under the macro.
+ */
+export declare const FRIGATE_PLUS_TO_MACRO: Readonly<Record<string, ClassMapMacroTarget>>;
+/**
+ * Frigate+ labels deliberately left OUT of {@link FRIGATE_PLUS_TO_MACRO}.
+ *
+ * - `attribute`: Frigate+ emits these INSIDE a parent box (a face inside a
+ *   person, a plate or a carrier logo on a vehicle). Mapping one to its
+ *   parent's macro would spawn a second, overlapping track for the same
+ *   subject; CamStack derives faces and plates with its own detail steps.
+ * - `no-macro`: an object with no detection macro to live under.
+ */
+export declare const FRIGATE_PLUS_UNMAPPED_LABELS: Readonly<Record<string, 'attribute' | 'no-macro'>>;
+/**
+ * The per-model classMap for a Frigate / Frigate+ detector, derived from ITS
+ * labelmap: each label resolves through {@link FRIGATE_PLUS_TO_MACRO} first,
+ * then `COCO_TO_MACRO` (Frigate's default model ships the COCO-91 labelmap, so
+ * a preset import may carry either vocabulary). A label neither knows is left
+ * out, and `preserveOriginal: false` drops it in the executor — the same
+ * contract as the COCO map, now with the Frigate+ vocabulary in it.
+ */
+export declare function buildFrigateClassMap(labels: readonly string[]): DetectionCatalogClassMap;
+/** The label-derived fields of a Frigate catalog entry. */
+export interface FrigateLabelFields {
+    readonly classMap: DetectionCatalogClassMap;
+    readonly fillsClassifierEffects?: readonly ClassifierFillDeclaration[];
+}
+/**
+ * Everything a Frigate / Frigate+ entry derives from its labelmap: the classMap
+ * and the steps it fills (D715). Every Frigate builder spreads this, so the two
+ * cannot be derived from different label lists. A COCO labelmap gets its map
+ * and no fill.
+ */
+export declare function frigateLabelFields(labels: readonly string[]): FrigateLabelFields;

package/dist/catalogs/index.d.ts

@@ -1,4 +1,6 @@
 export * from './coco-classmap.js';
+export * from './frigate-plus-classmap.js';
+export * from './classifier-fill.js';
 export * from './sensor-active-state.js';
 export * from './audio-classmap.js';
 export * from './event-taxonomy.js';

package/dist/client.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `@camstack/types/client` — the runtime values a CLIENT bundle needs, and
+ * nothing it does not.
+ *
+ * The bare entry is one pre-bundled `index.mjs` (~1.1 MB minified) and Metro
+ * does not tree-shake, so the viewer's web bundle carried every capability
+ * schema the hub knows for the ~80 values it actually reads (D721). This entry
+ * is built on its own (`vite.client.config.ts`) with module side effects
+ * OFF, so only the modules these names reach are emitted.
+ *
+ * The list is the viewer's: every non-type import of `@camstack/types` in
+ * `camstack/src` + `app`, plus what `@camstack/sdk` imports at runtime.
+ * The viewer's guard (`types-client-entry.spec.ts`) fails when it imports a
+ * value this entry does not export — a missing name here is `undefined` at
+ * runtime, not a build error.
+ */
+export { APPLE_SA_TO_MACRO, AUDIO_MACRO_LABELS, AlarmArmModeSchema, CLIP_BROKER_PACED_RATES, COCO_TO_MACRO, CamProfileSchema, DEFAULT_TIMELAPSE_PREVIEW_TEXT, DeviceType, EVENTFUL_CAP_NAMES, EVENT_KIND_BY_CAP, EVENT_TAXONOMY, MACRO_LABELS, NC_ALARM_DELAY_MAX_SEC, NC_ALARM_SENSORS_MAX, NC_ALARM_SYSTEM_EVENT_KINDS, NC_ALARM_TRIGGERED_MAX_SEC, NC_BATTERY_CONSUMABLE_SYSTEM_EVENT_KINDS, NC_CAMERA_SCOPE_CAP_NAME, NC_CONSUMABLE_LOW_PERCENT_DEFAULT, NC_CONSUMABLE_LOW_PERCENT_MAX, NC_GROUPING_DEFAULT_SEC, NC_GROUPING_MAX_SEC, NC_GROUPING_MIN_SEC, NC_RULE_EDITOR_SECTION_ORDER, NC_RULE_KIND_SPECS, NC_SENSOR_TRANSITION_UNSUPPORTED_REASON, NC_SYSTEM_EVENT_FAMILY_FILTERS, NC_SYSTEM_EVENT_KIND_GROUP_SPECS, NC_SYSTEM_EVENT_SUMMARY_FAMILIES, NC_TEMPLATE_HELD_BACK_SYSTEM_EVENT_KINDS, NC_TEMPLATE_VARS, NcAlarmConfigSchema, NcAlarmSensorsSchema, NcAlarmSettingsPatchSchema, NcHistoryEntrySchema, NcRuleLastRunsSchema, NodeDirectorySchema, RECORDING_EXPORT_MAX_READ_BYTES, SystemMirror, TIMELAPSE_DENSE_FLOOR_SEC, TimelapseRuleSchema, YAMNET_TO_MACRO, alarmDeviceBlocksArming, alarmDeviceSecureOnArm, alarmPatchLanded, conditionVisibleForKind, createSystemProxy, droppedConditionsForKind, isHeldBackTemplateVar, isSystemRuleKind, kindsForDiscriminator, knownValues, nodePickerItems, packagePickerItems, pickerForCondition, pickerForRuleClasses, resolveModeDelays, ruleDeviceCompatCapNames, ruleEditorSectionsForKind, ruleGroupingApplies, ruleKindOf, ruleKindSpec, ruleSeedForSection, sensorTransitionNeverFires, sensorTransitionOffered, stateLabel, systemEventDeliveryProblems, systemEventFilterAppliesToAnyKind, systemEventKindsOfFamily, systemFamilyOfKind, templateCarriesSummary, templateVarDeliveryApplies, templateVarKindApplies, templateVarSystemEventApplies, } from './index.js';