@nice2dev/ui-tools 1.0.10

package/dist/device-management.d.ts

@@ -0,0 +1,871 @@
+/**
+ * @file device-management.ts
+ * @module @nice2dev/ui-tools
+ * @description PRO-16.1 — Device Management
+ *
+ * Types for IoT device management: device registry, provisioning,
+ * device twins, firmware updates, health monitoring, PKI.
+ */
+/** Device status */
+export type DeviceStatus = 'online' | 'offline' | 'connecting' | 'error' | 'maintenance' | 'provisioning' | 'decommissioned';
+/** Device type */
+export type DeviceType = 'sensor' | 'actuator' | 'gateway' | 'edge' | 'display' | 'controller' | 'camera' | 'meter' | 'tracker' | 'custom';
+/** Connection protocol */
+export type ConnectionProtocol = 'mqtt' | 'amqp' | 'http' | 'https' | 'coap' | 'lwm2m' | 'websocket' | 'modbus' | 'opcua' | 'bacnet' | 'zigbee' | 'zwave' | 'bluetooth' | 'lora' | 'nbiot' | 'custom';
+/** Provisioning method */
+export type ProvisioningMethod = 'manual' | 'symmetric' | 'x509' | 'tpm' | 'dps' | 'qrcode' | 'nfc' | 'zeroTouch';
+/** Device registry configuration */
+export interface DeviceRegistryConfig {
+    /** Hub connection */
+    hub?: IoTHubConnection;
+    /** Theme */
+    theme?: DeviceRegistryTheme;
+    /** Locale */
+    locale?: string;
+    /** Features */
+    features?: DeviceRegistryFeatures;
+    /** Device types */
+    deviceTypes?: DeviceTypeDefinition[];
+    /** Groups */
+    groups?: DeviceGroupDefinition[];
+    /** Tags */
+    tags?: DeviceTagDefinition[];
+    /** Provisioning config */
+    provisioning?: ProvisioningConfig;
+    /** Update config */
+    updates?: FirmwareUpdateConfig;
+}
+/** IoT Hub connection */
+export interface IoTHubConnection {
+    type: 'azureIot' | 'awsIot' | 'gcpIot' | 'ibmWatson' | 'custom';
+    connectionString?: string;
+    endpoint?: string;
+    certificate?: string;
+    region?: string;
+    projectId?: string;
+    options?: Record<string, unknown>;
+}
+/** Device registry theme */
+export interface DeviceRegistryTheme {
+    name?: string;
+    background?: string;
+    surface?: string;
+    primary?: string;
+    deviceIcons?: DeviceIconSet;
+    statusColors?: StatusColorSet;
+}
+/** Device icon set */
+export interface DeviceIconSet {
+    sensor?: string;
+    actuator?: string;
+    gateway?: string;
+    edge?: string;
+    display?: string;
+    controller?: string;
+    camera?: string;
+    meter?: string;
+    tracker?: string;
+    custom?: string;
+}
+/** Status color set */
+export interface StatusColorSet {
+    online?: string;
+    offline?: string;
+    connecting?: string;
+    error?: string;
+    maintenance?: string;
+    provisioning?: string;
+    decommissioned?: string;
+}
+/** Device registry features */
+export interface DeviceRegistryFeatures {
+    provisioning?: boolean;
+    deviceTwin?: boolean;
+    commands?: boolean;
+    firmwareUpdate?: boolean;
+    health?: boolean;
+    location?: boolean;
+    certificates?: boolean;
+    bulkOperations?: boolean;
+    import?: boolean;
+    export?: boolean;
+}
+/** Device type definition */
+export interface DeviceTypeDefinition {
+    id: string;
+    name: string;
+    description?: string;
+    icon?: string;
+    capabilities?: DeviceCapability[];
+    properties?: DevicePropertySchema[];
+    commands?: DeviceCommandDefinition[];
+    telemetry?: TelemetryDefinition[];
+}
+/** Device capability */
+export type DeviceCapability = 'telemetry' | 'commands' | 'directMethods' | 'twinProperties' | 'cloudMessages' | 'fileUpload' | 'edgeModules' | 'offlineOperation';
+/** Device property schema */
+export interface DevicePropertySchema {
+    name: string;
+    displayName?: string;
+    type: PropertyType;
+    unit?: string;
+    writable?: boolean;
+    required?: boolean;
+    defaultValue?: unknown;
+    validation?: PropertyValidation;
+    semantic?: SemanticPropertyType;
+}
+/** Property type */
+export type PropertyType = 'string' | 'number' | 'integer' | 'boolean' | 'date' | 'datetime' | 'duration' | 'enum' | 'object' | 'array' | 'geopoint' | 'vector';
+/** Property validation */
+export interface PropertyValidation {
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    enum?: unknown[];
+    schema?: Record<string, unknown>;
+}
+/** Semantic property type */
+export type SemanticPropertyType = 'temperature' | 'humidity' | 'pressure' | 'voltage' | 'current' | 'power' | 'energy' | 'speed' | 'acceleration' | 'distance' | 'weight' | 'volume' | 'flow' | 'level' | 'brightness' | 'color' | 'angle' | 'frequency' | 'latitude' | 'longitude' | 'altitude' | 'heading' | 'timestamp';
+/** Device command definition */
+export interface DeviceCommandDefinition {
+    name: string;
+    displayName?: string;
+    description?: string;
+    requestSchema?: CommandSchema;
+    responseSchema?: CommandSchema;
+    timeout?: number;
+    confirmation?: boolean;
+}
+/** Command schema */
+export interface CommandSchema {
+    type: PropertyType;
+    properties?: DevicePropertySchema[];
+    required?: string[];
+}
+/** Telemetry definition */
+export interface TelemetryDefinition {
+    name: string;
+    displayName?: string;
+    description?: string;
+    type: PropertyType;
+    unit?: string;
+    semantic?: SemanticPropertyType;
+    aggregations?: TelemetryAggregation[];
+}
+/** Telemetry aggregation */
+export type TelemetryAggregation = 'avg' | 'min' | 'max' | 'sum' | 'count' | 'first' | 'last' | 'stddev';
+/** Device group definition */
+export interface DeviceGroupDefinition {
+    id: string;
+    name: string;
+    description?: string;
+    parent?: string;
+    filter?: DeviceFilter;
+    icon?: string;
+    color?: string;
+}
+/** Device filter */
+export interface DeviceFilter {
+    conditions: FilterCondition[];
+    operator: 'and' | 'or';
+}
+/** Filter condition */
+export interface FilterCondition {
+    field: string;
+    operator: FilterOperator;
+    value?: unknown;
+    values?: unknown[];
+}
+/** Filter operator */
+export type FilterOperator = 'equals' | 'notEquals' | 'contains' | 'startsWith' | 'endsWith' | 'greaterThan' | 'lessThan' | 'in' | 'notIn' | 'exists' | 'notExists';
+/** Device tag definition */
+export interface DeviceTagDefinition {
+    key: string;
+    displayName?: string;
+    description?: string;
+    type?: 'string' | 'number' | 'boolean';
+    allowedValues?: unknown[];
+    required?: boolean;
+}
+/** Provisioning configuration */
+export interface ProvisioningConfig {
+    methods?: ProvisioningMethod[];
+    defaultMethod?: ProvisioningMethod;
+    dps?: DPSConfig;
+    attestation?: AttestationConfig;
+    enrollment?: EnrollmentConfig;
+}
+/** Device Provisioning Service config */
+export interface DPSConfig {
+    endpoint?: string;
+    idScope?: string;
+    globalEndpoint?: string;
+}
+/** Attestation config */
+export interface AttestationConfig {
+    symmetric?: SymmetricKeyConfig;
+    x509?: X509Config;
+    tpm?: TPMConfig;
+}
+/** Symmetric key config */
+export interface SymmetricKeyConfig {
+    primaryKey?: string;
+    secondaryKey?: string;
+    keyLength?: number;
+}
+/** X.509 config */
+export interface X509Config {
+    rootCertificate?: string;
+    intermediateCertificates?: string[];
+    verification?: CertificateVerification;
+}
+/** Certificate verification */
+export interface CertificateVerification {
+    revocationCheck?: boolean;
+    crlEndpoint?: string;
+    ocspEndpoint?: string;
+}
+/** TPM config */
+export interface TPMConfig {
+    endorsementKey?: string;
+    storageRootKey?: string;
+}
+/** Enrollment config */
+export interface EnrollmentConfig {
+    individual?: boolean;
+    group?: boolean;
+    autoApprove?: boolean;
+    tags?: Record<string, string>;
+    twins?: Record<string, unknown>;
+}
+/** Firmware update config */
+export interface FirmwareUpdateConfig {
+    enabled?: boolean;
+    storage?: UpdateStorageConfig;
+    rollout?: RolloutConfig;
+    rollback?: RollbackConfig;
+}
+/** Update storage config */
+export interface UpdateStorageConfig {
+    type: 'blob' | 's3' | 'gcs' | 'http';
+    endpoint?: string;
+    container?: string;
+    bucket?: string;
+    credentials?: string;
+}
+/** Rollout config */
+export interface RolloutConfig {
+    strategy: 'all' | 'staged' | 'canary' | 'blueGreen';
+    stages?: RolloutStage[];
+    pauseOnFailure?: boolean;
+    failureThreshold?: number;
+}
+/** Rollout stage */
+export interface RolloutStage {
+    name: string;
+    percentage: number;
+    filter?: DeviceFilter;
+    delay?: number;
+}
+/** Rollback config */
+export interface RollbackConfig {
+    auto?: boolean;
+    failureThreshold?: number;
+    keepPrevious?: number;
+}
+/** Device */
+export interface Device {
+    id: string;
+    displayName?: string;
+    type: DeviceType;
+    typeId?: string;
+    status: DeviceStatus;
+    connectionState: ConnectionState;
+    provisioning?: DeviceProvisioning;
+    twin?: DeviceTwin;
+    health?: DeviceHealth;
+    location?: DeviceLocation;
+    certificates?: DeviceCertificates;
+    metadata?: DeviceMetadata;
+}
+/** Connection state */
+export interface ConnectionState {
+    connected: boolean;
+    connectedAt?: Date;
+    disconnectedAt?: Date;
+    protocol?: ConnectionProtocol;
+    ipAddress?: string;
+    port?: number;
+    sessionId?: string;
+    reconnectAttempts?: number;
+}
+/** Device provisioning */
+export interface DeviceProvisioning {
+    status: ProvisioningStatus;
+    method: ProvisioningMethod;
+    registrationId?: string;
+    enrollmentGroupId?: string;
+    provisionedAt?: Date;
+    assignedHub?: string;
+    attestationType?: string;
+}
+/** Provisioning status */
+export type ProvisioningStatus = 'unregistered' | 'pending' | 'assigned' | 'failed' | 'disabled';
+/** Device twin */
+export interface DeviceTwin {
+    desired: TwinProperties;
+    reported: TwinProperties;
+    tags?: Record<string, unknown>;
+    version?: number;
+    etag?: string;
+    lastUpdated?: Date;
+}
+/** Twin properties */
+export interface TwinProperties {
+    [key: string]: unknown;
+    $metadata?: TwinMetadata;
+    $version?: number;
+}
+/** Twin metadata */
+export interface TwinMetadata {
+    [key: string]: {
+        $lastUpdated?: string;
+        $lastUpdatedVersion?: number;
+    };
+}
+/** Device health */
+export interface DeviceHealth {
+    overall: HealthStatus;
+    lastHeartbeat?: Date;
+    heartbeatInterval?: number;
+    battery?: BatteryStatus;
+    signal?: SignalStatus;
+    memory?: ResourceStatus;
+    storage?: ResourceStatus;
+    cpu?: ResourceStatus;
+    temperature?: TemperatureStatus;
+    diagnostics?: DeviceDiagnostics;
+}
+/** Health status */
+export type HealthStatus = 'healthy' | 'degraded' | 'unhealthy' | 'unknown';
+/** Battery status */
+export interface BatteryStatus {
+    level: number;
+    charging?: boolean;
+    voltage?: number;
+    health?: number;
+    estimatedLife?: number;
+}
+/** Signal status */
+export interface SignalStatus {
+    strength: number;
+    quality?: number;
+    type?: 'wifi' | 'cellular' | 'lora' | 'zigbee' | 'bluetooth';
+    network?: string;
+}
+/** Resource status */
+export interface ResourceStatus {
+    used: number;
+    total: number;
+    percent: number;
+    unit?: string;
+}
+/** Temperature status */
+export interface TemperatureStatus {
+    current: number;
+    min?: number;
+    max?: number;
+    warning?: number;
+    critical?: number;
+    unit?: 'celsius' | 'fahrenheit' | 'kelvin';
+}
+/** Device diagnostics */
+export interface DeviceDiagnostics {
+    uptime?: number;
+    restarts?: number;
+    lastRestart?: Date;
+    restartReason?: string;
+    errors?: DeviceError[];
+    warnings?: DeviceWarning[];
+}
+/** Device error */
+export interface DeviceError {
+    code: string;
+    message: string;
+    timestamp: Date;
+    severity: 'error' | 'critical';
+    component?: string;
+    stack?: string;
+}
+/** Device warning */
+export interface DeviceWarning {
+    code: string;
+    message: string;
+    timestamp: Date;
+    component?: string;
+}
+/** Device location */
+export interface DeviceLocation {
+    latitude: number;
+    longitude: number;
+    altitude?: number;
+    accuracy?: number;
+    source?: LocationSource;
+    timestamp?: Date;
+    address?: LocationAddress;
+    geofences?: GeofenceStatus[];
+}
+/** Location source */
+export type LocationSource = 'gps' | 'wifi' | 'cell' | 'ip' | 'manual' | 'beacon';
+/** Location address */
+export interface LocationAddress {
+    street?: string;
+    city?: string;
+    state?: string;
+    country?: string;
+    postalCode?: string;
+    formatted?: string;
+}
+/** Geofence status */
+export interface GeofenceStatus {
+    id: string;
+    name: string;
+    inside: boolean;
+    enteredAt?: Date;
+    exitedAt?: Date;
+}
+/** Device certificates */
+export interface DeviceCertificates {
+    device?: DeviceCertificate;
+    ca?: CACertificate[];
+    expiringSoon?: boolean;
+    expirationWarningDays?: number;
+}
+/** Device certificate */
+export interface DeviceCertificate {
+    thumbprint: string;
+    subject: string;
+    issuer: string;
+    serialNumber: string;
+    validFrom: Date;
+    validTo: Date;
+    algorithm?: string;
+    keySize?: number;
+}
+/** CA certificate */
+export interface CACertificate {
+    thumbprint: string;
+    subject: string;
+    issuer: string;
+    validTo: Date;
+}
+/** Device metadata */
+export interface DeviceMetadata {
+    created: Date;
+    createdBy?: string;
+    modified?: Date;
+    modifiedBy?: string;
+    manufacturer?: string;
+    model?: string;
+    serialNumber?: string;
+    hwVersion?: string;
+    swVersion?: string;
+    fwVersion?: string;
+    osVersion?: string;
+    tags?: Record<string, string>;
+    groups?: string[];
+    notes?: string;
+}
+/** Device command */
+export interface DeviceCommand {
+    id: string;
+    deviceId: string;
+    name: string;
+    payload?: unknown;
+    status: CommandStatus;
+    requestedAt: Date;
+    requestedBy?: string;
+    executedAt?: Date;
+    completedAt?: Date;
+    response?: unknown;
+    error?: CommandError;
+    timeout?: number;
+}
+/** Command status */
+export type CommandStatus = 'queued' | 'pending' | 'executing' | 'completed' | 'failed' | 'timeout' | 'cancelled';
+/** Command error */
+export interface CommandError {
+    code: string;
+    message: string;
+    details?: unknown;
+}
+/** Direct method request */
+export interface DirectMethodRequest {
+    deviceId: string;
+    methodName: string;
+    payload?: unknown;
+    responseTimeout?: number;
+    connectionTimeout?: number;
+}
+/** Direct method response */
+export interface DirectMethodResponse {
+    status: number;
+    payload?: unknown;
+    requestId?: string;
+}
+/** Cloud-to-device message */
+export interface CloudToDeviceMessage {
+    id: string;
+    deviceId: string;
+    body: string | Uint8Array;
+    properties?: Record<string, string>;
+    correlationId?: string;
+    messageId?: string;
+    contentType?: string;
+    contentEncoding?: string;
+    expiryTimeUtc?: Date;
+    ack?: MessageAck;
+    status?: MessageStatus;
+    enqueuedTime?: Date;
+    deliveredTime?: Date;
+}
+/** Message acknowledgment */
+export type MessageAck = 'none' | 'positive' | 'negative' | 'full';
+/** Message status */
+export type MessageStatus = 'enqueued' | 'delivered' | 'completed' | 'abandoned' | 'rejected' | 'expired';
+/** Firmware */
+export interface Firmware {
+    id: string;
+    name: string;
+    version: string;
+    description?: string;
+    deviceType?: string;
+    size: number;
+    checksum: string;
+    checksumType: 'md5' | 'sha1' | 'sha256';
+    url?: string;
+    releaseNotes?: string;
+    releaseDate?: Date;
+    minHwVersion?: string;
+    maxHwVersion?: string;
+    dependencies?: FirmwareDependency[];
+    status: FirmwareStatus;
+    metadata?: FirmwareMetadata;
+}
+/** Firmware dependency */
+export interface FirmwareDependency {
+    name: string;
+    minVersion?: string;
+    maxVersion?: string;
+}
+/** Firmware status */
+export type FirmwareStatus = 'draft' | 'testing' | 'released' | 'deprecated' | 'recalled';
+/** Firmware metadata */
+export interface FirmwareMetadata {
+    created: Date;
+    createdBy?: string;
+    modified?: Date;
+    testedDevices?: number;
+    deployedDevices?: number;
+    successRate?: number;
+}
+/** Firmware update job */
+export interface FirmwareUpdateJob {
+    id: string;
+    firmwareId: string;
+    name?: string;
+    target: UpdateTarget;
+    rollout: RolloutConfig;
+    status: UpdateJobStatus;
+    progress?: UpdateProgress;
+    created: Date;
+    createdBy?: string;
+    started?: Date;
+    completed?: Date;
+    error?: string;
+}
+/** Update target */
+export interface UpdateTarget {
+    type: 'all' | 'group' | 'filter' | 'devices';
+    groupId?: string;
+    filter?: DeviceFilter;
+    deviceIds?: string[];
+}
+/** Update job status */
+export type UpdateJobStatus = 'created' | 'scheduled' | 'inProgress' | 'paused' | 'completed' | 'failed' | 'cancelled' | 'rollingBack';
+/** Update progress */
+export interface UpdateProgress {
+    total: number;
+    pending: number;
+    downloading: number;
+    installing: number;
+    succeeded: number;
+    failed: number;
+    skipped: number;
+    currentStage?: string;
+    stageProgress?: number;
+}
+/** Device update status */
+export interface DeviceUpdateStatus {
+    deviceId: string;
+    jobId: string;
+    status: DeviceUpdateState;
+    progress: number;
+    currentVersion?: string;
+    targetVersion?: string;
+    startedAt?: Date;
+    completedAt?: Date;
+    error?: string;
+    retryCount?: number;
+}
+/** Device update state */
+export type DeviceUpdateState = 'pending' | 'downloading' | 'downloaded' | 'installing' | 'rebooting' | 'verifying' | 'succeeded' | 'failed' | 'rolledBack' | 'skipped';
+/** Enrollment */
+export interface Enrollment {
+    id: string;
+    type: 'individual' | 'group';
+    registrationId?: string;
+    groupName?: string;
+    attestation: EnrollmentAttestation;
+    status: EnrollmentStatus;
+    devices?: string[];
+    initialTwin?: DeviceTwin;
+    iotHubs?: string[];
+    allocationPolicy?: AllocationPolicy;
+    created: Date;
+    modified?: Date;
+    etag?: string;
+}
+/** Enrollment attestation */
+export interface EnrollmentAttestation {
+    type: 'symmetricKey' | 'x509' | 'tpm';
+    symmetricKey?: SymmetricKeyAttestation;
+    x509?: X509Attestation;
+    tpm?: TPMAttestation;
+}
+/** Symmetric key attestation */
+export interface SymmetricKeyAttestation {
+    primaryKey: string;
+    secondaryKey?: string;
+}
+/** X.509 attestation */
+export interface X509Attestation {
+    clientCertificates?: X509Certificates;
+    signingCertificates?: X509Certificates;
+    caReferences?: CAReference[];
+}
+/** X.509 certificates */
+export interface X509Certificates {
+    primary?: X509CertificateInfo;
+    secondary?: X509CertificateInfo;
+}
+/** X.509 certificate info */
+export interface X509CertificateInfo {
+    certificate?: string;
+    thumbprint: string;
+    subject?: string;
+    notBefore?: Date;
+    notAfter?: Date;
+}
+/** CA reference */
+export interface CAReference {
+    certificateName: string;
+    thumbprint: string;
+}
+/** TPM attestation */
+export interface TPMAttestation {
+    endorsementKey: string;
+    storageRootKey?: string;
+}
+/** Enrollment status */
+export type EnrollmentStatus = 'enabled' | 'disabled';
+/** Allocation policy */
+export type AllocationPolicy = 'hashed' | 'geoLatency' | 'static' | 'custom';
+/** Registration state */
+export interface RegistrationState {
+    registrationId: string;
+    status: RegistrationStatus;
+    deviceId?: string;
+    assignedHub?: string;
+    substatus?: RegistrationSubstatus;
+    errorCode?: number;
+    errorMessage?: string;
+    lastUpdated: Date;
+    etag?: string;
+}
+/** Registration status */
+export type RegistrationStatus = 'unassigned' | 'assigning' | 'assigned' | 'failed' | 'disabled';
+/** Registration substatus */
+export type RegistrationSubstatus = 'initialAssignment' | 'deviceDataMigrated' | 'deviceDataReset';
+/** Device group */
+export interface DeviceGroup {
+    id: string;
+    name: string;
+    description?: string;
+    parent?: string;
+    path?: string;
+    filter?: DeviceFilter;
+    deviceCount?: number;
+    icon?: string;
+    color?: string;
+    metadata?: GroupMetadata;
+}
+/** Group metadata */
+export interface GroupMetadata {
+    created: Date;
+    createdBy?: string;
+    modified?: Date;
+    modifiedBy?: string;
+    tags?: Record<string, string>;
+}
+/** Group statistics */
+export interface GroupStatistics {
+    groupId: string;
+    totalDevices: number;
+    onlineDevices: number;
+    offlineDevices: number;
+    errorDevices: number;
+    healthyDevices: number;
+    unhealthyDevices: number;
+    updatedDevices?: number;
+    outdatedDevices?: number;
+}
+/** Device event */
+export interface DeviceEvent {
+    id: string;
+    deviceId: string;
+    type: DeviceEventType;
+    timestamp: Date;
+    data?: unknown;
+    properties?: Record<string, string>;
+    correlationId?: string;
+}
+/** Device event type */
+export type DeviceEventType = 'connected' | 'disconnected' | 'telemetry' | 'twinChange' | 'command' | 'error' | 'warning' | 'lifecycle' | 'update' | 'location' | 'alert';
+/** Telemetry message */
+export interface TelemetryMessage {
+    deviceId: string;
+    timestamp: Date;
+    enqueuedTime?: Date;
+    properties?: Record<string, string>;
+    systemProperties?: SystemProperties;
+    body: Record<string, unknown>;
+}
+/** System properties */
+export interface SystemProperties {
+    contentType?: string;
+    contentEncoding?: string;
+    correlationId?: string;
+    messageId?: string;
+    userId?: string;
+}
+/** Telemetry query */
+export interface TelemetryQuery {
+    deviceId?: string;
+    deviceIds?: string[];
+    groupId?: string;
+    metrics: string[];
+    startTime: Date;
+    endTime: Date;
+    interval?: string;
+    aggregation?: TelemetryAggregation;
+    filter?: string;
+    limit?: number;
+}
+/** Telemetry result */
+export interface TelemetryResult {
+    deviceId: string;
+    metric: string;
+    timestamps: Date[];
+    values: number[];
+    aggregation?: TelemetryAggregation;
+    count?: number;
+    min?: number;
+    max?: number;
+    avg?: number;
+    sum?: number;
+}
+/** Device alert */
+export interface DeviceAlert {
+    id: string;
+    deviceId: string;
+    ruleId?: string;
+    severity: AlertSeverity;
+    type: AlertType;
+    message: string;
+    timestamp: Date;
+    acknowledged?: boolean;
+    acknowledgedBy?: string;
+    acknowledgedAt?: Date;
+    resolved?: boolean;
+    resolvedAt?: Date;
+    data?: Record<string, unknown>;
+}
+/** Alert severity */
+export type AlertSeverity = 'info' | 'warning' | 'error' | 'critical';
+/** Alert type */
+export type AlertType = 'connectivity' | 'threshold' | 'anomaly' | 'health' | 'security' | 'update' | 'custom';
+/** Alert rule */
+export interface AlertRule {
+    id: string;
+    name: string;
+    description?: string;
+    enabled: boolean;
+    target: AlertTarget;
+    condition: AlertCondition;
+    severity: AlertSeverity;
+    actions: AlertAction[];
+    cooldown?: number;
+    metadata?: RuleMetadata;
+}
+/** Alert target */
+export interface AlertTarget {
+    type: 'all' | 'group' | 'device' | 'filter';
+    groupId?: string;
+    deviceId?: string;
+    filter?: DeviceFilter;
+}
+/** Alert condition */
+export interface AlertCondition {
+    type: ConditionTypes;
+    metric?: string;
+    operator?: ComparisonOperator;
+    threshold?: number;
+    duration?: number;
+    evaluationPeriod?: number;
+    aggregation?: TelemetryAggregation;
+}
+/** Condition types */
+export type ConditionTypes = 'threshold' | 'change' | 'absence' | 'anomaly' | 'connectivity' | 'expression';
+/** Comparison operator */
+export type ComparisonOperator = 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'neq';
+/** Alert action */
+export interface AlertAction {
+    type: ActionType;
+    config: ActionConfig;
+}
+/** Action type */
+export type ActionType = 'email' | 'sms' | 'webhook' | 'teams' | 'slack' | 'pagerduty' | 'command' | 'function';
+/** Action config */
+export interface ActionConfig {
+    recipients?: string[];
+    url?: string;
+    channel?: string;
+    message?: string;
+    template?: string;
+    command?: string;
+    payload?: unknown;
+}
+/** Rule metadata */
+export interface RuleMetadata {
+    created: Date;
+    createdBy?: string;
+    modified?: Date;
+    modifiedBy?: string;
+    triggerCount?: number;
+    lastTriggered?: Date;
+}
+//# sourceMappingURL=device-management.d.ts.map