import { DeviceType } from '../model/proto/constant/device_type';
import { ParsedModel } from '../model/parsed-model';
import { ProfileAccessStrategy } from '../model/proto/constant/profile_access_strategy';
import { ResponseAction } from '../model/proto/constant/response_action';
import Response from '../model/response';
import SessionCloseInfo from '../model/session-close-info';
import TurmsClient from '../turms-client';
import UserLocation from '../model/user-location';
import { UserStatus } from '../model/proto/constant/user_status';
export interface UserInfo {
    userId?: string;
    password?: string;
    deviceType?: DeviceType;
    deviceDetails?: Record<string, string>;
    onlineStatus?: UserStatus;
    location?: UserLocation;
}
export default class UserService {
    private _turmsClient;
    private _stateStore;
    private _userInfo;
    private _storePassword;
    private _onOnlineListeners;
    private _onOfflineListeners;
    constructor(turmsClient: TurmsClient);
    get userInfo(): UserInfo;
    get isLoggedIn(): boolean;
    addOnOnlineListener(listener: () => void): void;
    addOnOfflineListener(listener: (sessionCloseInfo: SessionCloseInfo) => void): void;
    removeOnOnlineListener(listener: () => void): void;
    removeOnOfflineListener(listener: () => void): void;
    static getUserLocationFromBrowser(): Promise<GeolocationPosition>;
    login({ userId, password, deviceType, deviceDetails, onlineStatus, location, storePassword }: {
        userId: string;
        password?: string;
        deviceType?: string | DeviceType;
        deviceDetails?: Record<string, string>;
        onlineStatus?: string | UserStatus;
        location?: GeolocationPosition | UserLocation;
        storePassword?: boolean;
    }): Promise<Response<void>>;
    private _connect;
    logout({ immediate }?: {
        immediate?: boolean;
    }): Promise<Response<void>>;
    updateOnlineStatus({ onlineStatus }: {
        onlineStatus: string | UserStatus;
    }): Promise<Response<void>>;
    disconnectOnlineDevices({ deviceTypes }: {
        deviceTypes: string[] | DeviceType[];
    }): Promise<Response<void>>;
    updatePassword({ password }: {
        password: string;
    }): Promise<Response<void>>;
    updateProfile({ name, intro, profilePicture, profileAccessStrategy }: {
        name?: string;
        intro?: string;
        profilePicture?: string;
        profileAccessStrategy?: string | ProfileAccessStrategy;
    }): Promise<Response<void>>;
    queryUserProfiles({ userIds, lastUpdatedDate }: {
        userIds: string[];
        lastUpdatedDate?: Date;
    }): Promise<Response<ParsedModel.UserInfo[]>>;
    queryNearbyUsers({ latitude, longitude, maxCount, maxDistance, withCoordinates, withDistance, withUserInfo }: {
        latitude: number;
        longitude: number;
        maxCount?: number;
        maxDistance?: number;
        withCoordinates?: boolean;
        withDistance?: boolean;
        withUserInfo?: boolean;
    }): Promise<Response<ParsedModel.NearbyUser[]>>;
    queryOnlineStatusesRequest({ userIds }: {
        userIds: string[];
    }): Promise<Response<ParsedModel.UserOnlineStatus[]>>;
    queryRelationships({ relatedUserIds, isBlocked, groupIndexes, lastUpdatedDate }: {
        relatedUserIds?: string[];
        isBlocked?: boolean;
        groupIndexes?: number[];
        lastUpdatedDate?: Date;
    }): Promise<Response<ParsedModel.UserRelationshipsWithVersion | undefined>>;
    queryRelatedUserIds({ isBlocked, groupIndexes, lastUpdatedDate }?: {
        isBlocked?: boolean;
        groupIndexes?: number[];
        lastUpdatedDate?: Date;
    }): Promise<Response<ParsedModel.LongsWithVersion | undefined>>;
    queryFriends({ groupIndexes, lastUpdatedDate }?: {
        groupIndexes?: number[];
        lastUpdatedDate?: Date;
    }): Promise<Response<ParsedModel.UserRelationshipsWithVersion | undefined>>;
    queryBlockedUsers({ groupIndexes, lastUpdatedDate }?: {
        groupIndexes?: number[];
        lastUpdatedDate?: Date;
    }): Promise<Response<ParsedModel.UserRelationshipsWithVersion | undefined>>;
    createRelationship({ userId, isBlocked, groupIndex }: {
        userId: string;
        isBlocked: boolean;
        groupIndex?: number;
    }): Promise<Response<void>>;
    createFriendRelationship({ userId, groupIndex }: {
        userId: string;
        groupIndex?: number;
    }): Promise<Response<void>>;
    createBlockedUserRelationship({ userId, groupIndex }: {
        userId: string;
        groupIndex?: number;
    }): Promise<Response<void>>;
    deleteRelationship({ relatedUserId, deleteGroupIndex, targetGroupIndex }: {
        relatedUserId: string;
        deleteGroupIndex?: number;
        targetGroupIndex?: number;
    }): Promise<Response<void>>;
    updateRelationship({ relatedUserId, isBlocked, groupIndex }: {
        relatedUserId: string;
        isBlocked?: boolean;
        groupIndex?: number;
    }): Promise<Response<void>>;
    sendFriendRequest({ recipientId, content }: {
        recipientId: string;
        content: string;
    }): Promise<Response<string>>;
    replyFriendRequest({ requestId, responseAction, reason }: {
        requestId: string;
        responseAction: string | ResponseAction;
        reason?: string;
    }): Promise<Response<void>>;
    queryFriendRequests({ areSentByMe, lastUpdatedDate }: {
        areSentByMe: boolean;
        lastUpdatedDate?: Date;
    }): Promise<Response<ParsedModel.UserFriendRequestsWithVersion | undefined>>;
    createRelationshipGroup({ name }: {
        name: string;
    }): Promise<Response<number>>;
    deleteRelationshipGroups({ groupIndex, targetGroupIndex }: {
        groupIndex: number;
        targetGroupIndex?: number;
    }): Promise<Response<void>>;
    updateRelationshipGroup({ groupIndex, newName }: {
        groupIndex: number;
        newName: string;
    }): Promise<Response<void>>;
    queryRelationshipGroups({ lastUpdatedDate }?: {
        lastUpdatedDate?: Date;
    }): Promise<Response<ParsedModel.UserRelationshipGroupsWithVersion | undefined>>;
    moveRelatedUserToGroup({ relatedUserId, groupIndex }: {
        relatedUserId: string;
        groupIndex: number;
    }): Promise<Response<void>>;
    updateLocation({ latitude, longitude, details }: {
        latitude: number;
        longitude: number;
        details?: Record<string, string>;
    }): Promise<Response<void>>;
    private static _parseDeviceType;
    private static _parseUserStatus;
    private _updateSharedUserInfo;
    private _changeToOnline;
    private _changeToOffline;
}
//# sourceMappingURL=user-service.d.ts.map