@camstack/types 1.2.7 → 1.2.9

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

@@ -0,0 +1,1601 @@
+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 trigger/urgency of a rule — which persistence moment evaluates it.
+ * The value maps 1:1 onto the evaluated record kind:
+ *  - `immediate`     ↔ object-event persist (lowest-latency detection burst)
+ *  - `track-end`     ↔ TrackCloser.closeExpired (finalized track record)
+ *  - `device-event`  ↔ SensorEventStore insert (doorbell press / sensor state
+ *                       change of a LINKED device, one row per linked camera)
+ *  - `package-event` ↔ PackageDropDetector object-event insert (a `package`
+ *                       delivery / pick-up)
+ *
+ * `immediate`/`track-end` carry the D-3 urgency semantics; `device-event`/
+ * `package-event` are pure trigger kinds (no urgency dimension). Extending
+ * this one field keeps the schema additive — a rule still declares exactly
+ * one trigger.
+ */
+export declare const NcDeliverySchema: z.ZodEnum<{
+    immediate: "immediate";
+    "track-end": "track-end";
+    "device-event": "device-event";
+    "package-event": "package-event";
+}>;
+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>;
+/**
+ * Occupancy condition (DEVICE-EVENT trigger). Fires on a ZoneAnalytics
+ * occupancy edge for a device — optionally narrowed to a single admin
+ * `zoneId` and/or object `className`. `op` selects the edge/threshold:
+ *  - `became-occupied` (default) — count crossed 0 → ≥ `count`
+ *  - `became-free`               — count crossed ≥ `count` → below it
+ *  - `>=` / `<=`                 — count is at/over or at/under `count`
+ * `sustainSeconds` requires the condition hold continuously that long
+ * before firing (debounces flicker; 0 = fire on the first matching edge).
+ * Fail-closed: no ZoneAnalytics snapshot / missing zone / null snapshot ⇒
+ * the condition never matches. Confirmed edge-state survives addon restarts
+ * (declared SQLite collection, reseeded on boot).
+ */
+export declare const NcOccupancyConditionSchema: z.ZodObject<{
+    zoneId: z.ZodOptional<z.ZodString>;
+    className: z.ZodOptional<z.ZodString>;
+    op: z.ZodDefault<z.ZodEnum<{
+        "<=": "<=";
+        ">=": ">=";
+        "became-occupied": "became-occupied";
+        "became-free": "became-free";
+    }>>;
+    count: z.ZodDefault<z.ZodNumber>;
+    sustainSeconds: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type NcOccupancyCondition = z.infer<typeof NcOccupancyConditionSchema>;
+/** 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>>;
+    identitiesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    minImportance: z.ZodOptional<z.ZodNumber>;
+    minDwellSeconds: z.ZodOptional<z.ZodNumber>;
+    source: z.ZodOptional<z.ZodEnum<{
+        sensor: "sensor";
+        any: "any";
+        pipeline: "pipeline";
+        onboard: "onboard";
+    }>>;
+    minLabelConfidence: z.ZodOptional<z.ZodNumber>;
+    eventTypeTokens: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sensorKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    packagePhase: z.ZodOptional<z.ZodEnum<{
+        both: "both";
+        delivered: "delivered";
+        "picked-up": "picked-up";
+    }>>;
+    customZones: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodLiteral<"polygon">;
+        points: z.ZodArray<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    occupancy: z.ZodOptional<z.ZodObject<{
+        zoneId: z.ZodOptional<z.ZodString>;
+        className: z.ZodOptional<z.ZodString>;
+        op: z.ZodDefault<z.ZodEnum<{
+            "<=": "<=";
+            ">=": ">=";
+            "became-occupied": "became-occupied";
+            "became-free": "became-free";
+        }>>;
+        count: z.ZodDefault<z.ZodNumber>;
+        sustainSeconds: 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 subject image at dispatch time (D-3).
+ *  - `best-matching` — the media that explains WHY the rule fired: a rule
+ *    matched on identities attaches the subject's `faceCrop`, one matched on
+ *    plates attaches the `plateCrop`; a rule with no identity/plate condition
+ *    (or when the specific crop is missing) degrades to `best`, then
+ *    `keyFrame`, then no attachment — never delaying the send. The matched
+ *    condition summary is frozen on the outbox row at enqueue (like the rule
+ *    name), so the choice never drifts from the record that fired it.
+ *  - `keyFrame` — the clean scene frame (no subject box).
+ *  - `none` — no attachment.
+ */
+export declare const NcMediaPolicySchema: z.ZodObject<{
+    attach: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        best: "best";
+        "best-matching": "best-matching";
+        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";
+        "device-event": "device-event";
+        "package-event": "package-event";
+    }>;
+    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>>;
+        identitiesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        minImportance: z.ZodOptional<z.ZodNumber>;
+        minDwellSeconds: z.ZodOptional<z.ZodNumber>;
+        source: z.ZodOptional<z.ZodEnum<{
+            sensor: "sensor";
+            any: "any";
+            pipeline: "pipeline";
+            onboard: "onboard";
+        }>>;
+        minLabelConfidence: z.ZodOptional<z.ZodNumber>;
+        eventTypeTokens: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        sensorKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        packagePhase: z.ZodOptional<z.ZodEnum<{
+            both: "both";
+            delivered: "delivered";
+            "picked-up": "picked-up";
+        }>>;
+        customZones: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodLiteral<"polygon">;
+            points: z.ZodArray<z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        occupancy: z.ZodOptional<z.ZodObject<{
+            zoneId: z.ZodOptional<z.ZodString>;
+            className: z.ZodOptional<z.ZodString>;
+            op: z.ZodDefault<z.ZodEnum<{
+                "<=": "<=";
+                ">=": ">=";
+                "became-occupied": "became-occupied";
+                "became-free": "became-free";
+            }>>;
+            count: z.ZodDefault<z.ZodNumber>;
+            sustainSeconds: 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";
+            "best-matching": "best-matching";
+            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>;
+    ownerUserId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type NcRuleInput = z.infer<typeof NcRuleInputSchema>;
+/**
+ * Partial patch for `updateRule` — any subset of the input fields, plus the
+ * persisted-only {@link NcRuleSchema} `disabledTargetIds` set. The latter is
+ * NOT a client-authored input field (it lives on the persisted rule, not the
+ * input), so it is added here explicitly to let the store's per-target opt-out
+ * toggle round-trip through the shared `update` path. Viewer opt-out mutations
+ * still flow through `nc.setRuleTargetEnabled` (owner-checked), never a raw
+ * `updateRule` patch.
+ */
+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";
+        "device-event": "device-event";
+        "package-event": "package-event";
+    }>>;
+    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>>;
+        identitiesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        minImportance: z.ZodOptional<z.ZodNumber>;
+        minDwellSeconds: z.ZodOptional<z.ZodNumber>;
+        source: z.ZodOptional<z.ZodEnum<{
+            sensor: "sensor";
+            any: "any";
+            pipeline: "pipeline";
+            onboard: "onboard";
+        }>>;
+        minLabelConfidence: z.ZodOptional<z.ZodNumber>;
+        eventTypeTokens: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        sensorKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        packagePhase: z.ZodOptional<z.ZodEnum<{
+            both: "both";
+            delivered: "delivered";
+            "picked-up": "picked-up";
+        }>>;
+        customZones: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodLiteral<"polygon">;
+            points: z.ZodArray<z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        occupancy: z.ZodOptional<z.ZodObject<{
+            zoneId: z.ZodOptional<z.ZodString>;
+            className: z.ZodOptional<z.ZodString>;
+            op: z.ZodDefault<z.ZodEnum<{
+                "<=": "<=";
+                ">=": ">=";
+                "became-occupied": "became-occupied";
+                "became-free": "became-free";
+            }>>;
+            count: z.ZodDefault<z.ZodNumber>;
+            sustainSeconds: 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";
+            "best-matching": "best-matching";
+            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>>;
+    ownerUserId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    disabledTargetIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, 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";
+        "device-event": "device-event";
+        "package-event": "package-event";
+    }>;
+    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>>;
+        identitiesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        minImportance: z.ZodOptional<z.ZodNumber>;
+        minDwellSeconds: z.ZodOptional<z.ZodNumber>;
+        source: z.ZodOptional<z.ZodEnum<{
+            sensor: "sensor";
+            any: "any";
+            pipeline: "pipeline";
+            onboard: "onboard";
+        }>>;
+        minLabelConfidence: z.ZodOptional<z.ZodNumber>;
+        eventTypeTokens: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        sensorKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        packagePhase: z.ZodOptional<z.ZodEnum<{
+            both: "both";
+            delivered: "delivered";
+            "picked-up": "picked-up";
+        }>>;
+        customZones: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodLiteral<"polygon">;
+            points: z.ZodArray<z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        occupancy: z.ZodOptional<z.ZodObject<{
+            zoneId: z.ZodOptional<z.ZodString>;
+            className: z.ZodOptional<z.ZodString>;
+            op: z.ZodDefault<z.ZodEnum<{
+                "<=": "<=";
+                ">=": ">=";
+                "became-occupied": "became-occupied";
+                "became-free": "became-free";
+            }>>;
+            count: z.ZodDefault<z.ZodNumber>;
+            sustainSeconds: 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";
+            "best-matching": "best-matching";
+            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>;
+    ownerUserId: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    createdBy: z.ZodString;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    disabledTargetIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type NcRule = z.infer<typeof NcRuleSchema>;
+export declare const NcTestResultSchema: z.ZodObject<{
+    recordId: z.ZodString;
+    recordKind: z.ZodEnum<{
+        "device-event": "device-event";
+        "package-event": "package-event";
+        "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<{
+        device: "device";
+        label: "label";
+        scope: "scope";
+        class: "class";
+        schedule: "schedule";
+        zones: "zones";
+        package: "package";
+        occupancy: "occupancy";
+        quality: "quality";
+    }>;
+    label: z.ZodString;
+    valueType: z.ZodEnum<{
+        number: "number";
+        schedule: "schedule";
+        packagePhase: "packagePhase";
+        occupancy: "occupancy";
+        deviceIdList: "deviceIdList";
+        stringList: "stringList";
+        number01: "number01";
+        sourceSelect: "sourceSelect";
+        zoneSelection: "zoneSelection";
+        zoneIdList: "zoneIdList";
+        plateMatcher: "plateMatcher";
+        polygonDraw: "polygonDraw";
+    }>;
+    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";
+        "device-event": "device-event";
+        "package-event": "package-event";
+    }>>;
+    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[];
+/**
+ * The delivery lifecycle status of a history row — a straight read of the
+ * durable outbox row's own status (single source of truth):
+ *  - `pending` — enqueued, in-flight or retrying with backoff
+ *  - `sent`    — delivered (terminal)
+ *  - `dead`    — dead-lettered after exhausting retries / a permanent
+ *                backend rejection / a deleted target (terminal; carries
+ *                the failure `error`)
+ *
+ * P1 has no `suppressed-quiet-hours` / `snoozed` states — those ride the P2
+ * user dimension (quiet hours / snooze) and are additive when they land.
+ */
+export declare const NcHistoryStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    sent: "sent";
+    dead: "dead";
+}>;
+export type NcHistoryStatus = z.infer<typeof NcHistoryStatusSchema>;
+/** The evaluated record kind a history row descends from (one per trigger). */
+export declare const NcHistoryRecordKindSchema: z.ZodEnum<{
+    "track-end": "track-end";
+    "device-event": "device-event";
+    "package-event": "package-event";
+    "object-event": "object-event";
+}>;
+export type NcHistoryRecordKind = z.infer<typeof NcHistoryRecordKindSchema>;
+/** Subject summary frozen on the row at fire time (survives rule/record edits). */
+export declare const NcHistorySubjectSchema: z.ZodObject<{
+    className: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    zones: z.ZodArray<z.ZodString>;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export type NcHistorySubject = z.infer<typeof NcHistorySubjectSchema>;
+/**
+ * One delivery-history row. This is a read-only VIEW over the durable
+ * outbox row (single source of truth — the same row the drain loop drives;
+ * NO second write path, so history can never drift from delivery state).
+ * The §3.2 fields map directly: `ruleId`/`targetId`/`deviceId` are columns,
+ * `eventRef` is `recordKind`+`recordId`, `timestamps` are `createdAt`
+ * (fire) / `updatedAt` (last transition), `status` + `error` are the
+ * lifecycle. `ruleName` + `subject` are the intent snapshot frozen at
+ * enqueue. `userId?` (per-recipient history) is P2 — no user dimension in
+ * P1 (admin scope only).
+ */
+export declare const NcHistoryEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    ruleId: z.ZodString;
+    ruleName: z.ZodString;
+    delivery: z.ZodEnum<{
+        immediate: "immediate";
+        "track-end": "track-end";
+        "device-event": "device-event";
+        "package-event": "package-event";
+    }>;
+    targetId: z.ZodString;
+    deviceId: z.ZodNumber;
+    recordKind: z.ZodEnum<{
+        "track-end": "track-end";
+        "device-event": "device-event";
+        "package-event": "package-event";
+        "object-event": "object-event";
+    }>;
+    recordId: z.ZodString;
+    trackId: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        sent: "sent";
+        dead: "dead";
+    }>;
+    attempts: z.ZodNumber;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    error: z.ZodOptional<z.ZodString>;
+    subject: z.ZodObject<{
+        className: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        zones: z.ZodArray<z.ZodString>;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type NcHistoryEntry = z.infer<typeof NcHistoryEntrySchema>;
+/** `getHistory` default page size + hard ceiling (bounded output). */
+export declare const NC_HISTORY_LIMIT_DEFAULT = 100;
+export declare const NC_HISTORY_LIMIT_MAX = 500;
+/**
+ * Query filter for `getHistory` (spec §4.2). Every field is a narrowing
+ * AND; absent = unbounded on that axis. `since`/`until` bound the fire time
+ * (`createdAt`, epoch ms, inclusive). `limit` is clamped to
+ * {@link NC_HISTORY_LIMIT_MAX}. `userId` (per-recipient filtering) is P2.
+ */
+export declare const NcHistoryFilterSchema: z.ZodObject<{
+    ruleId: z.ZodOptional<z.ZodString>;
+    deviceId: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodOptional<z.ZodEnum<{
+        pending: "pending";
+        sent: "sent";
+        dead: "dead";
+    }>>;
+    since: z.ZodOptional<z.ZodNumber>;
+    until: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type NcHistoryFilter = z.infer<typeof NcHistoryFilterSchema>;
+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";
+                    "device-event": "device-event";
+                    "package-event": "package-event";
+                }>;
+                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>>;
+                    identitiesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    minImportance: z.ZodOptional<z.ZodNumber>;
+                    minDwellSeconds: z.ZodOptional<z.ZodNumber>;
+                    source: z.ZodOptional<z.ZodEnum<{
+                        sensor: "sensor";
+                        any: "any";
+                        pipeline: "pipeline";
+                        onboard: "onboard";
+                    }>>;
+                    minLabelConfidence: z.ZodOptional<z.ZodNumber>;
+                    eventTypeTokens: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    sensorKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    packagePhase: z.ZodOptional<z.ZodEnum<{
+                        both: "both";
+                        delivered: "delivered";
+                        "picked-up": "picked-up";
+                    }>>;
+                    customZones: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        kind: z.ZodLiteral<"polygon">;
+                        points: z.ZodArray<z.ZodObject<{
+                            x: z.ZodNumber;
+                            y: z.ZodNumber;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>>;
+                    occupancy: z.ZodOptional<z.ZodObject<{
+                        zoneId: z.ZodOptional<z.ZodString>;
+                        className: z.ZodOptional<z.ZodString>;
+                        op: z.ZodDefault<z.ZodEnum<{
+                            "<=": "<=";
+                            ">=": ">=";
+                            "became-occupied": "became-occupied";
+                            "became-free": "became-free";
+                        }>>;
+                        count: z.ZodDefault<z.ZodNumber>;
+                        sustainSeconds: 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";
+                        "best-matching": "best-matching";
+                        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>;
+                ownerUserId: z.ZodOptional<z.ZodString>;
+                id: z.ZodString;
+                createdBy: z.ZodString;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+                disabledTargetIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, 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";
+                    "device-event": "device-event";
+                    "package-event": "package-event";
+                }>;
+                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>>;
+                    identitiesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    minImportance: z.ZodOptional<z.ZodNumber>;
+                    minDwellSeconds: z.ZodOptional<z.ZodNumber>;
+                    source: z.ZodOptional<z.ZodEnum<{
+                        sensor: "sensor";
+                        any: "any";
+                        pipeline: "pipeline";
+                        onboard: "onboard";
+                    }>>;
+                    minLabelConfidence: z.ZodOptional<z.ZodNumber>;
+                    eventTypeTokens: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    sensorKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    packagePhase: z.ZodOptional<z.ZodEnum<{
+                        both: "both";
+                        delivered: "delivered";
+                        "picked-up": "picked-up";
+                    }>>;
+                    customZones: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        kind: z.ZodLiteral<"polygon">;
+                        points: z.ZodArray<z.ZodObject<{
+                            x: z.ZodNumber;
+                            y: z.ZodNumber;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>>;
+                    occupancy: z.ZodOptional<z.ZodObject<{
+                        zoneId: z.ZodOptional<z.ZodString>;
+                        className: z.ZodOptional<z.ZodString>;
+                        op: z.ZodDefault<z.ZodEnum<{
+                            "<=": "<=";
+                            ">=": ">=";
+                            "became-occupied": "became-occupied";
+                            "became-free": "became-free";
+                        }>>;
+                        count: z.ZodDefault<z.ZodNumber>;
+                        sustainSeconds: 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";
+                        "best-matching": "best-matching";
+                        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>;
+                ownerUserId: z.ZodOptional<z.ZodString>;
+                id: z.ZodString;
+                createdBy: z.ZodString;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+                disabledTargetIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, 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";
+                    "device-event": "device-event";
+                    "package-event": "package-event";
+                }>;
+                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>>;
+                    identitiesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    minImportance: z.ZodOptional<z.ZodNumber>;
+                    minDwellSeconds: z.ZodOptional<z.ZodNumber>;
+                    source: z.ZodOptional<z.ZodEnum<{
+                        sensor: "sensor";
+                        any: "any";
+                        pipeline: "pipeline";
+                        onboard: "onboard";
+                    }>>;
+                    minLabelConfidence: z.ZodOptional<z.ZodNumber>;
+                    eventTypeTokens: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    sensorKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    packagePhase: z.ZodOptional<z.ZodEnum<{
+                        both: "both";
+                        delivered: "delivered";
+                        "picked-up": "picked-up";
+                    }>>;
+                    customZones: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        kind: z.ZodLiteral<"polygon">;
+                        points: z.ZodArray<z.ZodObject<{
+                            x: z.ZodNumber;
+                            y: z.ZodNumber;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>>;
+                    occupancy: z.ZodOptional<z.ZodObject<{
+                        zoneId: z.ZodOptional<z.ZodString>;
+                        className: z.ZodOptional<z.ZodString>;
+                        op: z.ZodDefault<z.ZodEnum<{
+                            "<=": "<=";
+                            ">=": ">=";
+                            "became-occupied": "became-occupied";
+                            "became-free": "became-free";
+                        }>>;
+                        count: z.ZodDefault<z.ZodNumber>;
+                        sustainSeconds: 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";
+                        "best-matching": "best-matching";
+                        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>;
+                ownerUserId: z.ZodOptional<z.ZodString>;
+            }, 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";
+                    "device-event": "device-event";
+                    "package-event": "package-event";
+                }>;
+                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>>;
+                    identitiesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    minImportance: z.ZodOptional<z.ZodNumber>;
+                    minDwellSeconds: z.ZodOptional<z.ZodNumber>;
+                    source: z.ZodOptional<z.ZodEnum<{
+                        sensor: "sensor";
+                        any: "any";
+                        pipeline: "pipeline";
+                        onboard: "onboard";
+                    }>>;
+                    minLabelConfidence: z.ZodOptional<z.ZodNumber>;
+                    eventTypeTokens: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    sensorKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    packagePhase: z.ZodOptional<z.ZodEnum<{
+                        both: "both";
+                        delivered: "delivered";
+                        "picked-up": "picked-up";
+                    }>>;
+                    customZones: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        kind: z.ZodLiteral<"polygon">;
+                        points: z.ZodArray<z.ZodObject<{
+                            x: z.ZodNumber;
+                            y: z.ZodNumber;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>>;
+                    occupancy: z.ZodOptional<z.ZodObject<{
+                        zoneId: z.ZodOptional<z.ZodString>;
+                        className: z.ZodOptional<z.ZodString>;
+                        op: z.ZodDefault<z.ZodEnum<{
+                            "<=": "<=";
+                            ">=": ">=";
+                            "became-occupied": "became-occupied";
+                            "became-free": "became-free";
+                        }>>;
+                        count: z.ZodDefault<z.ZodNumber>;
+                        sustainSeconds: 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";
+                        "best-matching": "best-matching";
+                        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>;
+                ownerUserId: z.ZodOptional<z.ZodString>;
+                id: z.ZodString;
+                createdBy: z.ZodString;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+                disabledTargetIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, 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";
+                    "device-event": "device-event";
+                    "package-event": "package-event";
+                }>>;
+                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>>;
+                    identitiesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    minImportance: z.ZodOptional<z.ZodNumber>;
+                    minDwellSeconds: z.ZodOptional<z.ZodNumber>;
+                    source: z.ZodOptional<z.ZodEnum<{
+                        sensor: "sensor";
+                        any: "any";
+                        pipeline: "pipeline";
+                        onboard: "onboard";
+                    }>>;
+                    minLabelConfidence: z.ZodOptional<z.ZodNumber>;
+                    eventTypeTokens: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    sensorKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    packagePhase: z.ZodOptional<z.ZodEnum<{
+                        both: "both";
+                        delivered: "delivered";
+                        "picked-up": "picked-up";
+                    }>>;
+                    customZones: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        kind: z.ZodLiteral<"polygon">;
+                        points: z.ZodArray<z.ZodObject<{
+                            x: z.ZodNumber;
+                            y: z.ZodNumber;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>>;
+                    occupancy: z.ZodOptional<z.ZodObject<{
+                        zoneId: z.ZodOptional<z.ZodString>;
+                        className: z.ZodOptional<z.ZodString>;
+                        op: z.ZodDefault<z.ZodEnum<{
+                            "<=": "<=";
+                            ">=": ">=";
+                            "became-occupied": "became-occupied";
+                            "became-free": "became-free";
+                        }>>;
+                        count: z.ZodDefault<z.ZodNumber>;
+                        sustainSeconds: 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";
+                        "best-matching": "best-matching";
+                        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>>;
+                ownerUserId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+                disabledTargetIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, 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";
+                    "device-event": "device-event";
+                    "package-event": "package-event";
+                }>;
+                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>>;
+                    identitiesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    minImportance: z.ZodOptional<z.ZodNumber>;
+                    minDwellSeconds: z.ZodOptional<z.ZodNumber>;
+                    source: z.ZodOptional<z.ZodEnum<{
+                        sensor: "sensor";
+                        any: "any";
+                        pipeline: "pipeline";
+                        onboard: "onboard";
+                    }>>;
+                    minLabelConfidence: z.ZodOptional<z.ZodNumber>;
+                    eventTypeTokens: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    sensorKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    packagePhase: z.ZodOptional<z.ZodEnum<{
+                        both: "both";
+                        delivered: "delivered";
+                        "picked-up": "picked-up";
+                    }>>;
+                    customZones: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        kind: z.ZodLiteral<"polygon">;
+                        points: z.ZodArray<z.ZodObject<{
+                            x: z.ZodNumber;
+                            y: z.ZodNumber;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>>;
+                    occupancy: z.ZodOptional<z.ZodObject<{
+                        zoneId: z.ZodOptional<z.ZodString>;
+                        className: z.ZodOptional<z.ZodString>;
+                        op: z.ZodDefault<z.ZodEnum<{
+                            "<=": "<=";
+                            ">=": ">=";
+                            "became-occupied": "became-occupied";
+                            "became-free": "became-free";
+                        }>>;
+                        count: z.ZodDefault<z.ZodNumber>;
+                        sustainSeconds: 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";
+                        "best-matching": "best-matching";
+                        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>;
+                ownerUserId: z.ZodOptional<z.ZodString>;
+                id: z.ZodString;
+                createdBy: z.ZodString;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+                disabledTargetIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, 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";
+                    "device-event": "device-event";
+                    "package-event": "package-event";
+                }>;
+                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>>;
+                    identitiesExclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    minImportance: z.ZodOptional<z.ZodNumber>;
+                    minDwellSeconds: z.ZodOptional<z.ZodNumber>;
+                    source: z.ZodOptional<z.ZodEnum<{
+                        sensor: "sensor";
+                        any: "any";
+                        pipeline: "pipeline";
+                        onboard: "onboard";
+                    }>>;
+                    minLabelConfidence: z.ZodOptional<z.ZodNumber>;
+                    eventTypeTokens: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    sensorKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    packagePhase: z.ZodOptional<z.ZodEnum<{
+                        both: "both";
+                        delivered: "delivered";
+                        "picked-up": "picked-up";
+                    }>>;
+                    customZones: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        kind: z.ZodLiteral<"polygon">;
+                        points: z.ZodArray<z.ZodObject<{
+                            x: z.ZodNumber;
+                            y: z.ZodNumber;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>>>;
+                    occupancy: z.ZodOptional<z.ZodObject<{
+                        zoneId: z.ZodOptional<z.ZodString>;
+                        className: z.ZodOptional<z.ZodString>;
+                        op: z.ZodDefault<z.ZodEnum<{
+                            "<=": "<=";
+                            ">=": ">=";
+                            "became-occupied": "became-occupied";
+                            "became-free": "became-free";
+                        }>>;
+                        count: z.ZodDefault<z.ZodNumber>;
+                        sustainSeconds: 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";
+                        "best-matching": "best-matching";
+                        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>;
+                ownerUserId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            lookbackMinutes: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            results: z.ZodArray<z.ZodObject<{
+                recordId: z.ZodString;
+                recordKind: z.ZodEnum<{
+                    "device-event": "device-event";
+                    "package-event": "package-event";
+                    "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<{
+                    device: "device";
+                    label: "label";
+                    scope: "scope";
+                    class: "class";
+                    schedule: "schedule";
+                    zones: "zones";
+                    package: "package";
+                    occupancy: "occupancy";
+                    quality: "quality";
+                }>;
+                label: z.ZodString;
+                valueType: z.ZodEnum<{
+                    number: "number";
+                    schedule: "schedule";
+                    packagePhase: "packagePhase";
+                    occupancy: "occupancy";
+                    deviceIdList: "deviceIdList";
+                    stringList: "stringList";
+                    number01: "number01";
+                    sourceSelect: "sourceSelect";
+                    zoneSelection: "zoneSelection";
+                    zoneIdList: "zoneIdList";
+                    plateMatcher: "plateMatcher";
+                    polygonDraw: "polygonDraw";
+                }>;
+                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";
+                    "device-event": "device-event";
+                    "package-event": "package-event";
+                }>>;
+                phase: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Queryable delivery history — a read-only view over the durable outbox
+         * (fired rule, subject summary, target, status, timestamps, error on a
+         * dead row). Newest-first, bounded by `filter.limit`. Retention follows
+         * the outbox's own terminal-row prune horizon (no separate history
+         * horizon — single collection, single source of truth). Admin-only in
+         * P1 (no user dimension); the P2 viewer History screen adds per-caller
+         * scoping on the same method.
+         */
+        readonly getHistory: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            filter: z.ZodDefault<z.ZodObject<{
+                ruleId: z.ZodOptional<z.ZodString>;
+                deviceId: z.ZodOptional<z.ZodNumber>;
+                status: z.ZodOptional<z.ZodEnum<{
+                    pending: "pending";
+                    sent: "sent";
+                    dead: "dead";
+                }>>;
+                since: z.ZodOptional<z.ZodNumber>;
+                until: z.ZodOptional<z.ZodNumber>;
+                limit: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            entries: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                ruleId: z.ZodString;
+                ruleName: z.ZodString;
+                delivery: z.ZodEnum<{
+                    immediate: "immediate";
+                    "track-end": "track-end";
+                    "device-event": "device-event";
+                    "package-event": "package-event";
+                }>;
+                targetId: z.ZodString;
+                deviceId: z.ZodNumber;
+                recordKind: z.ZodEnum<{
+                    "track-end": "track-end";
+                    "device-event": "device-event";
+                    "package-event": "package-event";
+                    "object-event": "object-event";
+                }>;
+                recordId: z.ZodString;
+                trackId: z.ZodOptional<z.ZodString>;
+                status: z.ZodEnum<{
+                    pending: "pending";
+                    sent: "sent";
+                    dead: "dead";
+                }>;
+                attempts: z.ZodNumber;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+                error: z.ZodOptional<z.ZodString>;
+                subject: z.ZodObject<{
+                    className: z.ZodString;
+                    label: z.ZodOptional<z.ZodString>;
+                    confidence: z.ZodOptional<z.ZodNumber>;
+                    zones: z.ZodArray<z.ZodString>;
+                    timestamp: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type INotificationRulesProvider = InferProvider<typeof notificationRulesCapability>;