import { CryptedFrameConverter } from './converter/crypted-frame-converter';
import { IoTizeClient as IoTizeClientInterface } from "../api/iotize-client.interface";
import { ComProtocol, ConnectionStateChangeEvent } from "../../protocol/api/com-protocol.interface";
import { Decoder, Encoder } from "../../core";
import { Response } from './response/response';
import { Command } from './request/command';
import { Observable } from 'rxjs';
import { BodyDecoder } from "../api/converter";
import { EncryptionAlgo } from '../api/encryption-algo.interface';
export declare class DefaultIoTizeClient implements IoTizeClientInterface {
    static TAG: string;
    private cmdCounter;
    private commandConverter;
    private responseDecoder;
    private lwm2mResponseConverter;
    private _lwm2mCommandConverter;
    private _apduResponseConverter;
    private _encryptionAlgo?;
    private _options;
    private protocols;
    private currentProtocolId?;
    protected _cryptedFrameConverter: CryptedFrameConverter;
    readonly cryptedFrameConverter: CryptedFrameConverter;
    /**
     * Enable/Disable encrytion when communicating with a device
     * @param value true if requests must be encrypted
     * @param algo optional if you have already provided the algo with @{link setEncryptionAlgo(algo)} method
     */
    enableEncryption(value: boolean, algo?: EncryptionAlgo): Promise<any>;
    static create(protocol?: ComProtocol): DefaultIoTizeClient;
    constructor(requestEncoder: Encoder<Command, Uint8Array>, responseDecoder: Decoder<Uint8Array, Response<any>>);
    getEncryptionAlgo(): EncryptionAlgo | undefined;
    setEncryptionAlgo(algo: EncryptionAlgo): void;
    isConnected(): boolean;
    getCurrentProtocol(): ComProtocol;
    addComProtocol(newProtocol: ComProtocol, id?: string): this;
    switchProtocol(name: string): this;
    hasProtocol(id: any): any;
    connect(): Observable<any>;
    disconnect(): Observable<any>;
    _encryptedCommand<T>(command: Command, bodyDecoder?: BodyDecoder<T>): Observable<Response<T>>;
    protected _startEncryption(encryptionAlog: EncryptionAlgo): Promise<any>;
    protected _stopEncryption(): Promise<any>;
    command<T>(command: Command, bodyDecoder?: BodyDecoder<T>): Observable<Response<T>>;
    protected _command<T>(command: Command, bodyDecoder?: BodyDecoder<T>): Observable<Response<T>>;
    onConnectionStateChange(): Observable<ConnectionStateChangeEvent>;
}
