@camstack/types 1.2.304 → 1.2.306

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/capabilities/pipeline-runner.cap.d.ts

@@ -180,6 +180,32 @@ export declare const MotionSourceEnum: z.ZodEnum<{
     "device-activity": "device-activity";
 }>;
 export type MotionSource = z.infer<typeof MotionSourceEnum>;
+/**
+ * What opened an on-motion detection SESSION: the motion source that passed the
+ * camera's `motionSources` gate, and what raised it (the camera itself, or a
+ * sensor the operator attached — D672). `sensorName` is the attached sensor's
+ * device name as the orchestrator's camera-sensors resolution last read it;
+ * absent when unknown or when the camera itself triggered.
+ *
+ * Carried on the session attach ONLY so the runner's `DetectionPhaseTransition`
+ * can say what started the session (D672 rule 11, amended 2026-10-06). The
+ * runner never decides anything on it.
+ */
+export declare const SessionTriggerSchema: z.ZodObject<{
+    source: z.ZodEnum<{
+        onboard: "onboard";
+        analyzer: "analyzer";
+        "device-activity": "device-activity";
+    }>;
+    triggeredBy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"camera">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"sensor">;
+        deviceId: z.ZodNumber;
+    }, z.core.$strip>], "kind">;
+    sensorName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SessionTrigger = z.infer<typeof SessionTriggerSchema>;
 /**
  * List of motion sources active on a camera. Empty array is valid:
  * "no source" — happens for battery cams without firmware motion when
@@ -371,6 +397,20 @@ declare const RunnerCameraConfigSchema: z.ZodObject<{
         analyzer: "analyzer";
         "device-activity": "device-activity";
     }>>>;
+    sessionTrigger: z.ZodOptional<z.ZodObject<{
+        source: z.ZodEnum<{
+            onboard: "onboard";
+            analyzer: "analyzer";
+            "device-activity": "device-activity";
+        }>;
+        triggeredBy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"camera">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"sensor">;
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>], "kind">;
+        sensorName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
     detectionSources: z.ZodDefault<z.ZodPreprocess<z.ZodArray<z.ZodEnum<{
         pipeline: "pipeline";
         onboard: "onboard";
@@ -660,6 +700,20 @@ export declare const pipelineRunnerCapability: {
                 analyzer: "analyzer";
                 "device-activity": "device-activity";
             }>>>;
+            sessionTrigger: z.ZodOptional<z.ZodObject<{
+                source: z.ZodEnum<{
+                    onboard: "onboard";
+                    analyzer: "analyzer";
+                    "device-activity": "device-activity";
+                }>;
+                triggeredBy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"camera">;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"sensor">;
+                    deviceId: z.ZodNumber;
+                }, z.core.$strip>], "kind">;
+                sensorName: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
             detectionSources: z.ZodDefault<z.ZodPreprocess<z.ZodArray<z.ZodEnum<{
                 pipeline: "pipeline";
                 onboard: "onboard";

package/dist/capabilities/viewer-link-url.d.ts

@@ -0,0 +1,104 @@
+/**
+ * viewer-link-url — the ONE builder for a link that opens a VIEWER page
+ * (a camera at an instant, the events timeline, the notification centre),
+ * and the one definition of the "CamStack app link" address (D709).
+ *
+ * The address a link points at is the endpoint the operator FLAGS for
+ * notifications on the admin Network page (`local-network`'s notification
+ * endpoint — one flag, one store). Among the addresses that page lists,
+ * `local-network` adds one generic entry: the app link,
+ * `https://camstack.zentik.app`, and that entry carries the flag BY DEFAULT.
+ * Two forms follow from which address is flagged:
+ *
+ * - `app` — the app link is flagged:
+ *   `https://camstack.zentik.app/<path>?<query>&hub=<hub origin>`. The central
+ *   domain the native app claims as a Universal Link / App Link
+ *   (docs/design/2026-08-19-central-link-redirect.md): on a phone with the app
+ *   it opens the app on that page; anywhere else the hosted viewer opens and
+ *   `hub=` tells it which hub to talk to. `hub=` is filled automatically from
+ *   the hub's own best public HTTPS address ({@link pickAppLinkHub}).
+ * - `hub` — one of the hub's own addresses is flagged:
+ *   `<hub base>/viewer/camstack/<path>?<query>` (the pre-D709 form).
+ *
+ * The paths are the viewer's own routes, verbatim (§2.3 of that design), and
+ * only the families the app claims in its AASA (`camstack/web-server/
+ * app-links.ts`): `/camera/*`, `/events*`, `/notifications*`. A destination
+ * is a typed union rather than a free path so a caller cannot mint a central
+ * link the domain would 404.
+ *
+ * The admin UI is NOT a viewer destination: the central site hosts the
+ * viewer only, so an admin page (an addon update row → `/system/addons`)
+ * always points at the hub itself — see `system-event-tap-url.ts`. Nor is the
+ * app link a HUB address: signed media and action-button links never use it.
+ */
+import type { ConnectionEndpoint } from './local-network.cap.js';
+/** The central link domain the viewer app claims (Universal Links / App Links). */
+export declare const CAMSTACK_APP_LINK_ORIGIN = "https://camstack.zentik.app";
+/** Where the hub serves the viewer SPA. */
+export declare const HUB_VIEWER_MOUNT = "/viewer/camstack";
+/** Which form a viewer link takes — see the module header. */
+export type ViewerLinkForm = 'hub' | 'app';
+/**
+ * The base a viewer link is built on. `hub`: the flagged hub address (null =
+ * none reachable — no link). `app`: the hub origin to carry as `hub=` (null =
+ * none known — the link is still minted, without `hub=`; the central page then
+ * asks once, design §5).
+ */
+export interface ViewerLinkBase {
+    readonly form: ViewerLinkForm;
+    readonly hubBaseUrl: string | null;
+}
+/** A viewer page a link may open. One member per AASA-claimed route family. */
+export type ViewerDestination = {
+    readonly kind: 'camera';
+    readonly deviceId: number;
+    /** Recorded seek instant (`?at=`), epoch ms. Absent = live. */
+    readonly atMs?: number;
+} | {
+    readonly kind: 'events';
+} | {
+    readonly kind: 'notifications';
+};
+export interface ViewerLinkInput {
+    readonly base: ViewerLinkBase;
+    readonly destination: ViewerDestination;
+}
+/** True when `baseUrl` names the CamStack app link rather than a hub address. */
+export declare function isAppLinkBase(baseUrl: string | null | undefined): boolean;
+/**
+ * The fields of `local-network.getNotificationEndpoint` a viewer link reads.
+ * `appLinkHub` is absent on a pre-D709 hub, which never flags the app link.
+ */
+export interface NotificationLinkEndpoint {
+    readonly baseUrl: string | null;
+    readonly resolved: string | null;
+    readonly appLinkHub?: string | null;
+}
+/**
+ * The base a viewer link is built on, from the flagged notification address:
+ * the effective address is the explicit choice, else AUTO's `resolved`. The
+ * one reading of that answer — the NC's tap and the Network page's preview
+ * both go through it.
+ */
+export declare function viewerLinkBaseOf(endpoint: NotificationLinkEndpoint): ViewerLinkBase;
+/**
+ * Reduce a base URL to the bare origin the central page accepts as `hub=`,
+ * or `null` when it cannot be one: not http(s), carries credentials, or does
+ * not parse. A path/query/fragment is dropped — the central page mounts the
+ * viewer under the origin itself.
+ */
+export declare function toAppLinkHubOrigin(baseUrl: string): string | null;
+/**
+ * The hub address an app link carries as `hub=`, chosen from the hub's OWN
+ * advertised palette so it always agrees with what the Network page lists:
+ * the public tunnel first, then the mesh (Tailscale MagicDNS) — HTTPS only,
+ * because the app and the hosted viewer reach it from off the LAN. `null`
+ * when the hub advertises neither.
+ */
+export declare function pickAppLinkHub(endpoints: readonly ConnectionEndpoint[]): string | null;
+/**
+ * The link for a viewer destination, or `null` when none can be minted: an
+ * unknown destination, or the `hub` form with no reachable base (a dead link
+ * is worse than none).
+ */
+export declare function buildViewerLink(input: ViewerLinkInput): string | null;

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';