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