docs: add guide documents (#50)

docs/.vuepress/config.js

 module.exports = {
-    lang: 'zh-CN',
-    title: 'Tencent Cloud IM Server SDK Document - Java',
-    description: '腾讯云 IM 服务端 SDK API 文档 Java 版',
-    base: '/qcloud-im-server-sdk-java/',
-    themeConfig: {
-      repo: 'doocs/qcloud-im-server-sdk-java',
-      logo: 'https://avatars.githubusercontent.com/u/43716716?s=200&v=4',
-      open: true,
-    },
-  }
+  lang: "zh-CN",
+  title: "腾讯云 IM 服务端 Java SDK 使用文档",
+  description: "腾讯云 IM 服务端 SDK API 文档 Java 版",
+  base: "/qcloud-im-server-sdk-java/",
+  themeConfig: {
+    repo: "doocs/qcloud-im-server-sdk-java",
+    logo: "https://avatars.githubusercontent.com/u/43716716?s=200&v=4",
+    open: true,
+    contributorsText: '贡献者',
+    editLinkText: '编辑',
\ No newline at end of file
+    lastUpdatedText: '最近更新时间',
+    sidebar: [
+      {
+        text: "指南",
+        children: [
+          '/guide/README.md', 
+          '/guide/quickstart.md',
+          '/guide/account.md',
+          '/guide/message.md',
+          '/guide/member.md',
+          '/guide/profile.md',
+          '/guide/sns.md',
+          '/guide/recent_contact.md',
+          '/guide/group.md',
+          '/guide/operation_1.md',
+          '/guide/operation_2.md'
+        ],
+      },
+    ],
+  },
+};

docs/guide/README.md

+# 介绍
+
+本文档基于 QCloud IM Server SDK v0.2.3 版本编写。
+
+## SDK 源码
+
+SDK 源码请参见 [GitHub](https://github.com/doocs/qcloud-im-server-sdk-java)。

docs/guide/account.md

+# 帐号管理
+
+## 导入单个帐号
+
+本接口用于将 App 自有帐号导入即时通信 IM 帐号系统，为该帐号创建一个对应的内部 ID，使该帐号能够使用即时通信 IM 服务。
+
+::: tip
+同一个帐号重复导入仅会创建 1 个内部 ID。
+:::
+
+使用示例：
+
+```java
+AccountImportRequest request = AccountImportRequest.builder()
+        .identifier("admin")
+        .faceUrl("https://avatars.githubusercontent.com/u/43716716?s=200&v=4")
+        .nick("doocs")
+        .build();
+
+AccountImportResult result = client.account.accountImport(request);
+```
+
+## 导入多个帐号
+
+本接口用于批量将 App 自有帐号导入即时通信 IM 帐号系统，为该帐号创建一个对应的内部 ID，使该帐号能够使用即时通信 IM 服务。
+
+注意： 本接口单次最多支持导入 100 个帐号，且不支持导入帐号的昵称和头像信息。请使用 [资料管理-设置资料](./profile.md#设置资料) 设置其他信息。
+
+使用示例：
+
+```java
+List<String> accounts = new ArrayList<>();
+accounts.add("doocs_1");
+accounts.add("doocs_2");
+MultiAccountImportRequest request = MultiAccountImportRequest.builder()
+        .accounts(accounts)
+        .build();
+
+MultiAccountImportResult result = client.account.multiAccountImport(request);
+```
+
+## 删除帐号
+
+仅支持删除套餐包类型为 IM 体验版的帐号，其他类型的账号（如：TRTC、白板、专业版、旗舰版）无法删除。
+
+::: tip
+帐号删除时，该用户的关系链、资料等数据也会被删除，且数据将无法恢复。
+:::
+
+使用示例：
+
+```java
+AccountDeleteItem deleteAccount = AccountDeleteItem.builder()
+        .userId("doocs")
+        .build();
+AccountDeleteRequest request = AccountDeleteRequest.builder()
+        .deleteItemList(Collections.singletonList(deleteAccount))
+        .build();
+
+AccountDeleteResult result = client.account.accountDelete(request);
+```
+
+## 查询帐号
+
+用于查询自有帐号是否已导入即时通信 IM, 支持批量查询。
+
+使用示例：
+
+```java
+AccountCheckItem account1 = new AccountCheckItem("doocs_1");
+AccountCheckItem account2 = new AccountCheckItem("doocs_2");
+AccountCheckRequest request = new AccountCheckRequest(Arrays.asList(account1, account2));
+
+AccountCheckResult result = client.account.accountCheck(request);
+```
+
+## 失效帐号登录状态
+
+本接口适用于将 App 用户帐号的登录状态（例如 UserSig）失效。
+
+例如，开发者判断一个用户为恶意帐号后，可以调用本接口将该用户当前的登录状态失效，这样用户使用历史 UserSig 登录即时通信 IM 会失败。
+
+::: tip
+支持一次失效一个帐号，用户可以使用重新生成的 UserSig 登录即时通信 IM
+:::
+
+使用示例：
+
+```java
+KickRequest request = new KickRequest("doocs_1");
+
+KickResult result = client.account.kick(request);
+```
+
+## 查询帐号在线状态
+
+获取用户当前的登录状态。
+
+使用示例：
+
+```java
+List<String> toAccount = Arrays.asList("doocs_1", "doocs_2");
+QueryOnlineStatusRequest request = QueryOnlineStatusRequest.builder()
+        .toAccount(toAccount)
+        .isNeedDetail(IsNeedDetail.YES)
+        .build();
+
+QueryOnlineStatusResult result = client.account.queryOnlineStatus(request);
+```

docs/guide/group.md

+# 群组管理
+
+## 获取 App 中的所有群组
+
+App 管理员可以通过该接口获取 App 中所有群组的 ID。
+
+::: tip
+即时通信 IM 内置多种群组类型，详情请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+:::
+
+使用示例：
+
+```java
+GetAppidGroupListRequest request = GetAppidGroupListRequest.builder()
+        .limit(10)
+        .groupType(GroupType.PUBLIC)
+        .next(0)
+        .build();
+
+GetAppidGroupListResult result = client.group.getAppIdGroupList(request);
+```
+
+## 创建群组
+
+App 管理员可以通过该接口创建群组。
+
+使用示例：
+
+```java
+CreateGroupRequest request = (CreateGroupRequest) CreateGroupRequest.builder()
+        .type(GroupType.PUBLIC)
+        .name("TestGroup")
+        .ownerAccount("doocs")
+        .groupId("MyFirstGroup")
+        .introduction("This is group Introduction")
+        .notification("This is group Notification")
+        .faceUrl("https://avatars.githubusercontent.com/u/43716716?s=200&v=4")
+        .maxMemberCount(500)
+        .applyJoinOption(ApplyJoinOption.FREE_ACCESS)
+        .build();
+
+CreateGroupResult result = client.group.createGroup(request);
+```
+
+## 获取群详细资料
+
+App 管理员可以根据群组 ID 获取群组的详细信息。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                      |
+| ----------- | ---------------------------------------- |
+| Private     | 支持，同新版本中的 Work（好友工作群）    |
+| Public      | 支持                                     |
+| ChatRoom    | 支持，同新版本中的 Meeting（临时会议群） |
+| AVChatRoom  | 支持                                     |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+:::
+
+使用示例：
+
+```java
+GetGroupInfoRequest request = new GetGroupInfoRequest(Collections.singletonList("MyFirstGroup"));
+
+GetGroupInfoResult result = client.group.getGroupInfo(request);
+```
+
+## 获取群成员详细资料
+
+App 管理员可以根据群组 ID 获取群组成员的资料。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                      |
+| ----------- | ---------------------------------------- |
+| Private     | 支持，同新版本中的 Work（好友工作群）    |
+| Public      | 支持                                     |
+| ChatRoom    | 支持，同新版本中的 Meeting（临时会议群） |
+| AVChatRoom  | 仅支持 300 人内                          |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+:::
+
+使用示例：
+
+```java
+GetGroupMemberInfoRequest request = GetGroupMemberInfoRequest.builder()
+        .groupId("MyFirstGroup")
+        .limit(100)
+        .offset(0)
+        .build();
+
+GetGroupMemberInfoResult result = client.group.getGroupMemberInfo(request);
+```
+
+## 修改群基础资料
+
+App 管理员可以通过该接口修改指定群组的基础信息。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                      |
+| ----------- | ---------------------------------------- |
+| Private     | 支持，同新版本中的 Work（好友工作群）    |
+| Public      | 支持                                     |
+| ChatRoom    | 支持，同新版本中的 Meeting（临时会议群） |
+| AVChatRoom  | 支持                                     |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+:::
+
+使用示例：
+
+```java
+ModifyGroupBaseInfoRequest request = ModifyGroupBaseInfoRequest.builder()
+        .groupId("MyFirstGroup")
+        .name("groupName")
+        .introduction("my first group")
+        .notification("hello world!")
+        .faceUrl("https://avatars.githubusercontent.com/u/43716716?s=200&v=4")
+        .maxMemberNum(500)
+        .applyJoinOption("NeedPermission")
+        .shutUpAllMember("Off")
+        .build();
+
+ModifyGroupBaseInfoResult result = client.group.modifyGroupBaseInfo(request);
+```
+
+## 增加群成员
+
+App 管理员可以通过该接口向指定的群中添加新成员。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                      |
+| ----------- | ---------------------------------------- |
+| Private     | 支持，同新版本中的 Work（好友工作群）    |
+| Public      | 支持                                     |
+| ChatRoom    | 支持，同新版本中的 Meeting（临时会议群） |
+| AVChatRoom  | 不支持                                   |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+
+AVChatRoom(直播群)不支持增加群成员，对此类型群组进行操作时会返回 10007 错误。用户加入此类型群组的唯一方式是用户申请加群。
+:::
+
+使用示例：
+
+```java
+AddGroupMemberRequest request = AddGroupMemberRequest.builder()
+        .groupId("MyFirstGroup")
+        .memberList(memberList)
+        .silence(1)
+        .build();
+
+AddGroupMemberResult result = client.group.addGroupMember(request);
+```
+
+## 删除群成员
+
+App 管理员可以通过该接口删除群成员。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                      |
+| ----------- | ---------------------------------------- |
+| Private     | 支持，同新版本中的 Work（好友工作群）    |
+| Public      | 支持                                     |
+| ChatRoom    | 支持，同新版本中的 Meeting（临时会议群） |
+| AVChatRoom  | 不支持                                   |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+
+AVChatRoom（直播群）不支持删除群成员，对这种类型的群组进行操作时会返回 10004 错误。如果管理员希望达到删除群成员的效果，可以通过设置 [批量禁言和取消禁言](#批量禁言和取消禁言) 的方式实现。
+:::
+
+使用示例：
+
+```java
+List<String> toDelAccount = Collections.singletonList("doocs");
+DeleteGroupMemberRequest request = DeleteGroupMemberRequest.builder()
+        .groupId("MyFirstGroup")
+        .memberToDelAccount(toDelAccount)
+        .build();
+
+DeleteGroupMemberResult result = client.group.deleteGroupMember(request);
+```
+
+## 修改群成员资料
+
+App 管理员可以通过该接口修改群成员资料。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                      |
+| ----------- | ---------------------------------------- |
+| Private     | 支持，同新版本中的 Work（好友工作群）    |
+| Public      | 支持                                     |
+| ChatRoom    | 支持，同新版本中的 Meeting（临时会议群） |
+| AVChatRoom  | 支持修改群组资料                         |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+
+AVChatRoom（直播群）不存储群成员资料，所以不能修改成员资料。只能修改管理员和群主的成员资料，修改普通成员资料时会返回 10007 错误。
+:::
+
+使用示例：
+
+```java
+ModifyGroupMemberInfoRequest request = ModifyGroupMemberInfoRequest.builder()
+        .groupId("MyFirstGroup")
+        .memberAccount("doocs")
+        .nameCard("hello World!")
+        .build();
+
+ModifyGroupMemberInfoResult result = client.group.modifyGroupMemberInfo(request);
+```
+
+## 解散群组
+
+App 管理员通过该接口解散群。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                      |
+| ----------- | ---------------------------------------- |
+| Private     | 支持，同新版本中的 Work（好友工作群）    |
+| Public      | 支持                                     |
+| ChatRoom    | 支持，同新版本中的 Meeting（临时会议群） |
+| AVChatRoom  | 支持修改群组资料                         |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+:::
+
+使用示例：
+
+```java
+DestroyGroupRequest request = new DestroyGroupRequest("MyFirstGroup");
+
+DestroyGroupResult result = client.group.destroyGroup(request);
+```
+
+## 获取用户所加入的群组
+
+App 管理员可以通过本接口获取某一用户加入的群信息。默认不获取用户已加入但未激活好友工作群（Work）以及直播群（AVChatRoom）群信息。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                                                                                                               |
+| ----------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| Private     | 支持，同新版本中的 Work（好友工作群），但默认不返回已加入但未激活的此类型群信息                                                   |
+| Public      | 支持                                                                                                                              |
+| ChatRoom    | 支持，同新版本中的 Meeting（临时会议群）                                                                                          |
+| AVChatRoom  | 支持，但默认不返回此类型群信息。如果指定拉取 AVChatRoom 类型群信息，获得的群信息可能不完整，AVChatRoom 并不存储所有的群成员资料。 |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+:::
+
+使用示例：
+
+```java
+GetJoinedGroupListRequest request = new GetJoinedGroupListRequest("doocs");
+
+GetJoinGroupListResult result = client.group.getJoinGroupList(request);
+```
+
+## 查询用户在群组中的身份
+
+App 管理员可以通过该接口获取一批用户在群内的身份，即“成员角色”。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                      |
+| ----------- | ---------------------------------------- |
+| Private     | 支持，同新版本中的 Work（好友工作群）    |
+| Public      | 支持                                     |
+| ChatRoom    | 支持，同新版本中的 Meeting（临时会议群） |
+| AVChatRoom  | 不支持                                   |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+
+AVChatRoom（直播群）不支持该接口，对此类型群组进行操作将返回 10007 错误；但可以通过 [获取群组成员详细资料](#获取群组成员详细资料) 达到查询“成员角色”的效果。
+:::
+
+使用示例：
+
+```java
+GetRoleInGroupRequest request = GetRoleInGroupRequest.builder()
+        .groupId("MyFirstGroup")
+        .userAccount(Collections.singletonList("doocs"))
+        .build();
+
+GetRoleInGroupResult result = client.group.getRoleInGroup(request);
+```
+
+## 批量禁言和取消禁言
+
+- App 管理员禁止指定群组中某些用户在一段时间内发言。
+- App 管理员取消对某些用户的禁言。
+- 被禁言用户退出群组之后再进入同一群组，禁言仍然有效。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                      |
+| ----------- | ---------------------------------------- |
+| Private     | 不支持，同新版本中的 Work（好友工作群）  |
+| Public      | 支持                                     |
+| ChatRoom    | 支持，同新版本中的 Meeting（临时会议群） |
+| AVChatRoom  | 支持                                     |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+
+Private（即新版本中的 Work，好友工作群）类型不支持禁言。
+:::
+
+使用示例：
+
+```java
+ForbidSendMsgRequest request = ForbidSendMsgRequest.builder()
+        .groupId("MyFirstGroup")
+        .membersAccount(Collections.singletonList("doocs"))
+        .shutUpTime(200)
+        .build();
+
+ForbidSendMsgResult result = client.group.forbidSendMsg(request);
+```
+
+## 获取被禁言群成员列表
+
+App 管理员可以根据群组 ID 获取群组中被禁言的用户列表。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                      |
+| ----------- | ---------------------------------------- |
+| Private     | 支持，同新版本中的 Work（好友工作群）    |
+| Public      | 支持                                     |
+| ChatRoom    | 支持，同新版本中的 Meeting（临时会议群） |
+| AVChatRoom  | 支持                                     |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+:::
+
+使用示例：
+
+```java
+GetGroupShuttedUinRequest request = new GetGroupShuttedUinRequest("MyFirstGroup");
+
+GetGroupShuttedUinResult result = client.group.getGroupShuttedUin(request);
+```
+
+## 在群组中发送普通消息
+
+App 管理员可以通过该接口在群组中发送普通消息。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                      |
+| ----------- | ---------------------------------------- |
+| Private     | 支持，同新版本中的 Work（好友工作群）    |
+| Public      | 支持                                     |
+| ChatRoom    | 支持，同新版本中的 Meeting（临时会议群） |
+| AVChatRoom  | 支持                                     |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+:::
+
+使用示例：
+
+```java
+SendGroupMsgRequest request = SendGroupMsgRequest.builder()
+        .groupId("MyFirstGroup")
+        .random(1314)
+        .msgBody(Collections.singletonList(new TIMTextMsgElement("red packet")))
+        .onlineOnlyFlag(OnlineOnlyFlag.YES)
+        .build();
+
+SendGroupMsgResult result = client.group.sendGroupMsg(request);
+```
+
+## 在群组中发送系统通知
+
+App 管理员可以通过该接口在群组中发送系统通知。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                      |
+| ----------- | ---------------------------------------- |
+| Private     | 支持，同新版本中的 Work（好友工作群）    |
+| Public      | 支持                                     |
+| ChatRoom    | 支持，同新版本中的 Meeting（临时会议群） |
+| AVChatRoom  | 支持，仅支持面向全员                     |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+
+- 非直播群支持向群组中的一部分指定成员发送系统通知，而 AVChatRoom（直播群）只支持向群组中所有成员发送系统通知。
+- 客户端接收系统通知接口（V2TIMGroupListener.onReceiveRESTCustomData）请参见 [Android](https://im.sdk.qcloud.com/doc/zh-cn/classcom_1_1tencent_1_1imsdk_1_1v2_1_1V2TIMGroupListener.html#a0775a137d293473aaed4cf9fc4c18795)、[iOS](https://im.sdk.qcloud.com/doc/zh-cn/protocolV2TIMGroupListener-p.html#a34108da2661d1b5ff68d1458ac4dd163) 。
+  :::
+
+使用示例：
+
+```java
+SendGroupSystemNotificationRequest request = SendGroupSystemNotificationRequest.builder()
+        .groupId("MyFirstGroup")
+        .content("hello world")
+        .toMembersAccount(Collections.singletonList("doocs"))
+        .build();
+
+SendGroupSystemNotificationResult result = client.group.sendGroupSystemNotification(request);
+```
+
+## 转让群主
+
+- App 管理员可以通过该接口将群主身份转移给他人。
+- 没有群主的群，App 管理员可以通过此接口指定他人作为群主。
+- 新群主必须为群内成员。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                      |
+| ----------- | ---------------------------------------- |
+| Private     | 支持，同新版本中的 Work（好友工作群）    |
+| Public      | 支持                                     |
+| ChatRoom    | 支持，同新版本中的 Meeting（临时会议群） |
+| AVChatRoom  | 不支持                                   |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+
+AVChatRoom（直播群）不支持转让群主，对该类型的群组进行操作时会返回 10007 错误。
+:::
+
+使用示例：
+
+```java
+ChangeGroupOwnerRequest request = ChangeGroupOwnerRequest.builder()
+        .groupId("MyFirstGroup")
+        .newOwnerAccount("doocs")
+        .build();
+
+ChangeGroupOwnerResult result = client.group.changeGroupOwner(request);
+```
+
+## 撤回群消息
+
+App 管理员通过该接口撤回指定群组的消息，消息需要在漫游有效期以内。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                      |
+| ----------- | ---------------------------------------- |
+| Private     | 支持，同新版本中的 Work（好友工作群）    |
+| Public      | 支持                                     |
+| ChatRoom    | 支持，同新版本中的 Meeting（临时会议群） |
+| AVChatRoom  | 不支持                                   |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+:::
+
+使用示例：
+
+```java
+GroupMsgRecallRequest request = GroupMsgRecallRequest.builder()
+        .groupId("MyFirstGroup")
+        .msgSeqList(Collections.singletonList(new MsgSeqItem(0)))
+        .build();
+
+GroupMsgRecallResult result = client.group.groupMsgRecall(request);
+```
+
+## 导入群基础资料
+
+App 管理员可以通过该接口导入群组，不会触发回调、不会下发通知；
+当 App 需要从其他即时通信系统迁移到即时通信 IM 时，使用该协议导入存量群组数据。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                      |
+| ----------- | ---------------------------------------- |
+| Private     | 支持，同新版本中的 Work（好友工作群）    |
+| Public      | 支持                                     |
+| ChatRoom    | 支持，同新版本中的 Meeting（临时会议群） |
+| AVChatRoom  | 不支持                                   |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+
+AVChatRoom（直播群）不支持导入群基础资料，对此类型的群组进行操作时会返回 10007 错误；如果需要达到导入群组基础资料的效果，可以通过 [创建群组](#创建群组) 和 [修改群基础资料](#修改群基础资料) 的方式实现。
+:::
+
+使用示例：
+
+```java
+ImportGroupRequest request = ImportGroupRequest.builder()
+        .type(GroupType.PUBLIC)
+        .name("groupName")
+        .build();
+
+ImportGroupResult result = client.group.importGroup(request);
+```
+
+## 导入群消息
+
+- 该 API 接口的作用是导入群组的消息，不会触发回调、不会下发通知。
+- 当 App 需要从其他即时通信系统迁移到即时通信 IM 时，使用该协议导入存量群消息数据。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                      |
+| ----------- | ---------------------------------------- |
+| Private     | 支持，同新版本中的 Work（好友工作群）    |
+| Public      | 支持                                     |
+| ChatRoom    | 支持，同新版本中的 Meeting（临时会议群） |
+| AVChatRoom  | 不支持                                   |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+
+AVChatRoom（直播群）不支持导入群消息，对此类型的群组进行操作时会返回 10007 错误；因为此类型群组所适用的场景不支持查看入群前的历史消息，所以没有提供这一功能。
+:::
+
+使用示例：
+
+```java
+GroupMsgItem item = GroupMsgItem.builder()
+        .fromAccount("doocs")
+        .sendTime(1628062005)
+        .msgBody(Collections.singletonList(new TIMTextMsgElement("hello world")))
+        .build();
+ImportGroupMsgRequest request = ImportGroupMsgRequest.builder()
+        .groupId("newGroup")
+        .msgList(Collections.singletonList(item))
+        .build();
+
+ImportGroupMsgResult result = client.group.importGroupMsg(request);
+```
+
+## 导入群成员
+
+- 该 API 接口的作用是导入群组成员，不会触发回调、不会下发通知。
+- 当 App 需要从其他即时通信系统迁移到即时通信 IM 时，使用该协议导入存量群成员数据。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                      |
+| ----------- | ---------------------------------------- |
+| Private     | 支持，同新版本中的 Work（好友工作群）    |
+| Public      | 支持                                     |
+| ChatRoom    | 支持，同新版本中的 Meeting（临时会议群） |
+| AVChatRoom  | 不支持                                   |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+
+AVChatRoom（直播群）所适用的场景一般不需要导入成员，因此不支持导入群成员功能，对此类型的群组进行操作时会返回 10007 错误。
+:::
+
+使用示例：
+
+```java
+MemberItem item = MemberItem.builder().memberAccount("doocs")
+        .joinTime(1628062005)
+        .role(MemberRole.ADMIN)
+        .unreadMsgNum(1)
+        .build();
+ImportGroupMemberRequest request = ImportGroupMemberRequest.builder()
+        .groupId("groupName")
+        .memberList(Collections.singletonList(item))
+        .build();
+
+ImportGroupMemberResult result = client.group.importGroupMember(request);
+```
+
+## 设置成员未读消息计数
+
+- App 管理员使用该接口设置群组成员未读消息数，不会触发回调、不会下发通知。
+- 当 App 需要从其他即时通信系统迁移到即时通信 IM 时，使用该协议设置群成员的未读消息计数。
+
+::: tip
+该文档仅限迁移用户使用，线上用户不能使用。
+
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                        |
+| ----------- | ------------------------------------------ |
+| Private     | 支持，同新版本中的 Work（好友工作群）      |
+| Public      | 支持                                       |
+| ChatRoom    | 不支持，同新版本中的 Meeting（临时会议群） |
+| AVChatRoom  | 不支持                                     |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+
+ChatRoom 和 AVChatroom（直播群）的客户端不支持未读消息计数，所以对这两种类型的群组成员设置未读消息计数是无效的（但是不会返回错误）。
+:::
+
+使用示例：
+
+```java
+SetUnreadMsgNumRequest result = SetUnreadMsgNumRequest.builder()
+        .groupId("MyFirstGroup")
+        .memberAccount("doocs")
+        .unreadMsgNum(1)
+        .build();
+
+SetUnreadMsgNumResult result = client.group.setUnreadMsgNum(request);
+```
+
+## 撤回指定用户发送的消息
+
+该 API 接口的作用是撤回最近 1000 条消息中指定用户发送的消息。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                      |
+| ----------- | ---------------------------------------- |
+| Private     | 支持，同新版本中的 Work（好友工作群）    |
+| Public      | 支持                                     |
+| ChatRoom    | 支持，同新版本中的 Meeting（临时会议群） |
+| AVChatRoom  | 不支持                                   |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+
+- AVChatRoom（直播群）不支持历史消息存储（此处撤回消息指撤回历史消息存储中的消息），对这此类型群组中的用户撤回消息是无效的（但是不会返回错误）。
+- 该接口目前只支持静默撤回，在服务端对该消息打上撤回标记，并不会通知到客户端，只有拉漫游时才知道该消息被撤回。
+  :::
+
+使用示例：
+
+```java
+DeleteGroupMsgBySenderRequest request = DeleteGroupMsgBySenderRequest.builder()
+        .groupId("MyFirstGroup")
+        .senderAccount("doocs")
+        .build();
+
+DeleteGroupMsgBySenderResult result = client.group.deleteGroupMsgBySender(request);
+```
+
+## 拉取群历史消息
+
+App 管理员可以通过该接口拉取群组的历史消息。
+
+背景说明：
+
+- 即时通信 IM 的群消息是按 Seq 排序的，按照 server 收到群消息的顺序分配 Seq，先发的群消息 Seq 小，后发的 Seq 大。
+- 如果用户想拉取一个群的全量消息，首次拉取时不用填拉取 Seq，Server 会自动返回最新的消息，以后拉取时拉取 Seq 填上次返回的最小 Seq 减 1。
+- 如果返回消息的 IsPlaceMsg 为 1，表示这个 Seq 的消息或者过期、或者存储失败、或者被删除了。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                      |
+| ----------- | ---------------------------------------- |
+| Private     | 支持，同新版本中的 Work（好友工作群）    |
+| Public      | 支持                                     |
+| ChatRoom    | 支持，同新版本中的 Meeting（临时会议群） |
+| AVChatRoom  | 不支持                                   |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+
+AVChatRoom(直播群) 不支持历史消息存储，所以不支持调用此接口。
+:::
+
+使用示例：
+
+```java
+GroupMsgGetSimpleRequest request = GroupMsgGetSimpleRequest.builder()
+        .groupId("MyFirstGroup")
+        .reqMsgNumber(1)
+        .reqMsgNumber(20)
+        .build();
+
+GroupMsgGetSimpleResult result = client.group.groupMsgGetSimple(request);
+```
+
+## 获取直播群在线人数
+
+App 管理员可以根据群组 ID 获取直播群在线人数。
+
+::: tip
+适用的群组类型
+
+| 群组类型 ID | 是否支持此 REST API                          |
+| ----------- | -------------------------------------------- |
+| Private     | 不支持，同新版本中的 Work（好友工作群）      |
+| Public      | 不支持                                       |
+| ChatRoom    | 不支持，同新版本中的 Meeting（临时会议群）） |
+| AVChatRoom  | 支持                                         |
+
+即时通信 IM 内置上述群组类型，详情介绍请参见 [群组系统](https://cloud.tencent.com/document/product/269/1502)。
+
+- 在线人数总体更新粒度为 10s。
+- 当群人数大于等于 300 或群内有 Web 端用户的时候，出现群成员上下线或者进退群的时候，由于当前 10s 周期内已经统计了用户在线状态的原因，会在下一个 10s 周期才会统计到剔除状态用户变更的在线人数，所以会出现调用接口 10s - 20s 才会更新的现象。
+- 当群人数小于 300 人且群内没有 Web 端用户的时候，用户进退群会触发即时更新在线人数。
+  :::
+
+使用示例：
+
+```java
+GetOnlineMemberNumRequest request = new GetOnlineMemberNumRequest("MyFirstAVChatRoom");
+
+GetOnlineMemberNumResult result = client.group.getOnlineMemberNum(request);
+```

docs/guide/member.md

+# 全员推送
+
+## 全员推送
+
+- 支持全员推送。
+- 支持按用户属性推送。
+- 支持按用户标签推送。
+- 管理员推送消息，接收方看到消息发送者是管理员。
+- 管理员指定某一帐号向其他帐号推送消息，接收方看到发送者不是管理员，而是管理员指定的帐号。
+- 支持消息离线存储，不支持漫游。
+- 由于全员推送需要下发的帐号数量巨大，下发完全部帐号需要一定时间（根据帐号总数而定，一般在一分钟内）。
+
+使用示例：
+
+```java
+TIMTextMsgElement msg = new TIMTextMsgElement("hi, beauty");
+List<TIMMsgElement> msgBody = Collections.singletonList(msg);
+ImPushRequest request = ImPushRequest.builder()
+        .msgRandom(9312457)
+        .msgBody(msgBody)
+        .fromAccount("admin")
+        .msgLifeTime(120)
+        .build();
+
+ImPushResult result = client.member.imPush(request);
+```
+
+## 设置应用属性名称
+
+每个应用可以设置自定义的用户属性，最多可以有 10 个。通过本接口可以设置每个属性的名称，设置完成后，即可用于按用户属性推送等。
+
+使用示例：
+
+```java
+Map<String, String> attrNames = new HashMap<>(3);
+attrNames.put("0", "sex");
+attrNames.put("1", "city");
+attrNames.put("2", "country");
+ImSetAttrNameRequest request = new ImSetAttrNameRequest(attrNames);
+
+ImSetAttrNameResult result = client.member.imSetAttrName(request);
+```
+
+## 获取应用属性名称
+
+管理员获取应用属性名称。使用前请先 [设置应用属性名称](#设置应用属性名称) 。
+
+使用示例：
+
+```java
+ImGetAttrNameRequest request = new ImGetAttrNameRequest();
+
+ImGetAttrNameResult result = client.member.imGetAttrName(request);
+```
+
+## 获取用户属性
+
+获取用户属性（必须以管理员帐号调用）；每次最多只能获取 100 个用户的属性。使用前请先 [设置应用属性名称](#设置应用属性名称) 。
+
+使用示例：
+
+```java
+List<String> toAccount = Arrays.asList("test1", "test2");
+ImGetAttrRequest request = new ImGetAttrRequest(toAccount);
+
+ImGetAttrResult result = client.member.imGetAttr(request);
+```
+
+### 设置用户属性
+
+管理员给用户设置属性。每次最多只能给 100 个用户设置属性。使用前请先 [设置应用属性名称](#设置应用属性名称) 。
+
+使用示例：
+
+```java
+Map<String, Object> attrs = new HashMap<>();
+attrs.put("sex", "attr1");
+attrs.put("city", "attr2");
+UserAttrItem item = new UserAttrItem("test1", attrs);
+ImSetAttrRequest request = new ImSetAttrRequest(Collections.singletonList(item));
+
+ImSetAttrResult result = client.member.imSetAttr(request);
+```
+
+### 删除用户属性
+
+管理员给用户删除属性。注意每次最多只能给 100 个用户删除属性。使用前请先 [设置应用属性名称](#设置应用属性名称) 。
+
+使用示例：
+
+```java
+Map<String, Object> attrs = new HashMap<>();
+attrs.put("sex", "attr1");
+attrs.put("city", "attr2");
+UserAttrItem item = UserAttrItem.builder()
+        .toAccount("test1")
+        .attrs(attrs)
+        .build();
+ImRemoveAttrRequest request = new ImRemoveAttrRequest(Collections.singletonList(item));
+
+ImRemoveAttrResult result = client.member.imRemoveAttr(request);
+```
+
+### 获取用户标签
+
+获取用户标签（必须以管理员帐号调用）。每次最多只能获取 100 个用户的标签。
+
+使用示例：
+
+```java
+ImGetTagRequest request = new ImGetTagRequest(Arrays.asList("test1", "test2"));
+
+ImGetTagResult result = client.member.imGetTag(request);
+```
+
+### 添加用户标签
+
+管理员给用户添加标签。
+
+::: tip
+
+- 每次请求最多只能给 100 个用户添加标签，请求体中单个用户添加标签数最多为 10 个。
+- 单个用户可设置最大标签数为 100 个，若用户当前标签超过 100，则添加新标签之前请先删除旧标签。
+- 单个标签最大长度为 50 字节。
+  :::
+
+使用示例：
+
+```java
+List<String> tags = Arrays.asList("a", "b");
+UserTagItem item = UserTagItem.builder()
+        .toAccount("test1")
+        .tags(tags)
+        .build();
+ImAddTagRequest request = new ImAddTagRequest(Collections.singletonList(item));
+
+ImAddTagResult result = client.member.imAddTag(request);
+```
+
+### 删除用户标签
+
+管理员给用户删除标签。注意每次最多只能给 100 个用户删除标签。
+
+使用示例：
+
+```java
+List<String> tags = Arrays.asList("a", "b");
+UserTagItem item = UserTagItem.builder()
+        .toAccount("test1")
+        .tags(tags)
+        .build();
+ImRemoveTagRequest request = new ImRemoveTagRequest(Collections.singletonList(item));
+
+ImRemoveTagResult result = client.member.imRemoveTag(request);
+```
+
+### 删除所有用户标签
+
+管理员给用户删除所有标签。注意每次最多只能给 100 个用户删除所有标签。
+
+使用示例：
+
+```java
+List<String> toAccount = Arrays.asList("test1", "test2");
+ImRemoveAllTagsRequest request = new ImRemoveAllTagsRequest(toAccount);
+
+ImRemoveAllTagsResult result = client.member.imRemoveAllTags(request);
+```

docs/guide/message.md

+# 单聊消息
+
+## 单发单聊消息
+
+- 管理员向帐号发消息，接收方看到消息发送者是管理员。
+- 管理员指定某一帐号向其他帐号发消息，接收方看到发送者不是管理员，而是管理员指定的帐号。
+- 该接口不会检查发送者和接收者的好友关系（包括黑名单），同时不会检查接收者是否被禁言。
+- 该接口默认不会检查接收者对发送者是否设置了免打扰，如需检查，请在"SendMsgControl"字段填上"WithMuteNotifications"。
+- 单聊消息 MsgSeq 字段的作用及说明：该字段在发送消息时由用户自行指定，该值可以重复，非后台生成，非全局唯一。与群聊消息的 MsgSeq 字段不同，群聊消息的 MsgSeq 由后台生成，每个群都维护一个 MsgSeq，从 1 开始严格递增。单聊消息历史记录对同一个会话的消息先以时间戳排序，同秒内的消息再以 MsgSeq 排序。
+
+使用示例：
+
+```java
+TIMTextMsgElement msg = new TIMTextMsgElement("hello world");
+List<TIMMsgElement> msgBody = Collections.singletonList(msg);
+SendMsgRequest request = SendMsgRequest.builder()
+        .fromAccount("test1")
+        .toAccount("test2")
+        .msgRandom(123)
+        .msgBody(msgBody)
+        .syncOtherMachine(SyncOtherMachine.YES)
+        .msgTimeStamp(1631934058)
+        .msgLifeTime(604800)
+        .build();
+
+SendMsgResult result = client.message.sendMsg(request);
+```
+
+## 批量发单聊消息
+
+- 支持一次对最多 500 个用户进行单发消息。
+- 与单发消息相比，该接口更适用于营销类消息、系统通知 tips 等时效性较强的消息。
+- 若消息不需要计入未读数，也不需要存储聊天记录，则可将 MsgLifeTime 字段设置为 0，这样可以带来更快的消息下发速度。
+- 管理员指定某一帐号向目标帐号批量发消息，接收方看到发送者不是管理员，而是管理员指定的帐号。
+- 该接口不触发回调请求。
+- 该接口不会检查发送者和接收者的好友关系（包括黑名单），同时不会检查接收者是否被禁言。
+- 该接口默认不会检查接收者对发送者是否设置了免打扰，如需检查，请在"SendMsgControl"字段填上"WithMuteNotifications"。
+- 单聊消息 MsgSeq 字段的作用及说明：该字段在发送消息时由用户自行指定，该值可以重复，非后台生成，非全局唯一。与群聊消息的 MsgSeq 字段不同，群聊消息的 MsgSeq 由后台生成，每个群都维护一个 MsgSeq，从 1 开始严格递增。单聊消息历史记录对同一个会话的消息先以时间戳排序，同秒内的消息再以 MsgSeq 排序。
+
+使用示例：
+
+```java
+List<String> toAccount = Arrays.asList("test1", "test2");
+TIMTextMsgElement msg = new TIMTextMsgElement("hi bingo");
+List<TIMMsgElement> msgBody = Collections.singletonList(msg);
+BatchSendMsgRequest request = BatchSendMsgRequest
+        .builder()
+        .toAccount(toAccount)
+        .msgRandom(123)
+        .msgBody(msgBody)
+        .syncOtherMachine(SyncOtherMachine.NO)
+        .msgSeq(28460)
+        .build();
+
+BatchSendMsgResult result = client.message.batchSendMsg(request);
+```
+
+## 导入单聊消息
+
+- 导入历史单聊消息到即时通信 IM。
+- 平滑过渡期间，将原有即时通信实时单聊消息导入到即时通信 IM。
+- 该接口会更新会话。
+- 该接口不会触发回调。
+- 对于同一个单聊会话的消息，该接口会根据 MsgSeq ， MsgRandom ， MsgTimeStamp 字段的值对导入的消息进行去重。**仅当这三个字段的值都对应相同时，才判定消息是重复的，消息是否重复与消息内容本身无关。** 另外，若两条消息的 MsgSeq ， MsgRandom ， MsgTimeStamp 字段对应相同，而 from_account 和 to_account 相反，则这两条消息也认为是重复的。
+- 重复导入的消息不会覆盖之前已导入的消息（即消息内容以首次导入的为准）。
+- 单聊消息 MsgSeq 字段的作用及说明：该字段在发送消息时由用户自行指定，该值可以重复，非后台生成，非全局唯一。与群聊消息的 MsgSeq 字段不同，群聊消息的 MsgSeq 由后台生成，每个群都维护一个 MsgSeq，从 1 开始严格递增。单聊消息历史记录对同一个会话的消息先以时间戳排序，同秒内的消息再以 MsgSeq 排序。
+
+使用示例：
+
+```java
+TIMTextMsgElement msg = new TIMTextMsgElement("hello bingo");
+List<TIMMsgElement> msgBody = Collections.singletonList(msg);
+ImportMsgRequest request = ImportMsgRequest.builder()
+        .fromAccount("bingo")
+        .toAccount("test1")
+        .msgRandom(122)
+        .msgTimeStamp(1557387418)
+        .msgBody(msgBody)
+        .build();
+
+ImportMsgResult result = client.message.importMsg(request);
+```
+
+## 查询单聊消息
+
+- 管理员按照时间范围查询某单聊会话的消息记录。
+- 查询的单聊会话由请求中的 From_Account 和 To_Account 指定。查询结果包含会话双方互相发送的消息，具体每条消息的发送方和接收方由每条消息里的 From_Account 和 To_Account 指定。
+- 一般情况下，请求中的 From_Account 和 To_Account 字段值互换，查询结果不变。但通过 [单发单聊消息](#单发单聊消息) 或 [批量发单聊消息](#批量发单聊消息) 接口发送的消息，如果指定 SyncOtherMachine 值为 2，则需要指定正确的 From_Account 和 To_Account 字段值才能查询到该消息。
+  例如，通过 [单发单聊消息](#单发单聊消息) 接口指定帐号 A 给帐号 B 发一条消息，同时指定 SyncOtherMachine 值为 2。则调用本接口时，From_Account 必须设置为帐号 B，To_Account 必须设置为帐号 A 才能查询到该消息。
+- 查询结果包含被撤回的消息，由消息里的 MsgFlagBits 字段标识。
+- 若想通过 [撤回单聊消息](#撤回单聊消息) 接口撤回某条消息，可先用本接口查询出该消息的 MsgKey，然后再调用撤回接口进行撤回。
+- 可查询的消息记录的时间范围取决于漫游消息存储时长，默认是 7 天。支持在控制台修改消息漫游时长，延长消息漫游时长是增值服务。具体请参考 [漫游消息存储](https://cloud.tencent.com/document/product/269/3571#.E6.BC.AB.E6.B8.B8.E6.B6.88.E6.81.AF.E5.AD.98.E5.82.A8)。
+- 若请求时间段内的消息总大小超过应答包体大小限制（目前为 13K）时，则需要续拉。您可以通过应答中的 Complete 字段查看是否已拉取请求的全部消息。
+
+使用示例：
+
+```java
+AdminGetRoamMsgRequest request = AdminGetRoamMsgRequest.builder()
+        .fromAccount("test1")
+        .toAccount("test2")
+        .maxCnt(123)
+        .minTime(1631934000)
+        .maxTime(1631934060)
+        .build();
+
+AdminRoamMsgResult result = client.message.getRoamMsg(request);
+```
+
+## 撤回单聊消息
+
+- 管理员撤回单聊消息。
+- 该接口可以撤回所有单聊消息，包括客户端发出的单聊消息，由 [单发](#单发单聊消息) 和 [批量发](#批量发单聊消息) 接口发出的单聊消息。
+- 若需要撤回由客户端发出的单聊消息，您可以开通 [发单聊消息之前回调](https://cloud.tencent.com/document/product/269/38980) 或 [发单聊消息之后回调](https://cloud.tencent.com/document/product/269/38980) ，通过该回调接口记录每条单聊消息的 MsgKey ，然后填在本接口的 MsgKey 字段进行撤回。您也可以通过 [查询单聊消息](#查询单聊消息) 查询出待撤回的单聊消息的 MsgKey 后，填在本接口的 MsgKey 字段进行撤回。
+- 若需要撤回由 [单发](#单发单聊消息) 和 [批量发](#批量发单聊消息) 接口发出的单聊消息，需要记录这些接口回包里的 MsgKey 字段以进行撤回。
+- 调用该接口撤回消息后，该条消息的离线、漫游存储，以及消息发送方和接收方的客户端的本地缓存都会被撤回。
+- 该接口可撤回的单聊消息没有时间限制，即可以撤回任何时间的单聊消息。
+
+::: tip
+
+- 使用该接口撤回单聊消息后，被撤回的消息不能恢复，请谨慎调用该接口。
+  :::
+
+使用示例：
+
+```java
+AdminMsgWithdrawRequest request = AdminMsgWithdrawRequest.builder()
+        .fromAccount("test1")
+        .toAccount("bingo")
+        .msgKey("31906_833502_1572869830")
+        .build();
+
+AdminMsgWithdrawResult result = client.message.msgWithdraw(request);
+```
+
+## 设置单聊消息已读
+
+- 设置用户的某个单聊会话的消息已读。
+
+使用示例：
+
+```java
+AdminSetMsgReadRequest request = AdminSetMsgReadRequest.builder()
+        .reportAccount("test1")
+        .peerAccount("test2")
+        .build();
+        
+AdminSetMsgReadResult result = client.message.setMsgRead(request);
+```
+
+## 查询单聊未读消息计数
+
+App 后台可以通过该接口查询特定账号的单聊总未读数（包含所有的单聊会话）或者单个单聊会话的未读数。
+
+使用示例：
+
+```java
+GetC2cUnreadMsgRequest request = new GetC2cUnreadMsgRequest("test2");
+request.setPeerAccount(Arrays.asList("test1", "bingo"));
+
+C2cUnreadMsgNumResult result = client.message.getC2cUnreadMsgNum(request);
+```

docs/guide/operation_1.md

+# 全局禁言管理
+
+## 设置全局禁言
+
+- 设置帐号的单聊消息全局禁言。
+- 设置帐号的群组消息全局禁言。
+
+使用示例：
+
+```java
+SetNoSpeakingRequest request = SetNoSpeakingRequest.builder()
+        .setAccount("test1")
+        .msgNoSpeakingTime(NoSpeakingTime.NEVER)
+        .groupMsgNoSpeakingTime(NoSpeakingTime.FOREVER)
+        .build();
+        
+SetNoSpeakingResult result = client.operation.setNoSpeaking(request);
+```
+
+## 查询全局禁言
+
+- 查询帐号的单聊消息全局禁言。
+- 查询帐号的群组消息全局禁言。
+
+使用示例：
+
+```java
+GetNoSpeakingRequest request = new GetNoSpeakingRequest("test1");
+
+GetNoSpeakingResult result = client.operation.getNoSpeaking(request);
+```

docs/guide/operation_2.md

+# 运营管理
+
+## 拉取运营数据
+
+App 管理员可以通过该接口拉取最近 30 天的运营数据，可拉取的字段见下文可拉取的运营字段。
+
+使用示例：
+
+```java
+GetAppInfoRequest request = new GetAppInfoRequest();
+request.setRequestField(Arrays.asList("ChainIncrease", "ChainDecrease"));
+
+GetAppInfoResult result = client.operation.getAppInfo(request);
+```
+
+## 下载最近消息记录
+
+App 管理员可以通过该接口获取 App 中最近 7 天中某天某小时的所有单发或群组消息记录的下载地址。
+
+::: tip
+
+- 下载消息记录里的图片、语音、文件和短视频，此功能仅适用于 4.X 版本 IM SDK，可通过聊天记录中的 URL 字段进行下载。如您使用 2.X 或 3.X 版本的 IM SDK，您将无法通过该方法获取到以上信息，如您需要此功能，请您升级至 4.X 版本。
+- 消息记录以日志文件形式保存并使用 GZip 压缩，通过该接口获取到下载地址后，请自行下载并处理；消息记录文件每小时产生一次，例如 0 点（00:00~00:59）的数据在 01:00 后开始处理，一般 1 小时内处理完毕（消息较多则处理时间较长）；文件有效期 7 天，无论是否下载过，都会在 7 天后删除，被删除后不支持重新导出；获取到的下载地址存在有效期，请在过期前进行下载，若地址失效，请通过该接口重新获取。
+- 此接口仅用于下载最近 7 天的聊天记录文件，用于备份或数据统计等。不建议使用该接口用于线上实时业务。
+  :::
+
+使用示例：
+
+```java
+GetHistoryRequest request = GetHistoryRequest.builder()
+        .chatType(ChatType.C2C)
+        .msgTime("2015120121")
+        .build();
+        
+GetHistoryResult result = client.operation.getHistory(request);
+```
+
+## 获取服务器 IP 地址
+
+基于安全等考虑，您可能需要获知服务器的 IP 地址列表，以便进行相关限制。App 管理员可以通过该接口获得 SDK、第三方回调所使用到的服务器 IP 地址列表或 IP 网段信息。
+
+::: tip
+此接口仅支持获取中国大陆地区的所有 IM 接入方式的 IP 地址或 IP 网段信息。
+:::
+
+使用示例：
+
+```java
+GetIpListRequest request = new GetIpListRequest();
+
+GetIpListResult result = client.op~eration.getIpList(request);
+```

docs/guide/profile.md

+# 资料管理
+
+## 设置资料
+
+支持 [标配资料字段](https://cloud.tencent.com/document/product/269/1500#.E6.A0.87.E9.85.8D.E8.B5.84.E6.96.99.E5.AD.97.E6.AE.B5) 和 [自定义资料字段](https://cloud.tencent.com/document/product/269/1500#.E8.87.AA.E5.AE.9A.E4.B9.89.E8.B5.84.E6.96.99.E5.AD.97.E6.AE.B5) 的设置。
+
+使用示例：
+
+```java
+ProfileItem profileItem = ProfileItem.builder()
+        .tag("Tag_Profile_IM_Nick")
+        .value("MyNickName")
+        .build();
+PortraitSetRequest request = new PortraitSetRequest("doocs", Collections.singletonList(profileItem));
+
+PortraitSetResult result = client.profile.portraitSet(request);
+```
+
+## 拉取资料
+
+- 支持拉取好友和非好友的资料字段。
+- 支持拉取 [标配资料字段](https://cloud.tencent.com/document/product/269/1500#.E6.A0.87.E9.85.8D.E8.B5.84.E6.96.99.E5.AD.97.E6.AE.B5) 和 [自定义资料字段](https://cloud.tencent.com/document/product/269/1500#.E8.87.AA.E5.AE.9A.E4.B9.89.E8.B5.84.E6.96.99.E5.AD.97.E6.AE.B5)。
+- 建议每次拉取的用户数不超过 100，避免因回包数据量太大导致回包失败。
+- 请确保请求中的所有帐号都已导入即时通信 IM，如果请求中含有未导入即时通信 IM 的帐号，即时通信 IM 后台将会提示错误。
+
+使用示例：
+
+```java
+List<String> tagList = Collections.singletonList("Tag_Profile_IM_Nick");
+PortraitGetRequest request = new PortraitGetRequest(Collections.singletonList("doocs"), tagList);
+
+PortraitGetResult result = client.profile.portraitGet(request);
+```

docs/guide/quickstart.md

+# 快速上手
+
+## 安装
+
+### Maven
+
+在项目的 `pom.xml` 的 dependencies 中加入以下内容:
+
+```xml
+<dependency>
+  <groupId>io.github.doocs</groupId>
+  <artifactId>im-server-sdk-java</artifactId>
+  <version>0.2.3</version>
+</dependency>
+```
+
+### Gradle
+
+```gradle
+implementation group: 'io.github.doocs', name: 'im-server-sdk-java', version: '0.2.3'
+```
+
+### 下载 jar
+
+[Maven 中央仓库](https://repo1.maven.org/maven2/io/github/doocs/im-server-sdk-java/)
+
+## 初始化
+
+在使用腾讯云即时 IM 服务端 API 之前， 需要初始化 `ImClient` 实例:
+
+```java
+// sdk appId
+long appId = 1400554812;
+
+// admin userId
+String identifier = "test";
+
+// application key
+String key = "60c6c5925f3ae52c7325ac5a8ec78e44c056d1dd84d54e12ffa39911267a2a70";
+
+// create a default ImClient instance
+ImClient client = ImClient.getInstance(appId, identifier, key);
+
+// create a custom ImClient instance
+ClientConfiguration config = new ClientConfiguration();
+ImClient client = ImClient.getInstance(appId, identifier, key, config);
+```
+
+`ClientConfiguration` 支持可配置参数如下：
+
+| 字段           | 类型    | 说明                         | 默认值 |
+| -------------- | ------- | ---------------------------- | ------ |
+| maxRetries     | Integer | HTTP 最大重试次数            | 3      |
+| connectTimeout | Long    | HTTP 连接超时（毫秒）        | 3000   |
+| readTimeout    | Long    | HTTP 读超时（毫秒）          | 3000   |
+| writeTimeout   | Long    | HTTP 写超时（毫秒）          | 3000   |
+| expireTime     | Long    | UserSig 签名失效时间（毫秒） | 86400  |
+| userAgent      | String  | User-Agent                   |        |
+
+## 使用示例
+
+初始化 `ImClient` 实例后， 以使用 [帐号管理-导入单个帐号](./account.md#导入单个帐号) 为例：
+
+```java
+AccountImportRequest request = AccountImportRequest.builder()
+<<<<<<< Updated upstream
+        .identifier("admin")
+        .faceUrl("https://avatars.githubusercontent.com/u/43716716?s=200&v=4")
+        .nick("doocs")
+        .build();
+        
+=======
+    .identifier("admin")
+    .faceUrl("https://avatars.githubusercontent.com/u/43716716?s=200&v=4")
+    .nick("doocs")
+    .build();
+
+>>>>>>> Stashed changes
+AccountImportResult result = client.account.accountImport(request);
+```

docs/guide/recent_contact.md

+# 最近联系人
+
+## 拉取会话列表
+
+支持分页拉取会话列表。
+
+使用示例：
+
+```java
+GetRecentContactListRequest request = GetRecentContactListRequest.builder()
+        .fromAccount("doocs")
+        .timestamp(0)
+        .startIndex(0)
+        .topTimestamp(0)
+        .topStartIndex(0)
+        .assistFlags(AssistFlags.BIT_0)
+        .build();
+
+GetRecentContactListResult result = client.recentContact.recentContactList(request);
+```
+
+## 删除单个会话
+
+删除指定会话，支持同步清理漫游消息。
+
+使用示例：
+
+```java
+DeleteRecentContactRequest request = DeleteRecentContactRequest.builder()
+        .fromAccount("doocs_1")
+        .type(RecentContactType.C2C)
+        .toAccount("doocs_2")
+        .clearRamble(ClearRamble.YES)
+        .build();
+
+DeleteRecentContactResult result = client.recentContact.deleteRecentContact(request);
+```

docs/guide/sns.md

+# 关系链管理
+
+## 添加好友
+
+添加好友，支持批量添加好友。
+
+使用示例：
+
+```java
+AddFriendItem addFriendItem = AddFriendItem.builder()
+        .toAccount("test2")
+        .addSource("AddSource_Type_XXXXXXXX")
+        .remark("Mr.A")
+        .groupName("schoolmate")
+        .addWording("Hi")
+        .build();
+List<AddFriendItem> addFriendItemList = Collections.singletonList(addFriendItem);
+FriendAddRequest request = FriendAddRequest.builder()
+        .fromAccount("test1")
+        .addFriendItemList(addFriendItemList)
+        .addType(AddType.BOTH)
+        .forceAddFlags(ForceAddFlags.FORCE)
+        .build();
+
+FriendAddResult result = client.sns.friendAdd(request);
+```
+
+## 导入好友
+
+- 支持批量导入单向好友。
+- 往同一个用户导入好友时建议采用批量导入的方式，避免并发写导致的写冲突。
+
+使用示例：
+
+```java
+ImportFriendItem importFriendItem = ImportFriendItem.builder()
+        .toAccount("test2")
+        .addSource("AddSource_Type_XXXXXXXX")
+        .build();
+List<ImportFriendItem> importFriendItems = Collections.singletonList(importFriendItem);
+FriendImportRequest request = FriendImportRequest.builder()
+        .fromAccount("test1")
+        .importFriendItemList(importFriendItems)
+        .build();
+
+FriendImportResult result = client.sns.friendImport(request);
+```
+
+## 更新好友
+
+- 支持批量更新同一用户的多个好友的关系链数据。
+- 更新一个用户多个好友时，建议采用批量方式，避免并发写导致的写冲突。
+
+使用示例：
+
+```java
+SnsItem snsItem = SnsItem.builder()
+        .tag("Tag_SNS_Custom_testTag")
+        .value("Tag_SNS_IM_AddWording")
+        .build();
+List<SnsItem> snsItems = Collections.singletonList(snsItem);
+UpdateItem updateItem = UpdateItem.builder()
+        .toAccount("test2")
+        .snsItemList(snsItems)
+        .build();
+List<UpdateItem> updateItems = Collections.singletonList(updateItem);
+FriendUpdateRequest request = FriendUpdateRequest.builder()
+        .fromAccount("test1")
+        .updateItemList(updateItems)
+        .build();
+
+FriendUpdateResult result = client.sns.friendUpdate(request);
+```
+
+## 删除好友
+
+删除好友，支持单向删除好友和双向删除好友。
+
+使用示例：
+
+```java
+List<String> toAccount = Collections.singletonList("test2");
+FriendDeleteRequest request = FriendDeleteRequest.builder()
+        .deleteType(DeleteType.BOTH)
+        .fromAccount("test1")
+        .toAccount(toAccount)
+        .build();
+
+FriendDeleteResult result = client.sns.friendDelete(request);
+```
+
+## 删除所有好友
+
+清除指定用户的标配好友数据和自定义好友数据。
+
+使用示例：
+
+```java
+FriendDeleteAllRequest request = FriendDeleteAllRequest.builder()
+        .deleteType(DeleteType.BOTH)
+        .fromAccount("test1")
+        .build();
+
+FriendDeleteAllResult result = client.sns.friendDeleteAll(request);
+```
+
+## 校验好友
+
+支持批量校验好友关系。
+
+使用示例：
+
+```java
+List<String> toAccount = Collections.singletonList("test2");
+FriendCheckRequest request = FriendCheckRequest.builder()
+        .fromAccount("test1")
+        .toAccount(toAccount)
+        .checkType(CheckResultType.BOTH)
+        .build();
+
+FriendCheckResult result = client.sns.friendCheck(request);
+```
+
+## 拉取好友
+
+- 分页拉取全量好友数据。
+- 不支持资料数据的拉取。
+- 不需要指定请求拉取的字段，默认返回全量的标配好友数据和自定义好友数据。
+
+使用示例：
+
+```java
+FriendGetRequest request = FriendGetRequest.builder()
+        .fromAccount("test1")
+        .startIndex(0)
+        .standardSequence(0)
+        .customSequence(0)
+        .build();
+
+FriendGetResult result = client.sns.friendGet(request);
+```
+
+## 拉取指定好友
+
+- 支持拉取指定好友的好友数据和资料数据。
+- 建议每次拉取的好友数不超过 100，避免因数据量太大导致回包失败。
+
+使用示例：
+
+```java
+List<String> toAccount = Collections.singletonList("test2");
+List<String> tagList = Arrays.asList(TagProfile.IM_ADMIN_FORBID_TYPE, TagProfile.IM_ALLOW_TYPE);
+FriendGetListRequest request = FriendGetListRequest.builder()
+        .fromAccount("test1")
+        .toAccount(toAccount)
+        .tagList(tagList)
+        .build();
+
+FriendGetListResult result = client.sns.friendGetList(request);
+```
+
+## 添加黑名单
+
+添加黑名单，支持批量添加黑名单。
+
+::: tip
+
+- 如果用户 A 与用户 B 之间存在好友关系，拉黑时会解除双向好友关系。
+- 如果用户 A 与用户 B 之间存在黑名单关系，二者之间无法发起加好友请求。
+- 如果用户 A 的黑名单中有用户 B 且用户 B 的黑名单中有用户 A，二者之间无法发起会话。
+- 如果用户 A 的黑名单中有用户 B 但用户 B 的黑名单中没有用户 A，那么用户 A 可以给用户 B 发消息，用户 B 不能给用户 A 发消息。
+  :::
+
+使用示例：
+
+```java
+List<String> toAccount = Collections.singletonList("test2");
+BlackListAddRequest request = BlackListAddRequest.builder()
+        .fromAccount("test1")
+        .toAccount(toAccount)
+        .build();
+
+BlackListAddResult result = client.sns.blackListAdd(request);
+```
+
+## 删除黑名单
+
+删除指定黑名单。
+
+使用示例：
+
+```java
+List<String> toAccount = Collections.singletonList("test2");
+BlackListDeleteRequest request = BlackListDeleteRequest.builder()
+        .fromAccount("test1")
+        .toAccount(toAccount)
+        .build();
+
+BlackListDeleteResult result = client.sns.blackListDelete(request);
+```
+
+## 拉取黑名单
+
+支持分页拉取所有黑名单。
+
+使用示例：
+
+```java
+BlackListGetRequest request = BlackListGetRequest.builder()
+        .fromAccount("test1")
+        .startIndex(0)
+        .maxLimited(10)
+        .lastSequence(0)
+        .build();
+
+BlackListGetResult result = client.sns.blackListGet(request);
+```
+
+## 校验黑名单
+
+支持批量校验黑名单。
+
+使用示例：
+
+```java
+List<String> toAccount = Collections.singletonList("test2");
+BlackListCheckRequest request = BlackListCheckRequest.builder()
+        .fromAccount("test1")
+        .toAccount(toAccount)
+        .checkType(BlackCheckResultType.BOTH)
+        .build();
+
+BlackListCheckResult result = client.sns.blackListCheck(request);
+```
+
+## 添加分组
+
+添加分组，支持批量添加分组，并将指定好友加入到新增分组中。
+
+使用示例：
+
+```java
+List<String> groupName = Collections.singletonList("classmate");
+List<String> toAccount = Collections.singletonList("test2");
+GroupAddRequest request = GroupAddRequest.builder()
+        .fromAccount("test1")
+        .groupName(groupName)
+        .toAccount(toAccount)
+        .build();
+
+GroupAddResult result = client.sns.groupAdd(request);
+```
+
+## 删除分组
+
+删除指定分组。
+
+使用示例：
+
+```java
+List<String> groupName = Collections.singletonList("classmate");
+GroupDeleteRequest request = GroupDeleteRequest.builder()
+        .fromAccount("test1")
+        .groupName(groupName)
+        .build();
+
+GroupDeleteResult result = client.sns.groupDelete(request);
+```
+
+## 拉取分组
+
+拉取分组，支持指定分组以及拉取分组下的好友列表。
+
+使用示例：
+
+```java
+List<String> groupName = Collections.singletonList("schoolmate");
+GroupGetRequest request = GroupGetRequest.builder()
+        .fromAccount("test1")
+        .lastSequence(0)
+        .groupName(groupName)
+        .needFriend(NeedFriendType.YES)
+        .build();
+        
+GroupGetResult result = client.sns.groupGet(request);
+```

src/main/java/io/github/doocs/im/model/group/GroupInfo.java

@@ -2,6 +2,9 @@ package io.github.doocs.im.model.group;
 
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.annotation.JsonProperty;
+import io.github.doocs.im.constant.ApplyJoinOption;
+import io.github.doocs.im.constant.GroupType;
+import io.github.doocs.im.model.request.CreateGroupRequest;
 
 import java.util.List;
 
@@ -68,7 +71,7 @@ public class GroupInfo {
         this.appMemberDefinedData = appMemberDefinedData;
     }
 
-    private GroupInfo(Builder builder) {
+    protected GroupInfo(Builder builder) {
         this.ownerAccount = builder.ownerAccount;
         this.type = builder.type;
         this.groupId = builder.groupId;
@@ -202,7 +205,22 @@ public class GroupInfo {
                 '}';
     }
 
-    public static final class Builder {
+    public static void main(String[] args) {
+        CreateGroupRequest request = (CreateGroupRequest) CreateGroupRequest.builder()
+                .type(GroupType.PUBLIC)
+                .name("TestGroup")
+                .ownerAccount("doocs")
+                .groupId("MyFirstGroup")
+                .introduction("This is group Introduction")
+                .notification("This is group Notification")
+                .faceUrl("https://avatars.githubusercontent.com/u/43716716?s=200&v=4")
+                .maxMemberCount(500)
+                .applyJoinOption(ApplyJoinOption.FREE_ACCESS)
+                .build();
+        System.out.println(request.getClass());
+    }
+
+    public static class Builder {
         private String ownerAccount;
         private String type;
         private String groupId;
@@ -216,7 +234,7 @@ public class GroupInfo {
         private List<MemberProfile> memberList;
         private List<AppMemberDefinedDataItem> appMemberDefinedData;
 
-        private Builder() {
+        protected Builder() {
         }
 
         public GroupInfo build() {

src/main/java/io/github/doocs/im/model/request/CreateGroupRequest.java

@@ -9,5 +9,18 @@ import io.github.doocs.im.model.group.GroupInfo;
  */
 @JsonInclude(JsonInclude.Include.NON_NULL)
 public class CreateGroupRequest extends GroupInfo {
+    public static Builder builder() {
+        return new Builder();
+    }
 
+    public CreateGroupRequest(Builder builder) {
+        super(builder);
+    }
+
+    public static class Builder extends GroupInfo.Builder {
+        @Override
+        public CreateGroupRequest build() {
+            return new CreateGroupRequest(this);
+        }
+    }
 }

src/main/java/io/github/doocs/im/model/response/UserAttrItem.java

@@ -25,6 +25,15 @@ public class UserAttrItem {
         this.attrs = attrs;
     }
 
+    private UserAttrItem(Builder builder) {
+        this.toAccount = builder.toAccount;
+        this.attrs = builder.attrs;
+    }
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
     public String getToAccount() {
         return toAccount;
     }
@@ -41,6 +50,29 @@ public class UserAttrItem {
         this.attrs = attrs;
     }
 
+
+    public static final class Builder {
+        private String toAccount;
+        private Map<String, Object> attrs;
+
+        private Builder() {
+        }
+
+        public UserAttrItem build() {
+            return new UserAttrItem(this);
+        }
+
+        public Builder toAccount(String toAccount) {
+            this.toAccount = toAccount;
+            return this;
+        }
+
+        public Builder attrs(Map<String, Object> attrs) {
+            this.attrs = attrs;
+            return this;
+        }
+    }
+
     @Override
     public String toString() {
         return "UserAttrItem{" +

src/main/java/io/github/doocs/im/model/response/UserTagItem.java

@@ -25,6 +25,15 @@ public class UserTagItem {
         this.tags = tags;
     }
 
+    private UserTagItem(Builder builder) {
+        this.toAccount = builder.toAccount;
+        this.tags = builder.tags;
+    }
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
     public String getToAccount() {
         return toAccount;
     }
@@ -41,6 +50,28 @@ public class UserTagItem {
         this.tags = tags;
     }
 
+    public static final class Builder {
+        private String toAccount;
+        private List<String> tags;
+
+        private Builder() {
+        }
+
+        public UserTagItem build() {
+            return new UserTagItem(this);
+        }
+
+        public Builder toAccount(String toAccount) {
+            this.toAccount = toAccount;
+            return this;
+        }
+
+        public Builder tags(List<String> tags) {
+            this.tags = tags;
+            return this;
+        }
+    }
+
     @Override
     public String toString() {
         return "UserTagItem{" +

src/test/java/io/github/doocs/im/AccountTest.java

@@ -60,7 +60,7 @@ public class AccountTest {
     public void testAccountDelete() throws IOException {
         AccountDeleteItem item1 = AccountDeleteItem.builder().userId("acbin").build();
         AccountDeleteItem item2 = AccountDeleteItem.builder().userId("test1").build();
-        AccountDeleteRequest request = AccountDeleteRequest.builder().deleteItemList(Arrays.asList(item1, item2)).build();
+        AccountDeleteRequest request = AccountDeleteRequest.builder().deleteItemList(Collections.singletonList(item1)).build();
         AccountDeleteResult result = client.account.accountDelete(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -86,9 +86,11 @@ public class AccountTest {
 
     @Test
     public void testQueryState() throws IOException {
-        List<String> toAccount = Collections.singletonList("bingo");
-        QueryOnlineStatusRequest request = new QueryOnlineStatusRequest(toAccount);
-        request.setIsNeedDetail(IsNeedDetail.YES);
+        List<String> toAccount = Arrays.asList("doocs_1", "doocs_2");
+        QueryOnlineStatusRequest request = QueryOnlineStatusRequest.builder()
+                .toAccount(toAccount)
+                .isNeedDetail(IsNeedDetail.YES)
+                .build();
         QueryOnlineStatusResult result = client.account.queryOnlineStatus(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());

src/test/java/io/github/doocs/im/GroupTest.java

@@ -4,6 +4,7 @@ import io.github.doocs.im.constant.ApplyJoinOption;
 import io.github.doocs.im.constant.GroupType;
 import io.github.doocs.im.constant.MemberRole;
 import io.github.doocs.im.constant.OnlineOnlyFlag;
+import io.github.doocs.im.model.group.GroupInfo;
 import io.github.doocs.im.model.message.TIMMsgElement;
 import io.github.doocs.im.model.message.TIMTextMsgElement;
 import io.github.doocs.im.model.request.*;
@@ -40,10 +41,12 @@ public class GroupTest {
 
     @Test
     public void testGetAppIdGroupList() throws IOException {
-        GetAppidGroupListRequest request = new GetAppidGroupListRequest();
-        request.setLimit(10);
-        request.setGroupType(GroupType.PUBLIC);
-        request.setNext(0);
+        GetAppidGroupListRequest request = GetAppidGroupListRequest.builder()
+                .limit(10)
+                .groupType(GroupType.PUBLIC)
+                .next(0)
+                .build();
+
         GetAppidGroupListResult result = client.group.getAppIdGroupList(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());
@@ -51,20 +54,18 @@ public class GroupTest {
 
     @Test
     public void testCreateGroup() throws IOException {
-        CreateGroupRequest request = new CreateGroupRequest();
-        request.setType(GroupType.PUBLIC);
-        request.setName("TestGroup");
-        request.setOwnerAccount("bingo");
-        request.setGroupId("MyFirstGroup");
-        request.setIntroduction("This is group Introduction");
-        request.setNotification("This is group Notification");
-        request.setFaceUrl("http://this.is.face.url");
-        request.setMaxMemberCount(5000);
-        request.setApplyJoinOption(ApplyJoinOption.FREE_ACCESS);
-        // Map<String, Object> map = new HashMap<>();
-        // map.put("Key", "test1");
-        // map.put("Value", "test2");
-        // request.setAppDefinedData(Collections.singletonList(map));
+        CreateGroupRequest request = (CreateGroupRequest) CreateGroupRequest.builder()
+                .type(GroupType.PUBLIC)
+                .name("TestGroup")
+                .ownerAccount("doocs")
+                .groupId("MyFirstGroup")
+                .introduction("This is group Introduction")
+                .notification("This is group Notification")
+                .faceUrl("https://avatars.githubusercontent.com/u/43716716?s=200&v=4")
+                .maxMemberCount(500)
+                .applyJoinOption(ApplyJoinOption.FREE_ACCESS)
+                .build();
+
         CreateGroupResult result = client.group.createGroup(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());
@@ -80,9 +81,12 @@ public class GroupTest {
 
     @Test
     public void testGetGroupMemberInfo() throws IOException {
-        GetGroupMemberInfoRequest request = new GetGroupMemberInfoRequest("MyFirstGroup");
-        request.setLimit(100);
-        request.setOffset(0);
+        GetGroupMemberInfoRequest request = GetGroupMemberInfoRequest.builder()
+                .groupId("MyFirstGroup")
+                .limit(100)
+                .offset(0)
+                .build();
+
         GetGroupMemberInfoResult result = client.group.getGroupMemberInfo(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());
@@ -90,14 +94,16 @@ public class GroupTest {
 
     @Test
     public void testModifyGroupBaseInfo() throws IOException {
-        ModifyGroupBaseInfoRequest request = new ModifyGroupBaseInfoRequest("MyFirstGroup");
-        request.setName("groupName");
-        request.setIntroduction("my first group");
-        request.setNotification("hello group member");
-        request.setFaceUrl("http://this.is.face.url");
-        request.setMaxMemberNum(500);
-        request.setApplyJoinOption("NeedPermission");
-        request.setShutUpAllMember("Off");
+        ModifyGroupBaseInfoRequest request = ModifyGroupBaseInfoRequest.builder()
+                .groupId("MyFirstGroup")
+                .name("groupName")
+                .introduction("my first group")
+                .notification("hello world!")
+                .faceUrl("https://avatars.githubusercontent.com/u/43716716?s=200&v=4")
+                .maxMemberNum(500)
+                .applyJoinOption("NeedPermission")
+                .shutUpAllMember("Off")
+                .build();
         ModifyGroupBaseInfoResult result = client.group.modifyGroupBaseInfo(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());
@@ -105,10 +111,12 @@ public class GroupTest {
 
     @Test
     public void testAddGroupMember() throws IOException {
-        MemberRequestItem memberItem = new MemberRequestItem("test2");
-        List<MemberRequestItem> memberList = Collections.singletonList(memberItem);
-        AddGroupMemberRequest request = new AddGroupMemberRequest("MyFirstGroup", memberList);
-        request.setSilence(1);
+        List<MemberRequestItem> memberList = Collections.singletonList(new MemberRequestItem("doocs_3"));
+        AddGroupMemberRequest request = AddGroupMemberRequest.builder()
+                .groupId("MyFirstGroup")
+                .memberList(memberList)
+                .silence(1)
+                .build();
         AddGroupMemberResult result = client.group.addGroupMember(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());
@@ -116,8 +124,11 @@ public class GroupTest {
 
     @Test
     public void testDeleteGroupMember() throws IOException {
-        List<String> toDelAccount = Collections.singletonList("test2");
-        DeleteGroupMemberRequest request = new DeleteGroupMemberRequest("MyFirstGroup", toDelAccount);
+        List<String> toDelAccount = Collections.singletonList("doocs_3");
+        DeleteGroupMemberRequest request = DeleteGroupMemberRequest.builder()
+                .groupId("MyFirstGroup")
+                .memberToDelAccount(toDelAccount)
+                .build();
         DeleteGroupMemberResult result = client.group.deleteGroupMember(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());
@@ -125,8 +136,12 @@ public class GroupTest {
 
     @Test
     public void testModifyGroupMemberInfo() throws IOException {
-        ModifyGroupMemberInfoRequest request = new ModifyGroupMemberInfoRequest("MyFirstGroup", "bingo");
-        request.setNameCard("hello bingo");
+        ModifyGroupMemberInfoRequest request = ModifyGroupMemberInfoRequest.builder()
+                .groupId("MyFirstGroup")
+                .memberAccount("doocs")
+                .nameCard("hello World!")
+                .build();
+
         ModifyGroupMemberInfoResult result = client.group.modifyGroupMemberInfo(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());
@@ -150,7 +165,11 @@ public class GroupTest {
 
     @Test
     public void testGetRoleInGroup() throws IOException {
-        GetRoleInGroupRequest request = new GetRoleInGroupRequest("MyFirstGroup", Collections.singletonList("bingo"));
+        GetRoleInGroupRequest request = GetRoleInGroupRequest.builder()
+                .groupId("MyFirstGroup")
+                .userAccount(Collections.singletonList("doocs"))
+                .build();
+
         GetRoleInGroupResult result = client.group.getRoleInGroup(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());
@@ -158,8 +177,12 @@ public class GroupTest {
 
     @Test
     public void testForbidSendMsg() throws IOException {
-        List<String> membersAccount = Collections.singletonList("bingo");
-        ForbidSendMsgRequest request = new ForbidSendMsgRequest("MyFirstGroup", membersAccount, 200);
+        ForbidSendMsgRequest request = ForbidSendMsgRequest.builder()
+                .groupId("MyFirstGroup")
+                .membersAccount(Collections.singletonList("doocs"))
+                .shutUpTime(200)
+                .build();
+
         ForbidSendMsgResult result = client.group.forbidSendMsg(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());
@@ -175,9 +198,13 @@ public class GroupTest {
 
     @Test
     public void testSendGroupMsg() throws IOException {
-        TIMTextMsgElement msg = new TIMTextMsgElement("red packet");
-        SendGroupMsgRequest request = new SendGroupMsgRequest("MyFirstGroup", 1212, Collections.singletonList(msg));
-        request.setOnlineOnlyFlag(OnlineOnlyFlag.YES);
+        SendGroupMsgRequest request = SendGroupMsgRequest.builder()
+                .groupId("MyFirstGroup")
+                .random(1314)
+                .msgBody(Collections.singletonList(new TIMTextMsgElement("red packet")))
+                .onlineOnlyFlag(OnlineOnlyFlag.YES)
+                .build();
+
         SendGroupMsgResult result = client.group.sendGroupMsg(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());
@@ -185,8 +212,12 @@ public class GroupTest {
 
     @Test
     public void testSendGroupSystemNotification() throws IOException {
-        SendGroupSystemNotificationRequest request = new SendGroupSystemNotificationRequest("MyFirstGroup", "hello world");
-        request.setToMembersAccount(Collections.singletonList("bingo"));
+        SendGroupSystemNotificationRequest request = SendGroupSystemNotificationRequest.builder()
+                .groupId("MyFirstGroup")
+                .content("hello world")
+                .toMembersAccount(Collections.singletonList("doocs"))
+                .build();
+
         SendGroupSystemNotificationResult result = client.group.sendGroupSystemNotification(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());
@@ -194,7 +225,11 @@ public class GroupTest {
 
     @Test
     public void testChangeGroupOwner() throws IOException {
-        ChangeGroupOwnerRequest request = new ChangeGroupOwnerRequest("MyFirstGroup", "test1");
+        ChangeGroupOwnerRequest request = ChangeGroupOwnerRequest.builder()
+                .groupId("MyFirstGroup")
+                .newOwnerAccount("doocs")
+                .build();
+
         ChangeGroupOwnerResult result = client.group.changeGroupOwner(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());
@@ -202,8 +237,11 @@ public class GroupTest {
 
     @Test
     public void testGroupMsgRecall() throws IOException {
-        MsgSeqItem item = new MsgSeqItem(123323);
-        GroupMsgRecallRequest request = new GroupMsgRecallRequest("MyFirstGroup", Collections.singletonList(item));
+        GroupMsgRecallRequest request = GroupMsgRecallRequest.builder()
+                .groupId("MyFirstGroup")
+                .msgSeqList(Collections.singletonList(new MsgSeqItem(0)))
+                .build();
+
         GroupMsgRecallResult result = client.group.groupMsgRecall(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());
@@ -211,7 +249,11 @@ public class GroupTest {
 
     @Test
     public void testImportGroup() throws IOException {
-        ImportGroupRequest request = new ImportGroupRequest(GroupType.PUBLIC, "群名");
+        ImportGroupRequest request = ImportGroupRequest.builder()
+                .type(GroupType.PUBLIC)
+                .name("groupName")
+                .build();
+
         ImportGroupResult result = client.group.importGroup(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());
@@ -219,10 +261,16 @@ public class GroupTest {
 
     @Test
     public void testImportGroupMsg() throws IOException {
-        TIMTextMsgElement msg = new TIMTextMsgElement("hello world");
-        List<TIMMsgElement> msgBody = Collections.singletonList(msg);
-        GroupMsgItem item = new GroupMsgItem("bingo", 1628062005, msgBody);
-        ImportGroupMsgRequest request = new ImportGroupMsgRequest("newGroup", Collections.singletonList(item));
+        GroupMsgItem item = GroupMsgItem.builder()
+                .fromAccount("doocs")
+                .sendTime(1628062005)
+                .msgBody(Collections.singletonList(new TIMTextMsgElement("hello world")))
+                .build();
+        ImportGroupMsgRequest request = ImportGroupMsgRequest.builder()
+                .groupId("newGroup")
+                .msgList(Collections.singletonList(item))
+                .build();
+
         ImportGroupMsgResult result = client.group.importGroupMsg(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());
@@ -230,11 +278,16 @@ public class GroupTest {
 
     @Test
     public void testImportGroupMember() throws IOException {
-        MemberItem item = new MemberItem("test1");
-        item.setJoinTime(1628062005);
-        item.setRole(MemberRole.ADMIN);
-        item.setUnreadMsgNum(4);
-        ImportGroupMemberRequest request = new ImportGroupMemberRequest("newGroup", Collections.singletonList(item));
+        MemberItem item = MemberItem.builder().memberAccount("doocs")
+                .joinTime(1628062005)
+                .role(MemberRole.ADMIN)
+                .unreadMsgNum(1)
+                .build();
+        ImportGroupMemberRequest request = ImportGroupMemberRequest.builder()
+                .groupId("groupName")
+                .memberList(Collections.singletonList(item))
+                .build();
+
         ImportGroupMemberResult result = client.group.importGroupMember(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());
@@ -242,7 +295,12 @@ public class GroupTest {
 
     @Test
     public void testSetUnreadMsgNum() throws IOException {
-        SetUnreadMsgNumRequest request = new SetUnreadMsgNumRequest("MyFirstGroup", "test1", 1);
+        SetUnreadMsgNumRequest request = SetUnreadMsgNumRequest.builder()
+                .groupId("MyFirstGroup")
+                .memberAccount("doocs")
+                .unreadMsgNum(1)
+                .build();
+
         SetUnreadMsgNumResult result = client.group.setUnreadMsgNum(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());
@@ -250,7 +308,11 @@ public class GroupTest {
 
     @Test
     public void testDeleteGroupMsgBySender() throws IOException {
-        DeleteGroupMsgBySenderRequest request = new DeleteGroupMsgBySenderRequest("MyFirstGroup", "test1");
+        DeleteGroupMsgBySenderRequest request = DeleteGroupMsgBySenderRequest.builder()
+                .groupId("MyFirstGroup")
+                .senderAccount("doocs")
+                .build();
+
         DeleteGroupMsgBySenderResult result = client.group.deleteGroupMsgBySender(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());
@@ -258,7 +320,12 @@ public class GroupTest {
 
     @Test
     public void testGroupMsgGetSimple() throws IOException {
-        GroupMsgGetSimpleRequest request = new GroupMsgGetSimpleRequest("MyFirstGroup", 1, 20);
+        GroupMsgGetSimpleRequest request = GroupMsgGetSimpleRequest.builder()
+                .groupId("MyFirstGroup")
+                .reqMsgNumber(1)
+                .reqMsgNumber(20)
+                .build();
+
         GroupMsgGetSimpleResult result = client.group.groupMsgGetSimple(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());

src/test/java/io/github/doocs/im/MemberTest.java

@@ -36,9 +36,12 @@ public class MemberTest {
     public void testImPush() throws IOException {
         TIMTextMsgElement msg = new TIMTextMsgElement("hi, beauty");
         List<TIMMsgElement> msgBody = Collections.singletonList(msg);
-        ImPushRequest request = new ImPushRequest(9312457, msgBody);
-        request.setFromAccount("admin");
-        request.setMsgLifeTime(120);
+        ImPushRequest request = ImPushRequest.builder()
+                .msgRandom(9312457)
+                .msgBody(msgBody)
+                .fromAccount("admin")
+                .msgLifeTime(120)
+                .build();
         ImPushResult result = client.member.imPush(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -90,7 +93,10 @@ public class MemberTest {
         Map<String, Object> attrs = new HashMap<>();
         attrs.put("sex", "attr1");
         attrs.put("city", "attr2");
-        UserAttrItem item = new UserAttrItem("test1", attrs);
+        UserAttrItem item = UserAttrItem.builder()
+                .toAccount("test1")
+                .attrs(attrs)
+                .build();
         ImRemoveAttrRequest request = new ImRemoveAttrRequest(Collections.singletonList(item));
         ImRemoveAttrResult result = client.member.imRemoveAttr(request);
         System.out.println(result);
@@ -107,7 +113,11 @@ public class MemberTest {
 
     @Test
     public void testImAddTag() throws IOException {
-        UserTagItem item = new UserTagItem("test1", Arrays.asList("a", "b"));
+        List<String> tags = Arrays.asList("a", "b");
+        UserTagItem item = UserTagItem.builder()
+                .toAccount("test1")
+                .tags(tags)
+                .build();
         ImAddTagRequest request = new ImAddTagRequest(Collections.singletonList(item));
         ImAddTagResult result = client.member.imAddTag(request);
         System.out.println(result);
@@ -116,7 +126,11 @@ public class MemberTest {
 
     @Test
     public void testImRemoveTag() throws IOException {
-        UserTagItem item = new UserTagItem("test1", Arrays.asList("a", "b"));
+        List<String> tags = Arrays.asList("a", "b");
+        UserTagItem item = UserTagItem.builder()
+                .toAccount("test1")
+                .tags(tags)
+                .build();
         ImRemoveTagRequest request = new ImRemoveTagRequest(Collections.singletonList(item));
         ImRemoveTagResult result = client.member.imRemoveTag(request);
         System.out.println(result);
@@ -125,7 +139,8 @@ public class MemberTest {
 
     @Test
     public void testImRemoveAllTags() throws IOException {
-        ImRemoveAllTagsRequest request = new ImRemoveAllTagsRequest(Arrays.asList("test1", "test2"));
+        List<String> toAccount = Arrays.asList("test1", "test2");
+        ImRemoveAllTagsRequest request = new ImRemoveAllTagsRequest(toAccount);
         ImRemoveAllTagsResult result = client.member.imRemoveAllTags(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());

src/test/java/io/github/doocs/im/MessageTest.java

@@ -37,12 +37,18 @@ public class MessageTest {
 
     @Test
     public void testSendMsg() throws IOException {
-        TIMMsgElement msg = new TIMTextMsgElement("hello world");
-        SendMsgRequest request = new SendMsgRequest("test2", 123, Collections.singletonList(msg));
-        request.setFromAccount("test1");
-        request.setSyncOtherMachine(SyncOtherMachine.YES);
-        request.setMsgTimeStamp(1631934058);
-        request.setMsgLifeTime(604800);
+        TIMTextMsgElement msg = new TIMTextMsgElement("hello world");
+        List<TIMMsgElement> msgBody = Collections.singletonList(msg);
+        SendMsgRequest request = SendMsgRequest.builder()
+                .fromAccount("test1")
+                .toAccount("test2")
+                .msgRandom(123)
+                .msgBody(msgBody)
+                .syncOtherMachine(SyncOtherMachine.YES)
+                .msgTimeStamp(1631934058)
+                .msgLifeTime(604800)
+                .build();
+      
         SendMsgResult result = client.message.sendMsg(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -52,9 +58,15 @@ public class MessageTest {
     public void testBatchSendMsg() throws IOException {
         List<String> toAccount = Arrays.asList("test1", "test2");
         TIMTextMsgElement msg = new TIMTextMsgElement("hi bingo");
-        BatchSendMsgRequest request = new BatchSendMsgRequest(toAccount, 123, Collections.singletonList(msg));
-        request.setSyncOtherMachine(SyncOtherMachine.NO);
-        request.setMsgSeq(28460);
+        List<TIMMsgElement> msgBody = Collections.singletonList(msg);
+        BatchSendMsgRequest request = BatchSendMsgRequest
+                .builder()
+                .toAccount(toAccount)
+                .msgRandom(123)
+                .msgBody(msgBody)
+                .syncOtherMachine(SyncOtherMachine.NO)
+                .msgSeq(28460)
+                .build();
         BatchSendMsgResult result = client.message.batchSendMsg(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -64,7 +76,13 @@ public class MessageTest {
     public void testImportMsg() throws IOException {
         TIMTextMsgElement msg = new TIMTextMsgElement("hello bingo");
         List<TIMMsgElement> msgBody = Collections.singletonList(msg);
-        ImportMsgRequest request = new ImportMsgRequest(1, "bingo", "test1", 122, 1557387418, msgBody);
+        ImportMsgRequest request = ImportMsgRequest.builder()
+                .fromAccount("bingo")
+                .toAccount("test1")
+                .msgRandom(122)
+                .msgTimeStamp(1557387418)
+                .msgBody(msgBody)
+                .build();
         ImportMsgResult result = client.message.importMsg(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -72,7 +90,13 @@ public class MessageTest {
 
     @Test
     public void testAdminGetRoamMsg() throws IOException {
-        AdminGetRoamMsgRequest request = new AdminGetRoamMsgRequest("200942", "151", 200, 1603954915, 1643954915);
+        AdminGetRoamMsgRequest request = AdminGetRoamMsgRequest.builder()
+                .fromAccount("test1")
+                .toAccount("test2")
+                .maxCnt(123)
+                .minTime(1631934000)
+                .maxTime(1631934060)
+                .build();
         AdminRoamMsgResult result = client.message.getRoamMsg(request);
         List<TIMMsgElement> msgBody = result.getMsgList().get(0).getMsgBody();
         System.out.println(msgBody.get(0).getMsgType());
@@ -88,7 +112,11 @@ public class MessageTest {
 
     @Test
     public void testAdminMsgWithdraw() throws IOException {
-        AdminMsgWithdrawRequest request = new AdminMsgWithdrawRequest("test1", "bingo", "31906_833502_1572869830");
+        AdminMsgWithdrawRequest request = AdminMsgWithdrawRequest.builder()
+                .fromAccount("test1")
+                .toAccount("bingo")
+                .msgKey("31906_833502_1572869830")
+                .build();
         AdminMsgWithdrawResult result = client.message.msgWithdraw(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -96,7 +124,10 @@ public class MessageTest {
 
     @Test
     public void testAdminSetMsgRead() throws IOException {
-        AdminSetMsgReadRequest request = new AdminSetMsgReadRequest("test1", "test2");
+        AdminSetMsgReadRequest request = AdminSetMsgReadRequest.builder()
+                .reportAccount("test1")
+                .peerAccount("test2")
+                .build();
         AdminSetMsgReadResult result = client.message.setMsgRead(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());

src/test/java/io/github/doocs/im/OperationTest.java

 package io.github.doocs.im;
 
-import io.github.doocs.im.constant.NoSpeakingTime;
 import io.github.doocs.im.constant.ChatType;
+import io.github.doocs.im.constant.NoSpeakingTime;
 import io.github.doocs.im.model.request.*;
 import io.github.doocs.im.model.response.*;
 import org.junit.Assert;
@@ -36,7 +36,11 @@ public class OperationTest {
 
     @Test
     public void testSetNoSpeaking() throws IOException {
-        SetNoSpeakingRequest request = new SetNoSpeakingRequest("test1", NoSpeakingTime.NEVER, NoSpeakingTime.FOREVER);
+        SetNoSpeakingRequest request = SetNoSpeakingRequest.builder()
+                .setAccount("test1")
+                .msgNoSpeakingTime(NoSpeakingTime.NEVER)
+                .groupMsgNoSpeakingTime(NoSpeakingTime.FOREVER)
+                .build();
         SetNoSpeakingResult result = client.operation.setNoSpeaking(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());
@@ -61,7 +65,10 @@ public class OperationTest {
 
     @Test
     public void testGetHistory() throws IOException {
-        GetHistoryRequest request = new GetHistoryRequest(ChatType.C2C, "2015120121");
+        GetHistoryRequest request = GetHistoryRequest.builder()
+                .chatType(ChatType.C2C)
+                .msgTime("2015120121")
+                .build();
         GetHistoryResult result = client.operation.getHistory(request);
         System.out.println(result);
         Assert.assertEquals(0, (int) result.getErrorCode());

src/test/java/io/github/doocs/im/ProfileTest.java

@@ -38,7 +38,10 @@ public class ProfileTest {
 
     @Test
     public void testPortraitSet() throws IOException {
-        ProfileItem profileItem = new ProfileItem("Tag_Profile_IM_Nick", "MyNickName");
+        ProfileItem profileItem = ProfileItem.builder()
+                .tag("Tag_Profile_IM_Nick")
+                .value("MyNickName")
+                .build();
         PortraitSetRequest request = new PortraitSetRequest("test1", Collections.singletonList(profileItem));
         PortraitSetResult result = client.profile.portraitSet(request);
         System.out.println(result);
@@ -47,9 +50,9 @@ public class ProfileTest {
 
     @Test
     public void testPortraitGet() throws IOException {
-        List<String> tagList = new ArrayList<>();
-        tagList.add("Tag_Profile_IM_Nick");
+        List<String> tagList = Collections.singletonList("Tag_Profile_IM_Nick");
         PortraitGetRequest request = new PortraitGetRequest(Collections.singletonList("test1"), tagList);
+
         PortraitGetResult result = client.profile.portraitGet(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());

src/test/java/io/github/doocs/im/RecentContactTest.java

@@ -37,7 +37,14 @@ public class RecentContactTest {
 
     @Test
     public void testGetRecentContactList() throws IOException {
-        GetRecentContactListRequest request = new GetRecentContactListRequest("bingo", 213213123, 0, 1121212121, 100, AssistFlags.BIT_0);
+        GetRecentContactListRequest request = GetRecentContactListRequest.builder()
+                .fromAccount("doocs")
+                .timestamp(0)
+                .startIndex(0)
+                .topTimestamp(0)
+                .topStartIndex(0)
+                .assistFlags(AssistFlags.BIT_0)
+                .build();
         GetRecentContactListResult result = client.recentContact.recentContactList(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -45,7 +52,12 @@ public class RecentContactTest {
 
     @Test
     public void testDeleteRecentContact() throws IOException {
-        DeleteRecentContactRequest request = new DeleteRecentContactRequest("bingo", RecentContactType.C2C, "test1", ClearRamble.YES);
+        DeleteRecentContactRequest request = DeleteRecentContactRequest.builder()
+                .fromAccount("doocs_1")
+                .type(RecentContactType.C2C)
+                .toAccount("doocs_2")
+                .clearRamble(ClearRamble.YES)
+                .build();
         DeleteRecentContactResult result = client.recentContact.deleteRecentContact(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());

src/test/java/io/github/doocs/im/SnsTest.java

@@ -36,13 +36,20 @@ public class SnsTest {
 
     @Test
     public void testFriendAdd() throws IOException {
-        AddFriendItem addFriendItem = new AddFriendItem("test2", "AddSource_Type_XXXXXXXX");
-        addFriendItem.setRemark("Mr.A");
-        addFriendItem.setGroupName("schoolmate");
-        addFriendItem.setAddWording("Hi");
-        FriendAddRequest request = new FriendAddRequest("test1", Collections.singletonList(addFriendItem));
-        request.setAddType(AddType.BOTH);
-        request.setForceAddFlags(ForceAddFlags.FORCE);
+        AddFriendItem addFriendItem = AddFriendItem.builder()
+                .toAccount("test2")
+                .addSource("AddSource_Type_XXXXXXXX")
+                .remark("Mr.A")
+                .groupName("schoolmate")
+                .addWording("Hi")
+                .build();
+        List<AddFriendItem> addFriendItemList = Collections.singletonList(addFriendItem);
+        FriendAddRequest request = FriendAddRequest.builder()
+                .fromAccount("test1")
+                .addFriendItemList(addFriendItemList)
+                .addType(AddType.BOTH)
+                .forceAddFlags(ForceAddFlags.FORCE)
+                .build();
         FriendAddResult result = client.sns.friendAdd(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -50,8 +57,15 @@ public class SnsTest {
 
     @Test
     public void testFriendImport() throws IOException {
-        ImportFriendItem importFriendItem = new ImportFriendItem("test2", "AddSource_Type_XXXXXXXX");
-        FriendImportRequest request = new FriendImportRequest("test1", Collections.singletonList(importFriendItem));
+        ImportFriendItem importFriendItem = ImportFriendItem.builder()
+                .toAccount("test2")
+                .addSource("AddSource_Type_XXXXXXXX")
+                .build();
+        List<ImportFriendItem> importFriendItems = Collections.singletonList(importFriendItem);
+        FriendImportRequest request = FriendImportRequest.builder()
+                .fromAccount("test1")
+                .importFriendItemList(importFriendItems)
+                .build();
         FriendImportResult result = client.sns.friendImport(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -59,11 +73,20 @@ public class SnsTest {
 
     @Test
     public void testFriendUpdate() throws IOException {
-        SnsItem snsItem = new SnsItem("Tag_SNS_Custom_testTag", "Tag_SNS_IM_AddWording");
-        UpdateItem updateItem = new UpdateItem("test2", Collections.singletonList(snsItem));
-        updateItem.setToAccount("test2");
-        updateItem.setSnsItemList(Collections.singletonList(snsItem));
-        FriendUpdateRequest request = new FriendUpdateRequest("test1", Collections.singletonList(updateItem));
+        SnsItem snsItem = SnsItem.builder()
+                .tag("Tag_SNS_Custom_testTag")
+                .value("Tag_SNS_IM_AddWording")
+                .build();
+        List<SnsItem> snsItems = Collections.singletonList(snsItem);
+        UpdateItem updateItem = UpdateItem.builder()
+                .toAccount("test2")
+                .snsItemList(snsItems)
+                .build();
+        List<UpdateItem> updateItems = Collections.singletonList(updateItem);
+        FriendUpdateRequest request = FriendUpdateRequest.builder()
+                .fromAccount("test1")
+                .updateItemList(updateItems)
+                .build();
         FriendUpdateResult result = client.sns.friendUpdate(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -71,8 +94,12 @@ public class SnsTest {
 
     @Test
     public void testFriendDelete() throws IOException {
-        FriendDeleteRequest request = new FriendDeleteRequest("test1", Collections.singletonList("test2"));
-        request.setDeleteType(DeleteType.BOTH);
+        List<String> toAccount = Collections.singletonList("test2");
+        FriendDeleteRequest request = FriendDeleteRequest.builder()
+                .deleteType(DeleteType.BOTH)
+                .fromAccount("test1")
+                .toAccount(toAccount)
+                .build();
         FriendDeleteResult result = client.sns.friendDelete(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -80,8 +107,10 @@ public class SnsTest {
 
     @Test
     public void testFriendDeleteAll() throws IOException {
-        FriendDeleteAllRequest request = new FriendDeleteAllRequest("test1");
-        request.setDeleteType(DeleteType.BOTH);
+        FriendDeleteAllRequest request = FriendDeleteAllRequest.builder()
+                .deleteType(DeleteType.BOTH)
+                .fromAccount("test1")
+                .build();
         FriendDeleteAllResult result = client.sns.friendDeleteAll(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -89,7 +118,12 @@ public class SnsTest {
 
     @Test
     public void testFriendCheck() throws IOException {
-        FriendCheckRequest request = new FriendCheckRequest("test1", Collections.singletonList("test2"), CheckResultType.BOTH);
+        List<String> toAccount = Collections.singletonList("test2");
+        FriendCheckRequest request = FriendCheckRequest.builder()
+                .fromAccount("test1")
+                .toAccount(toAccount)
+                .checkType(CheckResultType.BOTH)
+                .build();
         FriendCheckResult result = client.sns.friendCheck(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -97,7 +131,12 @@ public class SnsTest {
 
     @Test
     public void testFriendGet() throws IOException {
-        FriendGetRequest request = new FriendGetRequest("test1", 0, 0, 0);
+        FriendGetRequest request = FriendGetRequest.builder()
+                .fromAccount("test1")
+                .startIndex(0)
+                .standardSequence(0)
+                .customSequence(0)
+                .build();
         FriendGetResult result = client.sns.friendGet(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -107,7 +146,11 @@ public class SnsTest {
     public void testFriendGetList() throws IOException {
         List<String> toAccount = Collections.singletonList("test2");
         List<String> tagList = Arrays.asList(TagProfile.IM_ADMIN_FORBID_TYPE, TagProfile.IM_ALLOW_TYPE);
-        FriendGetListRequest request = new FriendGetListRequest("test1", toAccount, tagList);
+        FriendGetListRequest request = FriendGetListRequest.builder()
+                .fromAccount("test1")
+                .toAccount(toAccount)
+                .tagList(tagList)
+                .build();
         FriendGetListResult result = client.sns.friendGetList(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -115,7 +158,11 @@ public class SnsTest {
 
     @Test
     public void testBlackListAdd() throws IOException {
-        BlackListAddRequest request = new BlackListAddRequest("test1", Collections.singletonList("test2"));
+        List<String> toAccount = Collections.singletonList("test2");
+        BlackListAddRequest request = BlackListAddRequest.builder()
+                .fromAccount("test1")
+                .toAccount(toAccount)
+                .build();
         BlackListAddResult result = client.sns.blackListAdd(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -123,7 +170,11 @@ public class SnsTest {
 
     @Test
     public void testBlackListDelete() throws IOException {
-        BlackListDeleteRequest request = new BlackListDeleteRequest("test1", Collections.singletonList("test2"));
+        List<String> toAccount = Collections.singletonList("test2");
+        BlackListDeleteRequest request = BlackListDeleteRequest.builder()
+                .fromAccount("test1")
+                .toAccount(toAccount)
+                .build();
         BlackListDeleteResult result = client.sns.blackListDelete(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -131,7 +182,12 @@ public class SnsTest {
 
     @Test
     public void testBlackListGet() throws IOException {
-        BlackListGetRequest request = new BlackListGetRequest("test1", 0, 10, 0);
+        BlackListGetRequest request = BlackListGetRequest.builder()
+                .fromAccount("test1")
+                .startIndex(0)
+                .maxLimited(10)
+                .lastSequence(0)
+                .build();
         BlackListGetResult result = client.sns.blackListGet(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -140,7 +196,11 @@ public class SnsTest {
     @Test
     public void testBlackListCheck() throws IOException {
         List<String> toAccount = Collections.singletonList("test2");
-        BlackListCheckRequest request = new BlackListCheckRequest("test1", toAccount, BlackCheckResultType.BOTH);
+        BlackListCheckRequest request = BlackListCheckRequest.builder()
+                .fromAccount("test1")
+                .toAccount(toAccount)
+                .checkType(BlackCheckResultType.BOTH)
+                .build();
         BlackListCheckResult result = client.sns.blackListCheck(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -150,7 +210,11 @@ public class SnsTest {
     public void testGroupAdd() throws IOException {
         List<String> groupName = Collections.singletonList("classmate");
         List<String> toAccount = Collections.singletonList("test2");
-        GroupAddRequest request = new GroupAddRequest("test1", groupName, toAccount);
+        GroupAddRequest request = GroupAddRequest.builder()
+                .fromAccount("test1")
+                .groupName(groupName)
+                .toAccount(toAccount)
+                .build();
         GroupAddResult result = client.sns.groupAdd(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -159,7 +223,10 @@ public class SnsTest {
     @Test
     public void testGroupDelete() throws IOException {
         List<String> groupName = Collections.singletonList("classmate");
-        GroupDeleteRequest request = new GroupDeleteRequest("test1", groupName);
+        GroupDeleteRequest request = GroupDeleteRequest.builder()
+                .fromAccount("test1")
+                .groupName(groupName)
+                .build();
         GroupDeleteResult result = client.sns.groupDelete(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());
@@ -167,9 +234,13 @@ public class SnsTest {
 
     @Test
     public void testGroupGet() throws IOException {
-        GroupGetRequest request = new GroupGetRequest("test1", 0);
-        request.setGroupName(Collections.singletonList("schoolmate"));
-        request.setNeedFriend(NeedFriendType.YES);
+        List<String> groupName = Collections.singletonList("schoolmate");
+        GroupGetRequest request = GroupGetRequest.builder()
+                .fromAccount("test1")
+                .lastSequence(0)
+                .groupName(groupName)
+                .needFriend(NeedFriendType.YES)
+                .build();
         GroupGetResult result = client.sns.groupGet(request);
         System.out.println(result);
         Assert.assertEquals("OK", result.getActionStatus());