import { ITypedEvent } from "../TypedEvent";
import { IDataFrame } from "../DataFrame";
import { IDIService } from "../IDIService";
export interface IExalusConnectionService extends IDIService {
    SetServersBrokerAddress(address: string): void;
    SetDefaultPacketsBrokerAddress(address: string): void;
    GetServerAddressAsync(): Promise<string | null>;
    GetConnectedBrokerInfoAsync(timeoutMs?: number | null): Promise<BrokerInfo>;
    ConnectAsync(address: string): Promise<ConnectionResult>;
    AuthorizeAsync(authorizationInfo: AuthorizationInfo): Promise<boolean>;
    ConnectAndAuthorizeAsync(authorizationInfo: AuthorizationInfo): Promise<ConnectionResult>;
    DisconnectAsync(): Promise<void>;
    IsConnected(): boolean;
    EnablePacketsLogging(): void;
    DisablePacketsLogging(): void;
    SendAsync(dataFrame: IDataFrame<any>): Promise<boolean>;
    SendAndWaitForResponseAsync<T>(dataFrame: IDataFrame<any>, timeout: number, useCache: boolean): Promise<IDataFrame<T>>;
    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>;
    SendAndHandleStreamAsync<T>(dataFrame: IDataFrame<any>, streamHandler: StreamHandler<T>, logTransmission: boolean): Promise<void>;
    OnDataReceivedEvent(): ITypedEvent<IDataFrame<any>>;
    SubscribeTo<T>(resourceId: string, handler: {
        (data: IDataFrame<T>): void;
    }): () => void;
    OnErrorOccuredEvent(): ITypedEvent<[sender: string, data: string]>;
    OnConnectionStateChangedEvent(): ITypedEvent<ConnectionState>;
    GetAuthorizationInfo(): AuthorizationInfo | null;
}
export declare class AuthorizationInfo {
    serialNumber: string;
    pin: string;
    constructor(serialNumber: string, pin: string);
    SerialNumber: string;
    PIN: string;
}
export declare enum ConnectionType {
    ByCloud = 0,
    LocalNetwork = 1,
    P2P = 2
}
export declare enum ConnectionResult {
    FailedToConnect = 0,
    AuthorizationFailed = 1,
    FailedToConnectToServer = 2,
    Connected = 3,
    ControllerIsNotConnected = 4
}
export declare enum ConnectionState {
    Disconnected = 0,
    Connecting = 1,
    Connected = 3,
    Disconnecting = 4,
    Failed = 5,
    Reconnecting = 6,
    ConnectedAndAuthorized = 7
}
export declare class BrokerInfo {
    BrokerUrl: string;
    BrokerControllerUrl: string | undefined;
    Env: BrokerEnvironment;
    constructor(BrokerUrl: string, BrokerControllerUrl: string | undefined, Env?: BrokerEnvironment);
}
export declare enum BrokerEnvironment {
    Production = 0,
    Development = 1,
    Local = 2
}
export type StreamHandler<T> = {
    Next: (item: T) => void;
    Complete: () => void;
    Error: (err: any) => void;
};
export declare class StreamError extends Error {
    constructor(message: string);
}