@camstack/types 1.2.6 → 1.2.8

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

@@ -0,0 +1,908 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * notification-rules — the Notification Center rule surface (P1 core).
+ *
+ * Spec: `docs/superpowers/specs/2026-07-22-notification-center-requirements.md`
+ * (operator decisions D-1/D-2/D-3 are binding):
+ *
+ *  - D-2: rule EVALUATION lives in `addon-post-analysis` (the
+ *    `notification-center` module), hooked on the durable persistence
+ *    moments (object-event insert, TrackCloser.closeExpired) with a
+ *    persisted outbox + retry — never the lossy telemetry bus (D8).
+ *  - D-3: urgency belongs to the RULE. `delivery: 'immediate'` fires on the
+ *    FIRST persisted detection matching the conditions (per-track dedup,
+ *    `maxPerTrack` fixed at 1 — see {@link NC_MAX_PER_TRACK_IMMEDIATE});
+ *    `delivery: 'track-end'` evaluates the finalized track record at close.
+ *  - DISPATCH stays behind `notification-output` (rules reference targets
+ *    by id; per-backend params are a passthrough blob capped by the
+ *    target kind's own caps/degrade engine).
+ *
+ * P1 scope: admin-authored rules only (`createdBy` stamped from the
+ * server-injected caller identity — the first `caller: 'required'`
+ * adopter). The P1 condition subset is: devices, classes(+exclude),
+ * minConfidence, admin zones (any/all + exclude), weekly schedule
+ * windows, and the optional label/identity/plate matchers. User rules,
+ * private zones, per-recipient fan-out and the wider condition table are
+ * P2+ (see spec §7).
+ *
+ * All schemas here are the single source of truth — `NcRule` etc. are
+ * `z.infer` exports; no duplicate interfaces (the advanced-notifier
+ * schema/interface drift is explicitly not repeated).
+ */
+/** D-3: the urgency of a rule — which persistence moment evaluates it. */
+export declare const NcDeliverySchema: z.ZodEnum<{
+    immediate: "immediate";
+    "track-end": "track-end";
+}>;
+export type NcDelivery = z.infer<typeof NcDeliverySchema>;
+/**
+ * `maxPerTrack` for `immediate` rules is FIXED at 1 (D-3): a single track
+ * fires an immediate rule at most once, enforced durably by the outbox
+ * unique key `(ruleId, trackId, targetId)`. Not a rule field in P1.
+ */
+export declare const NC_MAX_PER_TRACK_IMMEDIATE = 1;
+/** One weekly activation window. `startMinute > endMinute` crosses midnight. */
+export declare const NcScheduleWindowSchema: z.ZodObject<{
+    days: z.ZodArray<z.ZodNumber>;
+    startMinute: z.ZodNumber;
+    endMinute: z.ZodNumber;
+}, z.core.$strip>;
+export type NcScheduleWindow = z.infer<typeof NcScheduleWindowSchema>;
+/** Weekly schedule — OR of windows; absence on the rule = always active. */
+export declare const NcScheduleSchema: z.ZodObject<{
+    windows: z.ZodArray<z.ZodObject<{
+        days: z.ZodArray<z.ZodNumber>;
+        startMinute: z.ZodNumber;
+        endMinute: z.ZodNumber;
+    }, z.core.$strip>>;
+    timezone: z.ZodOptional<z.ZodString>;
+    invert: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type NcSchedule = z.infer<typeof NcScheduleSchema>;
+/** Fuzzy plate matcher — OCR noise makes exact match useless (spec row 12/13). */
+export declare const NcPlateMatcherSchema: z.ZodObject<{
+    values: z.ZodArray<z.ZodString>;
+    maxDistance: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type NcPlateMatcher = z.infer<typeof NcPlateMatcherSchema>;
+/** Admin-zone membership condition (zone IDs as stamped by the ZoneEngine). */
+export declare const NcZoneConditionSchema: z.ZodObject<{
+    ids: z.ZodArray<z.ZodString>;
+    match: z.ZodDefault<z.ZodEnum<{
+        any: "any";
+        all: "all";
+    }>>;
+}, z.core.$strip>;
+export type NcZoneCondition = z.infer<typeof NcZoneConditionSchema>;
+/**
+ * The P1 condition set — a flat AND of groups; absent group = pass;
+ * membership lists are OR within the list (spec §2.3).
+ */
+export declare const NcConditionsSchema: z.ZodObject<{
+    devices: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    classesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+    zones: z.ZodOptional<z.ZodObject<{
+        ids: z.ZodArray<z.ZodString>;
+        match: z.ZodDefault<z.ZodEnum<{
+            any: "any";
+            all: "all";
+        }>>;
+    }, z.core.$strip>>;
+    zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    plates: z.ZodOptional<z.ZodObject<{
+        values: z.ZodArray<z.ZodString>;
+        maxDistance: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type NcConditions = z.infer<typeof NcConditionsSchema>;
+/** One delivery target: a `notification-output` Target ref + passthrough params. */
+export declare const NcRuleTargetSchema: z.ZodObject<{
+    targetId: z.ZodString;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type NcRuleTarget = z.infer<typeof NcRuleTargetSchema>;
+/**
+ * Media attachment policy (P1 still-image subset). `best` = the best
+ * AVAILABLE media at dispatch time (D-3); `best-matching` (track-end
+ * condition-best) is deferred — operator open point.
+ */
+export declare const NcMediaPolicySchema: z.ZodObject<{
+    attach: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        best: "best";
+        keyFrame: "keyFrame";
+    }>>;
+}, z.core.$strip>;
+export type NcMediaPolicy = z.infer<typeof NcMediaPolicySchema>;
+/** Throttle — cooldown survives restarts (rebuilt from the outbox on boot). */
+export declare const NcThrottleSchema: z.ZodObject<{
+    cooldownSec: z.ZodDefault<z.ZodNumber>;
+    scope: z.ZodDefault<z.ZodEnum<{
+        rule: "rule";
+        "rule-device": "rule-device";
+    }>>;
+}, z.core.$strip>;
+export type NcThrottle = z.infer<typeof NcThrottleSchema>;
+/** Client-supplied rule fields (server stamps id/createdBy/createdAt/updatedAt). */
+export declare const NcRuleInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    delivery: z.ZodEnum<{
+        immediate: "immediate";
+        "track-end": "track-end";
+    }>;
+    conditions: z.ZodDefault<z.ZodObject<{
+        devices: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        classesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        minConfidence: z.ZodOptional<z.ZodNumber>;
+        zones: z.ZodOptional<z.ZodObject<{
+            ids: z.ZodArray<z.ZodString>;
+            match: z.ZodDefault<z.ZodEnum<{
+                any: "any";
+                all: "all";
+            }>>;
+        }, z.core.$strip>>;
+        zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        plates: z.ZodOptional<z.ZodObject<{
+            values: z.ZodArray<z.ZodString>;
+            maxDistance: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    schedule: z.ZodOptional<z.ZodObject<{
+        windows: z.ZodArray<z.ZodObject<{
+            days: z.ZodArray<z.ZodNumber>;
+            startMinute: z.ZodNumber;
+            endMinute: z.ZodNumber;
+        }, z.core.$strip>>;
+        timezone: z.ZodOptional<z.ZodString>;
+        invert: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    targets: z.ZodArray<z.ZodObject<{
+        targetId: z.ZodString;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    media: z.ZodDefault<z.ZodObject<{
+        attach: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            best: "best";
+            keyFrame: "keyFrame";
+        }>>;
+    }, z.core.$strip>>;
+    throttle: z.ZodDefault<z.ZodObject<{
+        cooldownSec: z.ZodDefault<z.ZodNumber>;
+        scope: z.ZodDefault<z.ZodEnum<{
+            rule: "rule";
+            "rule-device": "rule-device";
+        }>>;
+    }, z.core.$strip>>;
+    template: z.ZodOptional<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        body: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    priority: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type NcRuleInput = z.infer<typeof NcRuleInputSchema>;
+/** Partial patch for `updateRule` — any subset of the input fields. */
+export declare const NcRulePatchSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    delivery: z.ZodOptional<z.ZodEnum<{
+        immediate: "immediate";
+        "track-end": "track-end";
+    }>>;
+    conditions: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        devices: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        classesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        minConfidence: z.ZodOptional<z.ZodNumber>;
+        zones: z.ZodOptional<z.ZodObject<{
+            ids: z.ZodArray<z.ZodString>;
+            match: z.ZodDefault<z.ZodEnum<{
+                any: "any";
+                all: "all";
+            }>>;
+        }, z.core.$strip>>;
+        zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        plates: z.ZodOptional<z.ZodObject<{
+            values: z.ZodArray<z.ZodString>;
+            maxDistance: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    schedule: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        windows: z.ZodArray<z.ZodObject<{
+            days: z.ZodArray<z.ZodNumber>;
+            startMinute: z.ZodNumber;
+            endMinute: z.ZodNumber;
+        }, z.core.$strip>>;
+        timezone: z.ZodOptional<z.ZodString>;
+        invert: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    targets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        targetId: z.ZodString;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    media: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        attach: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            best: "best";
+            keyFrame: "keyFrame";
+        }>>;
+    }, z.core.$strip>>>;
+    throttle: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        cooldownSec: z.ZodDefault<z.ZodNumber>;
+        scope: z.ZodDefault<z.ZodEnum<{
+            rule: "rule";
+            "rule-device": "rule-device";
+        }>>;
+    }, z.core.$strip>>>;
+    template: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        body: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    priority: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, z.core.$strip>;
+export type NcRulePatch = z.infer<typeof NcRulePatchSchema>;
+/** A persisted rule. */
+export declare const NcRuleSchema: z.ZodObject<{
+    name: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    delivery: z.ZodEnum<{
+        immediate: "immediate";
+        "track-end": "track-end";
+    }>;
+    conditions: z.ZodDefault<z.ZodObject<{
+        devices: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        classesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        minConfidence: z.ZodOptional<z.ZodNumber>;
+        zones: z.ZodOptional<z.ZodObject<{
+            ids: z.ZodArray<z.ZodString>;
+            match: z.ZodDefault<z.ZodEnum<{
+                any: "any";
+                all: "all";
+            }>>;
+        }, z.core.$strip>>;
+        zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        plates: z.ZodOptional<z.ZodObject<{
+            values: z.ZodArray<z.ZodString>;
+            maxDistance: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    schedule: z.ZodOptional<z.ZodObject<{
+        windows: z.ZodArray<z.ZodObject<{
+            days: z.ZodArray<z.ZodNumber>;
+            startMinute: z.ZodNumber;
+            endMinute: z.ZodNumber;
+        }, z.core.$strip>>;
+        timezone: z.ZodOptional<z.ZodString>;
+        invert: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    targets: z.ZodArray<z.ZodObject<{
+        targetId: z.ZodString;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    media: z.ZodDefault<z.ZodObject<{
+        attach: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            best: "best";
+            keyFrame: "keyFrame";
+        }>>;
+    }, z.core.$strip>>;
+    throttle: z.ZodDefault<z.ZodObject<{
+        cooldownSec: z.ZodDefault<z.ZodNumber>;
+        scope: z.ZodDefault<z.ZodEnum<{
+            rule: "rule";
+            "rule-device": "rule-device";
+        }>>;
+    }, z.core.$strip>>;
+    template: z.ZodOptional<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        body: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    priority: z.ZodDefault<z.ZodNumber>;
+    id: z.ZodString;
+    createdBy: z.ZodString;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type NcRule = z.infer<typeof NcRuleSchema>;
+export declare const NcTestResultSchema: z.ZodObject<{
+    recordId: z.ZodString;
+    recordKind: z.ZodEnum<{
+        "object-event": "object-event";
+        track: "track";
+    }>;
+    deviceId: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    wouldFire: z.ZodBoolean;
+    failedCondition: z.ZodOptional<z.ZodString>;
+    className: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type NcTestResult = z.infer<typeof NcTestResultSchema>;
+export declare const NcConditionDescriptorSchema: z.ZodObject<{
+    id: z.ZodString;
+    group: z.ZodEnum<{
+        label: "label";
+        scope: "scope";
+        class: "class";
+        schedule: "schedule";
+        zones: "zones";
+        quality: "quality";
+    }>;
+    label: z.ZodString;
+    valueType: z.ZodEnum<{
+        schedule: "schedule";
+        deviceIdList: "deviceIdList";
+        stringList: "stringList";
+        number01: "number01";
+        zoneSelection: "zoneSelection";
+        zoneIdList: "zoneIdList";
+        plateMatcher: "plateMatcher";
+    }>;
+    operator: z.ZodEnum<{
+        in: "in";
+        notIn: "notIn";
+        anyOf: "anyOf";
+        allOf: "allOf";
+        gte: "gte";
+        fuzzyIn: "fuzzyIn";
+        withinSchedule: "withinSchedule";
+    }>;
+    appliesTo: z.ZodArray<z.ZodEnum<{
+        immediate: "immediate";
+        "track-end": "track-end";
+    }>>;
+    phase: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type NcConditionDescriptor = z.infer<typeof NcConditionDescriptorSchema>;
+/**
+ * The P1 condition surface as data — served by `getConditionCatalog` so
+ * rule editors render from the catalog, not hardcoded forms (spec §4.2).
+ */
+export declare const NC_CONDITION_CATALOG: readonly NcConditionDescriptor[];
+export declare const notificationRulesCapability: {
+    readonly name: "notification-rules";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        readonly listRules: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+            rules: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                delivery: z.ZodEnum<{
+                    immediate: "immediate";
+                    "track-end": "track-end";
+                }>;
+                conditions: z.ZodDefault<z.ZodObject<{
+                    devices: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                    classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    classesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    minConfidence: z.ZodOptional<z.ZodNumber>;
+                    zones: z.ZodOptional<z.ZodObject<{
+                        ids: z.ZodArray<z.ZodString>;
+                        match: z.ZodDefault<z.ZodEnum<{
+                            any: "any";
+                            all: "all";
+                        }>>;
+                    }, z.core.$strip>>;
+                    zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    plates: z.ZodOptional<z.ZodObject<{
+                        values: z.ZodArray<z.ZodString>;
+                        maxDistance: z.ZodDefault<z.ZodNumber>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                schedule: z.ZodOptional<z.ZodObject<{
+                    windows: z.ZodArray<z.ZodObject<{
+                        days: z.ZodArray<z.ZodNumber>;
+                        startMinute: z.ZodNumber;
+                        endMinute: z.ZodNumber;
+                    }, z.core.$strip>>;
+                    timezone: z.ZodOptional<z.ZodString>;
+                    invert: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                targets: z.ZodArray<z.ZodObject<{
+                    targetId: z.ZodString;
+                    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>;
+                media: z.ZodDefault<z.ZodObject<{
+                    attach: z.ZodDefault<z.ZodEnum<{
+                        none: "none";
+                        best: "best";
+                        keyFrame: "keyFrame";
+                    }>>;
+                }, z.core.$strip>>;
+                throttle: z.ZodDefault<z.ZodObject<{
+                    cooldownSec: z.ZodDefault<z.ZodNumber>;
+                    scope: z.ZodDefault<z.ZodEnum<{
+                        rule: "rule";
+                        "rule-device": "rule-device";
+                    }>>;
+                }, z.core.$strip>>;
+                template: z.ZodOptional<z.ZodObject<{
+                    title: z.ZodOptional<z.ZodString>;
+                    body: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                priority: z.ZodDefault<z.ZodNumber>;
+                id: z.ZodString;
+                createdBy: z.ZodString;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getRule: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            ruleId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            rule: z.ZodNullable<z.ZodObject<{
+                name: z.ZodString;
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                delivery: z.ZodEnum<{
+                    immediate: "immediate";
+                    "track-end": "track-end";
+                }>;
+                conditions: z.ZodDefault<z.ZodObject<{
+                    devices: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                    classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    classesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    minConfidence: z.ZodOptional<z.ZodNumber>;
+                    zones: z.ZodOptional<z.ZodObject<{
+                        ids: z.ZodArray<z.ZodString>;
+                        match: z.ZodDefault<z.ZodEnum<{
+                            any: "any";
+                            all: "all";
+                        }>>;
+                    }, z.core.$strip>>;
+                    zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    plates: z.ZodOptional<z.ZodObject<{
+                        values: z.ZodArray<z.ZodString>;
+                        maxDistance: z.ZodDefault<z.ZodNumber>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                schedule: z.ZodOptional<z.ZodObject<{
+                    windows: z.ZodArray<z.ZodObject<{
+                        days: z.ZodArray<z.ZodNumber>;
+                        startMinute: z.ZodNumber;
+                        endMinute: z.ZodNumber;
+                    }, z.core.$strip>>;
+                    timezone: z.ZodOptional<z.ZodString>;
+                    invert: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                targets: z.ZodArray<z.ZodObject<{
+                    targetId: z.ZodString;
+                    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>;
+                media: z.ZodDefault<z.ZodObject<{
+                    attach: z.ZodDefault<z.ZodEnum<{
+                        none: "none";
+                        best: "best";
+                        keyFrame: "keyFrame";
+                    }>>;
+                }, z.core.$strip>>;
+                throttle: z.ZodDefault<z.ZodObject<{
+                    cooldownSec: z.ZodDefault<z.ZodNumber>;
+                    scope: z.ZodDefault<z.ZodEnum<{
+                        rule: "rule";
+                        "rule-device": "rule-device";
+                    }>>;
+                }, z.core.$strip>>;
+                template: z.ZodOptional<z.ZodObject<{
+                    title: z.ZodOptional<z.ZodString>;
+                    body: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                priority: z.ZodDefault<z.ZodNumber>;
+                id: z.ZodString;
+                createdBy: z.ZodString;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly createRule: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            rule: z.ZodObject<{
+                name: z.ZodString;
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                delivery: z.ZodEnum<{
+                    immediate: "immediate";
+                    "track-end": "track-end";
+                }>;
+                conditions: z.ZodDefault<z.ZodObject<{
+                    devices: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                    classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    classesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    minConfidence: z.ZodOptional<z.ZodNumber>;
+                    zones: z.ZodOptional<z.ZodObject<{
+                        ids: z.ZodArray<z.ZodString>;
+                        match: z.ZodDefault<z.ZodEnum<{
+                            any: "any";
+                            all: "all";
+                        }>>;
+                    }, z.core.$strip>>;
+                    zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    plates: z.ZodOptional<z.ZodObject<{
+                        values: z.ZodArray<z.ZodString>;
+                        maxDistance: z.ZodDefault<z.ZodNumber>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                schedule: z.ZodOptional<z.ZodObject<{
+                    windows: z.ZodArray<z.ZodObject<{
+                        days: z.ZodArray<z.ZodNumber>;
+                        startMinute: z.ZodNumber;
+                        endMinute: z.ZodNumber;
+                    }, z.core.$strip>>;
+                    timezone: z.ZodOptional<z.ZodString>;
+                    invert: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                targets: z.ZodArray<z.ZodObject<{
+                    targetId: z.ZodString;
+                    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>;
+                media: z.ZodDefault<z.ZodObject<{
+                    attach: z.ZodDefault<z.ZodEnum<{
+                        none: "none";
+                        best: "best";
+                        keyFrame: "keyFrame";
+                    }>>;
+                }, z.core.$strip>>;
+                throttle: z.ZodDefault<z.ZodObject<{
+                    cooldownSec: z.ZodDefault<z.ZodNumber>;
+                    scope: z.ZodDefault<z.ZodEnum<{
+                        rule: "rule";
+                        "rule-device": "rule-device";
+                    }>>;
+                }, z.core.$strip>>;
+                template: z.ZodOptional<z.ZodObject<{
+                    title: z.ZodOptional<z.ZodString>;
+                    body: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                priority: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            rule: z.ZodObject<{
+                name: z.ZodString;
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                delivery: z.ZodEnum<{
+                    immediate: "immediate";
+                    "track-end": "track-end";
+                }>;
+                conditions: z.ZodDefault<z.ZodObject<{
+                    devices: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                    classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    classesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    minConfidence: z.ZodOptional<z.ZodNumber>;
+                    zones: z.ZodOptional<z.ZodObject<{
+                        ids: z.ZodArray<z.ZodString>;
+                        match: z.ZodDefault<z.ZodEnum<{
+                            any: "any";
+                            all: "all";
+                        }>>;
+                    }, z.core.$strip>>;
+                    zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    plates: z.ZodOptional<z.ZodObject<{
+                        values: z.ZodArray<z.ZodString>;
+                        maxDistance: z.ZodDefault<z.ZodNumber>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                schedule: z.ZodOptional<z.ZodObject<{
+                    windows: z.ZodArray<z.ZodObject<{
+                        days: z.ZodArray<z.ZodNumber>;
+                        startMinute: z.ZodNumber;
+                        endMinute: z.ZodNumber;
+                    }, z.core.$strip>>;
+                    timezone: z.ZodOptional<z.ZodString>;
+                    invert: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                targets: z.ZodArray<z.ZodObject<{
+                    targetId: z.ZodString;
+                    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>;
+                media: z.ZodDefault<z.ZodObject<{
+                    attach: z.ZodDefault<z.ZodEnum<{
+                        none: "none";
+                        best: "best";
+                        keyFrame: "keyFrame";
+                    }>>;
+                }, z.core.$strip>>;
+                throttle: z.ZodDefault<z.ZodObject<{
+                    cooldownSec: z.ZodDefault<z.ZodNumber>;
+                    scope: z.ZodDefault<z.ZodEnum<{
+                        rule: "rule";
+                        "rule-device": "rule-device";
+                    }>>;
+                }, z.core.$strip>>;
+                template: z.ZodOptional<z.ZodObject<{
+                    title: z.ZodOptional<z.ZodString>;
+                    body: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                priority: z.ZodDefault<z.ZodNumber>;
+                id: z.ZodString;
+                createdBy: z.ZodString;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>, "mutation"> & {
+            readonly caller: "required";
+        };
+        readonly updateRule: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            ruleId: z.ZodString;
+            patch: z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+                delivery: z.ZodOptional<z.ZodEnum<{
+                    immediate: "immediate";
+                    "track-end": "track-end";
+                }>>;
+                conditions: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+                    devices: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                    classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    classesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    minConfidence: z.ZodOptional<z.ZodNumber>;
+                    zones: z.ZodOptional<z.ZodObject<{
+                        ids: z.ZodArray<z.ZodString>;
+                        match: z.ZodDefault<z.ZodEnum<{
+                            any: "any";
+                            all: "all";
+                        }>>;
+                    }, z.core.$strip>>;
+                    zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    plates: z.ZodOptional<z.ZodObject<{
+                        values: z.ZodArray<z.ZodString>;
+                        maxDistance: z.ZodDefault<z.ZodNumber>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>>;
+                schedule: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                    windows: z.ZodArray<z.ZodObject<{
+                        days: z.ZodArray<z.ZodNumber>;
+                        startMinute: z.ZodNumber;
+                        endMinute: z.ZodNumber;
+                    }, z.core.$strip>>;
+                    timezone: z.ZodOptional<z.ZodString>;
+                    invert: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>>;
+                targets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    targetId: z.ZodString;
+                    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>>;
+                media: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+                    attach: z.ZodDefault<z.ZodEnum<{
+                        none: "none";
+                        best: "best";
+                        keyFrame: "keyFrame";
+                    }>>;
+                }, z.core.$strip>>>;
+                throttle: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+                    cooldownSec: z.ZodDefault<z.ZodNumber>;
+                    scope: z.ZodDefault<z.ZodEnum<{
+                        rule: "rule";
+                        "rule-device": "rule-device";
+                    }>>;
+                }, z.core.$strip>>>;
+                template: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                    title: z.ZodOptional<z.ZodString>;
+                    body: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                priority: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            rule: z.ZodObject<{
+                name: z.ZodString;
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                delivery: z.ZodEnum<{
+                    immediate: "immediate";
+                    "track-end": "track-end";
+                }>;
+                conditions: z.ZodDefault<z.ZodObject<{
+                    devices: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                    classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    classesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    minConfidence: z.ZodOptional<z.ZodNumber>;
+                    zones: z.ZodOptional<z.ZodObject<{
+                        ids: z.ZodArray<z.ZodString>;
+                        match: z.ZodDefault<z.ZodEnum<{
+                            any: "any";
+                            all: "all";
+                        }>>;
+                    }, z.core.$strip>>;
+                    zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    plates: z.ZodOptional<z.ZodObject<{
+                        values: z.ZodArray<z.ZodString>;
+                        maxDistance: z.ZodDefault<z.ZodNumber>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                schedule: z.ZodOptional<z.ZodObject<{
+                    windows: z.ZodArray<z.ZodObject<{
+                        days: z.ZodArray<z.ZodNumber>;
+                        startMinute: z.ZodNumber;
+                        endMinute: z.ZodNumber;
+                    }, z.core.$strip>>;
+                    timezone: z.ZodOptional<z.ZodString>;
+                    invert: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                targets: z.ZodArray<z.ZodObject<{
+                    targetId: z.ZodString;
+                    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>;
+                media: z.ZodDefault<z.ZodObject<{
+                    attach: z.ZodDefault<z.ZodEnum<{
+                        none: "none";
+                        best: "best";
+                        keyFrame: "keyFrame";
+                    }>>;
+                }, z.core.$strip>>;
+                throttle: z.ZodDefault<z.ZodObject<{
+                    cooldownSec: z.ZodDefault<z.ZodNumber>;
+                    scope: z.ZodDefault<z.ZodEnum<{
+                        rule: "rule";
+                        "rule-device": "rule-device";
+                    }>>;
+                }, z.core.$strip>>;
+                template: z.ZodOptional<z.ZodObject<{
+                    title: z.ZodOptional<z.ZodString>;
+                    body: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                priority: z.ZodDefault<z.ZodNumber>;
+                id: z.ZodString;
+                createdBy: z.ZodString;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>, "mutation"> & {
+            readonly caller: "required";
+        };
+        readonly deleteRule: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            ruleId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        readonly setRuleEnabled: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            ruleId: z.ZodString;
+            enabled: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Dry-run a rule against recently persisted records (object events for
+         * `immediate`, closed tracks for `track-end`). Mutation kind only to
+         * carry the full rule object safely; no side effects.
+         */
+        readonly testRule: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            rule: z.ZodObject<{
+                name: z.ZodString;
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                delivery: z.ZodEnum<{
+                    immediate: "immediate";
+                    "track-end": "track-end";
+                }>;
+                conditions: z.ZodDefault<z.ZodObject<{
+                    devices: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                    classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    classesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    minConfidence: z.ZodOptional<z.ZodNumber>;
+                    zones: z.ZodOptional<z.ZodObject<{
+                        ids: z.ZodArray<z.ZodString>;
+                        match: z.ZodDefault<z.ZodEnum<{
+                            any: "any";
+                            all: "all";
+                        }>>;
+                    }, z.core.$strip>>;
+                    zonesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    labelEquals: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    identities: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    plates: z.ZodOptional<z.ZodObject<{
+                        values: z.ZodArray<z.ZodString>;
+                        maxDistance: z.ZodDefault<z.ZodNumber>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                schedule: z.ZodOptional<z.ZodObject<{
+                    windows: z.ZodArray<z.ZodObject<{
+                        days: z.ZodArray<z.ZodNumber>;
+                        startMinute: z.ZodNumber;
+                        endMinute: z.ZodNumber;
+                    }, z.core.$strip>>;
+                    timezone: z.ZodOptional<z.ZodString>;
+                    invert: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                targets: z.ZodArray<z.ZodObject<{
+                    targetId: z.ZodString;
+                    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>;
+                media: z.ZodDefault<z.ZodObject<{
+                    attach: z.ZodDefault<z.ZodEnum<{
+                        none: "none";
+                        best: "best";
+                        keyFrame: "keyFrame";
+                    }>>;
+                }, z.core.$strip>>;
+                throttle: z.ZodDefault<z.ZodObject<{
+                    cooldownSec: z.ZodDefault<z.ZodNumber>;
+                    scope: z.ZodDefault<z.ZodEnum<{
+                        rule: "rule";
+                        "rule-device": "rule-device";
+                    }>>;
+                }, z.core.$strip>>;
+                template: z.ZodOptional<z.ZodObject<{
+                    title: z.ZodOptional<z.ZodString>;
+                    body: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                priority: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>;
+            lookbackMinutes: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            results: z.ZodArray<z.ZodObject<{
+                recordId: z.ZodString;
+                recordKind: z.ZodEnum<{
+                    "object-event": "object-event";
+                    track: "track";
+                }>;
+                deviceId: z.ZodNumber;
+                timestamp: z.ZodNumber;
+                wouldFire: z.ZodBoolean;
+                failedCondition: z.ZodOptional<z.ZodString>;
+                className: z.ZodOptional<z.ZodString>;
+                label: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, "mutation">;
+        readonly getConditionCatalog: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+            catalog: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                group: z.ZodEnum<{
+                    label: "label";
+                    scope: "scope";
+                    class: "class";
+                    schedule: "schedule";
+                    zones: "zones";
+                    quality: "quality";
+                }>;
+                label: z.ZodString;
+                valueType: z.ZodEnum<{
+                    schedule: "schedule";
+                    deviceIdList: "deviceIdList";
+                    stringList: "stringList";
+                    number01: "number01";
+                    zoneSelection: "zoneSelection";
+                    zoneIdList: "zoneIdList";
+                    plateMatcher: "plateMatcher";
+                }>;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    notIn: "notIn";
+                    anyOf: "anyOf";
+                    allOf: "allOf";
+                    gte: "gte";
+                    fuzzyIn: "fuzzyIn";
+                    withinSchedule: "withinSchedule";
+                }>;
+                appliesTo: z.ZodArray<z.ZodEnum<{
+                    immediate: "immediate";
+                    "track-end": "track-end";
+                }>>;
+                phase: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type INotificationRulesProvider = InferProvider<typeof notificationRulesCapability>;