@camstack/types 0.1.14 → 0.1.16

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

@@ -0,0 +1,922 @@
+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