swarmdo 1.4.8 → 1.5.0

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/entities/index.d.ts

@@ -1,5 +0,0 @@
-export { DeviceTrustLevel, getDeviceTrustLabel, } from './device-trust-level.js';
-export type { DeviceStatus, DeviceCapability, DeviceTrustScore, VectorStoreStats, DeviceAgent, } from './device-agent.js';
-export type { FleetTopology, DeploymentStrategy, FirmwarePolicy, TelemetryPolicy, HealthThresholds, DeviceFleet, } from './device-fleet.js';
-export type { AnomalyType, AnomalyAction, TelemetryReading, AnomalyDetection, } from './telemetry.js';
-//# sourceMappingURL=index.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/entities/index.js

@@ -1,2 +0,0 @@
-export { DeviceTrustLevel, getDeviceTrustLabel, } from './device-trust-level.js';
-//# sourceMappingURL=index.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/entities/telemetry.d.ts

@@ -1,35 +0,0 @@
-export type AnomalyType = 'drift' | 'spike' | 'flatline' | 'oscillation' | 'pattern-break' | 'cluster-outlier';
-export type AnomalyAction = 'log' | 'alert' | 'quarantine' | 'recalibrate' | 'rollback-firmware' | 'human-review';
-/**
- * A single telemetry reading from a Cognitum Seed device.
- */
-export interface TelemetryReading {
-    readingId: string;
-    deviceId: string;
-    fleetId: string;
-    timestamp: Date;
-    /** Embedding vector for similarity search. */
-    vector: number[];
-    /** Raw sensor metrics keyed by metric name. */
-    rawMetrics: Record<string, number>;
-    /** Anomaly score, 0.0 (normal) - 1.0 (anomalous). */
-    anomalyScore: number;
-    metadata: Record<string, unknown>;
-}
-/**
- * Result of anomaly detection on a telemetry reading.
- */
-export interface AnomalyDetection {
-    readingId: string;
-    deviceId: string;
-    /** Anomaly score, 0.0 - 1.0. */
-    score: number;
-    type: AnomalyType;
-    /** Detection confidence, 0.0 - 1.0. */
-    confidence: number;
-    /** Identifier of the baseline pattern this was compared against. */
-    baselinePattern?: string;
-    suggestedAction: AnomalyAction;
-    metadata: Record<string, unknown>;
-}
-//# sourceMappingURL=telemetry.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/entities/telemetry.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=telemetry.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/repositories/device-repository.d.ts

@@ -1,11 +0,0 @@
-import type { DeviceAgent } from '../entities/index.js';
-export interface DeviceRepository {
-    save(device: DeviceAgent): Promise<void>;
-    findById(deviceId: string): Promise<DeviceAgent | null>;
-    findByFleet(fleetId: string): Promise<DeviceAgent[]>;
-    findByZone(zoneId: string): Promise<DeviceAgent[]>;
-    findAll(): Promise<DeviceAgent[]>;
-    delete(deviceId: string): Promise<boolean>;
-    count(): Promise<number>;
-}
-//# sourceMappingURL=device-repository.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/repositories/device-repository.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=device-repository.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/repositories/fleet-repository.d.ts

@@ -1,9 +0,0 @@
-import type { DeviceFleet } from '../entities/index.js';
-export interface FleetRepository {
-    save(fleet: DeviceFleet): Promise<void>;
-    findById(fleetId: string): Promise<DeviceFleet | undefined>;
-    findAll(): Promise<DeviceFleet[]>;
-    delete(fleetId: string): Promise<boolean>;
-    count(): Promise<number>;
-}
-//# sourceMappingURL=fleet-repository.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/repositories/fleet-repository.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=fleet-repository.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/repositories/index.d.ts

@@ -1,5 +0,0 @@
-export type { DeviceRepository } from './device-repository.js';
-export type { TrustHistoryEntry, TrustHistoryRepository, } from './trust-history-repository.js';
-export type { FleetRepository } from './fleet-repository.js';
-export type { TelemetryRepository } from './telemetry-repository.js';
-//# sourceMappingURL=index.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/repositories/index.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=index.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/repositories/telemetry-repository.d.ts

@@ -1,12 +0,0 @@
-import type { TelemetryReading, AnomalyDetection } from '../entities/telemetry.js';
-export interface TelemetryRepository {
-    store(reading: TelemetryReading): Promise<void>;
-    storeBatch(readings: TelemetryReading[]): Promise<number>;
-    findByDevice(deviceId: string, limit?: number): Promise<TelemetryReading[]>;
-    searchSimilar(vector: number[], k: number, deviceId?: string): Promise<TelemetryReading[]>;
-    storeAnomaly(anomaly: AnomalyDetection): Promise<void>;
-    findAnomalies(deviceId: string, limit?: number): Promise<AnomalyDetection[]>;
-    count(deviceId?: string): Promise<number>;
-    deleteByDevice(deviceId: string): Promise<number>;
-}
-//# sourceMappingURL=telemetry-repository.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/repositories/telemetry-repository.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=telemetry-repository.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/repositories/trust-history-repository.d.ts

@@ -1,19 +0,0 @@
-import type { DeviceTrustLevel } from '../entities/index.js';
-import type { DeviceTrustScore } from '../entities/index.js';
-export interface TrustHistoryEntry {
-    deviceId: string;
-    timestamp: Date;
-    oldLevel: DeviceTrustLevel;
-    newLevel: DeviceTrustLevel;
-    score: DeviceTrustScore;
-    /** What caused the change: 'registration', 'pair', 'unpair', 'refresh', 'probe'. */
-    trigger: string;
-}
-export interface TrustHistoryRepository {
-    append(entry: TrustHistoryEntry): Promise<void>;
-    findByDevice(deviceId: string, limit?: number): Promise<TrustHistoryEntry[]>;
-    findByLevel(level: DeviceTrustLevel): Promise<TrustHistoryEntry[]>;
-    deleteByDevice(deviceId: string): Promise<number>;
-    count(): Promise<number>;
-}
-//# sourceMappingURL=trust-history-repository.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/repositories/trust-history-repository.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=trust-history-repository.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/services/anomaly-detection-service.d.ts

@@ -1,44 +0,0 @@
-import type { TelemetryReading, AnomalyDetection } from '../entities/index.js';
-export interface AnomalyDetectionConfig {
-    /** Score threshold above which a reading is anomalous. Default 0.7. */
-    anomalyThreshold: number;
-    /** Score threshold for quarantine action. Default 0.9. */
-    quarantineThreshold: number;
-    /** Window size for baseline computation. */
-    baselineWindowSize: number;
-}
-export interface TelemetryBaseline {
-    deviceId: string;
-    /** Mean vector across the baseline window. */
-    meanVector: number[];
-    /** Standard deviation per dimension. */
-    stdVector: number[];
-    /** Number of readings in the baseline. */
-    sampleCount: number;
-    /** When the baseline was last computed. */
-    computedAt: Date;
-}
-export declare class AnomalyDetectionService {
-    private readonly config;
-    private readonly baselines;
-    constructor(config?: Partial<AnomalyDetectionConfig>);
-    /**
-     * Compute a baseline from a window of readings for a device.
-     * Calculates mean and standard deviation per vector dimension.
-     */
-    computeBaseline(deviceId: string, readings: TelemetryReading[]): TelemetryBaseline;
-    /** Get the current baseline for a device, if one has been computed. */
-    getBaseline(deviceId: string): TelemetryBaseline | undefined;
-    /**
-     * Detect anomalies in a reading by comparing against the device's baseline.
-     * Uses z-score based detection: how many standard deviations each dimension
-     * deviates from the baseline mean.
-     */
-    detect(reading: TelemetryReading): AnomalyDetection;
-    /** Classify an anomaly type based on the z-score pattern. */
-    private classifyAnomaly;
-    private suggestAction;
-    /** Check whether a detection result exceeds the anomaly threshold. */
-    isAnomalous(detection: AnomalyDetection): boolean;
-}
-//# sourceMappingURL=anomaly-detection-service.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/services/anomaly-detection-service.js

@@ -1,117 +0,0 @@
-export class AnomalyDetectionService {
-    config;
-    baselines = new Map();
-    constructor(config) {
-        this.config = {
-            anomalyThreshold: config?.anomalyThreshold ?? 0.7,
-            quarantineThreshold: config?.quarantineThreshold ?? 0.9,
-            baselineWindowSize: config?.baselineWindowSize ?? 100,
-        };
-    }
-    /**
-     * Compute a baseline from a window of readings for a device.
-     * Calculates mean and standard deviation per vector dimension.
-     */
-    computeBaseline(deviceId, readings) {
-        if (readings.length === 0)
-            throw new Error('Cannot compute baseline from empty readings');
-        const dim = readings[0].vector.length;
-        const n = readings.length;
-        // Compute mean
-        const mean = new Array(dim).fill(0);
-        for (const r of readings) {
-            for (let i = 0; i < dim; i++)
-                mean[i] += r.vector[i] / n;
-        }
-        // Compute standard deviation
-        const std = new Array(dim).fill(0);
-        for (const r of readings) {
-            for (let i = 0; i < dim; i++) {
-                const diff = r.vector[i] - mean[i];
-                std[i] += (diff * diff) / n;
-            }
-        }
-        for (let i = 0; i < dim; i++)
-            std[i] = Math.sqrt(std[i]);
-        const baseline = {
-            deviceId,
-            meanVector: mean,
-            stdVector: std,
-            sampleCount: n,
-            computedAt: new Date(),
-        };
-        this.baselines.set(deviceId, baseline);
-        return baseline;
-    }
-    /** Get the current baseline for a device, if one has been computed. */
-    getBaseline(deviceId) {
-        return this.baselines.get(deviceId);
-    }
-    /**
-     * Detect anomalies in a reading by comparing against the device's baseline.
-     * Uses z-score based detection: how many standard deviations each dimension
-     * deviates from the baseline mean.
-     */
-    detect(reading) {
-        const baseline = this.baselines.get(reading.deviceId);
-        if (!baseline) {
-            return {
-                readingId: reading.readingId,
-                deviceId: reading.deviceId,
-                score: 0,
-                type: 'drift',
-                confidence: 0,
-                suggestedAction: 'log',
-                metadata: { reason: 'no-baseline' },
-            };
-        }
-        // Z-score per dimension
-        const zScores = reading.vector.map((v, i) => {
-            const s = baseline.stdVector[i];
-            return s > 0 ? Math.abs(v - baseline.meanVector[i]) / s : 0;
-        });
-        const maxZ = Math.max(...zScores);
-        const meanZ = zScores.reduce((a, b) => a + b, 0) / zScores.length;
-        // Composite anomaly score (0-1): 3 std devs maps to score 1.0
-        const score = Math.min(1, meanZ / 3);
-        const type = this.classifyAnomaly(reading, zScores, maxZ);
-        const suggestedAction = this.suggestAction(score);
-        const confidence = Math.min(1, baseline.sampleCount / this.config.baselineWindowSize);
-        return {
-            readingId: reading.readingId,
-            deviceId: reading.deviceId,
-            score,
-            type,
-            confidence,
-            baselinePattern: `baseline-${reading.deviceId}`,
-            suggestedAction,
-            metadata: { maxZ, meanZ, baselineSamples: baseline.sampleCount },
-        };
-    }
-    /** Classify an anomaly type based on the z-score pattern. */
-    classifyAnomaly(reading, zScores, maxZ) {
-        const highZCount = zScores.filter((z) => z > 2).length;
-        const allLow = zScores.every((z) => z < 0.5);
-        if (maxZ > 5)
-            return 'spike';
-        if (allLow && reading.rawMetrics && Object.values(reading.rawMetrics).every((v) => v === 0))
-            return 'flatline';
-        if (highZCount > zScores.length * 0.5)
-            return 'cluster-outlier';
-        if (highZCount > 0 && highZCount <= 2)
-            return 'drift';
-        return 'pattern-break';
-    }
-    suggestAction(score) {
-        if (score >= this.config.quarantineThreshold)
-            return 'quarantine';
-        if (score >= this.config.anomalyThreshold)
-            return 'alert';
-        return 'log';
-    }
-    /** Check whether a detection result exceeds the anomaly threshold. */
-    isAnomalous(detection) {
-        return detection.score >= this.config.anomalyThreshold;
-    }
-}
-//# sourceMappingURL=anomaly-detection-service.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/services/device-lifecycle-service.d.ts

@@ -1,70 +0,0 @@
-import type { DeviceAgent, DeviceTrustScore } from '../entities/index.js';
-import { DeviceTrustLevel } from '../entities/index.js';
-export interface DeviceLifecycleDeps {
-    getStatus: (deviceId: string) => Promise<{
-        device_id: string;
-        uptime_secs: number;
-        epoch: number;
-        total_vectors: number;
-        dimension: number;
-        paired: boolean;
-        roles: string[];
-        witness_chain_length?: number;
-    }>;
-    getIdentity: (deviceId: string) => Promise<{
-        device_id: string;
-        public_key?: string;
-        firmware_version?: string;
-        epoch?: number;
-    }>;
-    getPairStatus: (deviceId: string) => Promise<{
-        paired: boolean;
-        client_count?: number;
-    }>;
-    getWitnessChain: (deviceId: string) => Promise<{
-        depth: number;
-        epoch: number;
-        head_hash: string;
-    }>;
-    getCustodyEpoch: (deviceId: string) => Promise<{
-        epoch: number;
-    }>;
-    pairDevice: (deviceId: string, clientName: string) => Promise<{
-        paired: boolean;
-        token?: string;
-    }>;
-    unpairDevice: (deviceId: string, clientName?: string) => Promise<void>;
-    onDeviceRegistered?: (device: DeviceAgent) => void;
-    onTrustChange?: (deviceId: string, oldLevel: DeviceTrustLevel, newLevel: DeviceTrustLevel) => void;
-}
-export declare class DeviceLifecycleService {
-    private readonly deps;
-    constructor(deps: DeviceLifecycleDeps);
-    /**
-     * Register a new device by fetching its status and identity, then
-     * constructing a DeviceAgent entity with initial trust REGISTERED.
-     */
-    registerDevice(endpoint: string, fleetId: string, zoneId: string): Promise<DeviceAgent>;
-    /**
-     * Pair a device using the SDK's pair.create() and promote its trust level.
-     */
-    pairDevice(device: DeviceAgent, clientName: string): Promise<DeviceAgent>;
-    /**
-     * Unpair a device and demote its trust level.
-     */
-    unpairDevice(device: DeviceAgent): Promise<DeviceAgent>;
-    /**
-     * Re-fetch all device state and recalculate trust.
-     */
-    refreshDeviceState(device: DeviceAgent): Promise<DeviceAgent>;
-    /**
-     * Compute a composite trust score from device telemetry signals.
-     */
-    computeTrustScore(device: DeviceAgent, witnessDepth: number, uptimeSecs: number, paired?: boolean): DeviceTrustScore;
-    /**
-     * Map a composite trust score to a discrete DeviceTrustLevel.
-     */
-    evaluateTrustLevel(score: DeviceTrustScore): DeviceTrustLevel;
-    private deriveCapabilities;
-}
-//# sourceMappingURL=device-lifecycle-service.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/services/device-lifecycle-service.js

@@ -1,194 +0,0 @@
-import { DeviceTrustLevel } from '../entities/index.js';
-// ---------------------------------------------------------------------------
-// Service
-// ---------------------------------------------------------------------------
-export class DeviceLifecycleService {
-    deps;
-    constructor(deps) {
-        this.deps = deps;
-    }
-    /**
-     * Register a new device by fetching its status and identity, then
-     * constructing a DeviceAgent entity with initial trust REGISTERED.
-     */
-    async registerDevice(endpoint, fleetId, zoneId) {
-        const status = await this.deps.getStatus(endpoint);
-        const identity = await this.deps.getIdentity(status.device_id);
-        const initialScore = this.computeTrustScore({}, status.witness_chain_length ?? 0, status.uptime_secs, status.paired);
-        const device = {
-            deviceId: status.device_id,
-            publicKey: identity.public_key ?? '',
-            firmwareVersion: identity.firmware_version ?? 'unknown',
-            trustLevel: DeviceTrustLevel.REGISTERED,
-            trustScore: initialScore,
-            fleetId,
-            zoneId,
-            status: 'online',
-            lastSeen: new Date(),
-            epoch: identity.epoch ?? status.epoch,
-            capabilities: this.deriveCapabilities(status.roles),
-            meshPeers: [],
-            vectorStoreStats: {
-                totalVectors: status.total_vectors,
-                deletedVectors: 0,
-                dimension: status.dimension,
-                fileSizeBytes: 0,
-            },
-            endpoint,
-            metadata: {},
-        };
-        this.deps.onDeviceRegistered?.(device);
-        return device;
-    }
-    /**
-     * Pair a device using the SDK's pair.create() and promote its trust level.
-     */
-    async pairDevice(device, clientName) {
-        const result = await this.deps.pairDevice(device.deviceId, clientName);
-        if (!result.paired) {
-            throw new Error(`Pairing failed for device ${device.deviceId}`);
-        }
-        const oldLevel = device.trustLevel;
-        const newLevel = device.trustLevel < DeviceTrustLevel.PROVISIONED
-            ? DeviceTrustLevel.PROVISIONED
-            : device.trustLevel;
-        const updated = {
-            ...device,
-            trustLevel: newLevel,
-            trustScore: {
-                ...device.trustScore,
-                overall: this.computeTrustScore(device, 0, 0, true).overall,
-                components: {
-                    ...device.trustScore.components,
-                    pairingIntegrity: 1.0,
-                },
-            },
-        };
-        if (oldLevel !== newLevel) {
-            this.deps.onTrustChange?.(device.deviceId, oldLevel, newLevel);
-        }
-        return updated;
-    }
-    /**
-     * Unpair a device and demote its trust level.
-     */
-    async unpairDevice(device) {
-        await this.deps.unpairDevice(device.deviceId);
-        const oldLevel = device.trustLevel;
-        const newLevel = DeviceTrustLevel.REGISTERED;
-        const updated = {
-            ...device,
-            trustLevel: newLevel,
-            trustScore: {
-                ...device.trustScore,
-                overall: this.computeTrustScore(device, 0, 0, false).overall,
-                components: {
-                    ...device.trustScore.components,
-                    pairingIntegrity: 0.0,
-                },
-            },
-        };
-        if (oldLevel !== newLevel) {
-            this.deps.onTrustChange?.(device.deviceId, oldLevel, newLevel);
-        }
-        return updated;
-    }
-    /**
-     * Re-fetch all device state and recalculate trust.
-     */
-    async refreshDeviceState(device) {
-        const [status, identity, pair, witness] = await Promise.all([
-            this.deps.getStatus(device.deviceId),
-            this.deps.getIdentity(device.deviceId),
-            this.deps.getPairStatus(device.deviceId),
-            this.deps.getWitnessChain(device.deviceId),
-        ]);
-        const updated = {
-            ...device,
-            publicKey: identity.public_key ?? device.publicKey,
-            firmwareVersion: identity.firmware_version ?? device.firmwareVersion,
-            epoch: identity.epoch ?? status.epoch,
-            lastSeen: new Date(),
-            status: 'online',
-            vectorStoreStats: {
-                ...device.vectorStoreStats,
-                totalVectors: status.total_vectors,
-                dimension: status.dimension,
-            },
-            capabilities: this.deriveCapabilities(status.roles),
-        };
-        const score = this.computeTrustScore({ ...updated, trustScore: device.trustScore }, witness.depth, status.uptime_secs, pair.paired);
-        const newLevel = this.evaluateTrustLevel(score);
-        const oldLevel = device.trustLevel;
-        updated.trustScore = score;
-        updated.trustLevel = newLevel;
-        if (oldLevel !== newLevel) {
-            this.deps.onTrustChange?.(device.deviceId, oldLevel, newLevel);
-        }
-        return updated;
-    }
-    /**
-     * Compute a composite trust score from device telemetry signals.
-     */
-    computeTrustScore(device, witnessDepth, uptimeSecs, paired) {
-        const SEVEN_DAYS_SECS = 604_800;
-        const EXPECTED_WITNESS_DEPTH = 10_000;
-        const pairingIntegrity = paired !== undefined
-            ? (paired ? 1.0 : 0.0)
-            : (device.trustScore?.components?.pairingIntegrity ?? 0.0);
-        const firmwareCurrency = 1.0; // Hardcoded — version comparison TBD
-        const uptimeStability = Math.min(1.0, uptimeSecs / SEVEN_DAYS_SECS);
-        const witnessIntegrity = Math.min(1.0, witnessDepth / EXPECTED_WITNESS_DEPTH);
-        const anomalyHistory = 1.0; // No anomaly detection yet
-        const meshParticipation = 0.5; // Single device, no mesh peers
-        const overall = 0.3 * pairingIntegrity +
-            0.15 * firmwareCurrency +
-            0.2 * uptimeStability +
-            0.15 * witnessIntegrity +
-            0.1 * anomalyHistory +
-            0.1 * meshParticipation;
-        return {
-            overall,
-            components: {
-                pairingIntegrity,
-                firmwareCurrency,
-                uptimeStability,
-                witnessIntegrity,
-                anomalyHistory,
-                meshParticipation,
-            },
-        };
-    }
-    /**
-     * Map a composite trust score to a discrete DeviceTrustLevel.
-     */
-    evaluateTrustLevel(score) {
-        if (score.overall < 0.3)
-            return DeviceTrustLevel.UNKNOWN;
-        if (score.overall < 0.5)
-            return DeviceTrustLevel.REGISTERED;
-        if (score.overall < 0.7)
-            return DeviceTrustLevel.PROVISIONED;
-        if (score.overall < 0.85)
-            return DeviceTrustLevel.CERTIFIED;
-        return DeviceTrustLevel.FLEET_TRUSTED;
-    }
-    // ---------------------------------------------------------------------------
-    // Helpers
-    // ---------------------------------------------------------------------------
-    deriveCapabilities(roles) {
-        const CAP_MAP = {
-            'vector-store': 'vector-store',
-            ota: 'ota-update',
-            mesh: 'mesh-routing',
-            witness: 'witness-chain',
-            sensor: 'sensor-telemetry',
-            compute: 'edge-compute',
-            mcp: 'mcp-server',
-        };
-        return roles
-            .map((r) => CAP_MAP[r])
-            .filter((c) => c != null);
-    }
-}
-//# sourceMappingURL=device-lifecycle-service.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/domain/services/firmware-orchestration-service.d.ts

@@ -1,69 +0,0 @@
-import type { DeploymentStrategy, FirmwarePolicy } from '../entities/index.js';
-export type RolloutStage = 'pending' | 'canary' | 'rolling' | 'complete' | 'rolled-back' | 'failed';
-export interface FirmwareRollout {
-    rolloutId: string;
-    fleetId: string;
-    firmwareVersion: string;
-    strategy: DeploymentStrategy;
-    stage: RolloutStage;
-    targetDeviceIds: string[];
-    canaryDeviceIds: string[];
-    completedDeviceIds: string[];
-    failedDeviceIds: string[];
-    anomalyThreshold: number;
-    startedAt: Date;
-    updatedAt: Date;
-    completedAt?: Date;
-}
-export interface FirmwareOrchestrationDeps {
-    getDeviceFirmwareVersion: (deviceId: string) => Promise<string>;
-    deployFirmware: (deviceId: string, version: string) => Promise<{
-        success: boolean;
-        error?: string;
-    }>;
-    getDeviceAnomalyScore: (deviceId: string) => Promise<number>;
-}
-/**
- * State-machine-based firmware rollout engine.
- *
- * Lifecycle: pending -> canary -> rolling -> complete
- *                         |                     |
- *                    rolled-back              failed
- */
-export declare class FirmwareOrchestrationService {
-    private readonly deps;
-    private readonly rollouts;
-    private rolloutCounter;
-    constructor(deps: FirmwareOrchestrationDeps);
-    /**
-     * Create a new rollout.  Canary devices are selected as the first N%
-     * of `targetDeviceIds` based on `policy.canaryPercentage`.
-     */
-    createRollout(fleetId: string, firmwareVersion: string, targetDeviceIds: string[], policy: FirmwarePolicy): FirmwareRollout;
-    /**
-     * Advance the rollout through its state machine:
-     *   pending   -> canary   (deploy to canary devices)
-     *   canary    -> rolling  (anomaly check passes)
-     *   canary    -> rolled-back (anomaly check fails)
-     *   rolling   -> complete (deploy to remaining devices)
-     */
-    advanceRollout(rolloutId: string): Promise<FirmwareRollout>;
-    /**
-     * Force-rollback a rollout regardless of current stage.
-     */
-    rollbackRollout(rolloutId: string): FirmwareRollout;
-    /**
-     * Retrieve a rollout by ID.  Throws if not found.
-     */
-    getRollout(rolloutId: string): FirmwareRollout;
-    /**
-     * List rollouts, optionally filtered by fleet ID.
-     */
-    listRollouts(fleetId?: string): FirmwareRollout[];
-    private transitionPendingToCanary;
-    private transitionCanaryToNextStage;
-    private transitionRollingToComplete;
-    private deployToDevices;
-    private getExistingRollout;
-}
-//# sourceMappingURL=firmware-orchestration-service.d.ts.map