import { z } from 'zod';
import { type InferProvider } from './capability-definition.js';
import type { ConfigUISchema, ConfigField } from '../interfaces/config-ui.js';
import type { InferenceCapabilities, ModelAvailability } from '../interfaces/inference-capabilities.js';
import type { PipelineConfig } from '../types/pipeline.js';
import type { FrameResult, AudioResult } from '../types/detection.js';
declare const PipelineEngineChoiceSchema: 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>;
declare const EngineDeviceInfoSchema: z.ZodObject<{
    id: z.ZodString;
    label: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
declare const AvailableEngineSchema: 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>;
    devices: z.ZodReadonly<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        label: z.ZodString;
        description: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    defaultDevice: z.ZodString;
}, z.core.$strip>;
export type PipelineDefaultStepOutput = {
    readonly addonId: string;
    readonly addonName: string;
    readonly slot: 'detector' | 'cropper' | 'classifier' | 'refiner' | 'audio-classifier';
    readonly inputClasses: readonly string[];
    readonly outputClasses: readonly string[];
    readonly enabled: boolean;
    readonly modelId: string;
    readonly children: readonly PipelineDefaultStepOutput[];
    readonly engine?: {
        readonly runtime: 'node' | 'python';
        readonly backend: string;
        readonly format: 'onnx' | 'coreml' | 'openvino' | 'tflite' | 'pt';
        readonly device?: string;
    };
    readonly group?: string;
    readonly settings?: Readonly<Record<string, unknown>>;
};
declare const PipelineDefaultStepSchema: z.ZodType<PipelineDefaultStepOutput>;
export type PipelineTemplateStepOutput = {
    readonly addonId: string;
    readonly enabled: boolean;
    readonly modelId: string;
    readonly children: readonly PipelineTemplateStepOutput[];
    readonly settings?: Readonly<Record<string, unknown>>;
};
declare const PipelineTemplateStepSchema: z.ZodType<PipelineTemplateStepOutput>;
declare const PipelineTemplateSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    createdAt: z.ZodString;
    updatedAt: z.ZodString;
    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<PipelineTemplateStepOutput, unknown, z.core.$ZodTypeInternals<PipelineTemplateStepOutput, unknown>>>>;
}, z.core.$strip>;
declare const PipelineModelOptionSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    formats: z.ZodRecord<z.ZodString, z.ZodObject<{
        downloaded: z.ZodBoolean;
        sizeMB: z.ZodNumber;
    }, z.core.$strip>>;
}, z.core.$strip>;
declare const PipelineAddonSchemaSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    slot: z.ZodEnum<{
        detector: "detector";
        cropper: "cropper";
        classifier: "classifier";
        refiner: "refiner";
        "audio-classifier": "audio-classifier";
    }>;
    inputClasses: z.ZodReadonly<z.ZodArray<z.ZodString>>;
    outputClasses: z.ZodReadonly<z.ZodArray<z.ZodString>>;
    childSlots: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
        detector: "detector";
        cropper: "cropper";
        classifier: "classifier";
        refiner: "refiner";
        "audio-classifier": "audio-classifier";
    }>>>;
    models: z.ZodReadonly<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        formats: z.ZodRecord<z.ZodString, z.ZodObject<{
            downloaded: z.ZodBoolean;
            sizeMB: z.ZodNumber;
        }, z.core.$strip>>;
    }, z.core.$strip>>>;
    defaultModelId: z.ZodString;
    defaultModelIdByFormat: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    enabledByDefault: z.ZodOptional<z.ZodBoolean>;
    defaultConfidence: z.ZodNumber;
    group: z.ZodOptional<z.ZodString>;
    configSchema: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodCustom<ConfigField, ConfigField>>>>;
}, z.core.$strip>;
declare const PipelineSlotSchemaSchema: z.ZodObject<{
    id: z.ZodEnum<{
        detector: "detector";
        cropper: "cropper";
        classifier: "classifier";
        refiner: "refiner";
        "audio-classifier": "audio-classifier";
    }>;
    label: z.ZodString;
    priority: z.ZodNumber;
    parentSlot: z.ZodNullable<z.ZodEnum<{
        detector: "detector";
        cropper: "cropper";
        classifier: "classifier";
        refiner: "refiner";
        "audio-classifier": "audio-classifier";
    }>>;
    addons: z.ZodReadonly<z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        slot: z.ZodEnum<{
            detector: "detector";
            cropper: "cropper";
            classifier: "classifier";
            refiner: "refiner";
            "audio-classifier": "audio-classifier";
        }>;
        inputClasses: z.ZodReadonly<z.ZodArray<z.ZodString>>;
        outputClasses: z.ZodReadonly<z.ZodArray<z.ZodString>>;
        childSlots: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
            detector: "detector";
            cropper: "cropper";
            classifier: "classifier";
            refiner: "refiner";
            "audio-classifier": "audio-classifier";
        }>>>;
        models: z.ZodReadonly<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            name: z.ZodString;
            formats: z.ZodRecord<z.ZodString, z.ZodObject<{
                downloaded: z.ZodBoolean;
                sizeMB: z.ZodNumber;
            }, z.core.$strip>>;
        }, z.core.$strip>>>;
        defaultModelId: z.ZodString;
        defaultModelIdByFormat: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        enabledByDefault: z.ZodOptional<z.ZodBoolean>;
        defaultConfidence: z.ZodNumber;
        group: z.ZodOptional<z.ZodString>;
        configSchema: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodCustom<ConfigField, ConfigField>>>>;
    }, z.core.$strip>>>;
}, z.core.$strip>;
declare const PipelineSchemaSchema: z.ZodObject<{
    availableEngines: z.ZodReadonly<z.ZodArray<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>;
        devices: z.ZodReadonly<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            label: z.ZodString;
            description: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>>>;
        defaultDevice: z.ZodString;
    }, z.core.$strip>>>;
    selectedEngine: 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>;
    slots: z.ZodReadonly<z.ZodArray<z.ZodObject<{
        id: z.ZodEnum<{
            detector: "detector";
            cropper: "cropper";
            classifier: "classifier";
            refiner: "refiner";
            "audio-classifier": "audio-classifier";
        }>;
        label: z.ZodString;
        priority: z.ZodNumber;
        parentSlot: z.ZodNullable<z.ZodEnum<{
            detector: "detector";
            cropper: "cropper";
            classifier: "classifier";
            refiner: "refiner";
            "audio-classifier": "audio-classifier";
        }>>;
        addons: z.ZodReadonly<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            name: z.ZodString;
            slot: z.ZodEnum<{
                detector: "detector";
                cropper: "cropper";
                classifier: "classifier";
                refiner: "refiner";
                "audio-classifier": "audio-classifier";
            }>;
            inputClasses: z.ZodReadonly<z.ZodArray<z.ZodString>>;
            outputClasses: z.ZodReadonly<z.ZodArray<z.ZodString>>;
            childSlots: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
                detector: "detector";
                cropper: "cropper";
                classifier: "classifier";
                refiner: "refiner";
                "audio-classifier": "audio-classifier";
            }>>>;
            models: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                name: z.ZodString;
                formats: z.ZodRecord<z.ZodString, z.ZodObject<{
                    downloaded: z.ZodBoolean;
                    sizeMB: z.ZodNumber;
                }, z.core.$strip>>;
            }, z.core.$strip>>>;
            defaultModelId: z.ZodString;
            defaultModelIdByFormat: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            enabledByDefault: z.ZodOptional<z.ZodBoolean>;
            defaultConfidence: z.ZodNumber;
            group: z.ZodOptional<z.ZodString>;
            configSchema: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodCustom<ConfigField, ConfigField>>>>;
        }, z.core.$strip>>>;
    }, z.core.$strip>>>;
}, z.core.$strip>;
declare const DetectorOutputSchema: z.ZodObject<{
    detections: z.ZodReadonly<z.ZodArray<z.ZodObject<{
        class: z.ZodString;
        originalClass: z.ZodString;
        score: z.ZodNumber;
        bbox: z.ZodObject<{
            x: z.ZodNumber;
            y: z.ZodNumber;
            w: z.ZodNumber;
            h: z.ZodNumber;
        }, z.core.$strip>;
    }, z.core.$strip>>>;
    inferenceMs: z.ZodNumber;
    modelId: z.ZodString;
}, z.core.$strip>;
export type PipelineStepInputOutput = {
    readonly addonId: string;
    readonly modelId: string;
    readonly enabled: boolean;
    readonly children?: readonly PipelineStepInputOutput[];
    readonly settings?: Readonly<Record<string, unknown>>;
};
export declare const PipelineStepInputSchema: z.ZodType<PipelineStepInputOutput>;
export declare const PipelineRunResultBridge: z.ZodCustom<FrameResult, FrameResult>;
/**
 * Pipeline executor — detection engine + configuration + inference API.
 *
 * Merged from: pipeline-executor, pipeline-config, inference, detection-config.
 * Implemented by the detection-pipeline addon.
 *
 * Per-device surface (DeviceSettingsContribution + the "is detection
 * enabled for this camera?" toggle) lives on the paired
 * `detection-pipeline` cap (device-scoped, singleton, wrapper
 * defaultActive) — same split pattern used by stream-broker /
 * camera-streams and audio-analyzer / audio-analysis.
 */
export declare const pipelineExecutorCapability: {
    readonly name: "pipeline-executor";
    readonly scope: "system";
    readonly mode: "singleton";
    readonly methods: {
        readonly getAvailableEngines: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodArray<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>>, import("./capability-definition.js").CapabilityMethodKind>;
        readonly getSelectedEngine: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, 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>, import("./capability-definition.js").CapabilityMethodKind>;
        readonly getDefaultSteps: import("./capability-definition.js").CapabilityMethodSchema<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>, z.ZodArray<z.ZodType<PipelineDefaultStepOutput, unknown, z.core.$ZodTypeInternals<PipelineDefaultStepOutput, unknown>>>, import("./capability-definition.js").CapabilityMethodKind>;
        /**
         * Re-run the platform probe for the inference engine and write the
         * detected runtime / backend / device back into the addon's own
         * global settings store. Returns the engine that was picked so the
         * UI can confirm without a second round-trip. Triggers the standard
         * `requiresRestart` auto-restart flow because all three fields are
         * marked restart-required. Replaces the legacy per-agent
         * `pipeline-orchestrator.reprobeAgentHwAccel` surface for the
         * engine dimension — each addon now owns its own probe.
         */
        readonly reprobeEngine: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, 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>, "mutation">;
        readonly getVideoPipelineSteps: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodRecord<z.ZodString, z.ZodObject<{
            modelId: z.ZodString;
            settings: z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
        readonly setVideoPipelineSteps: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
            steps: z.ZodRecord<z.ZodString, z.ZodObject<{
                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">;
        readonly getSchema: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
            availableEngines: z.ZodReadonly<z.ZodArray<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>;
                devices: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    label: z.ZodString;
                    description: z.ZodOptional<z.ZodString>;
                }, z.core.$strip>>>;
                defaultDevice: z.ZodString;
            }, z.core.$strip>>>;
            selectedEngine: 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>;
            slots: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                id: z.ZodEnum<{
                    detector: "detector";
                    cropper: "cropper";
                    classifier: "classifier";
                    refiner: "refiner";
                    "audio-classifier": "audio-classifier";
                }>;
                label: z.ZodString;
                priority: z.ZodNumber;
                parentSlot: z.ZodNullable<z.ZodEnum<{
                    detector: "detector";
                    cropper: "cropper";
                    classifier: "classifier";
                    refiner: "refiner";
                    "audio-classifier": "audio-classifier";
                }>>;
                addons: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    name: z.ZodString;
                    slot: z.ZodEnum<{
                        detector: "detector";
                        cropper: "cropper";
                        classifier: "classifier";
                        refiner: "refiner";
                        "audio-classifier": "audio-classifier";
                    }>;
                    inputClasses: z.ZodReadonly<z.ZodArray<z.ZodString>>;
                    outputClasses: z.ZodReadonly<z.ZodArray<z.ZodString>>;
                    childSlots: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
                        detector: "detector";
                        cropper: "cropper";
                        classifier: "classifier";
                        refiner: "refiner";
                        "audio-classifier": "audio-classifier";
                    }>>>;
                    models: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                        id: z.ZodString;
                        name: z.ZodString;
                        formats: z.ZodRecord<z.ZodString, z.ZodObject<{
                            downloaded: z.ZodBoolean;
                            sizeMB: z.ZodNumber;
                        }, z.core.$strip>>;
                    }, z.core.$strip>>>;
                    defaultModelId: z.ZodString;
                    defaultModelIdByFormat: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
                    enabledByDefault: z.ZodOptional<z.ZodBoolean>;
                    defaultConfidence: z.ZodNumber;
                    group: z.ZodOptional<z.ZodString>;
                    configSchema: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodCustom<ConfigField, ConfigField>>>>;
                }, z.core.$strip>>>;
            }, z.core.$strip>>>;
        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
        readonly getGlobalSteps: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodNullable<z.ZodReadonly<z.ZodArray<z.ZodType<PipelineDefaultStepOutput, unknown, z.core.$ZodTypeInternals<PipelineDefaultStepOutput, unknown>>>>>, import("./capability-definition.js").CapabilityMethodKind>;
        readonly getGlobalPipelineConfig: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodCustom<PipelineConfig | null, PipelineConfig | null>, import("./capability-definition.js").CapabilityMethodKind>;
        readonly getOrchestratorConfigSchema: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodCustom<ConfigUISchema, ConfigUISchema>, import("./capability-definition.js").CapabilityMethodKind>;
        readonly listTemplates: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
            id: z.ZodString;
            name: z.ZodString;
            createdAt: z.ZodString;
            updatedAt: z.ZodString;
            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<PipelineTemplateStepOutput, unknown, z.core.$ZodTypeInternals<PipelineTemplateStepOutput, unknown>>>>;
        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
        readonly saveTemplate: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
            name: z.ZodString;
            steps: z.ZodReadonly<z.ZodArray<z.ZodType<PipelineTemplateStepOutput, unknown, z.core.$ZodTypeInternals<PipelineTemplateStepOutput, unknown>>>>;
            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>;
        }, z.core.$strip>, z.ZodObject<{
            id: z.ZodString;
            name: z.ZodString;
            createdAt: z.ZodString;
            updatedAt: z.ZodString;
            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<PipelineTemplateStepOutput, unknown, z.core.$ZodTypeInternals<PipelineTemplateStepOutput, unknown>>>>;
        }, z.core.$strip>, "mutation">;
        readonly updateTemplate: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
            id: z.ZodString;
            name: z.ZodOptional<z.ZodString>;
            steps: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodType<PipelineTemplateStepOutput, unknown, z.core.$ZodTypeInternals<PipelineTemplateStepOutput, unknown>>>>>;
        }, z.core.$strip>, z.ZodObject<{
            id: z.ZodString;
            name: z.ZodString;
            createdAt: z.ZodString;
            updatedAt: z.ZodString;
            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<PipelineTemplateStepOutput, unknown, z.core.$ZodTypeInternals<PipelineTemplateStepOutput, unknown>>>>;
        }, z.core.$strip>, "mutation">;
        readonly deleteTemplate: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
            id: z.ZodString;
        }, z.core.$strip>, z.ZodVoid, "mutation">;
        readonly getCapabilities: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodCustom<InferenceCapabilities, InferenceCapabilities>, import("./capability-definition.js").CapabilityMethodKind>;
        readonly getAddonModels: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
            addonId: z.ZodString;
        }, z.core.$strip>, z.ZodCustom<readonly ModelAvailability[], readonly ModelAvailability[]>, import("./capability-definition.js").CapabilityMethodKind>;
        readonly downloadModel: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
            addonId: z.ZodString;
            modelId: z.ZodString;
            format: z.ZodEnum<{
                onnx: "onnx";
                coreml: "coreml";
                openvino: "openvino";
                tflite: "tflite";
                pt: "pt";
            }>;
        }, z.core.$strip>, z.ZodObject<{
            filePath: z.ZodString;
            sizeMB: z.ZodNumber;
            durationMs: z.ZodNumber;
        }, z.core.$strip>, "mutation">;
        readonly deleteModel: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
            addonId: z.ZodString;
            modelId: z.ZodString;
            format: z.ZodEnum<{
                onnx: "onnx";
                coreml: "coreml";
                openvino: "openvino";
                tflite: "tflite";
                pt: "pt";
            }>;
        }, z.core.$strip>, z.ZodObject<{
            success: z.ZodLiteral<true>;
        }, z.core.$strip>, "mutation">;
        readonly detect: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
            addonId: z.ZodString;
            frame: z.ZodObject<{
                data: z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
                format: z.ZodEnum<{
                    jpeg: "jpeg";
                    rgb: "rgb";
                    bgr: "bgr";
                    yuv420: "yuv420";
                    gray: "gray";
                }>;
                width: z.ZodNumber;
                height: z.ZodNumber;
                timestamp: z.ZodNumber;
            }, z.core.$strip>;
            config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strip>, z.ZodObject<{
            detections: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                class: z.ZodString;
                originalClass: z.ZodString;
                score: z.ZodNumber;
                bbox: z.ZodObject<{
                    x: z.ZodNumber;
                    y: z.ZodNumber;
                    w: z.ZodNumber;
                    h: z.ZodNumber;
                }, z.core.$strip>;
            }, z.core.$strip>>>;
            inferenceMs: z.ZodNumber;
            modelId: z.ZodString;
        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
        /**
         * Stateless single-frame execution. Callers (runner, benchmark) pass
         * the complete `engine` + `steps` tree; the executor holds no state
         * about cameras or saved pipelines.
         *
         * `engine` is optional during the migration window to preserve the
         * legacy call shape used by existing benchmark code; once all
         * callers pass it explicitly we make it required.
         *
         * Exactly one of `frame`, `imageBase64`, `referenceImage` must be
         * provided:
         *  - `frame`: runtime dispatch path (runner → decoded broker frame).
         *    Carries the raw buffer, dimensions, and format; the executor
         *    uses it directly without base64 round-tripping.
         *  - `imageBase64`: one-shot test path (benchmark ImageTab).
         *  - `referenceImage`: named file from the reference-image store.
         */
        readonly runPipeline: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
            engine: z.ZodOptional<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.ZodArray<z.ZodType<PipelineStepInputOutput, unknown, z.core.$ZodTypeInternals<PipelineStepInputOutput, unknown>>>;
            frame: z.ZodOptional<z.ZodObject<{
                data: z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
                format: z.ZodEnum<{
                    jpeg: "jpeg";
                    rgb: "rgb";
                    bgr: "bgr";
                    yuv420: "yuv420";
                    gray: "gray";
                }>;
                width: z.ZodNumber;
                height: z.ZodNumber;
                timestamp: z.ZodNumber;
            }, z.core.$strip>>;
            imageBase64: z.ZodOptional<z.ZodString>;
            image: z.ZodOptional<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>>;
            referenceImage: z.ZodOptional<z.ZodString>;
            deviceId: z.ZodOptional<z.ZodNumber>;
            sessionId: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>, z.ZodCustom<FrameResult, FrameResult>, "mutation">;
        /**
         * Batched run — N raw frames packed into one cap call. The provider
         * routes the batch through `SharedInferencePool.inferBatch`
         * (`MSG_INFER_BATCH = 0x03`) so the IPC framing and JSON response
         * envelope cost is amortised N:1 vs N concurrent `runPipeline`
         * calls. Single root step + uniform model assumed; trees with crop
         * children fall back to sequential execution.
         *
         * Used by `scripts/bench-scrypted-style.mts` to mirror Scrypted's
         * `detectObjects(media, {batch})` semantics for fair comparison.
         */
        readonly runPipelineBatch: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
            engine: z.ZodOptional<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.ZodArray<z.ZodType<PipelineStepInputOutput, unknown, z.core.$ZodTypeInternals<PipelineStepInputOutput, unknown>>>;
            frames: z.ZodArray<z.ZodObject<{
                data: z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
                format: z.ZodEnum<{
                    jpeg: "jpeg";
                    rgb: "rgb";
                    bgr: "bgr";
                    yuv420: "yuv420";
                    gray: "gray";
                }>;
                width: z.ZodNumber;
                height: z.ZodNumber;
                timestamp: z.ZodNumber;
            }, z.core.$strip>>;
            deviceId: z.ZodOptional<z.ZodNumber>;
            sessionId: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>, z.ZodObject<{
            results: z.ZodReadonly<z.ZodArray<z.ZodCustom<FrameResult, FrameResult>>>;
        }, z.core.$strip>, "mutation">;
        /**
         * Cache a raw frame inside the Python inference pool's memory.
         * Returns a numeric `frameId` that `inferCached` references —
         * subsequent calls send only 5 bytes through the pipe instead of
         * 1.2MB raw data, eliminating the pipe transfer bottleneck.
         */
        readonly cacheFrameInPool: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
            data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
            width: z.ZodNumber;
            height: z.ZodNumber;
            format: z.ZodEnum<{
                rgb: "rgb";
                bgr: "bgr";
                gray: "gray";
            }>;
        }, z.core.$strip>, z.ZodObject<{
            frameId: z.ZodNumber;
            width: z.ZodNumber;
            height: z.ZodNumber;
        }, z.core.$strip>, "mutation">;
        /**
         * Run inference on a previously cached frame. Sends only 5 bytes
         * (model_idx + frameId) through the IPC pipe — eliminates the
         * ~35ms per-call overhead of transferring 1.2MB raw data.
         */
        readonly inferCached: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
            stepId: z.ZodString;
            frameId: z.ZodNumber;
        }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>, "mutation">;
        /**
         * Release a cached frame from the Python pool's memory.
         */
        readonly uncacheFrame: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
            frameId: z.ZodNumber;
        }, z.core.$strip>, z.ZodVoid, "mutation">;
        /** Returns the effective pool tuning (resolved from user overrides + backend defaults). */
        readonly getEffectiveTuning: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
            batchMode: z.ZodString;
            windowMs: z.ZodNumber;
            maxBatchSize: z.ZodNumber;
            concurrency: z.ZodNumber;
        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
        /**
         * List every EngineFactory currently loaded in this executor's RAM,
         * with the models resident and a coarse "in use" marker derived from
         * ongoing inference activity. Used by the Pipeline page Engines tab.
         */
        readonly listLoadedEngines: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
            engineKey: z.ZodString;
            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>;
            modelsLoaded: z.ZodReadonly<z.ZodArray<z.ZodString>>;
            inUseByCameras: z.ZodReadonly<z.ZodArray<z.ZodNumber>>;
            kind: z.ZodEnum<{
                runtime: "runtime";
                "warm-override": "warm-override";
            }>;
            poolPid: z.ZodNullable<z.ZodNumber>;
            idleMs: z.ZodNullable<z.ZodNumber>;
            idleTtlMs: z.ZodNullable<z.ZodNumber>;
        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
        /** Warm up an engine without running a frame. No-op if already loaded. */
        readonly spinEngine: import("./capability-definition.js").CapabilityMethodSchema<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>;
        }, z.core.$strip>, z.ZodObject<{
            success: z.ZodLiteral<true>;
        }, z.core.$strip>, "mutation">;
        /**
         * Unload an engine from RAM. `force:true` unloads even when cameras
         * are actively using it (they re-spin on next frame). Default is
         * gated — returns `{success:false, reason}` when in use.
         */
        readonly killEngine: import("./capability-definition.js").CapabilityMethodSchema<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>;
            force: z.ZodOptional<z.ZodBoolean>;
        }, z.core.$strip>, z.ZodObject<{
            success: z.ZodBoolean;
            reason: z.ZodOptional<z.ZodString>;
        }, z.core.$strip>, "mutation">;
        readonly listReferenceImages: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
            filename: z.ZodString;
            stepIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
        readonly getReferenceImage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
            filename: z.ZodString;
        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
            base64: z.ZodString;
            filename: z.ZodString;
        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
        readonly getReferenceAudioFiles: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
            filename: z.ZodString;
            sizeKb: z.ZodNumber;
        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
        readonly getReferenceAudio: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
            filename: z.ZodString;
        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
            base64: z.ZodString;
        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
        readonly getAudioCapabilities: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
            activeBackend: z.ZodString;
            availableBackends: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                id: z.ZodString;
                name: z.ZodString;
                description: z.ZodString;
                available: z.ZodBoolean;
                rawLabels: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
            }, z.core.$strip>>>;
            sampleRate: z.ZodNumber;
            chunkDurationMs: z.ZodNumber;
        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
        readonly runAudioTest: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
            addonId: z.ZodString;
            modelId: z.ZodString;
            filename: z.ZodOptional<z.ZodString>;
            settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strip>, z.ZodObject<{
            success: z.ZodBoolean;
            error: z.ZodOptional<z.ZodString>;
            frame: z.ZodOptional<z.ZodCustom<AudioResult, AudioResult>>;
        }, z.core.$strip>, "mutation">;
        readonly getDetectionConfigSchema: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodCustom<ConfigUISchema | null, ConfigUISchema | null>, import("./capability-definition.js").CapabilityMethodKind>;
    };
};
export type IPipelineExecutorProvider = InferProvider<typeof pipelineExecutorCapability>;
export { PipelineEngineChoiceSchema, PipelineDefaultStepSchema, DetectorOutputSchema, PipelineSchemaSchema, PipelineAddonSchemaSchema, PipelineSlotSchemaSchema, PipelineModelOptionSchema, AvailableEngineSchema, PipelineTemplateSchema, PipelineTemplateStepSchema, EngineDeviceInfoSchema, };
//# sourceMappingURL=pipeline-executor.cap.d.ts.map