@camstack/types 0.1.14 → 0.1.16

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

@@ -0,0 +1,793 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+declare const CameraPipelineConfigSchema: z.ZodObject<{
+    engine: z.ZodObject<{
+        runtime: z.ZodEnum<{
+            node: "node";
+            python: "python";
+        }>;
+        backend: z.ZodString;
+        format: z.ZodEnum<{
+            onnx: "onnx";
+            coreml: "coreml";
+            openvino: "openvino";
+            tflite: "tflite";
+            pt: "pt";
+        }>;
+        device: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    steps: z.ZodReadonly<z.ZodArray<z.ZodType<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown, z.core.$ZodTypeInternals<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown>>>>;
+    audio: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        engine: z.ZodObject<{
+            runtime: z.ZodEnum<{
+                node: "node";
+                python: "python";
+            }>;
+            backend: z.ZodString;
+            format: z.ZodEnum<{
+                onnx: "onnx";
+                coreml: "coreml";
+                openvino: "openvino";
+                tflite: "tflite";
+                pt: "pt";
+            }>;
+            device: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        modelId: z.ZodString;
+        enabled: z.ZodBoolean;
+        settings: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const PipelineTemplateSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    config: z.ZodObject<{
+        engine: z.ZodObject<{
+            runtime: z.ZodEnum<{
+                node: "node";
+                python: "python";
+            }>;
+            backend: z.ZodString;
+            format: z.ZodEnum<{
+                onnx: "onnx";
+                coreml: "coreml";
+                openvino: "openvino";
+                tflite: "tflite";
+                pt: "pt";
+            }>;
+            device: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        steps: z.ZodReadonly<z.ZodArray<z.ZodType<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown, z.core.$ZodTypeInternals<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown>>>>;
+        audio: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            engine: z.ZodObject<{
+                runtime: z.ZodEnum<{
+                    node: "node";
+                    python: "python";
+                }>;
+                backend: z.ZodString;
+                format: z.ZodEnum<{
+                    onnx: "onnx";
+                    coreml: "coreml";
+                    openvino: "openvino";
+                    tflite: "tflite";
+                    pt: "pt";
+                }>;
+                device: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            modelId: z.ZodString;
+            enabled: z.ZodBoolean;
+            settings: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+declare const CameraStepOverridePatchSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    modelId: z.ZodOptional<z.ZodString>;
+    settings: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+/**
+ * Pipeline placement record persisted by `addon-pipeline-orchestrator` via
+ * the multi-level settings store. The orchestrator looks up these records
+ * on every `DeviceStreamsRegistered` event to decide whether the camera
+ * has a manual pipeline node pin (L1 affinity) or whether the load
+ * balancer (L2 capacity / L3 hardware-aware) needs to pick one.
+ *
+ * Naming convention: `{Pipeline,Decoder}AssignmentSchema` — one schema per
+ * placement domain managed by the orchestrator.
+ */
+declare const PipelineAssignmentSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    agentNodeId: z.ZodString;
+    pinned: z.ZodBoolean;
+    reason: z.ZodEnum<{
+        rebalance: "rebalance";
+        manual: "manual";
+        capacity: "capacity";
+        "hardware-affinity": "hardware-affinity";
+        failover: "failover";
+    }>;
+    assignedAt: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Decoder placement record. Symmetric to `PipelineAssignmentSchema` but for
+ * the decoder-node placement domain (`balanceDecoder` decision: manual pin
+ * → co-located with pipeline → capacity).
+ */
+declare const DecoderAssignmentSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    decoderNodeId: z.ZodString;
+    pinned: z.ZodBoolean;
+    reason: z.ZodEnum<{
+        manual: "manual";
+        capacity: "capacity";
+        "hardware-affinity": "hardware-affinity";
+        "co-located": "co-located";
+    }>;
+}, z.core.$strip>;
+/**
+ * Per-agent load summary surfaced to the load balancer + dashboards.
+ * Aggregated from each runner's `getLocalLoad` cap call.
+ */
+declare const AgentLoadSummarySchema: z.ZodObject<{
+    nodeId: z.ZodString;
+    online: z.ZodBoolean;
+    load: z.ZodObject<{
+        nodeId: z.ZodString;
+        attachedCameras: z.ZodNumber;
+        activeCameras: z.ZodNumber;
+        avgInferenceFps: z.ZodNumber;
+        avgInferenceTimeMs: z.ZodNumber;
+        queueDepthTotal: z.ZodNumber;
+        hardware: z.ZodObject<{
+            hasGpu: z.ZodBoolean;
+            inferenceBackend: z.ZodOptional<z.ZodString>;
+            cpuCores: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    score: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Aggregate metrics across the whole detection cluster. Replaces the legacy
+ * `IPipelineExecutorProvider.orchestratorStatus()` cap method as the
+ * canonical source of truth for global pipeline health.
+ */
+declare const GlobalMetricsSchema: z.ZodObject<{
+    totalAgents: z.ZodNumber;
+    onlineAgents: z.ZodNumber;
+    totalCameras: z.ZodNumber;
+    attachedCameras: z.ZodNumber;
+    activeCameras: z.ZodNumber;
+    avgInferenceTimeMs: z.ZodNumber;
+    queueDepth: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Per-node capability binding map: which addon implements each well-known
+ * cap on the named node. Persisted hub-side under
+ * `addon:pipeline-orchestrator` settings keyed by `nodeBindings.<nodeId>`.
+ *
+ * The kernel of each process consults its local copy of this map (via the
+ * `capability.binding-changed` event subscription) when resolving
+ * capability providers.
+ */
+declare const CapabilityBindingsSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+/**
+ * Pipeline Orchestrator capability — global load balancer + camera dispatcher.
+ *
+ * Lives on the hub. Tracks the camera-to-agent assignment map, listens to
+ * device lifecycle events, queries each runner's capacity + hardware
+ * profile, and dispatches `attachCamera` / `detachCamera` cap calls to the
+ * appropriate runner instances. Persists assignments via the multi-level
+ * settings store so they survive hub restarts.
+ *
+ * Strictly the control plane: never sees a frame, never calls inference,
+ * never drains queues. The runner does that work locally on each agent.
+ */
+export declare const pipelineOrchestratorCapability: {
+    readonly name: "pipeline-orchestrator";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly exposesDeviceSettings: true;
+    readonly methods: {
+        /**
+         * Pin a camera's pipeline to a specific agent (L1 affinity).
+         * The orchestrator re-evaluates the assignment immediately.
+         */
+        readonly assignPipeline: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            agentNodeId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Clear a camera's pipeline pin and let the auto-balancer re-pick
+         * the optimal agent. The orchestrator persists `preferredAgent=null`
+         * (and `pipelineNodeId='auto'`), then re-runs the balancer with the
+         * cached `RunnerCameraConfig` and migrates only when the chosen
+         * node differs. The camera stays in `getPipelineAssignments()` —
+         * just with `pinned=false`. If no runner is currently available
+         * (cluster-wide), the camera is left unassigned but the cached
+         * config is kept so the next dispatch event re-attaches it.
+         */
+        readonly unassignPipeline: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Trigger a full rebalance pass. Iterates over all assigned cameras,
+         * recomputes the optimal agent for each one based on current load +
+         * hardware affinity, and migrates cameras whose current agent is no
+         * longer optimal. Pinned cameras are never migrated.
+         */
+        readonly rebalance: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            migrated: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
+        /** Get the full camera-to-agent assignment map. */
+        readonly getPipelineAssignments: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            agentNodeId: z.ZodString;
+            pinned: z.ZodBoolean;
+            reason: z.ZodEnum<{
+                rebalance: "rebalance";
+                manual: "manual";
+                capacity: "capacity";
+                "hardware-affinity": "hardware-affinity";
+                failover: "failover";
+            }>;
+            assignedAt: z.ZodNumber;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Get one camera's assignment, or null if unassigned. */
+        readonly getPipelineAssignment: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            agentNodeId: z.ZodString;
+            pinned: z.ZodBoolean;
+            reason: z.ZodEnum<{
+                rebalance: "rebalance";
+                manual: "manual";
+                capacity: "capacity";
+                "hardware-affinity": "hardware-affinity";
+                failover: "failover";
+            }>;
+            assignedAt: z.ZodNumber;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Get per-agent load summaries used by the load balancer + dashboards. */
+        readonly getAgentLoad: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            nodeId: z.ZodString;
+            online: z.ZodBoolean;
+            load: z.ZodObject<{
+                nodeId: z.ZodString;
+                attachedCameras: z.ZodNumber;
+                activeCameras: z.ZodNumber;
+                avgInferenceFps: z.ZodNumber;
+                avgInferenceTimeMs: z.ZodNumber;
+                queueDepthTotal: z.ZodNumber;
+                hardware: z.ZodObject<{
+                    hasGpu: z.ZodBoolean;
+                    inferenceBackend: z.ZodOptional<z.ZodString>;
+                    cpuCores: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            score: z.ZodNumber;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Aggregate global metrics across the whole detection cluster. */
+        readonly getGlobalMetrics: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            totalAgents: z.ZodNumber;
+            onlineAgents: z.ZodNumber;
+            totalCameras: z.ZodNumber;
+            attachedCameras: z.ZodNumber;
+            activeCameras: z.ZodNumber;
+            avgInferenceTimeMs: z.ZodNumber;
+            queueDepth: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Per-camera live metrics (phase, fps, inference, queue, drops).
+         * The orchestrator owns the device→agent assignment map and is the
+         * canonical place to ask "give me the metrics for this camera". It
+         * resolves the agent that holds the camera and delegates to that
+         * runner's `getCameraMetrics`. Returns null if the device is not
+         * assigned or the runner has no record for it (e.g. the camera was
+         * just dispatched and the runner hasn't received the first frame).
+         */
+        readonly getCameraMetrics: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            detectionMode: z.ZodEnum<{
+                disabled: "disabled";
+                "always-on": "always-on";
+                "on-motion": "on-motion";
+            }>;
+            configuredFps: z.ZodNumber;
+            actualFps: z.ZodNumber;
+            queueDepth: z.ZodNumber;
+            avgInferenceTimeMs: z.ZodNumber;
+            droppedFrames: z.ZodNumber;
+            phase: z.ZodEnum<{
+                idle: "idle";
+                watching: "watching";
+                active: "active";
+            }>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Read the capability binding map for one node. Empty record = no overrides (first-registered wins). */
+        readonly getCapabilityBindings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            nodeId: z.ZodString;
+        }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodString>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Set the addon that implements `capName` on `nodeId`. Emits `capability.binding-changed`. */
+        readonly setCapabilityBinding: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            nodeId: z.ZodString;
+            capName: z.ZodString;
+            addonId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        /** Pin a device's decoder to a specific node. */
+        readonly assignDecoder: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            nodeId: z.ZodString;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /** Clear a device's decoder pin (revert to auto). */
+        readonly unassignDecoder: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /** Get every camera's decoder placement. */
+        readonly getDecoderAssignments: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            decoderNodeId: z.ZodString;
+            pinned: z.ZodBoolean;
+            reason: z.ZodEnum<{
+                manual: "manual";
+                capacity: "capacity";
+                "hardware-affinity": "hardware-affinity";
+                "co-located": "co-located";
+            }>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Pin a device's audio analysis to a specific cluster node. */
+        readonly assignAudio: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            nodeId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        /** Clear a device's audio node pin (revert to auto load-balanced). */
+        readonly unassignAudio: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        /** Get the current audio assignment for one device, or null if not yet assigned. */
+        readonly getAudioAssignment: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            nodeId: z.ZodString;
+            pinned: z.ZodBoolean;
+            assignedAt: z.ZodNumber;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Get per-node audio load (device counts) for all known audio-analyzer nodes. */
+        readonly getAudioNodeLoad: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodArray<z.ZodObject<{
+            nodeId: z.ZodString;
+            deviceCount: z.ZodNumber;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Get all current audio assignments across all devices. */
+        readonly getAudioAssignments: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodArray<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            nodeId: z.ZodString;
+            pinned: z.ZodBoolean;
+            assignedAt: z.ZodNumber;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Get one camera's decoder placement (computed if not yet pinned).
+         * Consumed by `stream-broker.createBroker` so decoder provider
+         * selection is deterministic — fixes the 2026-04-18 race where
+         * `capProviders[0]` silently picked ffmpeg-on-agent-0 for a
+         * hub-assigned camera.
+         *
+         * `pipelineNodeId` is the node already chosen to run inference for
+         * this camera. When provided, the balancer prefers co-location with
+         * it; omitted → falls back to the last known assignment in the
+         * `assignments` map and finally to 'hub'.
+         */
+        readonly getDecoderAssignment: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            pipelineNodeId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            deviceId: z.ZodNumber;
+            decoderNodeId: z.ZodString;
+            pinned: z.ZodBoolean;
+            reason: z.ZodEnum<{
+                manual: "manual";
+                capacity: "capacity";
+                "hardware-affinity": "hardware-affinity";
+                "co-located": "co-located";
+            }>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Read one agent's settings. Null when not yet seeded. */
+        readonly getAgentSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            agentNodeId: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            addonDefaults: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodObject<{
+                enabled: z.ZodBoolean;
+                modelId: z.ZodString;
+                settings: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Enumerate every agent's settings (hub + remote runners). */
+        readonly listAgentSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            nodeId: z.ZodString;
+            settings: z.ZodObject<{
+                addonDefaults: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    enabled: z.ZodBoolean;
+                    modelId: z.ZodString;
+                    settings: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Bulk-replace ALL addon configs on one agent. Used by the agent-level PipelineEditor which emits the full map per edit. Merges on top of existing entries — omitted addonIds are left alone. */
+        readonly setAgentAddonDefaults: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            agentNodeId: z.ZodString;
+            defaults: z.ZodRecord<z.ZodString, z.ZodObject<{
+                enabled: z.ZodBoolean;
+                modelId: z.ZodString;
+                settings: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Drop a single agent's persisted settings. Used by the cluster
+         * "Offline agents" panel to evict stale entries left behind when an
+         * agent's data dir was rebuilt (new random nodeId) or older code wrote
+         * the env name as the nodeId. The orchestrator otherwise never deletes
+         * agentSettings — entries accumulate until a hub reset.
+         *
+         * `success: false` indicates the nodeId wasn't in the store (no-op).
+         * Refuses to remove `hub` (the orchestrator always co-resides with it).
+         */
+        readonly removeAgentSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            agentNodeId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodBoolean;
+            removed: z.ZodBoolean;
+        }, z.core.$strip>, "mutation">;
+        /** Read one camera's settings. Null when never touched (inherits agent defaults fully). */
+        readonly getCameraSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            pinnedAgentNodeId: z.ZodOptional<z.ZodString>;
+            stepToggles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+            stepOverridesByAgent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                modelId: z.ZodOptional<z.ZodString>;
+                settings: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            }, z.core.$strip>>>>;
+            pipelineByAgent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                steps: z.ZodReadonly<z.ZodArray<z.ZodType<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown, z.core.$ZodTypeInternals<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown>>>>;
+                audio: z.ZodNullable<z.ZodObject<{
+                    modelId: z.ZodString;
+                    enabled: z.ZodBoolean;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Set or clear the 3-state toggle for one (camera, addonId). Pass `enabled: null` to clear and revert to agent default. */
+        readonly setCameraStepToggle: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            addonId: z.ZodString;
+            enabled: z.ZodNullable<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        /** Read every L2.5 override map for a device. Null when device has no overrides. */
+        readonly getCameraStepOverrides: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            modelId: z.ZodOptional<z.ZodString>;
+            settings: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        }, z.core.$strip>>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Write or clear the L2.5 per-agent override for one addonId on a device.
+         * `patch: null` clears the entry entirely for that (agent, addon) pair.
+         */
+        readonly setCameraStepOverride: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            agentNodeId: z.ZodString;
+            addonId: z.ZodString;
+            patch: z.ZodNullable<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                modelId: z.ZodOptional<z.ZodString>;
+                settings: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        /** Write or clear the wholesale per-agent pipeline override. Pass `pipeline: null` to drop the override. */
+        readonly setCameraPipelineForAgent: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            agentNodeId: z.ZodString;
+            pipeline: z.ZodNullable<z.ZodObject<{
+                steps: z.ZodReadonly<z.ZodArray<z.ZodType<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown, z.core.$ZodTypeInternals<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown>>>>;
+                audio: z.ZodNullable<z.ZodObject<{
+                    modelId: z.ZodString;
+                    enabled: z.ZodBoolean;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+        /** Resolve the effective pipeline for `(deviceId, agentNodeId?)` — walks the full precedence chain. Read-only preview used by the UI to show what will run. */
+        readonly resolvePipeline: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            agentNodeId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            engine: z.ZodObject<{
+                runtime: z.ZodEnum<{
+                    node: "node";
+                    python: "python";
+                }>;
+                backend: z.ZodString;
+                format: z.ZodEnum<{
+                    onnx: "onnx";
+                    coreml: "coreml";
+                    openvino: "openvino";
+                    tflite: "tflite";
+                    pt: "pt";
+                }>;
+                device: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            steps: z.ZodReadonly<z.ZodArray<z.ZodType<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown, z.core.$ZodTypeInternals<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown>>>>;
+            audio: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                engine: z.ZodObject<{
+                    runtime: z.ZodEnum<{
+                        node: "node";
+                        python: "python";
+                    }>;
+                    backend: z.ZodString;
+                    format: z.ZodEnum<{
+                        onnx: "onnx";
+                        coreml: "coreml";
+                        openvino: "openvino";
+                        tflite: "tflite";
+                        pt: "pt";
+                    }>;
+                    device: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                modelId: z.ZodString;
+                enabled: z.ZodBoolean;
+                settings: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** List every template the operator has saved. */
+        readonly listTemplates: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            config: z.ZodObject<{
+                engine: z.ZodObject<{
+                    runtime: z.ZodEnum<{
+                        node: "node";
+                        python: "python";
+                    }>;
+                    backend: z.ZodString;
+                    format: z.ZodEnum<{
+                        onnx: "onnx";
+                        coreml: "coreml";
+                        openvino: "openvino";
+                        tflite: "tflite";
+                        pt: "pt";
+                    }>;
+                    device: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                steps: z.ZodReadonly<z.ZodArray<z.ZodType<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown, z.core.$ZodTypeInternals<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown>>>>;
+                audio: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    engine: z.ZodObject<{
+                        runtime: z.ZodEnum<{
+                            node: "node";
+                            python: "python";
+                        }>;
+                        backend: z.ZodString;
+                        format: z.ZodEnum<{
+                            onnx: "onnx";
+                            coreml: "coreml";
+                            openvino: "openvino";
+                            tflite: "tflite";
+                            pt: "pt";
+                        }>;
+                        device: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>;
+                    modelId: z.ZodString;
+                    enabled: z.ZodBoolean;
+                    settings: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Create a new named preset from a given CameraPipelineConfig. */
+        readonly saveTemplate: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            config: z.ZodObject<{
+                engine: z.ZodObject<{
+                    runtime: z.ZodEnum<{
+                        node: "node";
+                        python: "python";
+                    }>;
+                    backend: z.ZodString;
+                    format: z.ZodEnum<{
+                        onnx: "onnx";
+                        coreml: "coreml";
+                        openvino: "openvino";
+                        tflite: "tflite";
+                        pt: "pt";
+                    }>;
+                    device: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                steps: z.ZodReadonly<z.ZodArray<z.ZodType<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown, z.core.$ZodTypeInternals<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown>>>>;
+                audio: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    engine: z.ZodObject<{
+                        runtime: z.ZodEnum<{
+                            node: "node";
+                            python: "python";
+                        }>;
+                        backend: z.ZodString;
+                        format: z.ZodEnum<{
+                            onnx: "onnx";
+                            coreml: "coreml";
+                            openvino: "openvino";
+                            tflite: "tflite";
+                            pt: "pt";
+                        }>;
+                        device: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>;
+                    modelId: z.ZodString;
+                    enabled: z.ZodBoolean;
+                    settings: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            config: z.ZodObject<{
+                engine: z.ZodObject<{
+                    runtime: z.ZodEnum<{
+                        node: "node";
+                        python: "python";
+                    }>;
+                    backend: z.ZodString;
+                    format: z.ZodEnum<{
+                        onnx: "onnx";
+                        coreml: "coreml";
+                        openvino: "openvino";
+                        tflite: "tflite";
+                        pt: "pt";
+                    }>;
+                    device: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                steps: z.ZodReadonly<z.ZodArray<z.ZodType<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown, z.core.$ZodTypeInternals<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown>>>>;
+                audio: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    engine: z.ZodObject<{
+                        runtime: z.ZodEnum<{
+                            node: "node";
+                            python: "python";
+                        }>;
+                        backend: z.ZodString;
+                        format: z.ZodEnum<{
+                            onnx: "onnx";
+                            coreml: "coreml";
+                            openvino: "openvino";
+                            tflite: "tflite";
+                            pt: "pt";
+                        }>;
+                        device: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>;
+                    modelId: z.ZodString;
+                    enabled: z.ZodBoolean;
+                    settings: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strip>, "mutation">;
+        /** Partial update of a template. Any omitted field is preserved. */
+        readonly updateTemplate: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            config: z.ZodOptional<z.ZodObject<{
+                engine: z.ZodObject<{
+                    runtime: z.ZodEnum<{
+                        node: "node";
+                        python: "python";
+                    }>;
+                    backend: z.ZodString;
+                    format: z.ZodEnum<{
+                        onnx: "onnx";
+                        coreml: "coreml";
+                        openvino: "openvino";
+                        tflite: "tflite";
+                        pt: "pt";
+                    }>;
+                    device: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                steps: z.ZodReadonly<z.ZodArray<z.ZodType<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown, z.core.$ZodTypeInternals<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown>>>>;
+                audio: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    engine: z.ZodObject<{
+                        runtime: z.ZodEnum<{
+                            node: "node";
+                            python: "python";
+                        }>;
+                        backend: z.ZodString;
+                        format: z.ZodEnum<{
+                            onnx: "onnx";
+                            coreml: "coreml";
+                            openvino: "openvino";
+                            tflite: "tflite";
+                            pt: "pt";
+                        }>;
+                        device: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>;
+                    modelId: z.ZodString;
+                    enabled: z.ZodBoolean;
+                    settings: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            config: z.ZodObject<{
+                engine: z.ZodObject<{
+                    runtime: z.ZodEnum<{
+                        node: "node";
+                        python: "python";
+                    }>;
+                    backend: z.ZodString;
+                    format: z.ZodEnum<{
+                        onnx: "onnx";
+                        coreml: "coreml";
+                        openvino: "openvino";
+                        tflite: "tflite";
+                        pt: "pt";
+                    }>;
+                    device: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                steps: z.ZodReadonly<z.ZodArray<z.ZodType<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown, z.core.$ZodTypeInternals<import("./pipeline-executor.cap.js").PipelineStepInputOutput, unknown>>>>;
+                audio: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    engine: z.ZodObject<{
+                        runtime: z.ZodEnum<{
+                            node: "node";
+                            python: "python";
+                        }>;
+                        backend: z.ZodString;
+                        format: z.ZodEnum<{
+                            onnx: "onnx";
+                            coreml: "coreml";
+                            openvino: "openvino";
+                            tflite: "tflite";
+                            pt: "pt";
+                        }>;
+                        device: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>;
+                    modelId: z.ZodString;
+                    enabled: z.ZodBoolean;
+                    settings: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+        }, z.core.$strip>, "mutation">;
+        /** Remove a template. Camera configs that were seeded from it keep a copy. */
+        readonly deleteTemplate: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            success: z.ZodLiteral<true>;
+        }, z.core.$strip>, "mutation">;
+    };
+};
+export type IPipelineOrchestratorProvider = InferProvider<typeof pipelineOrchestratorCapability>;
+export { PipelineAssignmentSchema, DecoderAssignmentSchema, AgentLoadSummarySchema, GlobalMetricsSchema, CapabilityBindingsSchema, CameraPipelineConfigSchema, CameraStepOverridePatchSchema, PipelineTemplateSchema as OrchestratorPipelineTemplateSchema, };
+//# sourceMappingURL=pipeline-orchestrator.cap.d.ts.map