import '@iotize/tap/service/impl/data-log';
import { Decoder } from '@iotize/common/converter/api';
import { ProgressState } from '@iotize/common/progress/api';
import { Tap } from '@iotize/tap';
import { TlvBundleConverter, TLVConverter } from '@iotize/tap/client/impl';
import { SinglePacket } from '@iotize/tap/service/impl/single-packet';
import { Observable } from 'rxjs';
/**
 * Experimental data logger class
 *
 * @experimental
 */
export declare class DataLogger {
    private tap;
    converter: DataLogSinglePacketToDataLogPacketConverter;
    constructor(tap: Tap, converter?: DataLogSinglePacketToDataLogPacketConverter);
    isAcquisitionRunning(): Promise<boolean>;
    startAcquisition(): Promise<void>;
    stopAcquisition(): Promise<void>;
    /**
     * Dequeue one data log packet
     */
    dequeue(): Promise<DataLogger.RawPacket>;
    /**
     * Get stored packet count in Tap
     */
    getPacketCount(): Promise<number>;
    /**
     * Download all packets from store
     */
    download(options?: {
        period?: number;
    }): Observable<DataLogger.DownloadEvent>;
}
export declare namespace DataLogger {
    interface Options {
        period: number;
    }
    type DownloadEvent = {
        type: 'new-packet';
        progress: ProgressState;
        packet: RawPacket;
    } | {
        type: 'error';
        error: Error;
    };
    /**
     * Data log packet containing raw values for each variables
     */
    interface RawPacket {
        /**
         * Bundle infor
         */
        meta: RawPacket.Meta;
        /**
         * Raw variable data mapping between a variable identifier and the raw data
         */
        data: RawPacket.Data;
    }
    namespace RawPacket {
        interface Meta {
            bundleId: number;
            logTime: Date;
            /**
             * Single packet indentifier
             */
            packetId: number;
            /**
             * Single packet sender identifier
             */
            senderId: number;
        }
        type Data = Record<number, Uint8Array>;
    }
}
/**
 *
 * @experimental
 */
export declare class DataLogSinglePacketToDataLogPacketConverter implements Decoder<SinglePacket, DataLogger.RawPacket> {
    tlvConverter: TLVConverter;
    bundleConverter: TlvBundleConverter<Record<string, Uint8Array>>;
    constructor(tlvConverter?: TLVConverter, bundleConverter?: TlvBundleConverter<Record<string, Uint8Array>>);
    decode(singlePacket: SinglePacket): DataLogger.RawPacket;
}
/**
 *
 * @experimental
 */
