import type { AutoMeasureSetting, BatteryInfo, BloodGlucoseData, BloodOxygenTestResult, BloodPressureTestResult, BluetoothStatus, ConnectOptions, ConnectionStatus, DaySummaryData, DeviceFunctions, DeviceVersion, HalfHourData, HeartRateTestResult, Language, OriginData, PasswordData, PermissionsResult, PersonalInfo, ReadOriginProgress, ScanOptions, SleepData, SocialMsgData, SportStepData, Spo2OriginData, StressData, TemperatureTestResult, VeepooDevice, VeepooError } from './types.js';
export type DataSource = 'device' | 'memory-cache' | 'storage-cache';
export type ReadStrategy = 'device-only' | 'cache-only' | 'cache-first' | 'device-first';
export interface ReadOptions {
    strategy?: ReadStrategy;
    maxAgeMs?: number;
    saveToCache?: boolean;
}
export interface UnifiedResult<T> {
    data: T;
    source: DataSource;
    deviceId?: string;
    timestamp: number;
    cachedAt?: number;
    stale?: boolean;
}
export type CacheDomain = 'sdk-state' | 'device-profile' | 'battery' | 'device-functions' | 'device-version' | 'social-message-settings' | 'sleep' | 'sport' | 'origin5m' | 'origin30m' | 'day-summary' | 'spo2-origin' | 'measurement' | 'auto-measure-settings';
export interface CacheEntryMeta {
    key: string;
    deviceId?: string;
    domain: CacheDomain;
    date?: string;
    timestamp: number;
    cachedAt: number;
    expiresAt?: number;
    stale?: boolean;
}
export interface CacheValue<T> extends UnifiedResult<T> {
    meta: CacheEntryMeta;
}
export interface SDKState {
    initialized: boolean;
    scanning: boolean;
    connectedDeviceId: string | null;
    ready: boolean;
}
export interface ConnectionSession {
    deviceId: string;
    status: 'ready';
    authenticated: boolean;
    deviceVersion?: string;
    deviceNumber?: string;
    isOadModel?: boolean;
}
export interface ConnectionSnapshot {
    deviceId?: string;
    status: ConnectionStatus;
    authenticated: boolean;
    ready: boolean;
}
export interface DeviceProfile {
    deviceId: string;
    version?: DeviceVersion;
    functions?: DeviceFunctions;
    battery?: BatteryInfo;
    socialMsg?: SocialMsgData;
    password?: PasswordData;
}
export type SyncDomain = 'sleep' | 'sport' | 'origin5m' | 'origin30m' | 'daySummary' | 'spo2Origin' | 'deviceProfile';
export interface SyncHealthOptions {
    days?: number;
    include?: SyncDomain[];
    saveToCache?: boolean;
}
export interface SyncTaskResult {
    taskId: string;
    startedAt: number;
}
export interface SyncState {
    taskId?: string;
    status: 'idle' | 'running' | 'completed' | 'failed';
    progress?: number;
    currentDay?: number;
    totalDays?: number;
    lastSyncAt?: number;
    error?: VeepooError;
}
export interface SyncProgressPayload {
    taskId: string;
    progress: ReadOriginProgress;
}
export interface DailyHealthSnapshot {
    date: string;
    sleep?: SleepData;
    sport?: SportStepData;
    origin5m?: OriginData[];
    origin30m?: HalfHourData[];
    summary?: DaySummaryData;
    spo2Origin?: Spo2OriginData[];
}
export type MetricSourceType = 'origin5m' | 'origin30m' | 'daySummary' | 'spo2Origin' | 'measurement';
export interface MetricPointBase {
    date: string;
    time: string;
    timestamp: number;
    sourceType: MetricSourceType;
}
export interface MetricItemQuery {
    date?: string;
    time?: string;
    timestamp?: number;
}
export interface HeartRatePoint extends MetricPointBase {
    value: number;
    stepCount?: number;
    distance?: number;
    calories?: number;
    sportValue?: number;
}
export interface BloodPressurePoint extends MetricPointBase {
    systolic: number;
    diastolic: number;
    pulse?: number;
}
export interface BloodOxygenPoint extends MetricPointBase {
    spo2: number;
    heartRate?: number;
    isHypoxia?: boolean;
    cardiacLoad?: number;
    sportValue?: number;
}
export interface TemperaturePoint extends MetricPointBase {
    temperature: number;
    originalTemp?: number;
}
export interface StressPoint extends MetricPointBase {
    stress: number;
    progress?: number;
    status?: string;
    state?: MeasurementState['state'];
    reason?: NormalizedStressMeasurementResult['reason'];
}
export interface BloodGlucosePoint extends MetricPointBase {
    glucose: number;
    level?: NormalizedBloodGlucoseMeasurementResult['level'];
    progress?: number;
    status?: string;
    state?: MeasurementState['state'];
    rawBloodGlucose?: number;
}
export interface SportPoint extends MetricPointBase {
    stepCount: number;
    distance?: number;
    calories?: number;
    sportValue?: number;
    met?: number;
}
export type MeasurementType = 'heartRate' | 'bloodPressure' | 'bloodOxygen' | 'temperature' | 'stress' | 'bloodGlucose';
export interface NormalizedStressMeasurementResult extends StressData {
    state: 'idle' | 'start' | 'testing' | 'notWear' | 'deviceBusy' | 'over' | 'error';
    reason?: 'unsupported' | 'lowPower' | 'deviceBusy' | 'notWear' | 'complete';
}
export interface NormalizedBloodGlucoseMeasurementResult {
    state: 'idle' | 'start' | 'testing' | 'notWear' | 'deviceBusy' | 'over' | 'error';
    glucose?: number;
    progress?: number;
    level?: 'low' | 'normal' | 'high' | 'unknown' | string;
    isEnd?: boolean;
    error?: string;
    status?: string;
    timestamp?: number;
    reason?: 'unsupported' | 'lowPower' | 'deviceBusy' | 'notWear';
}
export interface MeasurementResultMap {
    heartRate: HeartRateTestResult;
    bloodPressure: BloodPressureTestResult;
    bloodOxygen: BloodOxygenTestResult;
    temperature: TemperatureTestResult;
    stress: NormalizedStressMeasurementResult;
    bloodGlucose: NormalizedBloodGlucoseMeasurementResult;
}
export interface MeasurementState<T = unknown> {
    type: MeasurementType;
    state: 'idle' | 'start' | 'testing' | 'notWear' | 'deviceBusy' | 'over' | 'error';
    progress?: number;
    result?: T;
    timestamp: number;
}
export interface CacheStatus {
    keys: string[];
    count: number;
    size?: number;
    lastUpdatedAt?: number;
}
export interface CacheScope {
    deviceId?: string;
    domains?: CacheDomain[];
    date?: string;
}
export interface CacheReadOptions {
    key: string;
}
export interface CacheWarmupOptions extends SyncHealthOptions {
    deviceId?: string;
}
export interface UnifiedDiagnostic {
    level: 'info' | 'warning' | 'error';
    title: string;
    detail: string;
}
export interface UnifiedDiagnostics {
    sdkState: SDKState;
    cacheStatus: CacheStatus;
    origin30mPreview: HalfHourData[];
    stressMeasurement: NormalizedStressMeasurementResult | null;
    bloodGlucoseMeasurement: NormalizedBloodGlucoseMeasurementResult | null;
    diagnostics: {
        origin30m: UnifiedDiagnostic[];
        stress: UnifiedDiagnostic[];
        bloodGlucose: UnifiedDiagnostic[];
    };
}
export interface DiagnosticOptions {
    deviceId?: string;
    date?: string;
    originPreviewLimit?: number;
}
export interface UnifiedEventMap {
    'scan.deviceFound': {
        device: VeepooDevice;
        timestamp: number;
    };
    'connection.changed': {
        deviceId: string;
        status: ConnectionStatus;
        authenticated?: boolean;
        ready?: boolean;
    };
    'device.ready': {
        deviceId: string;
        isOadModel?: boolean;
    };
    'sync.progress': SyncProgressPayload;
    'sync.completed': {
        taskId: string;
        success: boolean;
        timestamp: number;
    };
    'measurement.updated': {
        type: MeasurementType;
        state: MeasurementState;
    };
    'cache.updated': {
        key: string;
        domain: CacheDomain;
        deviceId?: string;
        date?: string;
        timestamp: number;
    };
    error: VeepooError;
}
export interface VeepooUnifiedAPI {
    init(): Promise<void>;
    destroy(): void;
    getSDKState(): SDKState;
    getBluetoothStatus(): Promise<BluetoothStatus>;
    requestPermissions(): Promise<PermissionsResult>;
    startScan(options?: ScanOptions): Promise<void>;
    stopScan(): Promise<void>;
    connect(deviceId: string, options?: ConnectOptions): Promise<UnifiedResult<ConnectionSession>>;
    disconnect(deviceId?: string): Promise<void>;
    getConnectionState(deviceId?: string): Promise<ConnectionSnapshot>;
    verifyPassword(password?: string, is24Hour?: boolean): Promise<UnifiedResult<PasswordData>>;
    getDeviceProfile(options?: ReadOptions): Promise<UnifiedResult<DeviceProfile>>;
    getBatteryInfo(options?: ReadOptions): Promise<UnifiedResult<BatteryInfo>>;
    getDeviceFunctions(options?: ReadOptions): Promise<UnifiedResult<DeviceFunctions>>;
    getDeviceVersion(options?: ReadOptions): Promise<UnifiedResult<DeviceVersion>>;
    getSocialMessageSettings(options?: ReadOptions): Promise<UnifiedResult<SocialMsgData>>;
    syncHealthData(options?: SyncHealthOptions): Promise<SyncTaskResult>;
    cancelSyncHealthData(taskId?: string): Promise<void>;
    getLastSyncState(): SyncState;
    getSleepData(date?: string, options?: ReadOptions): Promise<UnifiedResult<SleepData>>;
    getSportData(date?: string, options?: ReadOptions): Promise<UnifiedResult<SportStepData>>;
    getOrigin5mData(date?: string, options?: ReadOptions): Promise<UnifiedResult<OriginData[]>>;
    getOrigin30mData(date?: string, options?: ReadOptions): Promise<UnifiedResult<HalfHourData[]>>;
    getDaySummaryData(date?: string, options?: ReadOptions): Promise<UnifiedResult<DaySummaryData>>;
    getSpo2OriginData(date?: string, options?: ReadOptions): Promise<UnifiedResult<Spo2OriginData[]>>;
    getDailyHealthSnapshot(date?: string, options?: ReadOptions): Promise<UnifiedResult<DailyHealthSnapshot>>;
    getHeartRateList(date?: string, options?: ReadOptions): Promise<UnifiedResult<HeartRatePoint[]>>;
    getHeartRateItem(query?: MetricItemQuery, options?: ReadOptions): Promise<UnifiedResult<HeartRatePoint> | null>;
    getLatestHeartRate(date?: string, options?: ReadOptions): Promise<UnifiedResult<HeartRatePoint> | null>;
    getBloodPressureList(date?: string, options?: ReadOptions): Promise<UnifiedResult<BloodPressurePoint[]>>;
    getBloodPressureItem(query?: MetricItemQuery, options?: ReadOptions): Promise<UnifiedResult<BloodPressurePoint> | null>;
    getLatestBloodPressure(date?: string, options?: ReadOptions): Promise<UnifiedResult<BloodPressurePoint> | null>;
    getBloodOxygenList(date?: string, options?: ReadOptions): Promise<UnifiedResult<BloodOxygenPoint[]>>;
    getBloodOxygenItem(query?: MetricItemQuery, options?: ReadOptions): Promise<UnifiedResult<BloodOxygenPoint> | null>;
    getLatestBloodOxygen(date?: string, options?: ReadOptions): Promise<UnifiedResult<BloodOxygenPoint> | null>;
    getTemperatureList(date?: string, options?: ReadOptions): Promise<UnifiedResult<TemperaturePoint[]>>;
    getTemperatureItem(query?: MetricItemQuery, options?: ReadOptions): Promise<UnifiedResult<TemperaturePoint> | null>;
    getLatestTemperature(date?: string, options?: ReadOptions): Promise<UnifiedResult<TemperaturePoint> | null>;
    getStressList(date?: string, options?: ReadOptions): Promise<UnifiedResult<StressPoint[]>>;
    getStressItem(query?: MetricItemQuery, options?: ReadOptions): Promise<UnifiedResult<StressPoint> | null>;
    getLatestStress(date?: string, options?: ReadOptions): Promise<UnifiedResult<StressPoint> | null>;
    getBloodGlucoseList(date?: string, options?: ReadOptions): Promise<UnifiedResult<BloodGlucosePoint[]>>;
    getBloodGlucoseItem(query?: MetricItemQuery, options?: ReadOptions): Promise<UnifiedResult<BloodGlucosePoint> | null>;
    getLatestBloodGlucose(date?: string, options?: ReadOptions): Promise<UnifiedResult<BloodGlucosePoint> | null>;
    getSportList(date?: string, options?: ReadOptions): Promise<UnifiedResult<SportPoint[]>>;
    getSportItem(query?: MetricItemQuery, options?: ReadOptions): Promise<UnifiedResult<SportPoint> | null>;
    getLatestSport(date?: string, options?: ReadOptions): Promise<UnifiedResult<SportPoint> | null>;
    startMeasurement(type: MeasurementType): Promise<void>;
    stopMeasurement(type: MeasurementType): Promise<void>;
    getMeasurementState<K extends MeasurementType>(type: K): MeasurementState<MeasurementResultMap[K]> | null;
    getLastMeasurementResult<K extends MeasurementType>(type: K, options?: ReadOptions): Promise<UnifiedResult<MeasurementResultMap[K]> | null>;
    syncPersonalInfo(info: PersonalInfo): Promise<boolean>;
    getAutoMeasureSettings(options?: ReadOptions): Promise<UnifiedResult<AutoMeasureSetting[]>>;
    updateAutoMeasureSetting(setting: Partial<AutoMeasureSetting>): Promise<UnifiedResult<AutoMeasureSetting[]>>;
    setLanguage(language: Language): Promise<boolean>;
    getCacheStatus(deviceId?: string): CacheStatus;
    getCachedValue<T = unknown>(options: CacheReadOptions): CacheValue<T> | null;
    clearCache(scope?: CacheScope): Promise<void>;
    invalidateCache(key: string | string[]): void;
    warmupCache(options: CacheWarmupOptions): Promise<SyncTaskResult>;
    getDiagnostics(options?: DiagnosticOptions): Promise<UnifiedDiagnostics>;
    on<K extends keyof UnifiedEventMap>(event: K, listener: (payload: UnifiedEventMap[K]) => void): this;
    off<K extends keyof UnifiedEventMap>(event: K, listener: (payload: UnifiedEventMap[K]) => void): this;
    once<K extends keyof UnifiedEventMap>(event: K, listener: (payload: UnifiedEventMap[K]) => void): this;
    removeAllListeners(event?: keyof UnifiedEventMap): this;
}
export type BloodGlucoseMeasurementInput = BloodGlucoseData;
//# sourceMappingURL=unified-api.d.ts.map