@nice2dev/ui-tools 1.0.10

package/dist/sensor-dashboard.d.ts

@@ -0,0 +1,845 @@
+/**
+ * @file sensor-dashboard.ts
+ * @module @nice2dev/ui-tools
+ * @description PRO-16.2 — Sensor Dashboard
+ *
+ * Types for real-time sensor dashboard: sensor types, live gauges,
+ * historical charts, threshold alerts, geospatial view, calibration.
+ */
+/** Sensor type */
+export type SensorTypeId = 'temperature' | 'humidity' | 'pressure' | 'light' | 'motion' | 'proximity' | 'accelerometer' | 'gyroscope' | 'magnetometer' | 'gps' | 'co2' | 'voc' | 'pm25' | 'pm10' | 'noise' | 'vibration' | 'current' | 'voltage' | 'power' | 'energy' | 'flow' | 'level' | 'ph' | 'conductivity' | 'turbidity' | 'weight' | 'strain' | 'distance' | 'speed' | 'rpm' | 'custom';
+/** Display mode */
+export type DisplayMode = 'gauge' | 'value' | 'chart' | 'sparkline' | 'status' | 'map' | 'heatmap';
+/** Alert status */
+export type SensorAlertStatus = 'normal' | 'warning' | 'critical' | 'unknown' | 'disabled';
+/** Time range preset */
+export type TimeRangePreset = 'realtime' | 'last5m' | 'last15m' | 'last30m' | 'last1h' | 'last6h' | 'last12h' | 'last24h' | 'last7d' | 'last30d' | 'custom';
+/** Sensor dashboard configuration */
+export interface SensorDashboardConfig {
+    /** Data source */
+    dataSource?: SensorDataSource;
+    /** Theme */
+    theme?: SensorDashboardTheme;
+    /** Locale */
+    locale?: string;
+    /** Features */
+    features?: SensorDashboardFeatures;
+    /** Sensor types */
+    sensorTypes?: SensorTypeConfig[];
+    /** Widgets */
+    widgets?: WidgetConfig[];
+    /** Alerts */
+    alerts?: AlertConfig;
+    /** Map config */
+    map?: MapConfig;
+    /** Export config */
+    export?: ExportConfig;
+}
+/** Sensor data source */
+export interface SensorDataSource {
+    type: 'iot' | 'timeseries' | 'mqtt' | 'websocket' | 'rest';
+    endpoint?: string;
+    credentials?: DataSourceCredentials;
+    options?: Record<string, unknown>;
+    polling?: PollingConfig;
+    streaming?: StreamingConfig;
+}
+/** Data source credentials */
+export interface DataSourceCredentials {
+    type: 'apiKey' | 'bearer' | 'basic' | 'oauth2';
+    apiKey?: string;
+    token?: string;
+    username?: string;
+    password?: string;
+    clientId?: string;
+    clientSecret?: string;
+}
+/** Polling config */
+export interface PollingConfig {
+    enabled: boolean;
+    interval: number;
+    backoff?: boolean;
+    maxInterval?: number;
+}
+/** Streaming config */
+export interface StreamingConfig {
+    enabled: boolean;
+    protocol: 'websocket' | 'sse' | 'mqtt';
+    reconnect?: boolean;
+    reconnectInterval?: number;
+    maxRetries?: number;
+}
+/** Sensor dashboard theme */
+export interface SensorDashboardTheme {
+    name?: string;
+    background?: string;
+    surface?: string;
+    primary?: string;
+    secondary?: string;
+    gaugeColors?: GaugeColorScheme;
+    chartColors?: string[];
+    alertColors?: AlertColorScheme;
+}
+/** Gauge color scheme */
+export interface GaugeColorScheme {
+    normal?: string;
+    warning?: string;
+    critical?: string;
+    background?: string;
+    needle?: string;
+    text?: string;
+}
+/** Alert color scheme */
+export interface AlertColorScheme {
+    normal?: string;
+    warning?: string;
+    critical?: string;
+    unknown?: string;
+}
+/** Sensor dashboard features */
+export interface SensorDashboardFeatures {
+    realtime?: boolean;
+    historical?: boolean;
+    alerts?: boolean;
+    map?: boolean;
+    calibration?: boolean;
+    export?: boolean;
+    annotations?: boolean;
+    comparison?: boolean;
+    anomalyDetection?: boolean;
+    forecasting?: boolean;
+}
+/** Sensor type configuration */
+export interface SensorTypeConfig {
+    id: SensorTypeId;
+    name: string;
+    icon?: string;
+    color?: string;
+    unit: string;
+    unitSymbol?: string;
+    precision?: number;
+    min?: number;
+    max?: number;
+    defaultThresholds?: SensorThresholds;
+    calibration?: CalibrationConfig;
+    display?: DisplayConfig;
+}
+/** Sensor thresholds */
+export interface SensorThresholds {
+    warningLow?: number;
+    warningHigh?: number;
+    criticalLow?: number;
+    criticalHigh?: number;
+}
+/** Calibration config */
+export interface CalibrationConfig {
+    enabled?: boolean;
+    offset?: number;
+    scale?: number;
+    formula?: string;
+    points?: CalibrationPoint[];
+}
+/** Calibration point */
+export interface CalibrationPoint {
+    raw: number;
+    calibrated: number;
+}
+/** Display config */
+export interface DisplayConfig {
+    mode?: DisplayMode;
+    gauge?: GaugeConfig;
+    chart?: ChartConfig;
+    format?: ValueFormatConfig;
+}
+/** Gauge config */
+export interface GaugeConfig {
+    type?: 'radial' | 'linear' | 'arc' | 'thermometer';
+    min?: number;
+    max?: number;
+    segments?: GaugeSegment[];
+    showValue?: boolean;
+    showMinMax?: boolean;
+    animated?: boolean;
+    size?: 'small' | 'medium' | 'large';
+}
+/** Gauge segment */
+export interface GaugeSegment {
+    from: number;
+    to: number;
+    color: string;
+    label?: string;
+}
+/** Chart config */
+export interface ChartConfig {
+    type?: 'line' | 'area' | 'bar' | 'scatter';
+    fill?: boolean;
+    smooth?: boolean;
+    showPoints?: boolean;
+    showGrid?: boolean;
+    showLegend?: boolean;
+    animation?: boolean;
+}
+/** Value format config */
+export interface ValueFormatConfig {
+    decimals?: number;
+    prefix?: string;
+    suffix?: string;
+    locale?: string;
+}
+/** Widget config */
+export interface WidgetConfig {
+    id: string;
+    type: WidgetType;
+    title?: string;
+    position: WidgetPosition;
+    size: WidgetSize;
+    sensors?: string[];
+    config?: WidgetTypeConfig;
+}
+/** Widget type */
+export type WidgetType = 'gauge' | 'value' | 'chart' | 'sparkline' | 'table' | 'map' | 'heatmap' | 'status' | 'alert' | 'comparison';
+/** Widget position */
+export interface WidgetPosition {
+    x: number;
+    y: number;
+}
+/** Widget size */
+export interface WidgetSize {
+    width: number;
+    height: number;
+}
+/** Widget type config */
+export type WidgetTypeConfig = GaugeWidgetConfig | ValueWidgetConfig | ChartWidgetConfig | TableWidgetConfig | MapWidgetConfig | HeatmapWidgetConfig;
+/** Gauge widget config */
+export interface GaugeWidgetConfig {
+    type: 'gauge';
+    gauge: GaugeConfig;
+    showTrend?: boolean;
+    showAlertStatus?: boolean;
+}
+/** Value widget config */
+export interface ValueWidgetConfig {
+    type: 'value';
+    format: ValueFormatConfig;
+    showChange?: boolean;
+    showSparkline?: boolean;
+    showTimestamp?: boolean;
+}
+/** Chart widget config */
+export interface ChartWidgetConfig {
+    type: 'chart';
+    chart: ChartConfig;
+    timeRange?: TimeRangePreset;
+    aggregation?: AggregationType;
+    showAnnotations?: boolean;
+    showThresholds?: boolean;
+}
+/** Aggregation type */
+export type AggregationType = 'raw' | 'avg' | 'min' | 'max' | 'sum' | 'count' | 'first' | 'last' | 'median' | 'p95' | 'p99';
+/** Table widget config */
+export interface TableWidgetConfig {
+    type: 'table';
+    columns: TableColumn[];
+    sortable?: boolean;
+    filterable?: boolean;
+    pageSize?: number;
+}
+/** Table column */
+export interface TableColumn {
+    field: string;
+    header: string;
+    width?: number;
+    format?: ValueFormatConfig;
+    sortable?: boolean;
+}
+/** Map widget config */
+export interface MapWidgetConfig {
+    type: 'map';
+    center?: MapCenter;
+    zoom?: number;
+    clustering?: boolean;
+    heatmap?: boolean;
+    geofences?: boolean;
+}
+/** Map center */
+export interface MapCenter {
+    latitude: number;
+    longitude: number;
+}
+/** Heatmap widget config */
+export interface HeatmapWidgetConfig {
+    type: 'heatmap';
+    xAxis: string;
+    yAxis: string;
+    colorScale: string[];
+    showLabels?: boolean;
+}
+/** Alert config */
+export interface AlertConfig {
+    enabled?: boolean;
+    rules?: SensorAlertRule[];
+    notifications?: NotificationConfig;
+    acknowledgment?: AcknowledgmentConfig;
+}
+/** Sensor alert rule */
+export interface SensorAlertRule {
+    id: string;
+    name: string;
+    enabled: boolean;
+    sensors?: string[];
+    sensorTypes?: SensorTypeId[];
+    condition: AlertCondition;
+    severity: 'warning' | 'critical';
+    message?: string;
+    cooldown?: number;
+}
+/** Alert condition */
+export interface AlertCondition {
+    type: 'threshold' | 'change' | 'absence' | 'anomaly';
+    operator?: 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'neq';
+    value?: number;
+    duration?: number;
+    changePercent?: number;
+    absenceMinutes?: number;
+}
+/** Notification config */
+export interface NotificationConfig {
+    inApp?: boolean;
+    email?: EmailNotificationConfig;
+    sms?: SMSNotificationConfig;
+    webhook?: WebhookNotificationConfig;
+    push?: PushNotificationConfig;
+}
+/** Email notification config */
+export interface EmailNotificationConfig {
+    enabled: boolean;
+    recipients: string[];
+    template?: string;
+}
+/** SMS notification config */
+export interface SMSNotificationConfig {
+    enabled: boolean;
+    recipients: string[];
+    provider?: string;
+}
+/** Webhook notification config */
+export interface WebhookNotificationConfig {
+    enabled: boolean;
+    url: string;
+    method?: 'POST' | 'PUT';
+    headers?: Record<string, string>;
+}
+/** Push notification config */
+export interface PushNotificationConfig {
+    enabled: boolean;
+    topics?: string[];
+}
+/** Acknowledgment config */
+export interface AcknowledgmentConfig {
+    required?: boolean;
+    autoResolve?: boolean;
+    autoResolveMinutes?: number;
+}
+/** Map config */
+export interface MapConfig {
+    provider: 'mapbox' | 'google' | 'leaflet' | 'azure';
+    apiKey?: string;
+    style?: string;
+    defaultCenter?: MapCenter;
+    defaultZoom?: number;
+    clustering?: ClusteringConfig;
+    geofences?: GeofenceConfig;
+}
+/** Clustering config */
+export interface ClusteringConfig {
+    enabled: boolean;
+    minPoints?: number;
+    radius?: number;
+    showCount?: boolean;
+}
+/** Geofence config */
+export interface GeofenceConfig {
+    enabled: boolean;
+    editable?: boolean;
+    fillColor?: string;
+    strokeColor?: string;
+    fillOpacity?: number;
+}
+/** Export config */
+export interface ExportConfig {
+    formats?: ('csv' | 'json' | 'xlsx' | 'pdf')[];
+    maxRows?: number;
+    includeMetadata?: boolean;
+}
+/** Sensor */
+export interface Sensor {
+    id: string;
+    name: string;
+    type: SensorTypeId;
+    deviceId: string;
+    deviceName?: string;
+    location?: SensorLocation;
+    status: SensorStatus;
+    currentValue?: SensorValue;
+    thresholds?: SensorThresholds;
+    calibration?: CalibrationConfig;
+    metadata?: SensorMetadata;
+}
+/** Sensor location */
+export interface SensorLocation {
+    latitude?: number;
+    longitude?: number;
+    altitude?: number;
+    floor?: number;
+    room?: string;
+    zone?: string;
+    building?: string;
+    custom?: Record<string, string>;
+}
+/** Sensor status */
+export interface SensorStatus {
+    online: boolean;
+    alertStatus: SensorAlertStatus;
+    lastSeen?: Date;
+    health?: SensorHealth;
+    battery?: number;
+    signal?: number;
+}
+/** Sensor health */
+export interface SensorHealth {
+    overall: 'good' | 'degraded' | 'poor' | 'unknown';
+    issues?: HealthIssue[];
+}
+/** Health issue */
+export interface HealthIssue {
+    type: 'calibration' | 'drift' | 'noise' | 'connectivity' | 'battery' | 'custom';
+    severity: 'warning' | 'critical';
+    message: string;
+    detected?: Date;
+}
+/** Sensor value */
+export interface SensorValue {
+    value: number;
+    unit: string;
+    timestamp: Date;
+    quality?: ValueQuality;
+    raw?: number;
+}
+/** Value quality */
+export type ValueQuality = 'good' | 'uncertain' | 'bad' | 'substituted';
+/** Sensor metadata */
+export interface SensorMetadata {
+    manufacturer?: string;
+    model?: string;
+    serialNumber?: string;
+    firmwareVersion?: string;
+    installDate?: Date;
+    lastCalibration?: Date;
+    nextCalibration?: Date;
+    tags?: Record<string, string>;
+    custom?: Record<string, unknown>;
+}
+/** Sensor reading */
+export interface SensorReading {
+    sensorId: string;
+    value: number;
+    unit: string;
+    timestamp: Date;
+    quality?: ValueQuality;
+    raw?: number;
+    metadata?: ReadingMetadata;
+}
+/** Reading metadata */
+export interface ReadingMetadata {
+    source?: 'device' | 'calculated' | 'interpolated' | 'manual';
+    confidence?: number;
+    annotations?: string[];
+}
+/** Historical query */
+export interface HistoricalQuery {
+    sensorIds: string[];
+    startTime: Date;
+    endTime: Date;
+    aggregation?: AggregationType;
+    interval?: string;
+    fill?: FillStrategy;
+    limit?: number;
+}
+/** Fill strategy */
+export type FillStrategy = 'none' | 'null' | 'previous' | 'linear' | 'zero';
+/** Historical result */
+export interface HistoricalResult {
+    sensorId: string;
+    sensorName?: string;
+    unit: string;
+    data: TimeSeriesPoint[];
+    statistics?: DataStatistics;
+}
+/** Time series point */
+export interface TimeSeriesPoint {
+    timestamp: Date;
+    value: number | null;
+    quality?: ValueQuality;
+    min?: number;
+    max?: number;
+    count?: number;
+}
+/** Data statistics */
+export interface DataStatistics {
+    count: number;
+    min: number;
+    max: number;
+    avg: number;
+    sum: number;
+    stddev?: number;
+    median?: number;
+    p95?: number;
+    p99?: number;
+    first?: number;
+    last?: number;
+    firstTime?: Date;
+    lastTime?: Date;
+}
+/** Sensor alert */
+export interface SensorAlert {
+    id: string;
+    sensorId: string;
+    sensorName?: string;
+    ruleId?: string;
+    ruleName?: string;
+    severity: 'warning' | 'critical';
+    status: 'active' | 'acknowledged' | 'resolved';
+    message: string;
+    value?: number;
+    threshold?: number;
+    timestamp: Date;
+    acknowledgedAt?: Date;
+    acknowledgedBy?: string;
+    resolvedAt?: Date;
+    resolvedBy?: string;
+    notes?: string;
+}
+/** Alert summary */
+export interface AlertSummary {
+    total: number;
+    active: number;
+    acknowledged: number;
+    resolved: number;
+    bySeverity: {
+        warning: number;
+        critical: number;
+    };
+    bySensor?: Record<string, number>;
+    byType?: Record<string, number>;
+}
+/** Aggregation query */
+export interface AggregationQuery {
+    sensorIds?: string[];
+    sensorTypes?: SensorTypeId[];
+    groupBy?: GroupByField[];
+    aggregations: AggregationField[];
+    timeRange: TimeRange;
+    interval?: string;
+    filters?: AggregationFilter[];
+}
+/** Group by field */
+export type GroupByField = 'sensor' | 'sensorType' | 'device' | 'location' | 'zone' | 'building' | 'time';
+/** Aggregation field */
+export interface AggregationField {
+    field: string;
+    aggregation: AggregationType;
+    alias?: string;
+}
+/** Time range */
+export interface TimeRange {
+    start: Date;
+    end: Date;
+}
+/** Aggregation filter */
+export interface AggregationFilter {
+    field: string;
+    operator: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'contains';
+    value: unknown;
+}
+/** Aggregation result */
+export interface AggregationResult {
+    groups: AggregationGroup[];
+    metadata: AggregationMetadata;
+}
+/** Aggregation group */
+export interface AggregationGroup {
+    keys: Record<string, string>;
+    values: Record<string, number>;
+    count: number;
+}
+/** Aggregation metadata */
+export interface AggregationMetadata {
+    totalGroups: number;
+    totalRecords: number;
+    executionTime: number;
+    truncated?: boolean;
+}
+/** Anomaly detection config */
+export interface AnomalyDetectionConfig {
+    method: 'zscore' | 'iqr' | 'isolation' | 'dbscan' | 'prophet' | 'custom';
+    sensitivity: number;
+    trainingPeriod?: string;
+    updateInterval?: string;
+    options?: Record<string, unknown>;
+}
+/** Anomaly */
+export interface Anomaly {
+    id: string;
+    sensorId: string;
+    timestamp: Date;
+    value: number;
+    expectedValue?: number;
+    deviation?: number;
+    confidence: number;
+    type: 'spike' | 'dip' | 'trend' | 'level' | 'pattern';
+    severity: 'low' | 'medium' | 'high';
+}
+/** Forecast config */
+export interface ForecastConfig {
+    method: 'arima' | 'prophet' | 'lstm' | 'holt-winters' | 'custom';
+    horizon: number;
+    interval: string;
+    confidenceLevel?: number;
+    seasonality?: SeasonalityConfig;
+}
+/** Seasonality config */
+export interface SeasonalityConfig {
+    daily?: boolean;
+    weekly?: boolean;
+    yearly?: boolean;
+    custom?: number[];
+}
+/** Forecast result */
+export interface ForecastResult {
+    sensorId: string;
+    predictions: ForecastPoint[];
+    confidence: number;
+    model: string;
+    trainingMetrics?: TrainingMetrics;
+}
+/** Forecast point */
+export interface ForecastPoint {
+    timestamp: Date;
+    value: number;
+    lower: number;
+    upper: number;
+}
+/** Training metrics */
+export interface TrainingMetrics {
+    mse?: number;
+    rmse?: number;
+    mae?: number;
+    mape?: number;
+    r2?: number;
+}
+/** Sensor map view */
+export interface SensorMapView {
+    sensors: SensorMapMarker[];
+    geofences?: Geofence[];
+    heatmap?: HeatmapData;
+    clusters?: SensorCluster[];
+}
+/** Sensor map marker */
+export interface SensorMapMarker {
+    sensorId: string;
+    name: string;
+    type: SensorTypeId;
+    latitude: number;
+    longitude: number;
+    value?: number;
+    unit?: string;
+    status: SensorAlertStatus;
+    icon?: string;
+    color?: string;
+}
+/** Geofence */
+export interface Geofence {
+    id: string;
+    name: string;
+    type: 'circle' | 'polygon' | 'rectangle';
+    coordinates: GeofenceCoordinates;
+    sensors?: string[];
+    alertOnEnter?: boolean;
+    alertOnExit?: boolean;
+    style?: GeofenceStyle;
+}
+/** Geofence coordinates */
+export type GeofenceCoordinates = CircleCoordinates | PolygonCoordinates | RectangleCoordinates;
+/** Circle coordinates */
+export interface CircleCoordinates {
+    type: 'circle';
+    center: {
+        latitude: number;
+        longitude: number;
+    };
+    radius: number;
+}
+/** Polygon coordinates */
+export interface PolygonCoordinates {
+    type: 'polygon';
+    points: Array<{
+        latitude: number;
+        longitude: number;
+    }>;
+}
+/** Rectangle coordinates */
+export interface RectangleCoordinates {
+    type: 'rectangle';
+    bounds: {
+        north: number;
+        south: number;
+        east: number;
+        west: number;
+    };
+}
+/** Geofence style */
+export interface GeofenceStyle {
+    fillColor?: string;
+    fillOpacity?: number;
+    strokeColor?: string;
+    strokeWidth?: number;
+}
+/** Heatmap data */
+export interface HeatmapData {
+    points: HeatmapPoint[];
+    min: number;
+    max: number;
+    radius?: number;
+    blur?: number;
+    gradient?: Record<number, string>;
+}
+/** Heatmap point */
+export interface HeatmapPoint {
+    latitude: number;
+    longitude: number;
+    value: number;
+}
+/** Sensor cluster */
+export interface SensorCluster {
+    id: string;
+    latitude: number;
+    longitude: number;
+    count: number;
+    sensors: string[];
+    bounds: ClusterBounds;
+}
+/** Cluster bounds */
+export interface ClusterBounds {
+    north: number;
+    south: number;
+    east: number;
+    west: number;
+}
+/** Calibration record */
+export interface CalibrationRecord {
+    id: string;
+    sensorId: string;
+    timestamp: Date;
+    performedBy?: string;
+    method: CalibrationType;
+    reference?: ReferenceStandard;
+    measurements: CalibrationMeasurement[];
+    result: CalibrationResult;
+    certificate?: CalibrationCertificate;
+    nextDue?: Date;
+}
+/** Calibration type */
+export type CalibrationType = 'offset' | 'twoPoint' | 'multiPoint' | 'linearization' | 'factory';
+/** Reference standard */
+export interface ReferenceStandard {
+    name: string;
+    value: number;
+    unit: string;
+    accuracy: number;
+    certificateId?: string;
+    traceable?: boolean;
+}
+/** Calibration measurement */
+export interface CalibrationMeasurement {
+    reference: number;
+    measured: number;
+    error?: number;
+    errorPercent?: number;
+}
+/** Calibration result */
+export interface CalibrationResult {
+    passed: boolean;
+    offset?: number;
+    scale?: number;
+    coefficients?: number[];
+    maxError?: number;
+    avgError?: number;
+    uncertainty?: number;
+}
+/** Calibration certificate */
+export interface CalibrationCertificate {
+    id: string;
+    issuer: string;
+    issuedDate: Date;
+    validUntil: Date;
+    documentUrl?: string;
+}
+/** Export request */
+export interface ExportRequest {
+    sensorIds: string[];
+    timeRange: TimeRange;
+    format: 'csv' | 'json' | 'xlsx' | 'pdf';
+    aggregation?: AggregationType;
+    interval?: string;
+    includeMetadata?: boolean;
+    includeStatistics?: boolean;
+    filename?: string;
+}
+/** Export result */
+export interface ExportResult {
+    id: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    format: string;
+    size?: number;
+    url?: string;
+    expiresAt?: Date;
+    error?: string;
+}
+/** Report template */
+export interface ReportTemplate {
+    id: string;
+    name: string;
+    description?: string;
+    type: ReportType;
+    sections: ReportSection[];
+    schedule?: ReportSchedule;
+    recipients?: string[];
+}
+/** Report type */
+export type ReportType = 'summary' | 'detailed' | 'compliance' | 'trend' | 'comparison' | 'custom';
+/** Report section */
+export interface ReportSection {
+    id: string;
+    type: 'chart' | 'table' | 'statistics' | 'text' | 'image';
+    title?: string;
+    config: ReportSectionConfig;
+}
+/** Report section config */
+export interface ReportSectionConfig {
+    sensors?: string[];
+    metrics?: string[];
+    aggregation?: AggregationType;
+    timeRange?: TimeRangePreset;
+    content?: string;
+    imageUrl?: string;
+}
+/** Report schedule */
+export interface ReportSchedule {
+    frequency: 'daily' | 'weekly' | 'monthly' | 'custom';
+    time?: string;
+    dayOfWeek?: number;
+    dayOfMonth?: number;
+    cron?: string;
+    timezone?: string;
+}
+//# sourceMappingURL=sensor-dashboard.d.ts.map