/**
 * This file contains the class History.
 *
 * @file history.ts
 * @author Luca Liguori
 * @date 2023-09-01
 * @version 2.7.8
 *
 * Copyright 2023, 2024 Luca Liguori.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License. * *
 */
import { AnsiLogger } from 'node-ansi-logger';
export interface OptionalHistoryParams {
    enableDebug?: boolean;
    enableAutopilot?: boolean;
    enableConfigData?: boolean;
    historySize?: number;
    fileName?: string;
    filePath?: string;
    timerMinutes?: number;
    edge?: boolean;
}
export interface HistoryParams {
    enableDebug: boolean;
    enableAutopilot: boolean;
    enableConfigData: boolean;
    historySize: number;
    fileName: string;
    filePath: string;
    timerMinutes: number;
}
export interface Entry extends ImmediateEntry, AveragedEntry {
    time: number;
    setRefTime?: number;
    immediate?: number;
}
export interface ImmediateEntry {
    time: number;
    status?: number;
    motion?: number;
    contact?: number;
    leak?: number;
    smoke?: number;
    action?: number;
    currentposition?: number;
    targetposition?: number;
    positionstate?: number;
    obstructiondetected?: number;
}
export interface AveragedEntry {
    time: number;
    consumption?: number;
    power?: number;
    voltage?: number;
    current?: number;
    temperature?: number;
    lux?: number;
    humidity?: number;
    pressure?: number;
    airquality?: number;
    voc?: number;
    co?: number;
    co2?: number;
    formaldehyd?: number;
    pm10?: number;
    pm25?: number;
    lqi?: number;
}
export interface HistoryLog {
    firstEntry: number;
    lastEntry: number;
    memorySize: number;
    initialTime: number;
    timeOffset: number;
    resetTotal: number;
    lastEvent: number;
    timesOpened: number;
    fileVersion: string;
    historyVersion: string;
    lastValues: Entry;
    history: Entry[];
    extra: any;
}
export interface Signature {
    tag: number;
    length: number;
    factor: number;
    precision: number;
    bitmask: number;
    entryName: keyof Entry;
}
export interface Tag {
    tag: number;
    length: number;
    factor: number;
    precision: number;
    entryName: keyof Entry;
}
export declare const enum WeatherTrend {
    BLANK = 0,
    SUN = 1,
    CLOUDS_SUN = 3,
    RAIN = 5,
    RAIN_WIND = 12
}
export declare const enum Sensitivity {
    HIGH = 0,
    MEDIUM = 4,
    LOW = 7
}
export declare const enum TemperatureDisplayUnits {
    CELSIUS = 0,
    FAHRENHEIT = 1
}
export interface TlvConfigData {
    field: number;
    length: number;
    name: string;
    data: Buffer;
    updated: boolean;
    value: boolean | number | string;
}
export interface TlvConfigDataField {
    field: number;
    type: number;
    name: string;
}
export declare class History {
    protected log: AnsiLogger;
    protected name: string;
    protected optionalParams?: OptionalHistoryParams | undefined;
    protected params: HistoryParams;
    protected eveEpoch: number;
    protected initialTime: number;
    protected timeOffset: number;
    protected memorySize: number;
    protected firstEntry: number;
    protected currentEntry: number;
    protected lastEntry: number;
    protected fileVersion: string;
    protected historyVersion: string;
    protected resetTotal: number;
    protected lastEvent: number;
    protected timesOpened: number;
    protected configData: Buffer;
    protected tlvConfigDataGet: TlvConfigData[];
    protected tlvConfigDataSet: TlvConfigData[];
    protected firmwareData: Buffer<ArrayBuffer>;
    protected historyLoaded: boolean;
    protected historyDebug: boolean;
    protected historyError: boolean;
    protected historyClosed: boolean;
    protected setRefTime: boolean;
    protected historyWriting: boolean;
    protected forceReloadHistoryStatus: boolean;
    protected forceReloadHistoryRequest: boolean;
    protected deviceOnline: boolean;
    protected addResetTotal: boolean;
    protected addLastEvent: boolean;
    protected addTimesOpened: boolean;
    protected addStatusFault: boolean;
    protected statusFault: number;
    protected addStatusActive: boolean;
    protected statusActive: boolean;
    protected addFakeSwitch: boolean;
    protected signature: Buffer;
    protected sigTable: Signature[];
    protected tags: Tag[];
    protected tagsMap: Map<number, Tag>;
    protected entryNameMap: Map<keyof Entry, Tag>;
    protected historyLog: HistoryLog;
    protected writingTimeout: NodeJS.Timeout | undefined;
    protected historyFile: string;
    protected queueTimeout: NodeJS.Timeout | undefined;
    protected queuedEntries: Entry[];
    protected toAverageEntries: AveragedEntry[];
    protected lastValuesEntry: Entry;
    protected immediateKeys: Array<keyof Entry>;
    protected averagedKeys: Array<keyof Entry>;
    protected lastValueKeys: Array<keyof Entry>;
    protected averageTimer: NodeJS.Timeout | null;
    constructor(log: AnsiLogger, name: string, optionalParams?: OptionalHistoryParams | undefined);
    close(): Promise<void>;
    /**
     * Get the initial time of the history.
     *
     * initialTime rappresents the number of seconds since Unix Epoch of the first entry of the history.
     * Even if the first entry is no more in the memory this is always the initialTime.
     * When passed to History is initialTime-epoch_sec=referenceTime
     *
     * 1970                              2001                        2023         now
     * ¦-----------------------------initialTime------------------------¦-----------¦
     * ¦--------eveEpoch------------------¦--------referenceTime--------¦-entryTime-¦
     *
     *
     * @return initialTime
     */
    getInitialTime(): number;
    /**
     * Get the offset time of the history.
     *
     * @return timeOffset
     */
    getTimeOffset(): number;
    /**
     * Get the first entry of the history.
     *
     * @return firstEntry
     */
    getFirstEntry(): number;
    /**
     * Get the last entry of the history.
     *
     * @return lastEntry
     */
    getLastEntry(): number;
    /**
     * Set the availability of the device.
     *
     * @param online State of the device.
     */
    setDeviceOnline(online: boolean): void;
    /**
     * Get lastEvent attribute of history.
     *
     * @return lastEvent
     */
    getLastEvent(): number;
    /**
     * Set lastEvent attribute of history.
     *
     * @return lastEvent updated
     */
    setLastEvent(): void;
    /**
     * Get timesOpened attribute of history.
     *
     * @return timesOpened
     */
    getTimesOpened(): number;
    /**
     * Get timesOpened attribute of history.
     *
     * @return timesOpened incremented
     */
    addToTimesOpened(): number;
    /**
     * Get the address of an entry into the circular memory
     *
     * @param entryNumber Entry to get the address of.
     * @return The address requested
     */
    protected getEntryAddress(entryNumber: number): number;
    /**
     * Get an entry
     *
     * @param entryNumber Entry number to get
     * @return The entry requested
     */
    protected getEntry(entryNumber: number): Entry;
    /**
     * Set an entry
     *
     * @param entryNumber Entry number to set
     * @param entry Entry to set at entryNumber
     */
    protected setEntry(entryNumber: number, entry: Entry): void;
    private tlvConfigDataFields;
    private tlvDataToValue;
    encodeConfigData(tlvConfigData: TlvConfigData[]): Buffer;
    decodeConfigData(buffer: Buffer, tlvConfigData?: TlvConfigData[]): string;
    configDataToString(tlvConfigData: TlvConfigData[]): string;
    setMaxMinTemperature(maxTemperature: number, minTemperature: number): void;
    /**
     * Encode HistoryStatus
     *
     * @param buffer The Buffer to decode
     * @return The string of decoded Buffer
     */
    decodeHistoryStatus(buffer: Buffer): string;
    /**
     * Encode HistoryStatus
     *
     * @return The encoded Buffer
     */
    encodeHistoryStatus(): Buffer;
    /**
     * Log the HistoryStatus Buffer to string
     *
     * @param buffer Buffer of historyStatus to log
     * @return The log string of historyStatus
     */
    historyStatusToString(buffer: Buffer): string;
    /**
     * Decode a Buffer into a HistoryEntry
     *
     * @param buffer The Buffer to decode
     * @return The string rappresenting the decoded buffer
     */
    decodeHistoryEntry(buffer: Buffer): string;
    /**
     * Encode a given HistoryEntry
     *
     * @param entryNumber Entry number to encode
     * @return The encoded buffer
     */
    encodeHistoryEntry(entryNumber: number): Buffer;
    /**
     * Log to a string a given HistoryEntry buffer
     *
     * @param buffer Entry buffer to log
     * @return The log string of the given entry buffer
     */
    historyEntryToString(buffer: Buffer): string;
    historyEntriesToString(buffer: Buffer): string;
    decodeHistorySetTime(buffer: Buffer): string;
    encodeHistorySetTime(seconds?: number): Buffer;
    historySetTimeToString(buffer: Buffer): string;
    decodeHistoryRequest(buffer: Buffer): string;
    encodeHistoryRequest(entryNumber: number): Buffer;
    historyRequestToString(buffer: Buffer): string;
    signatureToString(): string;
    /**
     * Add an entry to the history. History will choose to add immediates or averaged entries to the history.
     *
     * @param entry * { time: [seconds since unix()], ... }
     *
     * status: 0-OFF / 1-ON
     *
     * power: number
     *
     * motion: 0-no motion / 1-motion detected
     *
     * contact: 0-contact closed / 1-contact opened
     *
     * leak: 0-no leak / 1-leak detected
     *
     * smoke: 0-no smoke / 1-smoke detected
     *
     * temperature: number
     *
     * humidity: number
     *
     * pressure: number
     *
     * lux: number
     */
    addEntry(entry: Entry): void;
    /**
     * Add an entry to average by the callback timer.
     *
     * @param entry Entry to add.
     */
    protected addAveragedEntry(entry: Entry): void;
    /**
     * Add an immediate entry.
     *
     * @param entry Entry to add.
     */
    protected addImmediateEntry(entry: Entry): void;
    /**
     * Start the callback timer to average the entries.
     *
     * @param runNow If true call also immediately the callback
     */
    private averageTimerStart;
    /**
     * Timer callback to average the entries.
     */
    private averageTimerCallback;
    /**
     * Log the history class to the logger.
     *
     * @param logEntries If true also log all the history entries
     */
    logHistory(logEntries?: boolean): void;
    /**
     * Read asyncronously the history from disk.
     */
    readHistoryFile(callback?: (success: boolean) => void): void;
    /**
     * Write asyncronously the history to disk.
     */
    writeHistoryFile(): void;
    /**
     * Stringify an entry with appropriate value for time and bitmask.
     *
     * @param entry Entry object to stingify
     */
    protected entryStringify(entry: object): string;
    /**
     * Return a string rappresenting the time passed:
     *
     * 0-60 seconds
     *
     * 0-60 minutes
     *
     * 0-24 hours
     *
     * when more then 24 hours returns the number of days
     *
     * @param seconds number of seconds
     *
     * @return The string rappresenting the time passed
     */
    diffToString(seconds: number): string;
    /**
     * Return the date string from seconds in 'DD-MM-YYYY HH:mm:ss' format.
     *
     * @param seconds number of seconds
     *
     * @return The date string
     */
    secsToDateString(seconds: number): string;
    /**
     * Return the date string rappresented by seconds since epoch.
     *
     * @param secondsSinceEpoch number of seconds since epoch
     *
     * @return The date string
     */
    secsToDateStringSinceEveEpoch(secondsSinceEpoch: number): string;
    /**
     * Return the actual unix seconds.
     *
     * @return The unix seconds of now
     */
    now(): number;
    /**
     * Clamp a number to min and max.
     *
     * @param number - The number to clamp
     * @param min - Min value
     * @param max - Max value
     *
     * @return The clamped number
     *
     */
    clamp(number: number, min: number, max: number): number;
    /**
     * Round a number to the specified precision
     *
     * @param number - The number to round
     * @param precision - The number of decimals
     *
     * @return The rounded number
     *
     */
    round(number: number, precision: number): number;
    getFakeLevel(minLevel: number, maxLevel: number, round?: number): number;
    private secondsSinceMidnight;
    private secondsSinceNoon;
}
//# sourceMappingURL=history.d.ts.map