easemob-websdk 4.24.1 → 5.0.0

package/protocol/session-list/proto.d.ts

@@ -0,0 +1,207 @@
+declare const proto: {
+    readonly nested: {
+        readonly easemob: {
+            readonly nested: {
+                readonly sessionlist: {
+                    readonly nested: {
+                        readonly GatewayHeader: {
+                            readonly fields: {
+                                readonly resource: {
+                                    readonly type: "string";
+                                    readonly id: 1;
+                                };
+                                readonly timestamp: {
+                                    readonly type: "int64";
+                                    readonly id: 2;
+                                };
+                                readonly request_id: {
+                                    readonly type: "string";
+                                    readonly id: 3;
+                                };
+                                readonly protocol_version: {
+                                    readonly type: "int32";
+                                    readonly id: 4;
+                                };
+                            };
+                        };
+                        readonly JID: {
+                            readonly fields: {
+                                readonly app_key: {
+                                    readonly type: "string";
+                                    readonly id: 1;
+                                };
+                                readonly name: {
+                                    readonly type: "string";
+                                    readonly id: 2;
+                                };
+                                readonly domain: {
+                                    readonly type: "string";
+                                    readonly id: 3;
+                                };
+                                readonly client_resource: {
+                                    readonly type: "string";
+                                    readonly id: 4;
+                                };
+                            };
+                        };
+                        readonly Meta: {
+                            readonly fields: {
+                                readonly id: {
+                                    readonly type: "uint64";
+                                    readonly id: 1;
+                                };
+                                readonly from: {
+                                    readonly type: "JID";
+                                    readonly id: 2;
+                                };
+                                readonly timestamp: {
+                                    readonly type: "uint64";
+                                    readonly id: 4;
+                                };
+                                readonly payload: {
+                                    readonly type: "bytes";
+                                    readonly id: 6;
+                                };
+                            };
+                        };
+                        readonly SessionItem: {
+                            readonly fields: {
+                                readonly session_id: {
+                                    readonly type: "string";
+                                    readonly id: 1;
+                                };
+                                readonly session_type: {
+                                    readonly type: "int32";
+                                    readonly id: 2;
+                                };
+                                readonly last_message: {
+                                    readonly type: "Meta";
+                                    readonly id: 3;
+                                };
+                                readonly updated_at: {
+                                    readonly type: "int64";
+                                    readonly id: 6;
+                                };
+                                readonly pinned_time: {
+                                    readonly type: "int64";
+                                    readonly id: 7;
+                                };
+                                readonly unread_count: {
+                                    readonly type: "uint32";
+                                    readonly id: 8;
+                                };
+                                readonly marks: {
+                                    readonly rule: "repeated";
+                                    readonly type: "string";
+                                    readonly id: 9;
+                                };
+                                readonly read_receipt: {
+                                    readonly type: "int64";
+                                    readonly id: 10;
+                                };
+                                readonly remind_type: {
+                                    readonly type: "int32";
+                                    readonly id: 11;
+                                };
+                                readonly group_name: {
+                                    readonly type: "string";
+                                    readonly id: 12;
+                                };
+                                readonly group_avatar: {
+                                    readonly type: "string";
+                                    readonly id: 13;
+                                };
+                                readonly metadata: {
+                                    readonly type: "string";
+                                    readonly id: 14;
+                                };
+                            };
+                        };
+                        readonly GetSessionListRequest: {
+                            readonly fields: {
+                                readonly type: {
+                                    readonly type: "int32";
+                                    readonly id: 1;
+                                };
+                                readonly header: {
+                                    readonly type: "GatewayHeader";
+                                    readonly id: 2;
+                                };
+                                readonly org: {
+                                    readonly type: "string";
+                                    readonly id: 3;
+                                };
+                                readonly app: {
+                                    readonly type: "string";
+                                    readonly id: 4;
+                                };
+                                readonly username: {
+                                    readonly type: "string";
+                                    readonly id: 5;
+                                };
+                                readonly last_sync_time: {
+                                    readonly type: "int64";
+                                    readonly id: 6;
+                                };
+                                readonly need_empty_session: {
+                                    readonly type: "bool";
+                                    readonly id: 7;
+                                };
+                                readonly need_session_mark: {
+                                    readonly type: "bool";
+                                    readonly id: 8;
+                                };
+                            };
+                        };
+                        readonly GetSessionListResponse: {
+                            readonly fields: {
+                                readonly type: {
+                                    readonly type: "int32";
+                                    readonly id: 1;
+                                };
+                                readonly header: {
+                                    readonly type: "GatewayHeader";
+                                    readonly id: 2;
+                                };
+                                readonly sessions: {
+                                    readonly rule: "repeated";
+                                    readonly type: "SessionItem";
+                                    readonly id: 3;
+                                };
+                                readonly is_last_batch: {
+                                    readonly type: "bool";
+                                    readonly id: 4;
+                                };
+                                readonly last_sync_finished_ts: {
+                                    readonly type: "int64";
+                                    readonly id: 5;
+                                };
+                            };
+                        };
+                        readonly ErrorDetail: {
+                            readonly fields: {
+                                readonly type: {
+                                    readonly type: "int32";
+                                    readonly id: 1;
+                                };
+                                readonly header: {
+                                    readonly type: "GatewayHeader";
+                                    readonly id: 2;
+                                };
+                                readonly code: {
+                                    readonly type: "uint32";
+                                    readonly id: 3;
+                                };
+                                readonly message: {
+                                    readonly type: "string";
+                                    readonly id: 4;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+export default proto;

package/protocol/session-list/types.d.ts

@@ -0,0 +1,83 @@
+import type { SessionListRemindType } from '../../types/conversation';
+export declare const SessionListMessageType: {
+    readonly UNSPECIFIED: 0;
+    readonly ERROR: 5;
+    readonly GET_SESSION_LIST_REQUEST: 10;
+    readonly GET_SESSION_LIST_RESPONSE: 11;
+};
+export declare const SessionListProtocolSessionType: {
+    readonly SINGLE_CHAT: 0;
+    readonly GROUP_CHAT: 1;
+    readonly CHAT_ROOM: 2;
+};
+export declare const SessionListProtocolRemindType: {
+    readonly DEFAULT: 0;
+    readonly ALL: 1;
+    readonly AT: 2;
+    readonly NONE: 3;
+};
+export interface SessionListGatewayHeader {
+    readonly resource: string;
+    readonly timestamp: number;
+    readonly requestId: string;
+    readonly protocolVersion: number;
+}
+export interface SessionListJid {
+    readonly appKey?: string;
+    readonly name?: string;
+    readonly domain?: string;
+    readonly clientResource?: string;
+}
+export interface SessionListMeta {
+    readonly id?: string;
+    readonly from?: SessionListJid;
+    readonly timestamp?: number;
+    readonly payload?: Uint8Array;
+}
+export interface SessionListRequest {
+    readonly type: typeof SessionListMessageType.GET_SESSION_LIST_REQUEST;
+    readonly header?: SessionListGatewayHeader;
+    readonly org: string;
+    readonly app: string;
+    readonly username: string;
+    readonly lastSyncTime?: number;
+    readonly includeEmpty?: boolean;
+    readonly includeMark?: boolean;
+}
+export interface SessionListRequestParams {
+    readonly includeEmpty?: boolean;
+    readonly includeMark?: boolean;
+}
+export interface SessionListProtocolItem {
+    readonly session_id?: string;
+    readonly session_type?: number;
+    readonly last_message?: SessionListMeta;
+    readonly updated_at?: number;
+    readonly pinned_time?: number;
+    readonly unread_count?: number;
+    readonly marks?: ReadonlyArray<string>;
+    readonly read_receipt?: number;
+    readonly remind_type?: number;
+    readonly group_name?: string;
+    readonly group_avatar?: string;
+    readonly metadata?: string;
+    readonly display_source?: string;
+}
+export interface SessionListResponse {
+    readonly type: typeof SessionListMessageType.GET_SESSION_LIST_RESPONSE;
+    readonly header?: SessionListGatewayHeader;
+    readonly sessions: ReadonlyArray<SessionListProtocolItem>;
+    readonly isLastBatch?: boolean;
+    readonly lastSyncFinishedTs?: number;
+}
+export interface SessionListErrorDetail {
+    readonly type: typeof SessionListMessageType.ERROR;
+    readonly header?: SessionListGatewayHeader;
+    readonly code: number;
+    readonly message: string;
+}
+export type SessionListDecodedMessage = SessionListRequest | SessionListResponse | SessionListErrorDetail | {
+    readonly type: number;
+};
+export declare const mapProtocolSessionTypeToPublic: (value: number | undefined) => "singleChat" | "groupChat" | "chatRoom";
+export declare const mapProtocolRemindTypeToPublic: (value: number | undefined) => SessionListRemindType;

package/rest/chat-management.d.ts

@@ -0,0 +1,26 @@
+import type { RestClient } from './client';
+import type { RestContext } from '../types/chat-client';
+import type { GetGroupMessageReadReceiptsParams, GetHistoryMessagesParams, GetReactionDetailParams, GetReactionListParams, GroupMessageReadUsersResult, GroupMessageReadUsersParams, MessageReadReceiptDetail, MessageHistoryPage, MessageReactionDetailPage, MessageReactionListItem, RemoveHistoryMessagesParams, TranslationLanguage, MessageTranslationResult, SearchMessagesParams, SearchMessagesResult } from '../types/chat-manager';
+import type { Message } from '../types';
+type DecodeMetaMessage = (metaPayload: Uint8Array) => Message | null;
+export declare const requestGetHistoryMessages: (client: RestClient, context: RestContext, params: GetHistoryMessagesParams, decodeMetaMessage: DecodeMetaMessage) => Promise<MessageHistoryPage>;
+export declare const requestRemoveHistoryMessages: (client: RestClient, context: RestContext, params: RemoveHistoryMessagesParams) => Promise<void>;
+export declare const requestGetGroupMessageReadUsers: (client: RestClient, context: RestContext, params: GroupMessageReadUsersParams) => Promise<GroupMessageReadUsersResult>;
+export declare const requestGetGroupMessageReadReceipts: (client: RestClient, context: RestContext, params: GetGroupMessageReadReceiptsParams) => Promise<ReadonlyArray<MessageReadReceiptDetail>>;
+export declare const requestAddReaction: (client: RestClient, context: RestContext, params: {
+    messageId: string;
+    reaction: string;
+}) => Promise<void>;
+export declare const requestRemoveReaction: (client: RestClient, context: RestContext, params: {
+    messageId: string;
+    reaction: string;
+}) => Promise<void>;
+export declare const requestGetReactionList: (client: RestClient, context: RestContext, params: GetReactionListParams) => Promise<ReadonlyArray<MessageReactionListItem>>;
+export declare const requestGetReactionDetail: (client: RestClient, context: RestContext, params: GetReactionDetailParams) => Promise<MessageReactionDetailPage>;
+export declare const requestGetSupportedTranslationLanguages: (client: RestClient, context: RestContext) => Promise<ReadonlyArray<TranslationLanguage>>;
+export declare const requestTranslateMessage: (client: RestClient, context: RestContext, params: {
+    text: string;
+    targetLanguages: ReadonlyArray<string>;
+}) => Promise<MessageTranslationResult>;
+export declare const requestSearchMessages: (client: RestClient, context: RestContext, params: SearchMessagesParams) => Promise<SearchMessagesResult>;
+export {};

package/rest/chat-thread-management.d.ts

@@ -0,0 +1,14 @@
+import type { RestContext } from '../types/chat-client';
+import type { ChatThreadDetail, ChatThreadLastMessageListResult, ChatThreadListResult, ChatThreadMemberListResult, CreateChatThreadParams, CreateChatThreadResult, GetChatThreadLastMessageListParams, GetChatThreadListParams, GetChatThreadMemberListParams, GetJoinedChatThreadListParams, RemoveChatThreadMemberParams, UpdateChatThreadNameParams } from '../types/chat-thread';
+import type { RestClient } from './client';
+export declare const requestCreateChatThread: (client: RestClient, context: RestContext, params: CreateChatThreadParams) => Promise<CreateChatThreadResult>;
+export declare const requestGetChatThreadList: (client: RestClient, context: RestContext, params: GetChatThreadListParams) => Promise<ChatThreadListResult>;
+export declare const requestGetJoinedChatThreadList: (client: RestClient, context: RestContext, params?: GetJoinedChatThreadListParams) => Promise<ChatThreadListResult>;
+export declare const requestGetChatThreadInfo: (client: RestClient, context: RestContext, chatThreadId: string) => Promise<ChatThreadDetail>;
+export declare const requestJoinChatThread: (client: RestClient, context: RestContext, chatThreadId: string) => Promise<void>;
+export declare const requestLeaveChatThread: (client: RestClient, context: RestContext, chatThreadId: string) => Promise<void>;
+export declare const requestDestroyChatThread: (client: RestClient, context: RestContext, chatThreadId: string) => Promise<void>;
+export declare const requestUpdateChatThreadName: (client: RestClient, context: RestContext, params: UpdateChatThreadNameParams) => Promise<void>;
+export declare const requestGetChatThreadMemberList: (client: RestClient, context: RestContext, params: GetChatThreadMemberListParams) => Promise<ChatThreadMemberListResult>;
+export declare const requestRemoveChatThreadMember: (client: RestClient, context: RestContext, params: RemoveChatThreadMemberParams) => Promise<void>;
+export declare const requestGetChatThreadLastMessageList: (client: RestClient, context: RestContext, params: GetChatThreadLastMessageListParams) => Promise<ChatThreadLastMessageListResult>;

package/rest/chatroom-management.d.ts

@@ -0,0 +1,40 @@
+import type { RestContext } from '../types/chat-client';
+import type { RestClient } from './client';
+import type { ChatRoomAdminParams, ChatRoomAnnouncement, ChatRoomAnnouncementUpdateParams, ChatRoomAttributeMutationResult, ChatRoomAttributesSnapshot, ChatRoomBlocklistEntry, ChatRoomBlocklistParams, ChatRoomDetail, ChatRoomListResult, ChatRoomMemberActionListResult, ChatRoomMemberListParams, ChatRoomMemberListResult, ChatRoomMuteEntry, ChatRoomMuteListParams, ChatRoomMuteMembersParams, ChatRoomMuteStatus, ChatRoomMutationTarget, ChatRoomSharedFileListParams, ChatRoomSharedFileListResult, ChatRoomUpdateResult, ChatRoomUserBatchParams, DeleteChatRoomSharedFileParams, GetChatRoomAttributesParams, GetChatRoomInfoParams, GetChatRoomListParams, JoinChatRoomParams, RemoveChatRoomAttributesParams, SetChatRoomAttributesParams, UpdateChatRoomInfoParams } from '../types/chatroom';
+import type { UserInfo } from '../types/user-info';
+export declare const normalizeChatRoomId: (chatRoomId: string, path: string) => string;
+export declare const normalizeChatRoomUserIds: (userIds: ReadonlyArray<string>, path: string) => ReadonlyArray<string>;
+export declare const requestGetChatRoomList: (client: RestClient, context: RestContext, params?: GetChatRoomListParams) => Promise<ChatRoomListResult>;
+export declare const requestGetChatRoomInfo: (client: RestClient, context: RestContext, params: GetChatRoomInfoParams) => Promise<ChatRoomDetail>;
+export declare const requestUpdateChatRoomInfo: (client: RestClient, context: RestContext, params: UpdateChatRoomInfoParams) => Promise<ChatRoomUpdateResult>;
+export declare const requestDestroyChatRoom: (client: RestClient, context: RestContext, params: ChatRoomMutationTarget) => Promise<void>;
+export declare const requestJoinChatRoom: (client: RestClient, context: RestContext, params: JoinChatRoomParams) => Promise<void>;
+export declare const requestLeaveChatRoom: (client: RestClient, context: RestContext, params: ChatRoomMutationTarget) => Promise<void>;
+export declare const requestGetChatRoomMemberList: (client: RestClient, context: RestContext, params: ChatRoomMemberListParams) => Promise<ChatRoomMemberListResult>;
+export declare const requestAddChatRoomMembers: (client: RestClient, context: RestContext, params: ChatRoomUserBatchParams) => Promise<ChatRoomMemberActionListResult>;
+export declare const requestRemoveChatRoomMembers: (client: RestClient, context: RestContext, params: ChatRoomUserBatchParams) => Promise<ChatRoomMemberActionListResult>;
+export declare const requestGetChatRoomAdminList: (client: RestClient, context: RestContext, params: ChatRoomMutationTarget) => Promise<ReadonlyArray<UserInfo>>;
+export declare const requestSetChatRoomAdmin: (client: RestClient, context: RestContext, params: ChatRoomAdminParams) => Promise<void>;
+export declare const requestRemoveChatRoomAdmin: (client: RestClient, context: RestContext, params: ChatRoomAdminParams) => Promise<void>;
+export declare const requestGetChatRoomMuteList: (client: RestClient, context: RestContext, params: ChatRoomMuteListParams) => Promise<ReadonlyArray<ChatRoomMuteEntry>>;
+export declare const requestMuteChatRoomMembers: (client: RestClient, context: RestContext, params: ChatRoomMuteMembersParams) => Promise<void>;
+export declare const requestUnmuteChatRoomMembers: (client: RestClient, context: RestContext, params: ChatRoomUserBatchParams) => Promise<void>;
+export declare const requestMuteAllChatRoomMembers: (client: RestClient, context: RestContext, params: ChatRoomMutationTarget) => Promise<void>;
+export declare const requestUnmuteAllChatRoomMembers: (client: RestClient, context: RestContext, params: ChatRoomMutationTarget) => Promise<void>;
+export declare const requestCheckIfInChatRoomMuteList: (client: RestClient, context: RestContext, params: ChatRoomMutationTarget) => Promise<ChatRoomMuteStatus>;
+export declare const requestGetChatRoomBlocklist: (client: RestClient, context: RestContext, params: ChatRoomBlocklistParams) => Promise<ReadonlyArray<ChatRoomBlocklistEntry>>;
+export declare const requestBlockChatRoomMembers: (client: RestClient, context: RestContext, params: ChatRoomUserBatchParams) => Promise<ChatRoomMemberActionListResult>;
+export declare const requestUnblockChatRoomMembers: (client: RestClient, context: RestContext, params: ChatRoomUserBatchParams) => Promise<ChatRoomMemberActionListResult>;
+export declare const requestGetChatRoomAllowlist: (client: RestClient, context: RestContext, params: ChatRoomMutationTarget) => Promise<ReadonlyArray<{
+    readonly user: UserInfo;
+}>>;
+export declare const requestAddUsersToChatRoomAllowlist: (client: RestClient, context: RestContext, params: ChatRoomUserBatchParams) => Promise<ChatRoomMemberActionListResult>;
+export declare const requestRemoveUsersFromChatRoomAllowlist: (client: RestClient, context: RestContext, params: ChatRoomUserBatchParams) => Promise<ChatRoomMemberActionListResult>;
+export declare const requestCheckIfInChatRoomAllowList: (client: RestClient, context: RestContext, params: ChatRoomMutationTarget) => Promise<boolean>;
+export declare const requestGetChatRoomAnnouncement: (client: RestClient, context: RestContext, params: ChatRoomMutationTarget) => Promise<ChatRoomAnnouncement>;
+export declare const requestUpdateChatRoomAnnouncement: (client: RestClient, context: RestContext, params: ChatRoomAnnouncementUpdateParams) => Promise<void>;
+export declare const requestGetChatRoomSharedFileList: (client: RestClient, context: RestContext, params: ChatRoomSharedFileListParams) => Promise<ChatRoomSharedFileListResult>;
+export declare const requestDeleteChatRoomSharedFile: (client: RestClient, context: RestContext, params: DeleteChatRoomSharedFileParams) => Promise<void>;
+export declare const requestGetChatRoomAttributes: (client: RestClient, context: RestContext, params: GetChatRoomAttributesParams) => Promise<ChatRoomAttributesSnapshot>;
+export declare const requestSetChatRoomAttributes: (client: RestClient, context: RestContext, params: SetChatRoomAttributesParams) => Promise<ChatRoomAttributeMutationResult>;
+export declare const requestRemoveChatRoomAttributes: (client: RestClient, context: RestContext, params: RemoveChatRoomAttributesParams) => Promise<ChatRoomAttributeMutationResult>;

package/rest/client.d.ts

@@ -0,0 +1,86 @@
+/**
+ * REST 客户端基础类
+ *
+ * 统一 Promise 返回，不使用回调
+ */
+import type { RuntimeErrorMap } from './error-map-types';
+import type { RequestAdapter } from '../platform/types';
+/**
+ * HTTP 方法
+ */
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+/**
+ * 请求配置
+ */
+export interface RequestConfig {
+    method?: HttpMethod;
+    headers?: Record<string, string>;
+    body?: unknown;
+    timeout?: number;
+    operation?: string;
+}
+export interface RestClientOptions {
+    timeout?: number;
+    headers?: Record<string, string>;
+    errorMap?: RuntimeErrorMap;
+    requestAdapter?: RequestAdapter;
+    /** 为 true 时在请求头注入 X-Request-Id（Manager REST 使用） */
+    includeRequestId?: boolean;
+}
+/**
+ * REST 客户端
+ */
+export declare class RestClient {
+    private baseUrl;
+    private defaultHeaders;
+    private timeout;
+    private errorMap;
+    private requestAdapter;
+    private includeRequestId;
+    constructor(baseUrl: string, options?: RestClientOptions);
+    /**
+     * 脱敏 URL（屏蔽 query 参数值）
+     */
+    private sanitizeUrl;
+    /**
+     * 设置认证 token
+     */
+    setAuthToken(token: string): void;
+    /**
+     * 移除认证 token
+     */
+    removeAuthToken(): void;
+    /**
+     * 基于 HTTP 状态码的通用错误兜底
+     */
+    private buildHttpStatusFallbackError;
+    /**
+     * 发送请求
+     */
+    request<T>(endpoint: string, config?: RequestConfig): Promise<T>;
+    /**
+     * 处理错误响应
+     */
+    private handleErrorResponse;
+    private handleErrorPayload;
+    /**
+     * GET 请求
+     */
+    get<T>(endpoint: string, config?: Omit<RequestConfig, 'method' | 'body'>): Promise<T>;
+    /**
+     * POST 请求
+     */
+    post<T>(endpoint: string, body?: unknown, config?: Omit<RequestConfig, 'method'>): Promise<T>;
+    /**
+     * PUT 请求
+     */
+    put<T>(endpoint: string, body?: unknown, config?: Omit<RequestConfig, 'method'>): Promise<T>;
+    /**
+     * DELETE 请求
+     */
+    delete<T>(endpoint: string, config?: Omit<RequestConfig, 'method' | 'body'>): Promise<T>;
+    /**
+     * PATCH 请求
+     */
+    patch<T>(endpoint: string, body?: unknown, config?: Omit<RequestConfig, 'method'>): Promise<T>;
+}

package/rest/contact-management.d.ts

@@ -0,0 +1,27 @@
+import type { RestClient } from './client';
+import type { AddContactParams, BlocklistAddResult, BlocklistMutationParams, Contact, ContactMutationTarget, SetContactRemarkParams } from '../types/contact';
+import type { RestContext } from '../types/chat-client';
+import type { UserInfo } from '../types/user-info';
+interface GetContactListParams {
+    readonly pageSize?: number;
+    readonly cursor?: string;
+}
+interface ContactListPage {
+    readonly cursor: string;
+    readonly contacts: ReadonlyArray<Contact>;
+}
+export declare const dedupeUserIds: (userIds: ReadonlyArray<string>) => ReadonlyArray<string>;
+export declare const normalizeBlocklistEntries: (payload: unknown) => ReadonlyArray<UserInfo>;
+export declare const normalizeBlocklistAddResult: (payload: unknown) => BlocklistAddResult;
+export declare const normalizeContactListPage: (payload: unknown, existingContacts: ReadonlyMap<string, Contact>) => ContactListPage;
+export declare const assertNormalizedUserIds: (params: BlocklistMutationParams, path: string) => ReadonlyArray<string>;
+export declare const requestAddContact: (client: RestClient, context: RestContext, params: AddContactParams) => Promise<void>;
+export declare const requestDeleteContact: (client: RestClient, context: RestContext, params: ContactMutationTarget) => Promise<void>;
+export declare const requestAcceptContactInvite: (client: RestClient, context: RestContext, params: ContactMutationTarget) => Promise<void>;
+export declare const requestDeclineContactInvite: (client: RestClient, context: RestContext, params: ContactMutationTarget) => Promise<void>;
+export declare const requestSetContactRemark: (client: RestClient, context: RestContext, params: SetContactRemarkParams) => Promise<void>;
+export declare const requestGetBlocklist: (client: RestClient, context: RestContext) => Promise<ReadonlyArray<UserInfo>>;
+export declare const requestGetContactList: (client: RestClient, context: RestContext, params: GetContactListParams, existingContacts: ReadonlyMap<string, Contact>) => Promise<ContactListPage>;
+export declare const requestAddUsersToBlocklist: (client: RestClient, context: RestContext, userIds: ReadonlyArray<string>) => Promise<BlocklistAddResult>;
+export declare const requestRemoveUsersFromBlocklist: (client: RestClient, context: RestContext, userIds: ReadonlyArray<string>) => Promise<void>;
+export {};

package/rest/contact-metadata.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 联系人版本元数据查询
+ */
+import type { RestContext } from '../types/chat-client';
+import type { RequestAdapter } from '../platform/types';
+export interface ContactMetadataVersionResponse {
+    readonly version: string;
+    readonly requiresSync: boolean;
+    readonly checkedAt: number;
+}
+export declare const fetchContactMetadataVersion: (context: RestContext, currentVersion: string, requestAdapter?: RequestAdapter) => Promise<ContactMetadataVersionResponse>;

package/rest/conversation-management.d.ts

@@ -0,0 +1,11 @@
+import type { ConversationMarkMutationResult, ConversationMarkParams, ConversationMutationResult, DeleteConversationParams, GetPinnedMessageListParams, MessagePinMutationResult, PinnedMessageListResult, PinMessageParams, SetConversationPinnedParams } from '../types/conversation';
+import type { RestContext } from '../types/chat-client';
+import type { RestClient } from './client';
+export declare const requestDeleteConversation: (client: RestClient, context: RestContext, params: DeleteConversationParams) => Promise<ConversationMutationResult>;
+export declare const requestSetConversationPinned: (client: RestClient, context: RestContext, params: SetConversationPinnedParams) => Promise<ConversationMutationResult>;
+export declare const requestAddConversationMark: (client: RestClient, context: RestContext, params: ConversationMarkParams) => Promise<ConversationMarkMutationResult>;
+export declare const requestRemoveConversationMark: (client: RestClient, context: RestContext, params: ConversationMarkParams) => Promise<ConversationMarkMutationResult>;
+export declare const requestClearAllMessagesAndConversations: (client: RestClient, context: RestContext) => Promise<void>;
+export declare const requestPinMessage: (client: RestClient, context: RestContext, params: PinMessageParams) => Promise<MessagePinMutationResult>;
+export declare const requestUnpinMessage: (client: RestClient, context: RestContext, params: PinMessageParams) => Promise<MessagePinMutationResult>;
+export declare const requestGetPinnedMessageList: (client: RestClient, context: RestContext, params: GetPinnedMessageListParams) => Promise<PinnedMessageListResult>;

package/rest/dns-config.d.ts

@@ -0,0 +1,20 @@
+/**
+ * dnsconfig 请求与解析
+ */
+import type { DnsConfig } from '../types/chat-client';
+import type { RequestAdapter } from '../platform/types';
+export declare const DEFAULT_DNS_CONFIG_URLS: string[];
+export interface DnsConfigResult {
+    websocketUrl: string;
+    websocketUrls: string[];
+    syncWebsocketUrls: string[];
+    baseUrl: string;
+    restBaseUrl: string;
+    dnsConfig: DnsConfig;
+}
+export declare function resolveDnsConfig(options: {
+    appKey: string;
+    baseUrls?: string[];
+    pageProtocol?: 'http' | 'https';
+    requestAdapter?: RequestAdapter;
+}): Promise<DnsConfigResult>;

package/rest/error-map-types.d.ts

@@ -0,0 +1,32 @@
+export interface RuntimeApiErrorEntry {
+    readonly code: number;
+    readonly runtimeMessage?: string;
+    readonly retryable?: boolean;
+    readonly httpStatus?: number;
+    readonly provisional?: boolean;
+    readonly canonicalCode?: number;
+    readonly aliases?: readonly string[];
+    readonly matchField?: string;
+    readonly matchValue?: string | number;
+    readonly matchPattern?: string;
+}
+export type RuntimeErrorMatchedBy = 'key' | 'field' | 'code' | 'alias' | 'common';
+export interface ResolvedApiBusinessError {
+    readonly reasonKey: string;
+    readonly entry: RuntimeApiErrorEntry;
+    readonly matchedBy: RuntimeErrorMatchedBy;
+}
+export interface RuntimeApiErrorDefinition {
+    readonly range?: string;
+    readonly localErrors?: Readonly<Record<string, Readonly<Record<string, RuntimeApiErrorEntry>>>>;
+    readonly errors: Readonly<Record<string, RuntimeApiErrorEntry>>;
+}
+export interface RuntimeCommonErrorDefinition {
+    readonly range?: string;
+    readonly errors: Readonly<Record<string, RuntimeApiErrorEntry>>;
+}
+export interface RuntimeErrorMap {
+    readonly common: Readonly<Record<string, RuntimeCommonErrorDefinition>>;
+    readonly apis: Readonly<Record<string, RuntimeApiErrorDefinition>>;
+}
+export declare const mergeRuntimeErrorMaps: (...maps: ReadonlyArray<RuntimeErrorMap>) => RuntimeErrorMap;