import { Observable, BehaviorSubject } from 'rxjs';
import { VasatConfig, VasatStorage, VasatError, VasatServiceConfig, VasatSiteInfo, VasatSiteInitRequest, VasatModelDefinition, VasatPayload, VasatAPIResponse, RemoteLoginInfo } from './models/types';
import { VasatModelClass, VasatModel, VasatSession, VasatSearchQuery, VasatConnection, RemoteOAuthResponse } from './models/base-models';
import { DeviceMetaProvider } from './models/device';
export declare class Vasat<T extends VasatModel<T>> implements VasatConnection {
    config: VasatConfig;
    pathPrefix: string;
    private _logoutEvent;
    onLogout: Observable<any>;
    private _errorEvent;
    onErrorEvent: Observable<VasatError>;
    token?: string;
    mediaToken?: string;
    private _modelCache;
    private _cacheClass;
    private _modelCacheHash;
    private _sessionObservable;
    private _sessionSubject;
    private _persistSession;
    private _loadingSession?;
    private _siteInfo?;
    readonly siteInfo: BehaviorSubject<VasatSiteInfo | undefined>;
    services: VasatServiceConfig[];
    servicesLoading?: Observable<any>;
    private _remoteInfo?;
    UserModel: VasatModelClass<any>;
    storage: VasatStorage;
    constructor(config: VasatConfig, _storage?: VasatStorage, userModel?: VasatModelClass<T>);
    get authPrefix(): string;
    clientKey(): string;
    registerCacheClass<T extends VasatModel<T>>(obj: VasatModelClass<T> | string, items: T[], overrideExisting?: boolean): void;
    private _modelPrefixes;
    private _domainPrefixes;
    registerPathPrefix(m: VasatModelClass<any>, prefix: string): void;
    registerDomainPrefix(domain: string, prefix: string): void;
    modelPathPrefix(m: VasatModel<any>): string;
    classNameForType(obj: VasatModelClass<any>): string;
    registerClass<T extends VasatModel<T>>(obj: VasatModelClass<T>): void;
    findCached<T extends VasatModel<T>>(obj: VasatModelClass<T> | string, id: string | number | ((v: T) => boolean)): T | undefined;
    findCachedClass<T extends VasatModel<T>>(obj: string): VasatModelClass<T>;
    getCached<T extends VasatModel<T>>(obj: VasatModelClass<T> | string): T[];
    filterCached<T extends VasatModel<T>>(obj: VasatModelClass<T> | string, id: number | ((v: T) => boolean)): T[];
    registeredClassForString(key: string): VasatModelClass<any>;
    sessionObservable(fire?: Boolean): Observable<any>;
    onReady(): Observable<VasatSession>;
    localSession(): VasatSession | undefined;
    invalidateSession(): void;
    invalidateCache(): void;
    authToken(): any;
    saveLocalSession(obj: VasatSession): void;
    hasSession(): boolean;
    signup(username: string, password: string, email?: string, userMeta?: any, byoClientId?: string): Observable<any>;
    signupWith2FA(username: string, pass?: string, userMeta?: any, mode?: 'password' | 'magic'): Observable<any>;
    check2FASignup(token: string): Observable<any>;
    complete2FASignup(token: string, password?: string, userMeta?: any): Observable<any>;
    loginWithUsername(user: string, pass: string, persistSession?: boolean, byoClientId?: string): Observable<any>;
    loginWithClientCredentials(): Observable<VasatSession>;
    /**
     * Login using remote FacebookOauth
     * @param remoteClientId Facebook App ID
     * @param remoteClientToken Facebook access token given by the Facebook SDK.
     */
    loginWithClientFacebook(remoteClientId: string, remoteClientToken: string): Observable<any>;
    registerPushRegId(regId: string): Observable<any>;
    resetPasswordRequest(email: string): Observable<any>;
    /**
     *
     * @deprecated Renamed to resetPasswordRequest()
     */
    requestForgetPassword(email: string): Observable<any>;
    resetPasswordTokenCheck(token: string): Observable<VasatAPIResponse<any>>;
    resetPassword(token: string, newPassword: string): Observable<VasatAPIResponse<any>>;
    /**
     *
     * @deprecated Renamed to logout()
     */
    logoutObservable(): Observable<any>;
    logout(): Observable<any>;
    private _refreshing?;
    private _refreshingObs?;
    refreshToken(): Observable<VasatSession | undefined>;
    refreshMeUser(): Observable<T>;
    private processResp;
    protected _getURL(url: string): string;
    api(url: string, meth?: string, args?: any): Observable<any>;
    get(url: string, args?: any): Observable<VasatAPIResponse<any>>;
    delete(url: string, args?: any): Observable<VasatAPIResponse<any>>;
    put(url: string, obj: any, args?: any): Observable<VasatAPIResponse<any>>;
    post(url: string, obj: any, args?: any): Observable<VasatAPIResponse<any>>;
    _http(meth: string, url: string, obj: any, args?: any, tryedRefresh?: boolean): Observable<VasatAPIResponse<any>>;
    file(url: string, meth?: string, payload?: any): Observable<Blob>;
    searchByObject<T extends VasatModel<T>>(v: VasatModelClass<T>): VasatSearchQuery<T>;
    searchByObjectString<T extends VasatModel<T>>(obj: string): VasatSearchQuery<T>;
    searchByObjectStringAndDomain<T extends VasatModel<T>>(obj: string, domain: string): VasatSearchQuery<T>;
    /**
     * Generate a url to send the browser to so it can authenticate.
     * @client is the remote client uid
     * @redirectUrl is the url on your server to be sent to once the user has logged in (or not)
     *
     * returns observale of the url to be sent to
     */
    loginViaOAuthUrl(client: string, redirectUrl: string, state?: string, scope?: string[]): Observable<string>;
    /**
     * When an oauth site returns you back to this site
     * @client is the remote client uid
     * @redirectUrl is the url on your server to be sent to once the user has logged in (or not)
     * @code is the code returned by the oauth server
     * returns observale of the url to be sent to
     */
    loginRemoteOAuthCode(client: string, code: string, redirectUrl: string): Observable<RemoteOAuthResponse<T>>;
    completeRemoteOAuthSignup(sr: RemoteOAuthResponse<T>, user: any): Observable<VasatSession>;
    activeHostServices(): Observable<VasatServiceConfig[]>;
    private _defaultDeviceMeta;
    setDeviceMeta(dm: DeviceMetaProvider): void;
    deviceMeta(): import("./models/device").DeviceMeta;
    private _loadSiteInfo;
    loadSiteInfo(force?: boolean, nest?: boolean): Observable<VasatSiteInfo>;
    remoteLoginInfo(): Observable<RemoteLoginInfo[]>;
    /**
     * Returns the current VasatSiteInfo in memory. Will return null if not initialised.
     */
    getSiteInfo(): VasatSiteInfo | undefined;
    initSite(params: VasatSiteInitRequest): Observable<VasatSiteInfo | undefined>;
    apiModels(): Observable<VasatPayload<VasatModelDefinition>>;
    apiAccessModels(): Observable<VasatPayload<VasatModelDefinition>>;
    getOpenApiUrl(path: string): string;
    loginWith2FA(username: string, password: string): Observable<VasatAPIResponse<any>>;
    loginWithMagic(username: string): Observable<VasatAPIResponse<any>>;
    complete2FALogin(token: String): Observable<VasatSession>;
    processV2Token(resp: VasatAPIResponse<any>): VasatSession;
}