@camstack/types 1.2.43 → 1.2.45

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

@@ -0,0 +1,900 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * `osd-manager` — the ORCHESTRATOR over the device-scope `osd` cap.
+ *
+ * The `osd` cap is the firmware contract: it probes a camera's overlay
+ * SLOTS and writes literal text into one. It has no idea WHERE that text
+ * comes from, and it must not — a driver that grew a "show the temperature
+ * here" feature would grow it once per vendor.
+ *
+ * This cap owns the other half: a per-(camera, slot) BINDING that says
+ * which value feeds the slot, how it is formatted, and under which
+ * conditions it is shown at all. One addon renders every binding on every
+ * camera, so a new source costs zero driver code.
+ *
+ * Three deliberate choices, each with a rejected alternative:
+ *
+ *  1. A source is `(capName, valuePath)` over the kernel's device
+ *     runtime-state mirror — NOT a closed enum of source kinds. Every
+ *     cap-keyed slice a device publishes is bindable the day the cap
+ *     ships. The rejected alternative (one enum member per source, with
+ *     a resolver branch each) is what makes "add the humidity too" a
+ *     code change.
+ *  2. The display gate reuses `NcConditionsSchema` verbatim — the
+ *     notification centre's condition vocabulary — rather than a parallel
+ *     model. An operator who has learned one condition editor has learned
+ *     both.
+ *  3. Because the renderer's facts are device STATE and not a detection
+ *     record, only a SUBSET of that vocabulary can be answered here.
+ *     `setSlotBinding` REJECTS the rest at write time (see
+ *     `getConditionSupport`). It does not accept-then-fail-closed: a
+ *     condition that can never be true renders a permanently blank
+ *     overlay, and a blank overlay looks exactly like a broken camera.
+ */
+/** Where a slot's value comes from. */
+export declare const OsdSourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"static">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"clock">;
+    pattern: z.ZodDefault<z.ZodString>;
+    timezone: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"device-state">;
+    deviceId: z.ZodOptional<z.ZodNumber>;
+    capName: z.ZodString;
+    valuePath: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type OsdSource = z.infer<typeof OsdSourceSchema>;
+export declare const OsdSlotBindingSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"static">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"clock">;
+        pattern: z.ZodDefault<z.ZodString>;
+        timezone: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"device-state">;
+        deviceId: z.ZodOptional<z.ZodNumber>;
+        capName: z.ZodString;
+        valuePath: z.ZodString;
+    }, z.core.$strip>], "kind">;
+    template: z.ZodDefault<z.ZodString>;
+    maxCharacters: z.ZodOptional<z.ZodNumber>;
+    maxDecimals: z.ZodDefault<z.ZodNumber>;
+    unitLabel: z.ZodOptional<z.ZodString>;
+    valueMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    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>>;
+    conditions: z.ZodOptional<z.ZodObject<{
+        deviceState: z.ZodOptional<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            states: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        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>>;
+        crossing: z.ZodOptional<z.ZodEnum<{
+            any: "any";
+            enter: "enter";
+            exit: "exit";
+        }>>;
+        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";
+            audio: "audio";
+            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>>;
+    fallbackText: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type OsdSlotBinding = z.infer<typeof OsdSlotBindingSchema>;
+/** One camera slot, as the operator sees it: firmware truth + our binding. */
+export declare const OsdSlotViewSchema: z.ZodObject<{
+    slotId: z.ZodString;
+    kind: z.ZodEnum<{
+        timestamp: "timestamp";
+        text: "text";
+        watermark: "watermark";
+    }>;
+    readOnly: z.ZodBoolean;
+    cameraEnabled: z.ZodBoolean;
+    cameraText: z.ZodOptional<z.ZodString>;
+    binding: z.ZodNullable<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"static">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"clock">;
+            pattern: z.ZodDefault<z.ZodString>;
+            timezone: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"device-state">;
+            deviceId: z.ZodOptional<z.ZodNumber>;
+            capName: z.ZodString;
+            valuePath: z.ZodString;
+        }, z.core.$strip>], "kind">;
+        template: z.ZodDefault<z.ZodString>;
+        maxCharacters: z.ZodOptional<z.ZodNumber>;
+        maxDecimals: z.ZodDefault<z.ZodNumber>;
+        unitLabel: z.ZodOptional<z.ZodString>;
+        valueMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        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>>;
+        conditions: z.ZodOptional<z.ZodObject<{
+            deviceState: z.ZodOptional<z.ZodObject<{
+                deviceId: z.ZodNumber;
+                states: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+            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>>;
+            crossing: z.ZodOptional<z.ZodEnum<{
+                any: "any";
+                enter: "enter";
+                exit: "exit";
+            }>>;
+            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";
+                audio: "audio";
+                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>>;
+        fallbackText: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OsdSlotView = z.infer<typeof OsdSlotViewSchema>;
+/**
+ * What happened to one slot on one render pass. `unchanged` exists so the
+ * operator can tell "we are driving this and the value is steady" from
+ * "we never got there" — and so the loop can prove it is not rewriting
+ * identical text to the camera every tick.
+ */
+export declare const OsdRenderOutcomeEnum: z.ZodEnum<{
+    failed: "failed";
+    disabled: "disabled";
+    written: "written";
+    unchanged: "unchanged";
+    gated: "gated";
+    unreadable: "unreadable";
+    unbound: "unbound";
+}>;
+export type OsdRenderOutcome = z.infer<typeof OsdRenderOutcomeEnum>;
+export declare const OsdRenderResultSchema: z.ZodObject<{
+    slotId: z.ZodString;
+    outcome: z.ZodEnum<{
+        failed: "failed";
+        disabled: "disabled";
+        written: "written";
+        unchanged: "unchanged";
+        gated: "gated";
+        unreadable: "unreadable";
+        unbound: "unbound";
+    }>;
+    text: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type OsdRenderResult = z.infer<typeof OsdRenderResultSchema>;
+export declare const OsdSourceValueTypeEnum: z.ZodEnum<{
+    string: "string";
+    number: "number";
+    boolean: "boolean";
+    enum: "enum";
+}>;
+export type OsdSourceValueType = z.infer<typeof OsdSourceValueTypeEnum>;
+/**
+ * One bindable value, derived from a cap's `runtimeState` schema — never
+ * hand-listed. The editor renders from this, so a cap that ships a new
+ * state field becomes bindable with no UI change.
+ */
+export declare const OsdSourceOptionSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    deviceName: z.ZodString;
+    capName: z.ZodString;
+    valuePath: z.ZodString;
+    label: z.ZodString;
+    valueType: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        enum: "enum";
+    }>;
+    enumValues: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type OsdSourceOption = z.infer<typeof OsdSourceOptionSchema>;
+export declare const osdManagerCapability: {
+    readonly name: "osd-manager";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        /**
+         * The camera's slots, each with its binding. `supported: false` when
+         * the camera publishes no `osd` cap — the page then says so instead
+         * of rendering an empty list that reads as "no overlays configured".
+         */
+        readonly getDeviceOsd: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            supported: z.ZodBoolean;
+            slots: z.ZodArray<z.ZodObject<{
+                slotId: z.ZodString;
+                kind: z.ZodEnum<{
+                    timestamp: "timestamp";
+                    text: "text";
+                    watermark: "watermark";
+                }>;
+                readOnly: z.ZodBoolean;
+                cameraEnabled: z.ZodBoolean;
+                cameraText: z.ZodOptional<z.ZodString>;
+                binding: z.ZodNullable<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"static">;
+                        text: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"clock">;
+                        pattern: z.ZodDefault<z.ZodString>;
+                        timezone: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"device-state">;
+                        deviceId: z.ZodOptional<z.ZodNumber>;
+                        capName: z.ZodString;
+                        valuePath: z.ZodString;
+                    }, z.core.$strip>], "kind">;
+                    template: z.ZodDefault<z.ZodString>;
+                    maxCharacters: z.ZodOptional<z.ZodNumber>;
+                    maxDecimals: z.ZodDefault<z.ZodNumber>;
+                    unitLabel: z.ZodOptional<z.ZodString>;
+                    valueMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    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>>;
+                    conditions: z.ZodOptional<z.ZodObject<{
+                        deviceState: z.ZodOptional<z.ZodObject<{
+                            deviceId: z.ZodNumber;
+                            states: z.ZodArray<z.ZodString>;
+                        }, z.core.$strip>>;
+                        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>>;
+                        crossing: z.ZodOptional<z.ZodEnum<{
+                            any: "any";
+                            enter: "enter";
+                            exit: "exit";
+                        }>>;
+                        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";
+                            audio: "audio";
+                            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>>;
+                    fallbackText: z.ZodDefault<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Every value bindable on this camera: its own state leaves first,
+         * then every other device's. Derived from the cap definitions, so it
+         * cannot drift from what the resolver can actually read.
+         */
+        readonly getSourceCatalog: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            sources: z.ZodArray<z.ZodObject<{
+                deviceId: z.ZodNumber;
+                deviceName: z.ZodString;
+                capName: z.ZodString;
+                valuePath: z.ZodString;
+                label: z.ZodString;
+                valueType: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    enum: "enum";
+                }>;
+                enumValues: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * The condition ids this gate can answer, alongside the FULL notification
+         * condition catalog. Both, in one call, on purpose: an editor that showed
+         * the catalog without the supported set would offer conditions that
+         * `setSlotBinding` then rejects.
+         */
+        readonly getConditionSupport: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+            supported: z.ZodArray<z.ZodString>;
+            catalog: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                group: z.ZodEnum<{
+                    device: "device";
+                    label: "label";
+                    scope: "scope";
+                    class: "class";
+                    zones: "zones";
+                    schedule: "schedule";
+                    package: "package";
+                    occupancy: "occupancy";
+                    quality: "quality";
+                }>;
+                label: z.ZodString;
+                valueType: z.ZodEnum<{
+                    number: "number";
+                    deviceState: "deviceState";
+                    schedule: "schedule";
+                    packagePhase: "packagePhase";
+                    occupancy: "occupancy";
+                    deviceIdList: "deviceIdList";
+                    stringList: "stringList";
+                    number01: "number01";
+                    sourceSelect: "sourceSelect";
+                    zoneSelection: "zoneSelection";
+                    zoneIdList: "zoneIdList";
+                    plateMatcher: "plateMatcher";
+                    crossingSelect: "crossingSelect";
+                    polygonDraw: "polygonDraw";
+                }>;
+                operator: z.ZodEnum<{
+                    in: "in";
+                    notIn: "notIn";
+                    anyOf: "anyOf";
+                    allOf: "allOf";
+                    gte: "gte";
+                    fuzzyIn: "fuzzyIn";
+                    withinSchedule: "withinSchedule";
+                }>;
+                appliesTo: z.ZodArray<z.ZodEnum<{
+                    "device-event": "device-event";
+                    immediate: "immediate";
+                    "track-end": "track-end";
+                    "package-event": "package-event";
+                }>>;
+                phase: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                options: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    value: z.ZodString;
+                    label: z.ZodString;
+                    hint: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Persist a binding and render it immediately, returning the slot as
+         * it now stands. Throws when the binding names an unsupported
+         * condition, an unknown cap, or a value path that cap does not have.
+         */
+        readonly setSlotBinding: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            slotId: z.ZodString;
+            binding: z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"static">;
+                    text: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"clock">;
+                    pattern: z.ZodDefault<z.ZodString>;
+                    timezone: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"device-state">;
+                    deviceId: z.ZodOptional<z.ZodNumber>;
+                    capName: z.ZodString;
+                    valuePath: z.ZodString;
+                }, z.core.$strip>], "kind">;
+                template: z.ZodDefault<z.ZodString>;
+                maxCharacters: z.ZodOptional<z.ZodNumber>;
+                maxDecimals: z.ZodDefault<z.ZodNumber>;
+                unitLabel: z.ZodOptional<z.ZodString>;
+                valueMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                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>>;
+                conditions: z.ZodOptional<z.ZodObject<{
+                    deviceState: z.ZodOptional<z.ZodObject<{
+                        deviceId: z.ZodNumber;
+                        states: z.ZodArray<z.ZodString>;
+                    }, z.core.$strip>>;
+                    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>>;
+                    crossing: z.ZodOptional<z.ZodEnum<{
+                        any: "any";
+                        enter: "enter";
+                        exit: "exit";
+                    }>>;
+                    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";
+                        audio: "audio";
+                        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>>;
+                fallbackText: z.ZodDefault<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            slot: z.ZodObject<{
+                slotId: z.ZodString;
+                kind: z.ZodEnum<{
+                    timestamp: "timestamp";
+                    text: "text";
+                    watermark: "watermark";
+                }>;
+                readOnly: z.ZodBoolean;
+                cameraEnabled: z.ZodBoolean;
+                cameraText: z.ZodOptional<z.ZodString>;
+                binding: z.ZodNullable<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"static">;
+                        text: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"clock">;
+                        pattern: z.ZodDefault<z.ZodString>;
+                        timezone: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"device-state">;
+                        deviceId: z.ZodOptional<z.ZodNumber>;
+                        capName: z.ZodString;
+                        valuePath: z.ZodString;
+                    }, z.core.$strip>], "kind">;
+                    template: z.ZodDefault<z.ZodString>;
+                    maxCharacters: z.ZodOptional<z.ZodNumber>;
+                    maxDecimals: z.ZodDefault<z.ZodNumber>;
+                    unitLabel: z.ZodOptional<z.ZodString>;
+                    valueMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    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>>;
+                    conditions: z.ZodOptional<z.ZodObject<{
+                        deviceState: z.ZodOptional<z.ZodObject<{
+                            deviceId: z.ZodNumber;
+                            states: z.ZodArray<z.ZodString>;
+                        }, z.core.$strip>>;
+                        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>>;
+                        crossing: z.ZodOptional<z.ZodEnum<{
+                            any: "any";
+                            enter: "enter";
+                            exit: "exit";
+                        }>>;
+                        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";
+                            audio: "audio";
+                            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>>;
+                    fallbackText: z.ZodDefault<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            render: z.ZodObject<{
+                slotId: z.ZodString;
+                outcome: z.ZodEnum<{
+                    failed: "failed";
+                    disabled: "disabled";
+                    written: "written";
+                    unchanged: "unchanged";
+                    gated: "gated";
+                    unreadable: "unreadable";
+                    unbound: "unbound";
+                }>;
+                text: z.ZodString;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, "mutation">;
+        /** Forget the binding. The slot keeps whatever text it last carried. */
+        readonly clearSlotBinding: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            slotId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Render without writing. `binding` overrides the stored one so an
+         * editor can preview an unsaved change. Mutation kind only to carry
+         * the binding object safely; no side effects.
+         */
+        readonly previewSlot: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            slotId: z.ZodString;
+            binding: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"static">;
+                    text: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"clock">;
+                    pattern: z.ZodDefault<z.ZodString>;
+                    timezone: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"device-state">;
+                    deviceId: z.ZodOptional<z.ZodNumber>;
+                    capName: z.ZodString;
+                    valuePath: z.ZodString;
+                }, z.core.$strip>], "kind">;
+                template: z.ZodDefault<z.ZodString>;
+                maxCharacters: z.ZodOptional<z.ZodNumber>;
+                maxDecimals: z.ZodDefault<z.ZodNumber>;
+                unitLabel: z.ZodOptional<z.ZodString>;
+                valueMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                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>>;
+                conditions: z.ZodOptional<z.ZodObject<{
+                    deviceState: z.ZodOptional<z.ZodObject<{
+                        deviceId: z.ZodNumber;
+                        states: z.ZodArray<z.ZodString>;
+                    }, z.core.$strip>>;
+                    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>>;
+                    crossing: z.ZodOptional<z.ZodEnum<{
+                        any: "any";
+                        enter: "enter";
+                        exit: "exit";
+                    }>>;
+                    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";
+                        audio: "audio";
+                        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>>;
+                fallbackText: z.ZodDefault<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            slotId: z.ZodString;
+            outcome: z.ZodEnum<{
+                failed: "failed";
+                disabled: "disabled";
+                written: "written";
+                unchanged: "unchanged";
+                gated: "gated";
+                unreadable: "unreadable";
+                unbound: "unbound";
+            }>;
+            text: z.ZodString;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, "mutation">;
+        /** Force a render pass over one camera now, instead of at the next tick. */
+        readonly renderDevice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            results: z.ZodArray<z.ZodObject<{
+                slotId: z.ZodString;
+                outcome: z.ZodEnum<{
+                    failed: "failed";
+                    disabled: "disabled";
+                    written: "written";
+                    unchanged: "unchanged";
+                    gated: "gated";
+                    unreadable: "unreadable";
+                    unbound: "unbound";
+                }>;
+                text: z.ZodString;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, "mutation">;
+    };
+};
+export type IOsdManagerProvider = InferProvider<typeof osdManagerCapability>;