@sailboat-computer/data-storage/dist/types.d.ts

Shared data storage library for sailboat computer v3

/**
 * Data Storage Types
 *
 * This file contains type definitions for the data storage package.
 */
import { common, data_manager, hardware_interface } from '@sailboat-computer/sailboat-types';
export declare const CircuitBreakerState: {
    CLOSED: common.CircuitBreakerState;
    OPEN: common.CircuitBreakerState;
    HALF_OPEN: common.CircuitBreakerState;
};
export declare const HealthStatus: {
    HEALTHY: common.HealthStatus;
    DEGRADED: common.HealthStatus;
    UNHEALTHY: common.HealthStatus;
    CRITICAL: common.HealthStatus;
    UNKNOWN: common.HealthStatus;
};
export declare const AlertSeverity: {
    INFO: common.AlertSeverity;
    WARNING: common.AlertSeverity;
    ALARM: common.AlertSeverity;
    CRITICAL: common.AlertSeverity;
    EMERGENCY: common.AlertSeverity;
};
export declare const StorageTier: {
    HOT: data_manager.StorageTier;
    WARM: data_manager.StorageTier;
    COLD: data_manager.StorageTier;
};
export declare const StorageErrorCode: {
    CONNECTION_FAILED: data_manager.StorageErrorCode;
    CONNECTION_TIMEOUT: data_manager.StorageErrorCode;
    STORE_FAILED: data_manager.StorageErrorCode;
    RETRIEVE_FAILED: data_manager.StorageErrorCode;
    UPDATE_FAILED: data_manager.StorageErrorCode;
    DELETE_FAILED: data_manager.StorageErrorCode;
    INVALID_DATA: data_manager.StorageErrorCode;
    INVALID_QUERY: data_manager.StorageErrorCode;
    INVALID_CONFIG: data_manager.StorageErrorCode;
    MIGRATION_FAILED: data_manager.StorageErrorCode;
    DOWNSAMPLING_FAILED: data_manager.StorageErrorCode;
    CLEANUP_FAILED: data_manager.StorageErrorCode;
    OUT_OF_MEMORY: data_manager.StorageErrorCode;
    DISK_FULL: data_manager.StorageErrorCode;
    SYSTEM_ERROR: data_manager.StorageErrorCode;
    TIMEOUT: data_manager.StorageErrorCode;
    CIRCUIT_OPEN: data_manager.StorageErrorCode;
    NETWORK_ERROR: data_manager.StorageErrorCode;
    OFFLINE_MODE: data_manager.StorageErrorCode;
    RATE_LIMIT_EXCEEDED: data_manager.StorageErrorCode;
    CACHE_ERROR: data_manager.StorageErrorCode;
    SYNC_ERROR: data_manager.StorageErrorCode;
    WEBSOCKET_ERROR: data_manager.StorageErrorCode;
    AUTHENTICATION_ERROR: data_manager.StorageErrorCode;
    SUBSCRIPTION_ERROR: data_manager.StorageErrorCode;
};
export declare const BatchPriority: {
    LOW: data_manager.BatchPriority;
    NORMAL: data_manager.BatchPriority;
    HIGH: data_manager.BatchPriority;
    CRITICAL: data_manager.BatchPriority;
};
export type CircuitBreakerStateType = common.CircuitBreakerState;
export type HealthStatusType = common.HealthStatus;
export type AlertSeverityType = common.AlertSeverity;
export type StorageTierType = data_manager.StorageTier;
export type StorageErrorCodeType = data_manager.StorageErrorCode;
export type BatchPriorityType = data_manager.BatchPriority;
export type StorageProviderHealth = data_manager.StorageProviderHealth;
export type StorageProviderConfig = data_manager.StorageProviderConfig;
export type RedisConfig = data_manager.RedisConfig;
export type InfluxDBConfig = data_manager.InfluxDBConfig;
export type PostgreSQLConfig = data_manager.PostgreSQLConfig;
export type StorageConfig = data_manager.StorageConfig;
export type DataMetadata = data_manager.DataMetadata;
export type StoredData = data_manager.StoredData;
export type StorageOptions = data_manager.StorageOptions;
export type CleanupResult = data_manager.CleanupResult;
export type StorageStatus = data_manager.StorageStatus;
export type LocalStorageStatus = data_manager.LocalStorageStatus;
export type SyncResult = data_manager.SyncResult;
export type ClearResult = data_manager.ClearResult;
export type ResilienceMetrics = data_manager.ResilienceMetrics;
export type StorageProvider = data_manager.StorageProvider;
export type StorageManager = data_manager.StorageManager;
export type DataCondition = data_manager.DataCondition;
export type RawSensorData = hardware_interface.RawSensorData;
export interface DataQueryResponse {
    results: StoredData[];
    totalCount: number;
    hasMore: boolean;
    nextCursor?: string;
}
/**
 * Extended BatchConfig interface with implementation-specific properties
 */
export interface BatchConfig extends data_manager.BatchConfig {
    priorityOverride: boolean;
    maxRetries?: number;
    retryDelayMs?: number;
}
export type BatchingConfig = BatchConfig;
/**
 * Extended DataQuery interface with implementation-specific properties
 */
export interface DataQuery extends data_manager.DataQuery {
    id?: string;
    tags?: Record<string, string>;
    limit?: number;
    offset?: number;
    sensors?: string[];
    aggregation?: 'raw' | 'minute' | 'hour' | 'day';
    filters?: Record<string, any>;
}
/**
 * Storage manager options
 */
export interface StorageManagerOptions {
    providers?: {
        hot?: StorageProviderConfig;
        warm?: StorageProviderConfig;
        cold?: StorageProviderConfig;
    };
    batching?: BatchConfig;
    resilience?: {
        circuitBreaker?: {
            failureThreshold: number;
            resetTimeoutMs: number;
        };
        retry?: {
            maxRetries: number;
            baseDelayMs: number;
        };
        timeout?: {
            defaultTimeoutMs: number;
        };
    };
    logger?: {
        level: 'debug' | 'info' | 'warn' | 'error';
        console: boolean;
    };
    retryAttempts?: number;
    retryDelayMs?: number;
    enableMetrics?: boolean;
    metricsInterval?: number;
}
/**
 * Unified storage manager options
 */
export interface UnifiedStorageManagerOptions {
    localStorage: {
        directory: string;
        maxSizeBytes?: number;
        encrypt?: boolean;
        compressionLevel?: number;
    };
    sync: {
        enabled: boolean;
        intervalMs: number;
        batchSize: number;
    };
    resilience?: {
        circuitBreaker?: {
            failureThreshold: number;
            resetTimeoutMs: number;
        };
        retry?: {
            maxRetries: number;
            baseDelayMs: number;
        };
        timeout?: {
            defaultTimeoutMs: number;
            operationTimeouts?: Record<string, number>;
        };
        bulkhead?: {
            maxConcurrentOperations: number;
            maxQueueSize: number;
        };
        rateLimit?: {
            defaultTokensPerSecond: number;
            defaultBucketSize: number;
            tokensPerSecond: number;
            bucketSize: number;
            operationLimits?: any;
            waitWhenLimited: boolean;
            maxWaitTimeMs: number;
            bypassOperations?: string[];
        };
    };
    logger?: {
        level: 'debug' | 'info' | 'warn' | 'error';
        console: boolean;
    };
}
/**
 * Unified storage manager interface
 */
export interface UnifiedStorageManager extends StorageManager {
    getLocalStatus(): Promise<LocalStorageStatus>;
    clearLocalCache(): Promise<ClearResult>;
    synchronize(): Promise<SyncResult>;
    getResilienceMetrics(): ResilienceMetrics;
}
/**
 * Batch manager interface
 */
export interface BatchManager {
    initialize(config: BatchConfig): void;
    stop(): void;
    addToBatch(data: any, metadata: DataMetadata, priority: BatchPriorityType): void;
    flush(): Promise<void>;
    getBatchStatus(): BatchStatus;
}
/**
 * Batch status
 */
export interface BatchStatus {
    pendingItems: number;
    lastFlush?: Date;
    averageBatchSize: number;
    totalBatches: number;
    failedBatches: number;
}
/**
 * Downsampling engine interface
 */
export interface DownsamplingEngine {
    initialize(rules: DownsamplingRule[]): void;
    downsample(data: StoredData[]): Promise<StoredData[]>;
    registerDownsampler(downsampler: Downsampler): void;
    getDownsampler(strategyType: string): Downsampler | undefined;
}
/**
 * Downsampling rule
 */
export interface DownsamplingRule {
    id: string;
    name: string;
    dataType: string;
    strategy: DownsamplingStrategy;
    criticalDataConditions?: DataCondition[];
}
/**
 * Downsampler interface
 */
export interface Downsampler {
    readonly type: string;
    downsample(data: StoredData[], strategy: any): Promise<StoredData[]>;
}
/**
 * Lifecycle manager interface
 */
export interface LifecycleManager {
    initialize(config: LifecycleManagerConfig): void;
    stop(): void;
    runCleanup(): Promise<void>;
    runMigration(): Promise<void>;
    runDownsampling(ruleId: string): Promise<void>;
    getPolicies(): LifecyclePolicy[];
    onBeforeMigration(handler: MigrationHandler): void;
    onAfterMigration(handler: MigrationHandler): void;
    onBeforeDownsampling(handler: DownsamplingHandler): void;
    onAfterDownsampling(handler: DownsamplingHandler): void;
}
/**
 * Lifecycle manager configuration
 */
export interface LifecycleManagerConfig {
    policies: LifecyclePolicy[];
    downsamplingRules: DownsamplingRule[];
    downsamplingSchedules: DownsamplingSchedule[];
    cleanupInterval: number;
    migrationInterval: number;
}
/**
 * Lifecycle policy
 */
export interface LifecyclePolicy {
    category: string;
    hotRetentionDays: number;
    warmRetentionDays: number;
    coldRetentionDays: number;
    migrationThresholdDays: number;
    downsample: boolean;
    downsamplingRuleId?: string;
}
/**
 * Downsampling schedule
 */
export interface DownsamplingSchedule {
    ruleId: string;
    cronExpression: string;
    enabled: boolean;
}
/**
 * Migration handler
 */
export type MigrationHandler = (data: StoredData, fromTier: StorageTierType, toTier: StorageTierType) => Promise<void>;
/**
 * Downsampling handler
 */
export type DownsamplingHandler = (data: StoredData[], rule: DownsamplingRule) => Promise<void>;
/**
 * Downsampling strategy types
 */
export type DownsamplingStrategy = TimeBasedStrategy | GeospatialStrategy | CycleBasedStrategy | GeotemporalStrategy | GeotemporalGridStrategy | MaintenanceBasedStrategy;
/**
 * Time-based downsampling strategy
 */
export interface TimeBasedStrategy {
    type: 'time-based';
    levels: {
        ageThreshold: number;
        interval: string;
        aggregations: AggregationConfig[];
    }[];
}
/**
 * Aggregation configuration
 */
export interface AggregationConfig {
    function: string;
    field: string;
    outputField?: string;
    groupBy?: string[];
}
/**
 * Geospatial downsampling strategy
 */
export interface GeospatialStrategy {
    type: 'geospatial';
    simplificationTolerance: number;
    preserveDirectionChanges: boolean;
    minAngleChange: number;
    preserveKeyPoints: boolean;
}
/**
 * Cycle-based downsampling strategy
 */
export interface CycleBasedStrategy {
    type: 'cycle-based';
    cycleDetection: {
        startCondition: DataCondition;
        endCondition: DataCondition;
    };
    samplesPerCycle: number;
    preserveExtrema: boolean;
}
/**
 * Geotemporal downsampling strategy
 */
export interface GeotemporalStrategy {
    type: 'geotemporal';
    gridResolution: {
        latitude: number;
        longitude: number;
    };
    timeIntervals: string[];
    aggregations: AggregationConfig[];
    adaptiveResolution?: boolean;
}
/**
 * Geotemporal grid downsampling strategy
 */
export interface GeotemporalGridStrategy {
    type: 'geotemporal-grid';
    baseGridSize: number;
    adaptiveGridLevels: number;
    coastalResolutionBoost?: number;
    temporalHierarchy: {
        recent: {
            maxAge: number;
            resolution: number;
        };
        mediumTerm: {
            maxAge: number;
            resolution: number;
        };
        longTerm: {
            maxAge: number;
            resolution: number;
        };
        historical: {
            maxAge: number;
            resolution: number;
        };
        seasonal: {
            resolution: number;
        };
    };
    vesselPosition?: {
        latitude: number;
        longitude: number;
    };
    plannedRoute?: Array<{
        latitude: number;
        longitude: number;
    }>;
    historicalAreaOfInterest?: Array<{
        latitude: number;
        longitude: number;
        weight: number;
    }>;
    criticalFeatureThresholds?: {
        pressureChangeRate?: number;
        windSpeed?: number;
        waveHeight?: number;
        temperatureGradient?: number;
    };
}
/**
 * Maintenance-based downsampling strategy
 */
export interface MaintenanceBasedStrategy {
    type: 'maintenance-based';
    maintenanceEventType: string;
    samplesBeforeEvent: number;
    samplesAfterEvent: number;
    normalSamplingInterval: string;
    detailedSamplingInterval: string;
}