import _m0 from 'protobufjs/minimal';

interface LongsWithVersion {
    longs: string[];
    lastUpdatedDate?: string | undefined;
}
declare const LongsWithVersion: {
    encode(message: LongsWithVersion, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): LongsWithVersion;
};

interface StringsWithVersion {
    strings: string[];
    lastUpdatedDate?: string | undefined;
}
declare const StringsWithVersion: {
    encode(message: StringsWithVersion, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): StringsWithVersion;
};

interface GroupConversation {
    groupId: string;
    memberIdToReadDate: {
        [key: string]: string;
    };
}
declare const GroupConversation: {
    encode(message: GroupConversation, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): GroupConversation;
};

interface PrivateConversation {
    ownerId: string;
    targetId: string;
    readDate: string;
}
declare const PrivateConversation: {
    encode(message: PrivateConversation, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): PrivateConversation;
};

interface Conversations {
    privateConversations: PrivateConversation[];
    groupConversations: GroupConversation[];
}
declare const Conversations: {
    encode(message: Conversations, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Conversations;
};

declare enum RequestStatus {
    PENDING = 0,
    ACCEPTED = 1,
    ACCEPTED_WITHOUT_CONFIRM = 2,
    DECLINED = 3,
    IGNORED = 4,
    EXPIRED = 5,
    CANCELED = 6,
    UNRECOGNIZED = -1
}

interface GroupInvitation {
    id?: string | undefined;
    creationDate?: string | undefined;
    content?: string | undefined;
    status?: RequestStatus | undefined;
    expirationDate?: string | undefined;
    groupId?: string | undefined;
    inviterId?: string | undefined;
    inviteeId?: string | undefined;
}
declare const GroupInvitation: {
    encode(message: GroupInvitation, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): GroupInvitation;
};

interface GroupInvitationsWithVersion {
    groupInvitations: GroupInvitation[];
    lastUpdatedDate?: string | undefined;
}
declare const GroupInvitationsWithVersion: {
    encode(message: GroupInvitationsWithVersion, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): GroupInvitationsWithVersion;
};

interface GroupJoinQuestionsAnswerResult {
    score: number;
    questionIds: string[];
    joined: boolean;
}
declare const GroupJoinQuestionsAnswerResult: {
    encode(message: GroupJoinQuestionsAnswerResult, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): GroupJoinQuestionsAnswerResult;
};

interface GroupJoinQuestion {
    id?: string | undefined;
    groupId?: string | undefined;
    question?: string | undefined;
    answers: string[];
    score?: number | undefined;
}
declare const GroupJoinQuestion: {
    encode(message: GroupJoinQuestion, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): GroupJoinQuestion;
};

interface GroupJoinQuestionsWithVersion {
    groupJoinQuestions: GroupJoinQuestion[];
    lastUpdatedDate?: string | undefined;
}
declare const GroupJoinQuestionsWithVersion: {
    encode(message: GroupJoinQuestionsWithVersion, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): GroupJoinQuestionsWithVersion;
};

interface GroupJoinRequest {
    id?: string | undefined;
    creationDate?: string | undefined;
    content?: string | undefined;
    status?: RequestStatus | undefined;
    expirationDate?: string | undefined;
    groupId?: string | undefined;
    requesterId?: string | undefined;
    responderId?: string | undefined;
}
declare const GroupJoinRequest: {
    encode(message: GroupJoinRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): GroupJoinRequest;
};

interface GroupJoinRequestsWithVersion {
    groupJoinRequests: GroupJoinRequest[];
    lastUpdatedDate?: string | undefined;
}
declare const GroupJoinRequestsWithVersion: {
    encode(message: GroupJoinRequestsWithVersion, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): GroupJoinRequestsWithVersion;
};

declare enum DeviceType {
    DESKTOP = 0,
    BROWSER = 1,
    IOS = 2,
    ANDROID = 3,
    OTHERS = 4,
    UNKNOWN = 5,
    UNRECOGNIZED = -1
}

declare enum GroupMemberRole {
    OWNER = 0,
    MANAGER = 1,
    MEMBER = 2,
    GUEST = 3,
    ANONYMOUS_GUEST = 4,
    UNRECOGNIZED = -1
}

declare enum UserStatus {
    AVAILABLE = 0,
    OFFLINE = 1,
    INVISIBLE = 2,
    BUSY = 3,
    DO_NOT_DISTURB = 4,
    AWAY = 5,
    BE_RIGHT_BACK = 6,
    UNRECOGNIZED = -1
}

interface GroupMember {
    groupId?: string | undefined;
    userId?: string | undefined;
    name?: string | undefined;
    role?: GroupMemberRole | undefined;
    joinDate?: string | undefined;
    muteEndDate?: string | undefined;
    userStatus?: UserStatus | undefined;
    usingDeviceTypes: DeviceType[];
}
declare const GroupMember: {
    encode(message: GroupMember, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): GroupMember;
};

interface GroupMembersWithVersion {
    groupMembers: GroupMember[];
    lastUpdatedDate?: string | undefined;
}
declare const GroupMembersWithVersion: {
    encode(message: GroupMembersWithVersion, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): GroupMembersWithVersion;
};

interface Group {
    id?: string | undefined;
    typeId?: string | undefined;
    creatorId?: string | undefined;
    ownerId?: string | undefined;
    name?: string | undefined;
    intro?: string | undefined;
    announcement?: string | undefined;
    creationDate?: string | undefined;
    lastUpdatedDate?: string | undefined;
    muteEndDate?: string | undefined;
    active?: boolean | undefined;
}
declare const Group: {
    encode(message: Group, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Group;
};

interface GroupsWithVersion {
    groups: Group[];
    lastUpdatedDate?: string | undefined;
}
declare const GroupsWithVersion: {
    encode(message: GroupsWithVersion, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): GroupsWithVersion;
};

interface Message {
    id?: string | undefined;
    deliveryDate?: string | undefined;
    modificationDate?: string | undefined;
    text?: string | undefined;
    senderId?: string | undefined;
    groupId?: string | undefined;
    isSystemMessage?: boolean | undefined;
    recipientId?: string | undefined;
    records: Uint8Array[];
    sequenceId?: number | undefined;
    preMessageId?: string | undefined;
}
declare const Message: {
    encode(message: Message, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Message;
};

interface Messages {
    messages: Message[];
}
declare const Messages: {
    encode(message: Messages, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): Messages;
};

interface MessagesWithTotal {
    total: number;
    isGroupMessage: boolean;
    fromId: string;
    messages: Message[];
}
declare const MessagesWithTotal: {
    encode(message: MessagesWithTotal, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): MessagesWithTotal;
};

interface MessagesWithTotalList {
    messagesWithTotalList: MessagesWithTotal[];
}
declare const MessagesWithTotalList: {
    encode(message: MessagesWithTotalList, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): MessagesWithTotalList;
};

declare enum ProfileAccessStrategy {
    ALL = 0,
    ALL_EXCEPT_BLOCKED_USERS = 1,
    FRIENDS = 2,
    UNRECOGNIZED = -1
}

interface UserInfo$1 {
    id?: string | undefined;
    name?: string | undefined;
    intro?: string | undefined;
    profilePicture?: string | undefined;
    profileAccessStrategy?: ProfileAccessStrategy | undefined;
    registrationDate?: string | undefined;
    lastUpdatedDate?: string | undefined;
    active?: boolean | undefined;
}
declare const UserInfo$1: {
    encode(message: UserInfo$1, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UserInfo$1;
};

interface UserLocation$1 {
    latitude: number;
    longitude: number;
    timestamp?: string | undefined;
    details: {
        [key: string]: string;
    };
}
declare const UserLocation$1: {
    encode(message: UserLocation$1, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UserLocation$1;
};

interface NearbyUser {
    userId: string;
    deviceType?: DeviceType | undefined;
    info?: UserInfo$1 | undefined;
    distance?: number | undefined;
    location?: UserLocation$1 | undefined;
}
declare const NearbyUser: {
    encode(message: NearbyUser, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): NearbyUser;
};

interface NearbyUsers {
    nearbyUsers: NearbyUser[];
}
declare const NearbyUsers: {
    encode(message: NearbyUsers, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): NearbyUsers;
};

interface UserFriendRequest {
    id?: string | undefined;
    creationDate?: string | undefined;
    content?: string | undefined;
    requestStatus?: RequestStatus | undefined;
    reason?: string | undefined;
    expirationDate?: string | undefined;
    requesterId?: string | undefined;
    recipientId?: string | undefined;
}
declare const UserFriendRequest: {
    encode(message: UserFriendRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UserFriendRequest;
};

interface UserFriendRequestsWithVersion {
    userFriendRequests: UserFriendRequest[];
    lastUpdatedDate?: string | undefined;
}
declare const UserFriendRequestsWithVersion: {
    encode(message: UserFriendRequestsWithVersion, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UserFriendRequestsWithVersion;
};

interface UserInfosWithVersion {
    userInfos: UserInfo$1[];
    lastUpdatedDate?: string | undefined;
}
declare const UserInfosWithVersion: {
    encode(message: UserInfosWithVersion, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UserInfosWithVersion;
};

interface UserOnlineStatus {
    userId: string;
    userStatus: UserStatus;
    usingDeviceTypes: DeviceType[];
}
declare const UserOnlineStatus: {
    encode(message: UserOnlineStatus, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UserOnlineStatus;
};

interface UserOnlineStatuses {
    statuses: UserOnlineStatus[];
}
declare const UserOnlineStatuses: {
    encode(message: UserOnlineStatuses, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UserOnlineStatuses;
};

interface UserRelationshipGroup {
    index: number;
    name: string;
}
declare const UserRelationshipGroup: {
    encode(message: UserRelationshipGroup, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UserRelationshipGroup;
};

interface UserRelationshipGroupsWithVersion {
    userRelationshipGroups: UserRelationshipGroup[];
    lastUpdatedDate?: string | undefined;
}
declare const UserRelationshipGroupsWithVersion: {
    encode(message: UserRelationshipGroupsWithVersion, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UserRelationshipGroupsWithVersion;
};

interface UserRelationship {
    ownerId?: string | undefined;
    relatedUserId?: string | undefined;
    blockDate?: string | undefined;
    groupIndex?: string | undefined;
    establishmentDate?: string | undefined;
}
declare const UserRelationship: {
    encode(message: UserRelationship, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UserRelationship;
};

interface UserRelationshipsWithVersion {
    userRelationships: UserRelationship[];
    lastUpdatedDate?: string | undefined;
}
declare const UserRelationshipsWithVersion: {
    encode(message: UserRelationshipsWithVersion, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UserRelationshipsWithVersion;
};

interface UserSession {
    sessionId: string;
    serverId: string;
}
declare const UserSession: {
    encode(message: UserSession, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UserSession;
};

interface QueryConversationsRequest {
    targetIds: string[];
    groupIds: string[];
}
declare const QueryConversationsRequest: {
    encode(message: QueryConversationsRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryConversationsRequest;
};

interface UpdateConversationRequest {
    targetId?: string | undefined;
    groupId?: string | undefined;
    readDate: string;
}
declare const UpdateConversationRequest: {
    encode(message: UpdateConversationRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UpdateConversationRequest;
};

interface UpdateTypingStatusRequest {
    isGroupMessage: boolean;
    toId: string;
}
declare const UpdateTypingStatusRequest: {
    encode(message: UpdateTypingStatusRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UpdateTypingStatusRequest;
};

interface CreateGroupBlockedUserRequest {
    groupId: string;
    userId: string;
}
declare const CreateGroupBlockedUserRequest: {
    encode(message: CreateGroupBlockedUserRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): CreateGroupBlockedUserRequest;
};

interface DeleteGroupBlockedUserRequest {
    groupId: string;
    userId: string;
}
declare const DeleteGroupBlockedUserRequest: {
    encode(message: DeleteGroupBlockedUserRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): DeleteGroupBlockedUserRequest;
};

interface QueryGroupBlockedUserIdsRequest {
    groupId: string;
    lastUpdatedDate?: string | undefined;
}
declare const QueryGroupBlockedUserIdsRequest: {
    encode(message: QueryGroupBlockedUserIdsRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGroupBlockedUserIdsRequest;
};

interface QueryGroupBlockedUserInfosRequest {
    groupId: string;
    lastUpdatedDate?: string | undefined;
}
declare const QueryGroupBlockedUserInfosRequest: {
    encode(message: QueryGroupBlockedUserInfosRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGroupBlockedUserInfosRequest;
};

interface CreateGroupRequest {
    name: string;
    intro?: string | undefined;
    announcement?: string | undefined;
    minimumScore?: number | undefined;
    groupTypeId?: string | undefined;
    muteEndDate?: string | undefined;
}
declare const CreateGroupRequest: {
    encode(message: CreateGroupRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): CreateGroupRequest;
};

interface DeleteGroupRequest {
    groupId: string;
}
declare const DeleteGroupRequest: {
    encode(message: DeleteGroupRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): DeleteGroupRequest;
};

interface CheckGroupJoinQuestionsAnswersRequest {
    questionIdToAnswer: {
        [key: string]: string;
    };
}
declare const CheckGroupJoinQuestionsAnswersRequest: {
    encode(message: CheckGroupJoinQuestionsAnswersRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): CheckGroupJoinQuestionsAnswersRequest;
};

interface CreateGroupInvitationRequest {
    groupId: string;
    inviteeId: string;
    content: string;
}
declare const CreateGroupInvitationRequest: {
    encode(message: CreateGroupInvitationRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): CreateGroupInvitationRequest;
};

interface CreateGroupJoinQuestionsRequest {
    groupId: string;
    questions: GroupJoinQuestion[];
}
declare const CreateGroupJoinQuestionsRequest: {
    encode(message: CreateGroupJoinQuestionsRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): CreateGroupJoinQuestionsRequest;
};

interface CreateGroupJoinRequestRequest {
    groupId: string;
    content: string;
}
declare const CreateGroupJoinRequestRequest: {
    encode(message: CreateGroupJoinRequestRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): CreateGroupJoinRequestRequest;
};

interface DeleteGroupInvitationRequest {
    invitationId: string;
}
declare const DeleteGroupInvitationRequest: {
    encode(message: DeleteGroupInvitationRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): DeleteGroupInvitationRequest;
};

interface DeleteGroupJoinQuestionsRequest {
    groupId: string;
    questionIds: string[];
}
declare const DeleteGroupJoinQuestionsRequest: {
    encode(message: DeleteGroupJoinQuestionsRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): DeleteGroupJoinQuestionsRequest;
};

interface DeleteGroupJoinRequestRequest {
    requestId: string;
}
declare const DeleteGroupJoinRequestRequest: {
    encode(message: DeleteGroupJoinRequestRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): DeleteGroupJoinRequestRequest;
};

interface QueryGroupInvitationsRequest {
    groupId?: string | undefined;
    areSentByMe?: boolean | undefined;
    lastUpdatedDate?: string | undefined;
}
declare const QueryGroupInvitationsRequest: {
    encode(message: QueryGroupInvitationsRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGroupInvitationsRequest;
};

interface QueryGroupJoinQuestionsRequest {
    groupId: string;
    withAnswers: boolean;
    lastUpdatedDate?: string | undefined;
}
declare const QueryGroupJoinQuestionsRequest: {
    encode(message: QueryGroupJoinQuestionsRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGroupJoinQuestionsRequest;
};

interface QueryGroupJoinRequestsRequest {
    groupId?: string | undefined;
    lastUpdatedDate?: string | undefined;
}
declare const QueryGroupJoinRequestsRequest: {
    encode(message: QueryGroupJoinRequestsRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGroupJoinRequestsRequest;
};

interface UpdateGroupJoinQuestionRequest {
    questionId: string;
    question?: string | undefined;
    answers: string[];
    score?: number | undefined;
}
declare const UpdateGroupJoinQuestionRequest: {
    encode(message: UpdateGroupJoinQuestionRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UpdateGroupJoinQuestionRequest;
};

interface CreateGroupMembersRequest {
    groupId: string;
    userIds: string[];
    name?: string | undefined;
    role: GroupMemberRole;
    muteEndDate?: string | undefined;
}
declare const CreateGroupMembersRequest: {
    encode(message: CreateGroupMembersRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): CreateGroupMembersRequest;
};

interface DeleteGroupMembersRequest {
    groupId: string;
    memberIds: string[];
    successorId?: string | undefined;
    quitAfterTransfer?: boolean | undefined;
}
declare const DeleteGroupMembersRequest: {
    encode(message: DeleteGroupMembersRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): DeleteGroupMembersRequest;
};

interface QueryGroupMembersRequest {
    groupId: string;
    lastUpdatedDate?: string | undefined;
    memberIds: string[];
    withStatus?: boolean | undefined;
}
declare const QueryGroupMembersRequest: {
    encode(message: QueryGroupMembersRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGroupMembersRequest;
};

interface UpdateGroupMemberRequest {
    groupId: string;
    memberId: string;
    name?: string | undefined;
    role?: GroupMemberRole | undefined;
    muteEndDate?: string | undefined;
}
declare const UpdateGroupMemberRequest: {
    encode(message: UpdateGroupMemberRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UpdateGroupMemberRequest;
};

interface QueryGroupsRequest {
    groupIds: string[];
    lastUpdatedDate?: string | undefined;
}
declare const QueryGroupsRequest: {
    encode(message: QueryGroupsRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryGroupsRequest;
};

interface QueryJoinedGroupIdsRequest {
    lastUpdatedDate?: string | undefined;
}
declare const QueryJoinedGroupIdsRequest: {
    encode(message: QueryJoinedGroupIdsRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryJoinedGroupIdsRequest;
};

interface QueryJoinedGroupInfosRequest {
    lastUpdatedDate?: string | undefined;
}
declare const QueryJoinedGroupInfosRequest: {
    encode(message: QueryJoinedGroupInfosRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryJoinedGroupInfosRequest;
};

interface UpdateGroupRequest {
    groupId: string;
    groupName?: string | undefined;
    intro?: string | undefined;
    announcement?: string | undefined;
    minimumScore?: number | undefined;
    groupTypeId?: string | undefined;
    muteEndDate?: string | undefined;
    successorId?: string | undefined;
    quitAfterTransfer?: boolean | undefined;
}
declare const UpdateGroupRequest: {
    encode(message: UpdateGroupRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UpdateGroupRequest;
};

interface CreateMessageRequest {
    messageId?: string | undefined;
    isSystemMessage?: boolean | undefined;
    groupId?: string | undefined;
    recipientId?: string | undefined;
    deliveryDate?: string | undefined;
    text?: string | undefined;
    records: Uint8Array[];
    burnAfter?: number | undefined;
    preMessageId?: string | undefined;
}
declare const CreateMessageRequest: {
    encode(message: CreateMessageRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): CreateMessageRequest;
};

interface QueryMessagesRequest {
    ids: string[];
    areGroupMessages?: boolean | undefined;
    areSystemMessages?: boolean | undefined;
    fromIds: string[];
    deliveryDateAfter?: string | undefined;
    deliveryDateBefore?: string | undefined;
    maxCount?: number | undefined;
    withTotal: boolean;
}
declare const QueryMessagesRequest: {
    encode(message: QueryMessagesRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryMessagesRequest;
};

interface UpdateMessageRequest {
    messageId: string;
    text?: string | undefined;
    records: Uint8Array[];
    recallDate?: string | undefined;
}
declare const UpdateMessageRequest: {
    encode(message: UpdateMessageRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UpdateMessageRequest;
};

declare enum StorageResourceType {
    USER_PROFILE_PICTURE = 0,
    GROUP_PROFILE_PICTURE = 1,
    MESSAGE_ATTACHMENT = 2,
    UNRECOGNIZED = -1
}

interface DeleteResourceRequest {
    type: StorageResourceType;
    keyStr?: string | undefined;
    keyNum?: string | undefined;
}
declare const DeleteResourceRequest: {
    encode(message: DeleteResourceRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): DeleteResourceRequest;
};

interface QueryResourceDownloadInfoRequest {
    type: StorageResourceType;
    keyStr?: string | undefined;
    keyNum?: string | undefined;
}
declare const QueryResourceDownloadInfoRequest: {
    encode(message: QueryResourceDownloadInfoRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryResourceDownloadInfoRequest;
};

interface QueryResourceUploadInfoRequest {
    type: StorageResourceType;
    keyStr?: string | undefined;
    keyNum?: string | undefined;
}
declare const QueryResourceUploadInfoRequest: {
    encode(message: QueryResourceUploadInfoRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryResourceUploadInfoRequest;
};

interface CreateSessionRequest {
    version: number;
    userId: string;
    password?: string | undefined;
    userStatus?: UserStatus | undefined;
    deviceType: DeviceType;
    deviceDetails: {
        [key: string]: string;
    };
    location?: UserLocation$1 | undefined;
}
declare const CreateSessionRequest: {
    encode(message: CreateSessionRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): CreateSessionRequest;
};

interface DeleteSessionRequest {
}
declare const DeleteSessionRequest: {
    encode(_: DeleteSessionRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): DeleteSessionRequest;
};

interface QueryNearbyUsersRequest {
    latitude: number;
    longitude: number;
    maxCount?: number | undefined;
    maxDistance?: number | undefined;
    withCoordinates?: boolean | undefined;
    withDistance?: boolean | undefined;
    withUserInfo?: boolean | undefined;
}
declare const QueryNearbyUsersRequest: {
    encode(message: QueryNearbyUsersRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryNearbyUsersRequest;
};

interface QueryUserOnlineStatusesRequest {
    userIds: string[];
}
declare const QueryUserOnlineStatusesRequest: {
    encode(message: QueryUserOnlineStatusesRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryUserOnlineStatusesRequest;
};

interface QueryUserProfilesRequest {
    userIds: string[];
    lastUpdatedDate?: string | undefined;
}
declare const QueryUserProfilesRequest: {
    encode(message: QueryUserProfilesRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryUserProfilesRequest;
};

interface CreateFriendRequestRequest {
    recipientId: string;
    content: string;
}
declare const CreateFriendRequestRequest: {
    encode(message: CreateFriendRequestRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): CreateFriendRequestRequest;
};

interface CreateRelationshipGroupRequest {
    name: string;
}
declare const CreateRelationshipGroupRequest: {
    encode(message: CreateRelationshipGroupRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): CreateRelationshipGroupRequest;
};

interface CreateRelationshipRequest {
    userId: string;
    blocked: boolean;
    groupIndex?: number | undefined;
}
declare const CreateRelationshipRequest: {
    encode(message: CreateRelationshipRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): CreateRelationshipRequest;
};

interface DeleteRelationshipGroupRequest {
    groupIndex: number;
    targetGroupIndex?: number | undefined;
}
declare const DeleteRelationshipGroupRequest: {
    encode(message: DeleteRelationshipGroupRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): DeleteRelationshipGroupRequest;
};

interface DeleteRelationshipRequest {
    userId: string;
    groupIndex?: number | undefined;
    targetGroupIndex?: number | undefined;
}
declare const DeleteRelationshipRequest: {
    encode(message: DeleteRelationshipRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): DeleteRelationshipRequest;
};

interface QueryFriendRequestsRequest {
    areSentByMe: boolean;
    lastUpdatedDate?: string | undefined;
}
declare const QueryFriendRequestsRequest: {
    encode(message: QueryFriendRequestsRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryFriendRequestsRequest;
};

interface QueryRelatedUserIdsRequest {
    blocked?: boolean | undefined;
    groupIndexes: number[];
    lastUpdatedDate?: string | undefined;
}
declare const QueryRelatedUserIdsRequest: {
    encode(message: QueryRelatedUserIdsRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryRelatedUserIdsRequest;
};

interface QueryRelationshipGroupsRequest {
    lastUpdatedDate?: string | undefined;
}
declare const QueryRelationshipGroupsRequest: {
    encode(message: QueryRelationshipGroupsRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryRelationshipGroupsRequest;
};

interface QueryRelationshipsRequest {
    userIds: string[];
    blocked?: boolean | undefined;
    groupIndexes: number[];
    lastUpdatedDate?: string | undefined;
}
declare const QueryRelationshipsRequest: {
    encode(message: QueryRelationshipsRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): QueryRelationshipsRequest;
};

declare enum ResponseAction {
    ACCEPT = 0,
    DECLINE = 1,
    IGNORE = 2,
    UNRECOGNIZED = -1
}

interface UpdateFriendRequestRequest {
    requestId: string;
    responseAction: ResponseAction;
    reason?: string | undefined;
}
declare const UpdateFriendRequestRequest: {
    encode(message: UpdateFriendRequestRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UpdateFriendRequestRequest;
};

interface UpdateRelationshipGroupRequest {
    groupIndex: number;
    newName: string;
}
declare const UpdateRelationshipGroupRequest: {
    encode(message: UpdateRelationshipGroupRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UpdateRelationshipGroupRequest;
};

interface UpdateRelationshipRequest {
    userId: string;
    blocked?: boolean | undefined;
    newGroupIndex?: number | undefined;
    deleteGroupIndex?: number | undefined;
}
declare const UpdateRelationshipRequest: {
    encode(message: UpdateRelationshipRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UpdateRelationshipRequest;
};

interface UpdateUserLocationRequest {
    latitude: number;
    longitude: number;
    details: {
        [key: string]: string;
    };
}
declare const UpdateUserLocationRequest: {
    encode(message: UpdateUserLocationRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UpdateUserLocationRequest;
};

interface UpdateUserOnlineStatusRequest {
    userStatus: UserStatus;
    deviceTypes: DeviceType[];
}
declare const UpdateUserOnlineStatusRequest: {
    encode(message: UpdateUserOnlineStatusRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UpdateUserOnlineStatusRequest;
};

interface UpdateUserRequest {
    password?: string | undefined;
    name?: string | undefined;
    intro?: string | undefined;
    profilePicture?: string | undefined;
    profileAccessStrategy?: ProfileAccessStrategy | undefined;
}
declare const UpdateUserRequest: {
    encode(message: UpdateUserRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): UpdateUserRequest;
};

interface TurmsRequest {
    requestId?: string | undefined;
    createSessionRequest?: CreateSessionRequest | undefined;
    deleteSessionRequest?: DeleteSessionRequest | undefined;
    queryConversationsRequest?: QueryConversationsRequest | undefined;
    updateConversationRequest?: UpdateConversationRequest | undefined;
    updateTypingStatusRequest?: UpdateTypingStatusRequest | undefined;
    createMessageRequest?: CreateMessageRequest | undefined;
    queryMessagesRequest?: QueryMessagesRequest | undefined;
    updateMessageRequest?: UpdateMessageRequest | undefined;
    createGroupMembersRequest?: CreateGroupMembersRequest | undefined;
    deleteGroupMembersRequest?: DeleteGroupMembersRequest | undefined;
    queryGroupMembersRequest?: QueryGroupMembersRequest | undefined;
    updateGroupMemberRequest?: UpdateGroupMemberRequest | undefined;
    queryUserProfilesRequest?: QueryUserProfilesRequest | undefined;
    queryNearbyUsersRequest?: QueryNearbyUsersRequest | undefined;
    queryUserOnlineStatusesRequest?: QueryUserOnlineStatusesRequest | undefined;
    updateUserLocationRequest?: UpdateUserLocationRequest | undefined;
    updateUserOnlineStatusRequest?: UpdateUserOnlineStatusRequest | undefined;
    updateUserRequest?: UpdateUserRequest | undefined;
    createFriendRequestRequest?: CreateFriendRequestRequest | undefined;
    createRelationshipGroupRequest?: CreateRelationshipGroupRequest | undefined;
    createRelationshipRequest?: CreateRelationshipRequest | undefined;
    deleteRelationshipGroupRequest?: DeleteRelationshipGroupRequest | undefined;
    deleteRelationshipRequest?: DeleteRelationshipRequest | undefined;
    queryFriendRequestsRequest?: QueryFriendRequestsRequest | undefined;
    queryRelatedUserIdsRequest?: QueryRelatedUserIdsRequest | undefined;
    queryRelationshipGroupsRequest?: QueryRelationshipGroupsRequest | undefined;
    queryRelationshipsRequest?: QueryRelationshipsRequest | undefined;
    updateFriendRequestRequest?: UpdateFriendRequestRequest | undefined;
    updateRelationshipGroupRequest?: UpdateRelationshipGroupRequest | undefined;
    updateRelationshipRequest?: UpdateRelationshipRequest | undefined;
    createGroupRequest?: CreateGroupRequest | undefined;
    deleteGroupRequest?: DeleteGroupRequest | undefined;
    queryGroupsRequest?: QueryGroupsRequest | undefined;
    queryJoinedGroupIdsRequest?: QueryJoinedGroupIdsRequest | undefined;
    queryJoinedGroupInfosRequest?: QueryJoinedGroupInfosRequest | undefined;
    updateGroupRequest?: UpdateGroupRequest | undefined;
    createGroupBlockedUserRequest?: CreateGroupBlockedUserRequest | undefined;
    deleteGroupBlockedUserRequest?: DeleteGroupBlockedUserRequest | undefined;
    queryGroupBlockedUserIdsRequest?: QueryGroupBlockedUserIdsRequest | undefined;
    queryGroupBlockedUserInfosRequest?: QueryGroupBlockedUserInfosRequest | undefined;
    checkGroupJoinQuestionsAnswersRequest?: CheckGroupJoinQuestionsAnswersRequest | undefined;
    createGroupInvitationRequest?: CreateGroupInvitationRequest | undefined;
    createGroupJoinRequestRequest?: CreateGroupJoinRequestRequest | undefined;
    createGroupJoinQuestionsRequest?: CreateGroupJoinQuestionsRequest | undefined;
    deleteGroupInvitationRequest?: DeleteGroupInvitationRequest | undefined;
    deleteGroupJoinRequestRequest?: DeleteGroupJoinRequestRequest | undefined;
    deleteGroupJoinQuestionsRequest?: DeleteGroupJoinQuestionsRequest | undefined;
    queryGroupInvitationsRequest?: QueryGroupInvitationsRequest | undefined;
    queryGroupJoinRequestsRequest?: QueryGroupJoinRequestsRequest | undefined;
    queryGroupJoinQuestionsRequest?: QueryGroupJoinQuestionsRequest | undefined;
    updateGroupJoinQuestionRequest?: UpdateGroupJoinQuestionRequest | undefined;
    deleteResourceRequest?: DeleteResourceRequest | undefined;
    queryResourceDownloadInfoRequest?: QueryResourceDownloadInfoRequest | undefined;
    queryResourceUploadInfoRequest?: QueryResourceUploadInfoRequest | undefined;
}
declare const TurmsRequest: {
    encode(message: TurmsRequest, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): TurmsRequest;
};

interface TurmsNotification {
    timestamp: string;
    requestId?: string | undefined;
    code?: number | undefined;
    reason?: string | undefined;
    data?: TurmsNotification_Data;
    requesterId?: string | undefined;
    closeStatus?: number | undefined;
    relayedRequest?: TurmsRequest;
}
declare const TurmsNotification: {
    encode(message: TurmsNotification, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): TurmsNotification;
};
interface TurmsNotification_Data {
    long: string | undefined;
    string: string | undefined;
    longsWithVersion?: LongsWithVersion | undefined;
    stringsWithVersion?: StringsWithVersion | undefined;
    conversations?: Conversations | undefined;
    messages?: Messages | undefined;
    messagesWithTotalList?: MessagesWithTotalList | undefined;
    userSession?: UserSession | undefined;
    userInfosWithVersion?: UserInfosWithVersion | undefined;
    userOnlineStatuses?: UserOnlineStatuses | undefined;
    userFriendRequestsWithVersion?: UserFriendRequestsWithVersion | undefined;
    userRelationshipGroupsWithVersion?: UserRelationshipGroupsWithVersion | undefined;
    userRelationshipsWithVersion?: UserRelationshipsWithVersion | undefined;
    nearbyUsers?: NearbyUsers | undefined;
    groupInvitationsWithVersion?: GroupInvitationsWithVersion | undefined;
    groupJoinQuestionAnswerResult?: GroupJoinQuestionsAnswerResult | undefined;
    groupJoinRequestsWithVersion?: GroupJoinRequestsWithVersion | undefined;
    groupJoinQuestionsWithVersion?: GroupJoinQuestionsWithVersion | undefined;
    groupMembersWithVersion?: GroupMembersWithVersion | undefined;
    groupsWithVersion?: GroupsWithVersion | undefined;
}
declare const TurmsNotification_Data: {
    encode(message: TurmsNotification_Data, writer?: _m0.Writer): _m0.Writer;
    decode(input: _m0.Reader | Uint8Array, length?: number): TurmsNotification_Data;
};

declare type ParsedNotification = TurmsNotification;

declare class WebSocketMetrics {
    connectTime?: number;
    dataReceived: number;
    dataSent: number;
}

declare type OnClosedParams = {
    code: number;
    reason: string;
};
interface EventListener {
    onOpened: (() => any);
    onClosed: ((event: OnClosedParams) => any);
    onMessage: ((data: ArrayBuffer) => any);
}
declare abstract class WebSocketClient {
    private readonly _url;
    private readonly _listener;
    protected constructor(url: string, listener: EventListener);
    get url(): string;
    abstract get isConnecting(): boolean;
    abstract get isConnected(): boolean;
    abstract get metrics(): WebSocketMetrics;
    protected notifyOnOpened(): void;
    protected notifyOnClosed(event: OnClosedParams): void;
    protected notifyOnMessage(data: ArrayBuffer): void;
    abstract close(): void;
    abstract send(data: ArrayBufferLike | Blob | ArrayBufferView): Promise<void>;
}

declare abstract class BaseService {
    protected readonly _stateStore: StateStore;
    protected constructor(stateStore: StateStore);
    abstract close(): Promise<void>;
    abstract onDisconnected(error?: Error): void;
}

declare const enum RequestType {
    REGISTER = "register",
    UNREGISTER = "unregister",
    REBIND_CONTEXT_ID = "rebindContextId",
    REQUEST_LOGIN = "requestLogin",
    FINISH_LOGIN_REQUEST = "finishLoginRequest",
    UPDATE_LOGGED_IN_USER_INFO = "updateLoggedInUserInfo",
    UPDATE_IS_SESSION_OPEN = "updateIsSessionOpen",
    UPDATE_SESSION_ID = "updateSessionId",
    UPDATE_SERVER_ID = "updateServerId",
    UPDATE_LAST_REQUEST_DATE = "updateLastRequestDate",
    CONNECT = "connect",
    SEND_DATA = "sendData"
}
declare const enum NotificationType {
    UPDATE_LOGGED_IN_USER_INFO = "updateLoggedInUserInfo",
    UPDATE_IS_SESSION_OPEN = "updateIsSessionOpen",
    UPDATE_SESSION_ID = "updateSessionId",
    UPDATE_SERVER_ID = "updateServerId",
    UPDATE_LAST_REQUEST_DATE = "updateLastRequestDate",
    WEBSOCKET_CONNECTING = "websocketConnecting",
    WEBSOCKET_CONNECTED = "websocketConnected",
    WEBSOCKET_CLOSED = "websocketClosed",
    WEBSOCKET_MESSAGE_RECEIVED = "websocketMessageReceived"
}
declare type Request = {
    id?: number;
    type: RequestType;
    data?: any;
};
declare type Notification$1 = {
    type: NotificationType;
    data?: any;
};
declare class SharedContextService extends BaseService {
    private readonly _sharedContextWorker;
    private readonly _port;
    private _globalId;
    private readonly _pendingRequests;
    private readonly _registerRequest;
    private requestSeq;
    private readonly _listeners;
    constructor(stateStore: StateStore);
    addNotificationListener(type: NotificationType, listener: (notification: Notification$1) => void): void;
    request(request: Request): Promise<any>;
    private _resolveRequest;
    private _handleNotification;
    close(): Promise<void>;
    onDisconnected(error?: Error): void;
}

declare class StateStore {
    private readonly _sharedContextService?;
    private _websocket?;
    private _isSessionOpen;
    private _sessionId?;
    private _serverId?;
    private _lastRequestDate;
    constructor(sharedContextService?: SharedContextService);
    get sharedContextService(): SharedContextService | undefined;
    get useSharedContext(): boolean;
    get websocket(): WebSocketClient | undefined;
    set websocket(value: WebSocketClient);
    get isConnected(): boolean;
    get isSessionOpen(): boolean;
    set isSessionOpen(value: boolean);
    get sessionId(): string;
    set sessionId(value: string);
    get serverId(): string;
    set serverId(value: string);
    get lastRequestDate(): number;
    set lastRequestDate(value: number);
    reset(): void;
}

interface ConnectOptions {
    wsUrl?: string;
    connectTimeout?: number;
}
interface ConnectionDisconnectInfo {
    wasConnected: boolean;
    wsUrl: string;
    code: number;
    reason: string;
}
declare class ConnectionService extends BaseService {
    private readonly _initialWsUrl;
    private readonly _initialConnectTimeout;
    private _disconnectPromises;
    private _onConnectedListeners;
    private _onDisconnectedListeners;
    private _messageListeners;
    constructor(stateStore: StateStore, wsUrl?: string, connectTimeout?: number);
    private _resetStates;
    addOnConnectedListener(listener: () => void): void;
    addOnDisconnectedListener(listener: (info: ConnectionDisconnectInfo) => void): void;
    addMessageListener(listener: (message: ArrayBuffer) => void): void;
    removeOnConnectedListener(listener: () => void): void;
    removeOnDisconnectedListener(listener: (info: ConnectionDisconnectInfo) => void): void;
    removeMessageListener(listener: (message: ArrayBuffer) => void): void;
    private _notifyOnConnectedListeners;
    private _notifyOnDisconnectedListeners;
    private _notifyMessageListeners;
    private _resolveDisconnectPromises;
    connect({ wsUrl, connectTimeout }?: ConnectOptions): Promise<void>;
    disconnect(): Promise<void>;
    private _onWebSocketOpen;
    private _onWebSocketClosed;
    close(): Promise<void>;
    onDisconnected(error?: Error): void;
}

declare class TurmsDriver {
    private readonly _stateStore;
    private readonly _connectionService;
    private readonly _heartbeatService;
    private readonly _messageService;
    private readonly _sharedContextService?;
    constructor(wsUrl?: string, connectTimeout?: number, requestTimeout?: number, minRequestInterval?: number, heartbeatInterval?: number, useSharedContext?: boolean);
    stateStore(): StateStore;
    initConnectionService(wsUrl?: string, connectTimeout?: number): ConnectionService;
    close(): Promise<void>;
    addSharedContextNotificationListener(type: NotificationType, listener: ((notification: Notification$1) => void)): void;
    requestSharedContext(request: Request): Promise<any>;
    startHeartbeat(): void;
    stopHeartbeat(): void;
    sendHeartbeat(): Promise<void>;
    get isHeartbeatRunning(): boolean;
    connect(options?: ConnectOptions): Promise<void>;
    disconnect(): Promise<void>;
    get isConnected(): boolean;
    get connectionMetrics(): WebSocketMetrics | undefined;
    addOnConnectedListener(listener: () => void): void;
    addOnDisconnectedListener(listener: (disconnectInfo: ConnectionDisconnectInfo) => void): void;
    removeOnConnectedListener(listener: () => void): void;
    removeOnDisconnectedListener(listener: (disconnectInfo: ConnectionDisconnectInfo) => void): void;
    send(message: TurmsRequest): Promise<TurmsNotification>;
    addNotificationListener(listener: ((notification: ParsedNotification) => void)): void;
    removeNotificationListener(listener: ((notification: ParsedNotification) => void)): void;
    private _onConnectionDisconnected;
    private _onMessage;
}

interface ClientOptions {
    wsUrl?: string;
    connectionTimeout?: number;
    requestTimeout?: number;
    minRequestInterval?: number;
    heartbeatInterval?: number;
    storageServerUrl?: string;
    useSharedContext?: boolean;
}

declare namespace ParsedModel {
    interface Data {
        data: Uint8Array;
    }
    interface LongsWithVersion {
        longs?: string[];
        lastUpdatedDate?: Date;
    }
    interface UserRelationshipGroupsWithVersion {
        userRelationshipGroups?: UserRelationshipGroup;
        lastUpdatedDate?: Date;
    }
    interface UserRelationshipGroup {
        index?: number;
        name?: string;
    }
    interface UserFriendRequestsWithVersion {
        userFriendRequests?: UserFriendRequest[];
        lastUpdatedDate?: Date;
    }
    interface UserFriendRequest {
        id?: string;
        creationDate?: Date;
        content?: string;
        requestStatus?: RequestStatus;
        reason?: string;
        expirationDate?: Date;
        requesterId?: string;
        recipientId?: string;
    }
    interface UserInfosWithVersion {
        userInfos?: UserInfo[];
        lastUpdatedDate?: Date;
    }
    interface NearbyUser {
        userId: string;
        deviceType?: DeviceType;
        info?: UserInfo;
        distance?: number;
        location?: UserLocation$1;
    }
    interface PrivateConversation {
        ownerId: string;
        targetId: string;
        readDate: Date;
    }
    interface GroupConversation {
        groupId: string;
        memberIdAndReadDate: {
            [k: string]: Date;
        };
    }
    interface Message {
        id?: string;
        isSystemMessage?: boolean;
        deliveryDate?: Date;
        text?: string;
        senderId?: string;
        groupId?: string;
        recipientId?: string;
        records?: Uint8Array[];
        sequenceId?: number;
        preMessageId?: string;
    }
    interface MessagesWithTotal {
        total?: number;
        isGroupMessage?: boolean;
        fromId?: string;
        messages?: Message;
    }
    interface UserRelationship {
        ownerId?: string;
        relatedUserId?: string;
        blockDate?: Date;
        groupIndex?: number;
        establishmentDate?: Date;
    }
    interface UserRelationshipsWithVersion {
        userRelationships?: UserRelationship;
        lastUpdatedDate?: Date;
    }
    interface UserInfo {
        id?: string;
        name?: string;
        intro?: string;
        profilePicture?: string;
        profileAccessStrategy?: ProfileAccessStrategy;
        registrationDate?: Date;
        lastUpdatedDate?: string;
        active?: boolean;
    }
    interface UserOnlineStatus {
        userId?: string;
        userStatus?: UserStatus;
        usingDeviceTypes?: DeviceType[];
    }
    interface GroupInvitationsWithVersion {
        groupInvitations?: GroupInvitation[];
        lastUpdatedDate?: Date;
    }
    interface GroupInvitation {
        id?: string;
        creationDate?: Date;
        content?: string;
        status?: RequestStatus;
        expirationDate?: Date;
        groupId?: string;
        inviterId?: string;
        inviteeId?: string;
    }
    interface GroupMember {
        groupId?: string;
        userId?: string;
        name?: string;
        role?: GroupMemberRole;
        joinDate?: Date;
        muteEndDate?: Date;
        userStatus?: UserStatus;
        usingDeviceTypes?: DeviceType[];
    }
    interface GroupMembersWithVersion {
        groupMembers?: GroupMember[];
        lastUpdatedDate?: Date;
    }
    interface GroupJoinQuestion {
        id?: string;
        groupId?: string;
        question?: string;
        answers?: string;
        score?: number;
    }
    interface GroupJoinQuestionsWithVersion {
        groupJoinQuestions?: GroupJoinQuestion[];
        lastUpdatedDate?: Date;
    }
    interface GroupJoinRequest {
        id?: string;
        creationDate?: Date;
        content?: string;
        status?: RequestStatus;
        expirationDate?: Date;
        groupId?: string;
        requesterId?: string;
        responderId?: string;
    }
    interface GroupJoinRequestsWithVersion {
        groupJoinRequests?: GroupJoinRequest[];
        lastUpdatedDate?: Date;
    }
    interface GroupsWithVersion {
        lastUpdatedDate?: Date;
        groups?: Group[];
    }
    interface Group {
        id?: string;
        typeId?: string;
        creatorId?: string;
        ownerId?: string;
        name?: string;
        intro?: string;
        announcement?: string;
        creationDate?: Date;
        lastUpdatedDate?: Date;
        muteEndDate?: Date;
        active?: boolean;
    }
}

declare class Response<T> {
    readonly timestamp: Date;
    readonly requestId?: string;
    readonly code: number;
    readonly data: T;
    constructor(timestamp: Date, requestId: string, code: number, data: any);
    static get isTurmsResponse(): boolean;
    static value<T>(data: T): Response<T>;
    static nullValue<T>(): Response<T>;
    static emptyList<T>(): Response<T[]>;
    static fromNotification<T>(notification: TurmsNotification, dataTransformer?: (data: TurmsNotification_Data) => T): Response<T>;
}

declare class ConversationService {
    private _turmsClient;
    constructor(turmsClient: TurmsClient);
    queryPrivateConversations({ targetIds }: {
        targetIds: string[];
    }): Promise<Response<ParsedModel.PrivateConversation[]>>;
    queryGroupConversations({ groupIds }: {
        groupIds: string[];
    }): Promise<Response<ParsedModel.GroupConversation[]>>;
    updatePrivateConversationReadDate({ targetId, readDate }: {
        targetId: string;
        readDate?: Date;
    }): Promise<Response<void>>;
    updateGroupConversationReadDate({ groupId, readDate }: {
        groupId: string;
        readDate?: Date;
    }): Promise<Response<void>>;
    updatePrivateConversationTypingStatus({ targetId }: {
        targetId: string;
    }): Promise<Response<void>>;
    updateGroupConversationTypingStatus({ groupId }: {
        groupId: string;
    }): Promise<Response<void>>;
}

declare class NewGroupJoinQuestion {
    question: string;
    answers: string[];
    score: number;
    constructor(question: string, answers: string[], score: number);
}

declare class GroupService {
    private _turmsClient;
    constructor(turmsClient: TurmsClient);
    createGroup({ name, intro, announcement, minimumScore, muteEndDate, groupTypeId }: {
        name: string;
        intro?: string;
        announcement?: string;
        minimumScore?: number;
        muteEndDate?: Date;
        groupTypeId?: string;
    }): Promise<Response<string>>;
    deleteGroup({ groupId }: {
        groupId: string;
    }): Promise<Response<void>>;
    updateGroup({ groupId, groupName, intro, announcement, minimumScore, groupTypeId, muteEndDate, successorId, quitAfterTransfer }: {
        groupId: string;
        groupName?: string;
        intro?: string;
        announcement?: string;
        minimumScore?: number;
        groupTypeId?: string;
        muteEndDate?: Date;
        successorId?: string;
        quitAfterTransfer?: boolean;
    }): Promise<Response<void>>;
    transferOwnership({ groupId, successorId, quitAfterTransfer }: {
        groupId: string;
        successorId: string;
        quitAfterTransfer: boolean;
    }): Promise<Response<void>>;
    muteGroup({ groupId, muteEndDate }: {
        groupId: string;
        muteEndDate: Date;
    }): Promise<Response<void>>;
    unmuteGroup({ groupId }: {
        groupId: string;
    }): Promise<Response<void>>;
    queryGroups({ groupIds, lastUpdatedDate }: {
        groupIds: string[];
        lastUpdatedDate?: Date;
    }): Promise<Response<ParsedModel.Group[]>>;
    queryJoinedGroupIds({ lastUpdatedDate }?: {
        lastUpdatedDate?: Date;
    }): Promise<Response<ParsedModel.LongsWithVersion | undefined>>;
    queryJoinedGroupInfos({ lastUpdatedDate }?: {
        lastUpdatedDate?: Date;
    }): Promise<Response<ParsedModel.GroupsWithVersion | undefined>>;
    addGroupJoinQuestions({ groupId, questions }: {
        groupId: string;
        questions: NewGroupJoinQuestion[];
    }): Promise<Response<string[]>>;
    deleteGroupJoinQuestions({ groupId, questionIds }: {
        groupId: string;
        questionIds: string[];
    }): Promise<Response<void>>;
    updateGroupJoinQuestion({ questionId, question, answers, score }: {
        questionId: string;
        question?: string;
        answers?: string[];
        score?: number;
    }): Promise<Response<void>>;
    blockUser({ groupId, userId }: {
        groupId: string;
        userId: string;
    }): Promise<Response<void>>;
    unblockUser({ groupId, userId }: {
        groupId: string;
        userId: string;
    }): Promise<Response<void>>;
    queryBlockedUserIds({ groupId, lastUpdatedDate }: {
        groupId: string;
        lastUpdatedDate?: Date;
    }): Promise<Response<ParsedModel.LongsWithVersion | undefined>>;
    queryBlockedUserInfos({ groupId, lastUpdatedDate }: {
        groupId: string;
        lastUpdatedDate?: Date;
    }): Promise<Response<ParsedModel.UserInfosWithVersion | undefined>>;
    createInvitation({ groupId, inviteeId, content }: {
        groupId: string;
        inviteeId: string;
        content: string;
    }): Promise<Response<string>>;
    deleteInvitation({ invitationId }: {
        invitationId: string;
    }): Promise<Response<void>>;
    queryInvitationsByGroupId({ groupId, lastUpdatedDate }: {
        groupId: string;
        lastUpdatedDate?: Date;
    }): Promise<Response<ParsedModel.GroupInvitationsWithVersion | undefined>>;
    queryInvitations({ areSentByMe, lastUpdatedDate }: {
        areSentByMe: boolean;
        lastUpdatedDate?: Date;
    }): Promise<Response<ParsedModel.GroupInvitationsWithVersion | undefined>>;
    createJoinRequest({ groupId, content }: {
        groupId: string;
        content: string;
    }): Promise<Response<string>>;
    deleteJoinRequest({ requestId }: {
        requestId: string;
    }): Promise<Response<void>>;
    queryJoinRequests({ groupId, lastUpdatedDate }: {
        groupId: string;
        lastUpdatedDate?: Date;
    }): Promise<Response<ParsedModel.GroupJoinRequestsWithVersion | undefined>>;
    querySentJoinRequests({ lastUpdatedDate }?: {
        lastUpdatedDate?: Date;
    }): Promise<Response<ParsedModel.GroupJoinRequestsWithVersion | undefined>>;
    queryGroupJoinQuestionsRequest({ groupId, withAnswers, lastUpdatedDate }: {
        groupId: string;
        withAnswers: boolean;
        lastUpdatedDate?: Date;
    }): Promise<Response<ParsedModel.GroupJoinQuestionsWithVersion | undefined>>;
    answerGroupQuestions({ questionIdToAnswer }: {
        questionIdToAnswer: Record<string, string>;
    }): Promise<Response<GroupJoinQuestionsAnswerResult | undefined>>;
    addGroupMembers({ groupId, userIds, name, role, muteEndDate }: {
        groupId: string;
        userIds: string[];
        name?: string;
        role?: string | GroupMemberRole;
        muteEndDate?: Date;
    }): Promise<Response<void>>;
    quitGroup({ groupId, successorId, quitAfterTransfer }: {
        groupId: string;
        successorId?: string;
        quitAfterTransfer?: boolean;
    }): Promise<Response<void>>;
    removeGroupMembers({ groupId, memberIds }: {
        groupId: string;
        memberIds: string[];
    }): Promise<Response<void>>;
    updateGroupMemberInfo({ groupId, memberId, name, role, muteEndDate }: {
        groupId: string;
        memberId: string;
        name?: string;
        role?: string | GroupMemberRole;
        muteEndDate?: Date;
    }): Promise<Response<void>>;
    muteGroupMember({ groupId, memberId, muteEndDate }: {
        groupId: string;
        memberId: string;
        muteEndDate: Date;
    }): Promise<Response<void>>;
    unmuteGroupMember({ groupId, memberId }: {
        groupId: string;
        memberId: string;
    }): Promise<Response<void>>;
    queryGroupMembers({ groupId, withStatus, lastUpdatedDate }: {
        groupId: string;
        withStatus: boolean;
        lastUpdatedDate?: Date;
    }): Promise<Response<ParsedModel.GroupMembersWithVersion | undefined>>;
    queryGroupMembersByMemberIds({ groupId, memberIds, withStatus }: {
        groupId: string;
        memberIds: string[];
        withStatus: boolean;
    }): Promise<Response<ParsedModel.GroupMembersWithVersion | undefined>>;
}

declare class MessageAddition {
    readonly isMentioned: boolean;
    readonly mentionedUserIds: string[];
    readonly recalledMessageIds: string[];
    constructor(isMentioned: boolean, mentionedUserIds: string[], recalledMessageIds: string[]);
}

declare class MessageService {
    private static readonly DEFAULT_MENTIONED_USER_IDS_PARSER;
    private _turmsClient;
    private _mentionedUserIdsParser?;
    private _messageListeners;
    constructor(turmsClient: TurmsClient);
    addMessageListener(listener: (message: ParsedModel.Message, messageAddition: MessageAddition) => void): void;
    removeMessageListener(listener: (message: ParsedModel.Message, messageAddition: MessageAddition) => void): void;
    sendMessage({ isGroupMessage, targetId, deliveryDate, text, records, burnAfter, preMessageId }: {
        isGroupMessage: boolean;
        targetId: string;
        deliveryDate?: Date;
        text?: string;
        records?: Uint8Array[];
        burnAfter?: number;
        preMessageId?: string;
    }): Promise<Response<string>>;
    forwardMessage({ messageId, isGroupMessage, targetId }: {
        messageId: string;
        isGroupMessage: boolean;
        targetId: string;
    }): Promise<Response<string>>;
    updateSentMessage({ messageId, text, records }: {
        messageId: string;
        text?: string;
        records?: Uint8Array[];
    }): Promise<Response<void>>;
    queryMessages({ ids, areGroupMessages, areSystemMessages, fromIds, deliveryDateAfter, deliveryDateBefore, maxCount }: {
        ids?: string[];
        areGroupMessages?: boolean;
        areSystemMessages?: boolean;
        fromIds?: string[];
        deliveryDateAfter?: Date;
        deliveryDateBefore?: Date;
        maxCount?: number;
    }): Promise<Response<ParsedModel.Message[]>>;
    queryMessagesWithTotal({ ids, areGroupMessages, areSystemMessages, fromIds, deliveryDateAfter, deliveryDateBefore, maxCount }: {
        ids?: string[];
        areGroupMessages?: boolean;
        areSystemMessages?: boolean;
        fromIds?: string[];
        deliveryDateAfter?: Date;
        deliveryDateBefore?: Date;
        maxCount?: number;
    }): Promise<Response<ParsedModel.MessagesWithTotal[]>>;
    recallMessage({ messageId, recallDate }: {
        messageId: string;
        recallDate?: Date;
    }): Promise<Response<void>>;
    isMentionEnabled(): boolean;
    enableMention(mentionedUserIdsParser?: (message: ParsedModel.Message) => string[]): void;
    static generateLocationRecord({ latitude, longitude, details }: {
        latitude: number;
        longitude: number;
        details?: {
            [_: string]: string;
        };
    }): Uint8Array;
    static generateAudioRecordByDescription({ url, duration, format, size }: {
        url: string;
        duration?: number;
        format?: string;
        size?: number;
    }): Uint8Array;
    static generateAudioRecordByData({ data }: {
        data: ArrayBuffer;
    }): Uint8Array;
    static generateVideoRecordByDescription({ url, duration, format, size }: {
        url: string;
        duration?: number;
        format?: string;
        size?: number;
    }): Uint8Array;
    static generateVideoRecordByData({ data }: {
        data: ArrayBuffer;
    }): Uint8Array;
    static generateImageRecordByData({ data }: {
        data: ArrayBuffer;
    }): Uint8Array;
    static generateImageRecordByDescription({ url, fileSize, imageSize, original }: {
        url: string;
        fileSize?: number;
        imageSize?: number;
        original?: boolean;
    }): Uint8Array;
    static generateFileRecordByDate({ data }: {
        data: ArrayBuffer;
    }): Uint8Array;
    static generateFileRecordByDescription({ url, format, size }: {
        url: string;
        format?: string;
        size?: number;
    }): Uint8Array;
    private _parseMessageAddition;
    private static _createMessageRequest2Message;
}

declare type ParsedRelayedRequest = TurmsRequest;

declare class Notification {
    readonly timestamp: Date;
    readonly relayedRequest: ParsedRelayedRequest;
    constructor(timestamp: Date, relayedRequest: ParsedRelayedRequest);
}

declare class NotificationService {
    private _turmsClient;
    private _notificationListeners;
    constructor(turmsClient: TurmsClient);
    addNotificationListener(listener: (notification: Notification) => void): void;
    removeNotificationListener(listener: (notification: Notification) => void): void;
}

declare class StorageResource {
    readonly uri: string;
    readonly data: Uint8Array;
    constructor(uri: string, data: Uint8Array);
}

declare class StorageUpdateResult {
    readonly uri: string;
    readonly data: string;
    constructor(uri: string, data: string);
}

declare class StorageService {
    private static readonly _RESOURCE_KEY_NAME;
    private static readonly _DEFAULT_URL_KEY_NAME;
    private static readonly _RESOURCE_TYPE_TO_BUCKET_NAME;
    private readonly _turmsClient;
    private _serverUrl;
    constructor(turmsClient: TurmsClient, storageServerUrl?: string);
    get serverUrl(): string;
    set serverUrl(serverUrl: string);
    uploadUserProfilePicture({ mediaType, data, urlKeyName }: {
        mediaType: string;
        data: Uint8Array;
        urlKeyName?: string;
    }): Promise<Response<StorageUpdateResult>>;
    deleteUserProfilePicture(): Promise<Response<void>>;
    queryUserProfilePicture({ userId, urlKeyName, fetchDownloadInfo }: {
        userId: string;
        urlKeyName?: string;
        fetchDownloadInfo?: boolean;
    }): Promise<Response<StorageResource>>;
    queryUserProfilePictureUploadInfo(): Promise<Response<Record<string, string>>>;
    queryUserProfilePictureDownloadInfo({ userId, fetch, urlKeyName }: {
        userId: string;
        fetch?: boolean;
        urlKeyName?: string;
    }): Promise<Response<Record<string, string>>>;
    uploadGroupProfilePicture({ groupId, mediaType, data, urlKeyName }: {
        groupId: string;
        mediaType: string;
        data: Uint8Array;
        urlKeyName?: string;
    }): Promise<Response<StorageUpdateResult>>;
    deleteGroupProfilePicture({ groupId }: {
        groupId: string;
    }): Promise<Response<void>>;
    queryGroupProfilePicture({ groupId, fetchDownloadInfo, urlKeyName }: {
        groupId: string;
        fetchDownloadInfo?: boolean;
        urlKeyName?: string;
    }): Promise<Response<StorageResource>>;
    queryGroupProfilePictureUploadInfo({ groupId }: {
        groupId: string;
    }): Promise<Response<Record<string, string>>>;
    queryGroupProfilePictureDownloadInfo({ groupId, fetch, urlKeyName }: {
        groupId: string;
        fetch?: boolean;
        urlKeyName?: string;
    }): Promise<Response<Record<string, string>>>;
    uploadMessageAttachment({ messageId, mediaType, data, name, urlKeyName }: {
        messageId: string;
        mediaType: string;
        data: Uint8Array;
        name?: string;
        urlKeyName?: string;
    }): Promise<Response<StorageUpdateResult>>;
    deleteMessageAttachment({ messageId, name }: {
        messageId: string;
        name?: string;
    }): Promise<Response<void>>;
    queryMessageAttachment({ messageId, name, fetchDownloadInfo, urlKeyName }: {
        messageId: string;
        name?: string;
        fetchDownloadInfo?: boolean;
        urlKeyName?: string;
    }): Promise<Response<StorageResource>>;
    queryMessageAttachmentUploadInfo({ messageId, name }: {
        messageId: string;
        name?: string;
    }): Promise<Response<Record<string, string>>>;
    queryMessageAttachmentDownloadInfo({ messageId, name, fetch, urlKeyName }: {
        messageId: string;
        name?: string;
        fetch?: boolean;
        urlKeyName?: string;
    }): Promise<Response<Record<string, string>>>;
    private _upload;
    private _deleteResource;
    private _queryResource;
    private _queryResourceUploadInfo;
    private _queryResourceDownloadInfo;
    private static _getBucketName;
    private static _getAndRemoveResourceKey;
    private static _getAndRemoveResourceUrl;
}

interface SessionCloseInfo {
    closeStatus: number;
    businessStatus?: number;
    reason?: string;
}

declare class UserLocation {
    longitude: number;
    latitude: number;
    details: Record<string, string>;
    constructor(longitude: number, latitude: number, details: Record<string, string>);
    toString(): string;
}

interface UserInfo {
    userId?: string;
    password?: string;
    deviceType?: DeviceType;
    deviceDetails?: Record<string, string>;
    onlineStatus?: UserStatus;
    location?: UserLocation;
}
declare 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;
}

declare class TurmsClient {
    static readonly version: string;
    private readonly _driver;
    private readonly _userService;
    private readonly _groupService;
    private readonly _conversationService;
    private readonly _messageService;
    private readonly _storageService;
    private readonly _notificationService;
    constructor(options?: ClientOptions);
    constructor(wsUrl?: string, connectionTimeout?: number, requestTimeout?: number, minRequestInterval?: number, heartbeatInterval?: number, storageServerUrl?: string, useSharedContext?: boolean);
    static isSharedContextSupported(): boolean;
    get driver(): TurmsDriver;
    get userService(): UserService;
    get groupService(): GroupService;
    get conversationService(): ConversationService;
    get messageService(): MessageService;
    get storageService(): StorageService;
    get notificationService(): NotificationService;
    close(): Promise<void>;
}

export { TurmsClient as default };