@camstack/types 1.0.3 → 1.0.5

package/dist/capabilities/addons.cap.d.ts

@@ -63,9 +63,9 @@ declare const AddonListItemSchema: z.ZodObject<{
     hasBackup: z.ZodOptional<z.ZodBoolean>;
     health: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         phase: z.ZodEnum<{
+            failed: "failed";
             pending: "pending";
             healthy: "healthy";
-            failed: "failed";
         }>;
         retryCount: z.ZodNumber;
         firstFailureAt: z.ZodNullable<z.ZodNumber>;
@@ -145,8 +145,8 @@ declare const UpdateFrameworkPackageResultSchema: z.ZodObject<{
 declare const BulkUpdateItemStatusSchema: z.ZodEnum<{
     failed: "failed";
     queued: "queued";
-    updating: "updating";
     done: "done";
+    updating: "updating";
     "done-pending-restart": "done-pending-restart";
 }>;
 declare const BulkUpdateItemSchema: z.ZodObject<{
@@ -157,8 +157,8 @@ declare const BulkUpdateItemSchema: z.ZodObject<{
     status: z.ZodEnum<{
         failed: "failed";
         queued: "queued";
-        updating: "updating";
         done: "done";
+        updating: "updating";
         "done-pending-restart": "done-pending-restart";
     }>;
     error: z.ZodOptional<z.ZodString>;
@@ -167,8 +167,8 @@ declare const BulkUpdateItemSchema: z.ZodObject<{
 }, z.core.$strip>;
 declare const BulkUpdatePhaseSchema: z.ZodEnum<{
     system: "system";
-    regular: "regular";
     restarting: "restarting";
+    regular: "regular";
     finalizing: "finalizing";
 }>;
 declare const BulkUpdateStateSchema: z.ZodObject<{
@@ -182,8 +182,8 @@ declare const BulkUpdateStateSchema: z.ZodObject<{
     current: z.ZodNullable<z.ZodString>;
     phase: z.ZodEnum<{
         system: "system";
-        regular: "regular";
         restarting: "restarting";
+        regular: "regular";
         finalizing: "finalizing";
     }>;
     cancelled: z.ZodBoolean;
@@ -195,8 +195,8 @@ declare const BulkUpdateStateSchema: z.ZodObject<{
         status: z.ZodEnum<{
             failed: "failed";
             queued: "queued";
-            updating: "updating";
             done: "done";
+            updating: "updating";
             "done-pending-restart": "done-pending-restart";
         }>;
         error: z.ZodOptional<z.ZodString>;
@@ -281,9 +281,9 @@ export declare const addonsCapability: {
             hasBackup: z.ZodOptional<z.ZodBoolean>;
             health: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                 phase: z.ZodEnum<{
+                    failed: "failed";
                     pending: "pending";
                     healthy: "healthy";
-                    failed: "failed";
                 }>;
                 retryCount: z.ZodNumber;
                 firstFailureAt: z.ZodNullable<z.ZodNumber>;
@@ -509,122 +509,6 @@ export declare const addonsCapability: {
             toVersion: z.ZodString;
             restartingAt: z.ZodNumber;
         }, z.core.$strip>, "mutation">;
-        /**
-         * Kicks off a server-side bulk update operation and returns the bulk
-         * id immediately. The operation runs asynchronously; observe progress
-         * via the `AddonsBulkUpdateProgress` event or `getBulkUpdateState`.
-         * Items with `isSystem: true` use `deferRestart` — the hub restarts
-         * ONCE at the end of the system phase, after all system packages are
-         * installed.
-         *
-         * `items[].version` is REQUIRED — callers must pass the resolved
-         * version from `listUpdates`. There is no `'latest'` default here
-         * (unlike `updatePackage`) to guarantee deterministic bulk rolls.
-         */
-        readonly startBulkUpdate: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            nodeId: z.ZodString;
-            items: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                version: z.ZodString;
-                isSystem: z.ZodBoolean;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>, z.ZodObject<{
-            id: z.ZodString;
-        }, z.core.$strip>, "mutation">;
-        /**
-         * Returns the current state of a bulk update by id.
-         * Returns `null` if the id is unknown or has been auto-cleaned
-         * (5 minutes after `completedAt` the record is evicted from memory).
-         */
-        readonly getBulkUpdateState: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            id: z.ZodString;
-        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
-            id: z.ZodString;
-            nodeId: z.ZodString;
-            startedAtMs: z.ZodNumber;
-            completedAtMs: z.ZodOptional<z.ZodNumber>;
-            total: z.ZodNumber;
-            completed: z.ZodNumber;
-            failed: z.ZodNumber;
-            current: z.ZodNullable<z.ZodString>;
-            phase: z.ZodEnum<{
-                system: "system";
-                regular: "regular";
-                restarting: "restarting";
-                finalizing: "finalizing";
-            }>;
-            cancelled: z.ZodBoolean;
-            items: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                isSystem: z.ZodBoolean;
-                fromVersion: z.ZodString;
-                toVersion: z.ZodString;
-                status: z.ZodEnum<{
-                    failed: "failed";
-                    queued: "queued";
-                    updating: "updating";
-                    done: "done";
-                    "done-pending-restart": "done-pending-restart";
-                }>;
-                error: z.ZodOptional<z.ZodString>;
-                startedAtMs: z.ZodOptional<z.ZodNumber>;
-                completedAtMs: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
-        /**
-         * Cancels an in-flight bulk update. The update loop exits after the
-         * currently-processing item completes — cancellation is not
-         * instantaneous. Has no effect once the `restarting` phase has been
-         * entered (the hub is already shutting down at that point).
-         * Returns `{ cancelled: false }` if the id is unknown, the operation
-         * has already completed, or the `restarting` phase is active.
-         */
-        readonly cancelBulkUpdate: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            id: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            cancelled: z.ZodBoolean;
-        }, z.core.$strip>, "mutation">;
-        /**
-         * Lists all currently active (non-completed) bulk updates.
-         * If `nodeId` is provided, filters to only bulk updates targeting
-         * that node. Useful for restoring an in-progress banner on a fresh
-         * page load when the UI reconnects mid-operation.
-         */
-        readonly listActiveBulkUpdates: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
-            nodeId: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            nodeId: z.ZodString;
-            startedAtMs: z.ZodNumber;
-            completedAtMs: z.ZodOptional<z.ZodNumber>;
-            total: z.ZodNumber;
-            completed: z.ZodNumber;
-            failed: z.ZodNumber;
-            current: z.ZodNullable<z.ZodString>;
-            phase: z.ZodEnum<{
-                system: "system";
-                regular: "regular";
-                restarting: "restarting";
-                finalizing: "finalizing";
-            }>;
-            cancelled: z.ZodBoolean;
-            items: z.ZodReadonly<z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                isSystem: z.ZodBoolean;
-                fromVersion: z.ZodString;
-                toVersion: z.ZodString;
-                status: z.ZodEnum<{
-                    failed: "failed";
-                    queued: "queued";
-                    updating: "updating";
-                    done: "done";
-                    "done-pending-restart": "done-pending-restart";
-                }>;
-                error: z.ZodOptional<z.ZodString>;
-                startedAtMs: z.ZodOptional<z.ZodNumber>;
-                completedAtMs: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>>;
-        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         readonly getVersions: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             name: z.ZodString;
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
@@ -694,6 +578,193 @@ export declare const addonsCapability: {
             action: z.ZodString;
             input: z.ZodUnknown;
         }, z.core.$strip>, z.ZodUnknown, "mutation">;
+        /**
+         * Start a lifecycle job (install / update / uninstall / restart) for one
+         * or more addon packages. Returns the `jobId` immediately — the job runs
+         * asynchronously. Observe progress via `EventCategory.AddonsJobProgress` /
+         * `AddonsJobLog` events or poll `getJob`.
+         *
+         * For a single-addon update on the hub the provider also routes
+         * `updatePackage` through this path so the fast swap + atomic-restart
+         * path (`applyStagedAddonUpdate`) is always used.
+         */
+        readonly startJob: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            kind: z.ZodEnum<{
+                update: "update";
+                install: "install";
+                uninstall: "uninstall";
+                restart: "restart";
+            }>;
+            targets: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodString;
+            }, z.core.$strip>>;
+            nodeIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            jobId: z.ZodString;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Retrieve a lifecycle job by id. Returns `null` when the id is unknown
+         * (e.g. evicted after the retention window).
+         */
+        readonly getJob: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            jobId: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            jobId: z.ZodString;
+            kind: z.ZodEnum<{
+                update: "update";
+                install: "install";
+                uninstall: "uninstall";
+                restart: "restart";
+            }>;
+            createdAtMs: z.ZodNumber;
+            createdBy: z.ZodString;
+            scope: z.ZodEnum<{
+                single: "single";
+                bulk: "bulk";
+                cluster: "cluster";
+            }>;
+            tasks: z.ZodArray<z.ZodObject<{
+                taskId: z.ZodString;
+                nodeId: z.ZodString;
+                packageName: z.ZodString;
+                fromVersion: z.ZodNullable<z.ZodString>;
+                toVersion: z.ZodString;
+                target: z.ZodEnum<{
+                    addon: "addon";
+                    framework: "framework";
+                }>;
+                phase: z.ZodEnum<{
+                    failed: "failed";
+                    queued: "queued";
+                    fetching: "fetching";
+                    staged: "staged";
+                    validating: "validating";
+                    applying: "applying";
+                    restarting: "restarting";
+                    applied: "applied";
+                    done: "done";
+                    skipped: "skipped";
+                }>;
+                stagedPath: z.ZodNullable<z.ZodString>;
+                attempts: z.ZodNumber;
+                steps: z.ZodArray<z.ZodObject<{
+                    tsMs: z.ZodNumber;
+                    nodeId: z.ZodString;
+                    packageName: z.ZodString;
+                    phase: z.ZodEnum<{
+                        failed: "failed";
+                        queued: "queued";
+                        fetching: "fetching";
+                        staged: "staged";
+                        validating: "validating";
+                        applying: "applying";
+                        restarting: "restarting";
+                        applied: "applied";
+                        done: "done";
+                        skipped: "skipped";
+                    }>;
+                    message: z.ZodString;
+                }, z.core.$strip>>;
+                error: z.ZodNullable<z.ZodString>;
+                startedAtMs: z.ZodNullable<z.ZodNumber>;
+                finishedAtMs: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>;
+            state: z.ZodEnum<{
+                running: "running";
+                failed: "failed";
+                completed: "completed";
+                "partially-failed": "partially-failed";
+                cancelled: "cancelled";
+            }>;
+            schemaVersion: z.ZodLiteral<1>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * List lifecycle jobs. When `activeOnly` is true, only jobs still in
+         * `running` state are returned.
+         */
+        readonly listJobs: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            activeOnly: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            jobId: z.ZodString;
+            kind: z.ZodEnum<{
+                update: "update";
+                install: "install";
+                uninstall: "uninstall";
+                restart: "restart";
+            }>;
+            createdAtMs: z.ZodNumber;
+            createdBy: z.ZodString;
+            scope: z.ZodEnum<{
+                single: "single";
+                bulk: "bulk";
+                cluster: "cluster";
+            }>;
+            tasks: z.ZodArray<z.ZodObject<{
+                taskId: z.ZodString;
+                nodeId: z.ZodString;
+                packageName: z.ZodString;
+                fromVersion: z.ZodNullable<z.ZodString>;
+                toVersion: z.ZodString;
+                target: z.ZodEnum<{
+                    addon: "addon";
+                    framework: "framework";
+                }>;
+                phase: z.ZodEnum<{
+                    failed: "failed";
+                    queued: "queued";
+                    fetching: "fetching";
+                    staged: "staged";
+                    validating: "validating";
+                    applying: "applying";
+                    restarting: "restarting";
+                    applied: "applied";
+                    done: "done";
+                    skipped: "skipped";
+                }>;
+                stagedPath: z.ZodNullable<z.ZodString>;
+                attempts: z.ZodNumber;
+                steps: z.ZodArray<z.ZodObject<{
+                    tsMs: z.ZodNumber;
+                    nodeId: z.ZodString;
+                    packageName: z.ZodString;
+                    phase: z.ZodEnum<{
+                        failed: "failed";
+                        queued: "queued";
+                        fetching: "fetching";
+                        staged: "staged";
+                        validating: "validating";
+                        applying: "applying";
+                        restarting: "restarting";
+                        applied: "applied";
+                        done: "done";
+                        skipped: "skipped";
+                    }>;
+                    message: z.ZodString;
+                }, z.core.$strip>>;
+                error: z.ZodNullable<z.ZodString>;
+                startedAtMs: z.ZodNullable<z.ZodNumber>;
+                finishedAtMs: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>;
+            state: z.ZodEnum<{
+                running: "running";
+                failed: "failed";
+                completed: "completed";
+                "partially-failed": "partially-failed";
+                cancelled: "cancelled";
+            }>;
+            schemaVersion: z.ZodLiteral<1>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Cancel a lifecycle job that is queued but not yet actively running.
+         * Returns `{ cancelled: false }` if the job is unknown, already in a
+         * terminal state, or actively executing (cannot abort mid-flight).
+         */
+        readonly cancelJob: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            jobId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            cancelled: z.ZodBoolean;
+        }, z.core.$strip>, "mutation">;
         readonly onAddonLogs: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             addonId: z.ZodString;
             level: z.ZodOptional<z.ZodEnum<{

package/dist/capabilities/alerts.cap.d.ts

@@ -14,8 +14,8 @@ export declare const AlertSeveritySchema: z.ZodEnum<{
     warning: "warning";
 }>;
 export declare const AlertStatusSchema: z.ZodEnum<{
-    active: "active";
     failed: "failed";
+    active: "active";
     completed: "completed";
     "in-progress": "in-progress";
     dismissed: "dismissed";
@@ -36,8 +36,8 @@ export declare const AlertSchema: z.ZodObject<{
     title: z.ZodString;
     message: z.ZodString;
     status: z.ZodEnum<{
-        active: "active";
         failed: "failed";
+        active: "active";
         completed: "completed";
         "in-progress": "in-progress";
         dismissed: "dismissed";
@@ -72,8 +72,8 @@ export declare const alertsCapability: {
             title: z.ZodString;
             message: z.ZodString;
             status: z.ZodEnum<{
-                active: "active";
                 failed: "failed";
+                active: "active";
                 completed: "completed";
                 "in-progress": "in-progress";
                 dismissed: "dismissed";
@@ -102,8 +102,8 @@ export declare const alertsCapability: {
                 title: z.ZodOptional<z.ZodString>;
                 message: z.ZodOptional<z.ZodString>;
                 status: z.ZodOptional<z.ZodEnum<{
-                    active: "active";
                     failed: "failed";
+                    active: "active";
                     completed: "completed";
                     "in-progress": "in-progress";
                     dismissed: "dismissed";
@@ -134,8 +134,8 @@ export declare const alertsCapability: {
             title: z.ZodString;
             message: z.ZodString;
             status: z.ZodEnum<{
-                active: "active";
                 failed: "failed";
+                active: "active";
                 completed: "completed";
                 "in-progress": "in-progress";
                 dismissed: "dismissed";

package/dist/capabilities/camera-streams.cap.d.ts

@@ -116,8 +116,8 @@ export declare const cameraStreamsCapability: {
             status: z.ZodEnum<{
                 error: "error";
                 streaming: "streaming";
-                unassigned: "unassigned";
                 idle: "idle";
+                unassigned: "unassigned";
                 connecting: "connecting";
             }>;
             resolution: z.ZodOptional<z.ZodObject<{
@@ -279,8 +279,8 @@ export declare const cameraStreamsCapability: {
                 status: z.ZodEnum<{
                     error: "error";
                     streaming: "streaming";
-                    unassigned: "unassigned";
                     idle: "idle";
+                    unassigned: "unassigned";
                     connecting: "connecting";
                 }>;
                 resolution: z.ZodOptional<z.ZodObject<{
@@ -322,22 +322,22 @@ export declare const cameraStreamsCapability: {
             high: z.ZodOptional<z.ZodEnum<{
                 error: "error";
                 streaming: "streaming";
-                unassigned: "unassigned";
                 idle: "idle";
+                unassigned: "unassigned";
                 connecting: "connecting";
             }>>;
             mid: z.ZodOptional<z.ZodEnum<{
                 error: "error";
                 streaming: "streaming";
-                unassigned: "unassigned";
                 idle: "idle";
+                unassigned: "unassigned";
                 connecting: "connecting";
             }>>;
             low: z.ZodOptional<z.ZodEnum<{
                 error: "error";
                 streaming: "streaming";
-                unassigned: "unassigned";
                 idle: "idle";
+                unassigned: "unassigned";
                 connecting: "connecting";
             }>>;
         }, z.core.$strip>;

package/dist/capabilities/index.d.ts

@@ -70,7 +70,8 @@ export { pipelineExecutorCapability, PipelineEngineChoiceSchema, PipelineDefault
 export type { PipelineStepInputOutput } from './pipeline-executor.cap.js';
 export { pipelineRunnerCapability, RunnerCameraConfigSchema, RunnerLocalLoadSchema, RunnerLocalMetricsSchema, MotionSourceEnum, MotionSourcesSchema, ReportMotionInputSchema, RunnerCameraDeviceUIFields, } from './pipeline-runner.cap.js';
 export type { MotionSource, MotionSources, ReportMotionInput } from './pipeline-runner.cap.js';
-export { pipelineOrchestratorCapability, PipelineAssignmentSchema, DecoderAssignmentSchema, AgentLoadSummarySchema, GlobalMetricsSchema, CapabilityBindingsSchema, } from './pipeline-orchestrator.cap.js';
+export { pipelineOrchestratorCapability, PipelineAssignmentSchema, DecoderAssignmentSchema, AgentLoadSummarySchema, GlobalMetricsSchema, CapabilityBindingsSchema, CameraStatusSchema, CameraAssignmentStatusSchema, CameraSourceStatusSchema, CameraSourceStreamSchema, CameraBrokerStatusSchema, CameraBrokerProfileSchema, CameraDecoderStatusSchema, CameraDecoderShmSchema, CameraMotionStatusSchema, CameraDetectionStatusSchema, CameraDetectionProvisioningSchema, CameraDetectionProvisioningStateSchema, CameraDetectionPhaseSchema, CameraAudioStatusSchema, CameraRecordingStatusSchema, CameraRecordingModeSchema, } from './pipeline-orchestrator.cap.js';
+export type { CameraStatus, CameraAssignmentStatus, CameraSourceStatus, CameraSourceStream, CameraBrokerStatus, CameraBrokerProfile, CameraDecoderStatus, CameraDecoderShm, CameraMotionStatus, CameraDetectionStatus, CameraDetectionProvisioning, CameraDetectionProvisioningState, CameraDetectionPhase, CameraAudioStatus, CameraRecordingStatus, CameraRecordingMode, } from './pipeline-orchestrator.cap.js';
 export { OrchestratorMetricsSchema, CameraMetricsSchema, CameraMetricsWithDeviceIdSchema, } from './schemas/orchestrator-metrics.js';
 export { audioAnalyzerCapability, AUDIO_BACKEND_CHOICES, DEFAULT_AUDIO_ANALYZER_CONFIG, AudioAnalysisResultSchema, AudioAnalysisSettingsSchema, AudioClassificationResultSchema, } from './audio-analyzer.cap.js';
 export type { IAudioAnalyzerProvider, AudioBackendChoice, AudioAnalyzerGlobalConfig, } from './audio-analyzer.cap.js';

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

@@ -297,6 +297,25 @@ declare const DetectorOutputSchema: z.ZodObject<{
     inferenceMs: z.ZodNumber;
     modelId: z.ZodString;
 }, z.core.$strip>;
+declare const EngineProvisioningSchema: z.ZodObject<{
+    runtimeId: z.ZodNullable<z.ZodEnum<{
+        onnx: "onnx";
+        coreml: "coreml";
+        openvino: "openvino";
+    }>>;
+    device: z.ZodNullable<z.ZodString>;
+    state: z.ZodEnum<{
+        ready: "ready";
+        idle: "idle";
+        installing: "installing";
+        verifying: "verifying";
+        failed: "failed";
+    }>;
+    progress: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodString>;
+    nextRetryAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type EngineProvisioning = z.infer<typeof EngineProvisioningSchema>;
 export type PipelineStepInputOutput = {
     readonly addonId: string;
     readonly modelId: string;
@@ -393,6 +412,34 @@ export declare const pipelineExecutorCapability: {
             }>;
             device: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>, "mutation">;
+        /**
+         * Per-node detection-engine provisioning snapshot. Returns the live
+         * state of the lazy runtime-provisioning machine on `nodeId`
+         * (idle / installing / verifying / ready / failed). The UI pairs this
+         * one-shot query with the `pipeline.engine-provisioning` live event
+         * (emitted on every transition) to drive a per-node "engine ready?"
+         * indicator without polling. Phase 2.
+         */
+        readonly getEngineProvisioning: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            nodeId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            runtimeId: z.ZodNullable<z.ZodEnum<{
+                onnx: "onnx";
+                coreml: "coreml";
+                openvino: "openvino";
+            }>>;
+            device: z.ZodNullable<z.ZodString>;
+            state: z.ZodEnum<{
+                ready: "ready";
+                idle: "idle";
+                installing: "installing";
+                verifying: "verifying";
+                failed: "failed";
+            }>;
+            progress: z.ZodOptional<z.ZodNumber>;
+            error: z.ZodOptional<z.ZodString>;
+            nextRetryAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         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>>;
@@ -918,4 +965,4 @@ export declare const pipelineExecutorCapability: {
     };
 };
 export type IPipelineExecutorProvider = InferProvider<typeof pipelineExecutorCapability>;
-export { PipelineEngineChoiceSchema, PipelineDefaultStepSchema, DetectorOutputSchema, PipelineSchemaSchema, PipelineAddonSchemaSchema, PipelineSlotSchemaSchema, PipelineModelOptionSchema, AvailableEngineSchema, PipelineTemplateSchema, PipelineTemplateStepSchema, EngineDeviceInfoSchema, };
+export { PipelineEngineChoiceSchema, PipelineDefaultStepSchema, DetectorOutputSchema, PipelineSchemaSchema, PipelineAddonSchemaSchema, PipelineSlotSchemaSchema, PipelineModelOptionSchema, AvailableEngineSchema, PipelineTemplateSchema, PipelineTemplateStepSchema, EngineDeviceInfoSchema, EngineProvisioningSchema, };