import * as i0 from '@angular/core';
import { HttpClient } from '@angular/common/http';
import * as rxjs from 'rxjs';
import { Observable } from 'rxjs';

declare class Path {
    static dotToSlash(path: string): string;
    static contextToPath(context: string): string;
}
declare class Message {
    static updates(): {
        context: null;
        updates: never[];
    };
    static subscribe(): {
        context: null;
        subscribe: never[];
    };
    static unsubscribe(): {
        context: null;
        unsubscribe: never[];
    };
    static request(): {
        requestId: string;
    };
}
declare class Alarm {
    private _state;
    private _method;
    private _message;
    constructor(message: string, state?: AlarmState, visual?: boolean, sound?: boolean);
    get value(): {
        message: string;
        state: AlarmState;
        method: AlarmMethod[];
    };
}
declare enum AlarmState {
    normal = "normal",
    alert = "alert",
    warn = "warn",
    alarm = "alarm",
    emergency = "emergency"
}
declare enum AlarmMethod {
    visual = "visual",
    sound = "sound"
}
declare enum AlarmType {
    mob = "notifications.mob",
    fire = "notifications.fire",
    sinking = "notifications.sinking",
    flooding = "notifications.flooding",
    collision = "notifications.collision",
    grounding = "notifications.grounding",
    listing = "notifications.listing",
    adrift = "notifications.adrift",
    piracy = "notifications.piracy",
    abandon = "notifications.abandon"
}

declare class SignalKHttp {
    private http;
    private _token;
    private _observe;
    server: any;
    endpoint: string;
    version: number;
    set authToken(val: string);
    set observeResponse(value: boolean);
    constructor(http: HttpClient);
    getSelf(): any;
    getSelfId(): any;
    getMeta(context: string, path: string): any;
    get(path: string): any;
    get(version: number, path: string): any;
    private parseApiPut;
    put(path: string, value: any): any;
    put(version: number, path: string, value: any): any;
    putWithContext(context: string, path: string, value: any): any;
    putWithContext(version: number, context: string, path: string, value: any): any;
    post(path: string, value: any): any;
    post(version: number, path: string, value: any): any;
    delete(path: string): any;
    delete(version: number, path: string): any;
    raiseAlarm(context: string, name: string, alarm: Alarm): any;
    raiseAlarm(context: string, type: AlarmType, alarm: Alarm): any;
    clearAlarm(context: string | undefined, name: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<SignalKHttp, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SignalKHttp>;
}

declare class SignalKStream {
    private _connect;
    private _close;
    private _error;
    private _message;
    private ws;
    private _filter;
    private _wsTimeout;
    private _token;
    private _playbackMode;
    onConnect: Observable<any>;
    onClose: Observable<any>;
    onError: Observable<any>;
    onMessage: Observable<any>;
    version: number;
    endpoint: string;
    selfId: string;
    _source: any;
    set source(val: string);
    set authToken(val: string);
    get connectionTimeout(): number;
    set connectionTimeout(val: number);
    get isOpen(): boolean;
    get filter(): string;
    set filter(id: string);
    get playbackMode(): boolean;
    constructor();
    close(): void;
    open(url: string, subscribe?: string, token?: string): void;
    private parseOnMessage;
    sendRequest(value: any): string;
    put(context: string, path: string, value: any): string;
    login(username: string, password: string): string;
    send(data: any): void;
    sendUpdate(context: string, path: Array<any>): void;
    sendUpdate(context: string, path: string, value: any): void;
    subscribe(context: string, path: Array<any>): void;
    subscribe(context: string, path: string, options?: any): void;
    unsubscribe(context?: string, path?: any): void;
    raiseAlarm(context: string, name: string, alarm: Alarm): void;
    raiseAlarm(context: string, type: AlarmType, alarm: Alarm): void;
    clearAlarm(context: string | undefined, name: string): void;
    isSelf(msg: any): boolean;
    isDelta(msg: any): boolean;
    isHello(msg: any): boolean;
    isResponse(msg: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SignalKStream, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SignalKStream>;
}

declare class SignalKApps {
    private http;
    endpoint: string;
    constructor(http: HttpClient);
    ngOnDestroy(): void;
    list(): rxjs.Observable<Object>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SignalKApps, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SignalKApps>;
}

interface Server_Info {
    endpoints: {
        [key: string]: any;
    };
    info: {
        [key: string]: any;
    };
    apiVersions: Array<any>;
}
interface JSON_Patch {
    op: 'add' | 'replace' | 'remove' | 'copy' | 'move' | 'test';
    path: string;
    value: any;
}
declare enum APPDATA_CONTEXT {
    USER = "user",
    GLOBAL = "global"
}
declare class SignalKClient {
    private http;
    apps: SignalKApps;
    api: SignalKHttp;
    stream: SignalKStream;
    private hostname;
    private port;
    private protocol;
    private _version;
    private _token;
    private debug;
    private fallbackEndpoints;
    server: Server_Info;
    fallback: boolean;
    proxied: boolean;
    get version(): number;
    set version(val: number);
    set authToken(val: string);
    get message(): typeof Message;
    get uuid(): string;
    get signalkUuid(): string;
    constructor(http: HttpClient, apps: SignalKApps, api: SignalKHttp, stream: SignalKStream);
    ngOnDestroy(): void;
    private init;
    hello(hostname?: string, port?: number, useSSL?: boolean): Observable<Object>;
    connect(hostname?: string, port?: number, useSSL?: boolean): Observable<any>;
    disconnect(): void;
    connectStream(hostname?: string, port?: number, useSSL?: boolean, subscribe?: string): Observable<any>;
    connectPlayback(hostname: string | undefined, port: number | undefined, useSSL: boolean | undefined, options: any): Observable<any>;
    openStream(url?: string, subscribe?: string, token?: string): true | Error;
    openPlayback(url?: string, options?: any, token?: string): true | Error;
    private processHello;
    private resolveAppsEndpoint;
    resolveStreamEndpoint(): string;
    private resolveHttpEndpoint;
    private disconnectedFromServer;
    get(path: string): Observable<Object>;
    put(path: string, value: any): Observable<Object>;
    post(path: string, value: any): Observable<Object>;
    login(username: string, password: string): Observable<Object>;
    logout(): Observable<boolean>;
    isLoggedIn(): Observable<boolean>;
    getLoginStatus(): Observable<any>;
    snapshot(context: string, time: string): Observable<Object> | undefined;
    /*******************************
     *  applicationData api methods
     * context: 'user' or 'global'
     * appId: application id string
     *******************************/
    private _appId;
    private _appVersion;
    private resolveAppDataEndpoint;
    setAppId(value: string): void;
    setAppVersion(value: string): void;
    appDataVersions(context?: APPDATA_CONTEXT, appId?: string): Observable<Object>;
    appDataKeys(path?: string, context?: APPDATA_CONTEXT, appId?: string, version?: string): Observable<Object>;
    appDataGet(path?: string, context?: APPDATA_CONTEXT, appId?: string, version?: string): Observable<Object>;
    appDataSet(path: string, value: any, context?: APPDATA_CONTEXT, appId?: string, version?: string): Observable<Object> | undefined;
    appDataPatch(value: Array<JSON_Patch>, context?: APPDATA_CONTEXT, appId?: string, version?: string): Observable<Object> | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<SignalKClient, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SignalKClient>;
}

declare class SignalKClientModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SignalKClientModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SignalKClientModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SignalKClientModule>;
}

export { APPDATA_CONTEXT, Alarm, AlarmMethod, AlarmState, AlarmType, Message, Path, SignalKApps, SignalKClient, SignalKClientModule, SignalKHttp, SignalKStream };