import { IDataFrame } from "../DataFrame";
import { ITypedEvent } from "../TypedEvent";
import { AuthorizationInfo, BrokerInfo, ConnectionResult, ConnectionState, IExalusConnectionService, StreamHandler } from "./IExalusConnectionService";
export declare class LocalNetworkExalusConnectionService implements IExalusConnectionService {
    SendAndHandleStreamAsync<T>(dataFrame: IDataFrame<any>, streamHandler: StreamHandler<T>, logTransmission: boolean): Promise<void>;
    private _errorOccuredEvent;
    private _connectionStateChangedEvent;
    private _dataReceivedEvent;
    private _onMessageReceived;
    private _log;
    private _controllerConfiguration;
    private _cache;
    private _session;
    static readonly ServiceName: string;
    private _logPackets;
    private socket;
    private _address;
    private _port;
    private _isOpen;
    private _pin;
    private _serial;
    private _auth;
    private _initialized;
    private _pingInterval;
    private _pingIntervalId;
    private _lastReceivedPacketTime;
    private _disconnectedOnPurpose;
    private _restoreTask;
    constructor();
    GetConnectedBrokerInfoAsync(timeoutMs?: number | null): Promise<BrokerInfo>;
    private Initialize;
    private checkIfAuthInfoIsCorrectAsync;
    PingControllerAsync(): Promise<boolean>;
    SubscribeTo<T>(resourceId: string, handler: {
        (data: IDataFrame<T>): void;
    }): () => void;
    GetControllerSerialNumber(): string | undefined;
    GetControllerPin(): string | undefined;
    SetServersBrokerAddress(address: string): void;
    SetDefaultPacketsBrokerAddress(address: string): void;
    GetServerAddressAsync(): Promise<string | null>;
    ConnectAsync(address: string): Promise<ConnectionResult>;
    AuthorizeAsync(authorizationInfo: AuthorizationInfo): Promise<boolean>;
    ConnectAndAuthorizeAsync(authorizationInfo: AuthorizationInfo): Promise<ConnectionResult>;
    DisconnectAsync(): Promise<void>;
    IsConnected(): boolean;
    EnablePacketsLogging(): void;
    DisablePacketsLogging(): void;
    private SendData;
    SendAsync(dataFrame: IDataFrame<any>): Promise<boolean>;
    SendAndWaitForResponseAsync<T>(dataFrame: IDataFrame<any>, timeout: number, useCache: boolean, logTransmission?: boolean): Promise<IDataFrame<T>>;
    SendAndHandleResponseAsync<T>(dataFrame: IDataFrame<any>, timeout: number, dataHandler: (result: IDataFrame<T>) => void, logTransmission: boolean): Promise<void>;
    SendAndWaitForResponseWithRepeatAsync<T>(dataFrame: IDataFrame<any>, timeout: number, useCache: boolean, repeat?: boolean, logTransmission?: boolean): Promise<IDataFrame<T>>;
    OnDataReceivedEvent(): ITypedEvent<IDataFrame<any>>;
    OnErrorOccuredEvent(): ITypedEvent<[sender: string, data: string]>;
    OnConnectionStateChangedEvent(): ITypedEvent<ConnectionState>;
    GetAuthorizationInfo(): AuthorizationInfo | null;
    GetServiceName(): string;
    private RestoreConnectionAsync;
}