Group | Chat SDK for WEB

Group contains APIs for group-related operations.

Functions

acceptGroupInvite

acceptGroupInvite(this: Connection, params: { groupId: string; invitee: string; error?: any; success?: any }): Promise<AsyncResult<Common.CommonRequestResult>>

Accepts a group invitation. If a group member invites a user to join the group, the invitee can call this method to accept the invitation. The inviter will receive "operation: 'acceptInvite'" in the callback of onGroupEvent. The new group member will receive "operation: 'memberPresence'" in the callback of onGroupEvent.
```
connection.acceptGroupInvite({invitee: 'myUserId', groupId: 'groupId'})
```
Parameters
- this: Connection
- params: { groupId: string; invitee: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - invitee: string
    
    The user ID of the invitee.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<Common.CommonRequestResult>): void
    - Parameters
      - res: AsyncResult<Common.CommonRequestResult>
      Returns void
Returns Promise<AsyncResult<Common.CommonRequestResult>>

acceptGroupJoinRequest

acceptGroupJoinRequest(this: Connection, params: { applicant: string; groupId: string; error?: any; success?: any }): Promise<AsyncResult<Common.CommonRequestResult>>

Accepts a group request. Only the group owner or admin can call this method. The user who joins the group will receive "operation: 'acceptRequest'" in the callback of onGroupEvent.
```
connection.acceptGroupJoinRequest({applicant: 'user1', groupId: 'groupId'})
```
Parameters
- this: Connection
- params: { applicant: string; groupId: string; error?: any; success?: any }
  - applicant: string
    
    The ID of the user requesting to join the group.
  - groupId: string
    
    The group ID.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<Common.CommonRequestResult>): void
    - Parameters
      - res: AsyncResult<Common.CommonRequestResult>
      Returns void
Returns Promise<AsyncResult<Common.CommonRequestResult>>

addUsersToGroupAllowlist

addUsersToGroupAllowlist(this: Connection, params: { groupId: string; users: string[]; error?: any; success?: any }): Promise<AsyncResult<GroupRequestResult[]>>

Adds members to the group allowlist. Members on the allowlist can still post messages even if they are muted in the group. Only the group admin or above can call this method. Members added to the allowlist will receive "operation: 'addUserToAllowlist'" in the callback of onGroupEvent.
```
connection.addUsersToGroupAllowlist({groupId: 'groupId'})
```
Parameters
- this: Connection
- params: { groupId: string; users: string[]; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - users: string[]
    
    An array of member IDs to be added to the allowlist.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<GroupRequestResult[]>): void
    - Parameters
      - res: AsyncResult<GroupRequestResult[]>
      Returns void
Returns Promise<AsyncResult<GroupRequestResult[]>>

blockGroupMember

blockGroupMember(this: Connection, params: { groupId: string; username: string; error?: any; success?: any }): Promise<AsyncResult<GroupRequestResult>>

Adds a member to the group blocklist. Only the group owner or admin can call this method. The member added to the blocklist will receive "operation: 'removeMember'" in the callback of onGroupEvent.
```
connection.blockGroupMember({groupId: 'groupId', username: 'user1'})
```
Parameters
- this: Connection
- params: { groupId: string; username: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - username: string
    
    User ID to be added to the blocklist.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<GroupRequestResult>): void
    - Parameters
      - res: AsyncResult<GroupRequestResult>
      Returns void
Returns Promise<AsyncResult<GroupRequestResult>>

blockGroupMembers

blockGroupMembers(this: Connection, params: { groupId: string; usernames: string[]; error?: any; success?: any }): Promise<AsyncResult<GroupRequestResult[]>>

Adds members to the group blocklist in bulk. Only the group admin can call this method. Members added to the blocklist will receive "operation: 'removeMember'" in the callback of onGroupEvent.
```
connection.blockGroupMembers({usernames: ['user1', 'user2'], groupId: 'groupId'})
```
Parameters
- this: Connection
- params: { groupId: string; usernames: string[]; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - usernames: string[]
    
    The array of member's user IDs to be added to the blocklist.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<GroupRequestResult[]>): void
    - Parameters
      - res: AsyncResult<GroupRequestResult[]>
      Returns void
Returns Promise<AsyncResult<GroupRequestResult[]>>

blockGroupMessages

blockGroupMessages(this: Connection, params: { groupId: string; error?: any; success?: any }): Promise<AsyncResult<BlockGroupResult>>

Blocks group messages. This method is only valid for mobile devices.
```
connection.blockGroupMessages({groupId: 'groupId'})
```
Parameters
- this: Connection
- params: { groupId: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<BlockGroupResult>): void
    - Parameters
      - res: AsyncResult<BlockGroupResult>
      Returns void
Returns Promise<AsyncResult<BlockGroupResult>>

changeGroupOwner

changeGroupOwner(this: Connection, params: { groupId: string; newOwner: string; error?: any; success?: any }): Promise<AsyncResult<ChangeGroupOwnerResult>>

Transfers a group. Only the group owner can call this method. Group members will receive "operation: 'changeOwner'" in the callback of onGroupEvent.
```
connection.changeGroupOwner({groupId: 'groupId', newOwner: 'user1'})
```
Parameters
- this: Connection
- params: { groupId: string; newOwner: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - newOwner: string
    
    The new group owner.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<ChangeGroupOwnerResult>): void
    - Parameters
      - res: AsyncResult<ChangeGroupOwnerResult>
      Returns void
Returns Promise<AsyncResult<ChangeGroupOwnerResult>>

createGroup

createGroup(this: Connection, params: { data: { allowinvites: boolean; approval: boolean; desc: string; ext?: string; groupname: string; inviteNeedConfirm: boolean; maxusers: number; members: string[]; public: boolean }; error?: any; success?: any }): Promise<AsyncResult<CreateGroupResult>>

Creates a group instance.
```
connection.createGroup({
 data: {
     groupname: 'groupname',
     desc: 'this is my group',
     members: ['user1', 'user2'],
     public: true,
     approval: false,
     allowinvites: true,
     inviteNeedConfirm: false,
        ext: {info: 'group info'}
  }
})
```
Parameters
- this: Connection
- params: { data: { allowinvites: boolean; approval: boolean; desc: string; ext?: string; groupname: string; inviteNeedConfirm: boolean; maxusers: number; members: string[]; public: boolean }; error?: any; success?: any }
  - data: { allowinvites: boolean; approval: boolean; desc: string; ext?: string; groupname: string; inviteNeedConfirm: boolean; maxusers: number; members: string[]; public: boolean }
    
    The group information.
    - allowinvites: boolean
      
      Whether to allow group members to invite others to the group. true: Allow; false: Do not allow.
    - approval: boolean
      
      Whether a user requires the approval from the group admin to join the group. -true: Yes; -false: No.
    - desc: string
      
      The description of the group.
    - Optional ext?: string
      
      Group detail extensions which can be in the JSON format to contain more group information.
    - groupname: string
      
      The group name.
    - inviteNeedConfirm: boolean
      Whether the invitee needs to accept the invitation before joining the group.
      
      true: The invitee's consent is required. The default value is true.
      
      false: The invitee will be directly added to the group without confirmation.
    - maxusers: number
      
      The group max users.
    - members: string[]
      
      The array of member IDs to add to the group. These users will be added directly into the group and receive "operation: 'directJoined'" in the callback of onGroupEvent.
    - public: boolean
      
      Whether it is a public group. -true: Yes; -false: No. Public group: the group that others can query by calling listgroups.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<CreateGroupResult>): void
    - Parameters
      - res: AsyncResult<CreateGroupResult>
      Returns void
Returns Promise<AsyncResult<CreateGroupResult>>

deleteGroupSharedFile

deleteGroupSharedFile(this: Connection, params: { fileId: string; groupId: string; error?: any; success?: any }): Promise<AsyncResult<DeleteGroupSharedFileResult>>

Deletes shared files of the group.
```
connection.deleteGroupSharedFile({groupId: 'groupId', fileId: 'fileId'})
```
Parameters
- this: Connection
- params: { fileId: string; groupId: string; error?: any; success?: any }
  - fileId: string
    
    The shared file ID.
  - groupId: string
    
    The group ID.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<DeleteGroupSharedFileResult>): void
    - Parameters
      - res: AsyncResult<DeleteGroupSharedFileResult>
      Returns void
Returns Promise<AsyncResult<DeleteGroupSharedFileResult>>

destroyGroup

destroyGroup(this: Connection, params: { groupId: string; error?: any; success?: any }): Promise<AsyncResult<DestroyGroupResult>>

Destroys a group. Only the group owner can call this method. Group members will receive "operation: 'destroy'" in the callback of onGroupEvent.
```
connection.destroyGroup({groupId: 'groupId'})
```
Parameters
- this: Connection
- params: { groupId: string; error?: any; success?: any }
  - groupId: string
    
    The group id.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<DestroyGroupResult>): void
    - Parameters
      - res: AsyncResult<DestroyGroupResult>
      Returns void
Returns Promise<AsyncResult<DestroyGroupResult>>

disableSendGroupMsg

disableSendGroupMsg(this: Connection, params: { groupId: string; error?: any; success?: any }): Promise<AsyncResult<{ mute: true }>>

Mutes all members. Only the group admin or above can call this method. Group members will receive "operation: 'muteAllMembers'" in the callback of onGroupEvent.
```
 connection.disableSendGroupMsg({groupId: 'groupId'})
```
Parameters
- this: Connection
- params: { groupId: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<{ mute: true }>): void
    - Parameters
      - res: AsyncResult<{ mute: true }>
      Returns void
Returns Promise<AsyncResult<{ mute: true }>>

downloadGroupSharedFile

downloadGroupSharedFile(this: Connection, params: { fileId: string; groupId: string; secret?: string; onFileDownloadComplete?: any; onFileDownloadError?: any }): void

Down load group file.
```
connection.downloadGroupSharedFile({groupId: 'groupId', fileId: 'fileId', onFileDownloadComplete: (data)=>{console.log(data)}})
```
Parameters
- this: Connection
- params: { fileId: string; groupId: string; secret?: string; onFileDownloadComplete?: any; onFileDownloadError?: any }
  - fileId: string
    
    The shared file ID.
  - groupId: string
    
    The group ID.
  - Optional secret?: string
    
    The secret key required to download the file.
  - onFileDownloadComplete?:function
    - onFileDownloadComplete(data: Blob): void
    - Parameters
      - data: Blob
      Returns void
  - onFileDownloadError?:function
    - onFileDownloadError(err: Common.ErrorEvent): void
    - Parameters
      - err: Common.ErrorEvent
      Returns void
Returns void

enableSendGroupMsg

enableSendGroupMsg(this: Connection, params: { groupId: string; error?: any; success?: any }): Promise<AsyncResult<{ mute: false }>>

Unmute all members. Only the group admin or above can call this method. Group members will receive "operation: 'unmuteAllMembers'" in the callback of onGroupEvent.
```
connection.enableSendGroupMsg({groupId: 'groupId'})
```
Parameters
- this: Connection
- params: { groupId: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<{ mute: false }>): void
    - Parameters
      - res: AsyncResult<{ mute: false }>
      Returns void
Returns Promise<AsyncResult<{ mute: false }>>

fetchGroupAnnouncement

fetchGroupAnnouncement(this: Connection, params: { groupId: string; error?: any; success?: any }): Promise<AsyncResult<{ announcement: string }>>

Gets the group announcement.
```
connection.fetchGroupAnnouncement({groupId: 'groupId'})
```
Parameters
- this: Connection
- params: { groupId: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<{ announcement: string }>): void
    - Parameters
      - res: AsyncResult<{ announcement: string }>
      Returns void
Returns Promise<AsyncResult<{ announcement: string }>>

getGroupAdmin

getGroupAdmin(this: Connection, params: { groupId: string; error?: any; success?: any }): Promise<AsyncResult<UserId[]>>

Gets all admins in the group.
```
connection.getGroupAdmin({groupId: 'groupId'})
```
Parameters
- this: Connection
- params: { groupId: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<string[]>): void
    - Parameters
      - res: AsyncResult<string[]>
      Returns void
Returns Promise<AsyncResult<UserId[]>>

getGroupAllowlist

getGroupAllowlist(this: Connection, params: { groupId: string; error?: any; success?: any }): Promise<AsyncResult<UserId[]>>

Gets the group allowlist. Only the group admin or above can call this method.
```
connection.getGroupAllowlist({groupId: 'groupId'})
```
Parameters
- this: Connection
- params: { groupId: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<string[]>): void
    - Parameters
      - res: AsyncResult<string[]>
      Returns void
Returns Promise<AsyncResult<UserId[]>>

getGroupBlocklist

getGroupBlocklist(this: Connection, params: { groupId: string; error?: any; success?: any }): Promise<AsyncResult<UserId[]>>

Gets the group blocklist.
```
connection.getGroupBlocklist({groupId: 'groupId'})
```
Parameters
- this: Connection
- params: { groupId: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<string[]>): void
    - Parameters
      - res: AsyncResult<string[]>
      Returns void
Returns Promise<AsyncResult<UserId[]>>

getGroupInfo

getGroupInfo(this: Connection, params: { groupId: string | string[]; error?: any; success?: any }): Promise<AsyncResult<GroupDetailInfo[]>>

Gets specifications of the group.
```
connection.getGroupInfo({groupId: groupId})
```
Parameters
- this: Connection
- params: { groupId: string | string[]; error?: any; success?: any }
  - groupId: string | string[]
    
    The group ID or group ID list.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<GroupDetailInfo[]>): void
    - Parameters
      - res: AsyncResult<GroupDetailInfo[]>
      Returns void
Returns Promise<AsyncResult<GroupDetailInfo[]>>

getGroupMemberAttributes

getGroupMemberAttributes(this: Connection, params: { groupId: string; userId: string }): Promise<AsyncResult<MemberAttributes>>

Gets all custom attributes of a group member.
```
connection.getGroupMemberAttributes({groupId: 'groupId', userId: 'userId'})
```
Parameters
- this: Connection
- params: { groupId: string; userId: string }
  - groupId: string
    
    The group ID.
  - userId: string
    
    The user ID of the group member.
Returns Promise<AsyncResult<MemberAttributes>>

getGroupMembersAttributes

getGroupMembersAttributes(this: Connection, params: { groupId: string; keys?: string[]; userIds: string[] }): Promise<AsyncResult<GetGroupMembersAttributesResult>>

Gets custom attributes of multiple group members by attribute key.
```
connection.getGroupMembersAttributes({groupId: 'groupId', userIds: ['userId'], keys: ['avatar', 'nickname']})
```
Parameters
- this: Connection
- params: { groupId: string; keys?: string[]; userIds: string[] }
  - groupId: string
    
    The group ID.
  - Optional keys?: string[]
    
    The array of keys of custom attributes to be retrieved. If you pass in an empty array or do not set this parameter, the SDK gets all custom attributes of these group members.
  - userIds: string[]
    
    The array of user IDs of group members whose custom attributes are retrieved.
Returns Promise<AsyncResult<GetGroupMembersAttributesResult>>

getGroupMsgReadUser

getGroupMsgReadUser(this: Connection, params: { groupId: string; msgId: string; error?: any; success?: any }): Promise<AsyncResult<GetGroupMsgReadUserResult>>

Checks which members have read group message. This is a [value-added function] and .
```
connection.getGroupMsgReadUser({groupId: 'groupId', msgId: 'msgId'})
```
Parameters
- this: Connection
- params: { groupId: string; msgId: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - msgId: string
    
    The ID of message to query.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<GetGroupMsgReadUserResult>): void
    - Parameters
      - res: AsyncResult<GetGroupMsgReadUserResult>
      Returns void
Returns Promise<AsyncResult<GetGroupMsgReadUserResult>>

getGroupMutelist

getGroupMutelist(this: Connection, params: { groupId: string; error?: any; success?: any }): Promise<AsyncResult<GetGroupMuteListResult[]>>

Gets the mute list of the group. Only the group admin or above can call this method.
```
connection.getGroupMutelist({groupId: 'groupId'})
```
Parameters
- this: Connection
- params: { groupId: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<GetGroupMuteListResult[]>): void
    - Parameters
      - res: AsyncResult<GetGroupMuteListResult[]>
      Returns void
Returns Promise<AsyncResult<GetGroupMuteListResult[]>>

getGroupSharedFilelist

getGroupSharedFilelist(this: Connection, params: { groupId: string; pageNum: number; pageSize: number; error?: any; success?: any }): Promise<AsyncResult<FetchGroupSharedFileListResult>>

Parameters
- this: Connection
- params: { groupId: string; pageNum: number; pageSize: number; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - pageNum: number
    
    The page number, starting from 1.
  - pageSize: number
    
    The number of members per page. The value cannot exceed 10.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<FetchGroupSharedFileListResult>): void
    - Parameters
      - res: AsyncResult<FetchGroupSharedFileListResult>
      Returns void
Returns Promise<AsyncResult<FetchGroupSharedFileListResult>>

getJoinedGroups

getJoinedGroups(this: Connection, params: { needAffiliations?: boolean; needRole?: boolean; pageNum: number; pageSize: number; error?: any; success?: any }): Promise<AsyncResult<BaseGroupInfo[] | GroupInfo[]>>

Lists all the groups a user has joined.
note
If either needAffiliations or needAffiliations is set true, when you get data with pagination, the current page number (pageNum) starts from 0 and you can get a maximum of 20 groups (pageSize) on each page and the function return type is Promise<AsyncResult<GroupTypes.GroupInfo[]>

If neither of the parameters is set, when you get data with pagination, the current page number (pageNum) starts from 1 and you can get a maximum of 500 groups (pageSize) on each page and and the function return type is Promise<AsyncResult<GroupTypes.BaseGroupInfo[]>
```
connection.getJoinedGroups({
        pageNum: 1,
        pageSize: 500,
        needAffiliations: false,
        needRole: false
})
```
Parameters
- this: Connection
- params: { needAffiliations?: boolean; needRole?: boolean; pageNum: number; pageSize: number; error?: any; success?: any }
  - Optional needAffiliations?: boolean
    
    Whether the number of group members is required. true: Yes; (Default)false: No.
  - Optional needRole?: boolean
    
    Whether the role of the current user in the group is required. true: Yes; (Default)false: No.
  - pageNum: number
    
    If either needAffiliations or needAffiliations is set, when you get data with pagination, the current page number (pageNum) starts from 0.
    
    If neither of the parameters is set, when you get data with pagination, the current page number (pageNum) starts from 1.
  - pageSize: number
    
    If either needAffiliations or needAffiliations is set, when you get data with pagination, you can get a maximum of 20 groups (pageSize) on each page.
    
    If neither of the parameters is set, when you get data with pagination, you can get a maximum of 500 groups (pageSize) on each page.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<BaseGroupInfo[] | GroupInfo[]>): void
    - Parameters
      - res: AsyncResult<BaseGroupInfo[] | GroupInfo[]>
      Returns void
Returns Promise<AsyncResult<BaseGroupInfo[] | GroupInfo[]>>

getPublicGroups

getPublicGroups(this: Connection, params: { cursor?: string; limit: number; error?: any; success?: any }): Promise<AsyncResult<BaseGroupInfo[]>>

Gets public groups with pagination.
```
connection.getPublicGroups({limit: 20, cursor: null})
```
Parameters
- this: Connection
- params: { cursor?: string; limit: number; error?: any; success?: any }
  - Optional cursor?: string
    
    The cursor that specifies where to start to get data. If there will be data on the next page, this method will return the value of this field to indicate the position to start to get data of the next page. If it is null, the data of the first page will be fetched.
  - limit: number
    
    The number of records per page.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<BaseGroupInfo[]>): void
    - Parameters
      - res: AsyncResult<BaseGroupInfo[]>
      Returns void
Returns Promise<AsyncResult<BaseGroupInfo[]>>

inviteUsersToGroup

inviteUsersToGroup(this: Connection, params: { groupId: string; users: string[]; error?: any; success?: any }): Promise<AsyncResult<InviteUsersToGroupResult[]>>

Invites users into a group. Creates a group instance "inviteNeedConfirm:true", the invited users will receive "operation: 'inviteToJoin'" in the callback of onGroupEvent. Creates a group instance "inviteNeedConfirm:false", the invited users will receive "operation: 'directJoined'" in the callback of onGroupEvent.
```
connection.inviteUsersToGroup({groupId: 'groupId', users: ['user1', 'user2']})
```
Parameters
- this: Connection
- params: { groupId: string; users: string[]; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - users: string[]
    
    The array of invitee IDs.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<InviteUsersToGroupResult[]>): void
    - Parameters
      - res: AsyncResult<InviteUsersToGroupResult[]>
      Returns void
Returns Promise<AsyncResult<InviteUsersToGroupResult[]>>

isInGroupAllowlist

isInGroupAllowlist(this: Connection, params: { groupId: string; userName: string; error?: any; success?: any }): Promise<AsyncResult<IsInGroupWhiteListResult>>

Checks whether the current member is on the allowlist. The app admin can check all users; app users can only check themselves.
```
connection.isInGroupAllowlist({groupId: 'groupId', userName: 'user1'})
```
Parameters
- this: Connection
- params: { groupId: string; userName: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - userName: string
    
    The user ID to query.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<IsInGroupWhiteListResult>): void
    - Parameters
      - res: AsyncResult<IsInGroupWhiteListResult>
      Returns void
Returns Promise<AsyncResult<IsInGroupWhiteListResult>>

isInGroupMutelist

isInGroupMutelist(this: Connection, params: { groupId: string }): Promise<boolean>

Check whether you are on the group mute list.
```
connection.isInGroupMutelist({groupId: 'groupId'})
```
Parameters
- this: Connection
- params: { groupId: string }
  - groupId: string
    
    The group ID.
Returns Promise<boolean>

joinGroup

joinGroup(this: Connection, params: { groupId: string; message: string; error?: any; success?: any }): Promise<AsyncResult<Common.CommonRequestResult>>

Applies to join the group. The group owner and admin will receive "operation: 'requestToJoin'" in the callback of onGroupEvent.
```
connection.joinGroup({groupId: 'groupId', message: 'I want to join the group'})
```
Parameters
- this: Connection
- params: { groupId: string; message: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - message: string
    
    The additional information of the request.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<Common.CommonRequestResult>): void
    - Parameters
      - res: AsyncResult<Common.CommonRequestResult>
      Returns void
Returns Promise<AsyncResult<Common.CommonRequestResult>>

leaveGroup

leaveGroup(this: Connection, params: { groupId: string; error?: any; success?: any }): Promise<AsyncResult<{ result: true }>>

Leaves the group. Group members will receive "operation: 'memberAbsence'" in the callback of onGroupEvent.
```
connection.leaveGroup({groupId: 'groupId'})
```
Parameters
- this: Connection
- params: { groupId: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<{ result: true }>): void
    - Parameters
      - res: AsyncResult<{ result: true }>
      Returns void
Returns Promise<AsyncResult<{ result: true }>>

listGroupMembers

listGroupMembers(this: Connection, params: { groupId: string; pageNum: number; pageSize: number; error?: any; success?: any }): Promise<AsyncResult<GroupMember[]>>

Lists all members of the group with pagination.
```
connection.listGroupMembers({pageNum: 1, pageSize: 20, groupId: 'groupId'})
```
Parameters
- this: Connection
- params: { groupId: string; pageNum: number; pageSize: number; error?: any; success?: any }
  - groupId: string
    
    The group ID。
  - pageNum: number
    
    The page number, starting from 1.
  - pageSize: number
    
    The number of members per page. The value cannot exceed 1000.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<GroupMember[]>): void
    - Parameters
      - res: AsyncResult<GroupMember[]>
      Returns void
Returns Promise<AsyncResult<GroupMember[]>>

modifyGroup

modifyGroup(this: Connection, params: { description?: string; ext?: string; groupId: string; groupName?: string; error?: any; success?: any }): Promise<AsyncResult<ModifyGroupResult>>

Modifies group information. Only the group admin can call this method.
```
connection.modifyGroup({groupId: 'groupId', groupName: 'groupName', description:'description'})
```
Parameters
- this: Connection
- params: { description?: string; ext?: string; groupId: string; groupName?: string; error?: any; success?: any }
  - Optional description?: string
    
    The group description.
  - Optional ext?: string
    
    Group detail extensions which can be in the JSON format to contain more group information.
  - groupId: string
    
    The Group ID.
  - Optional groupName?: string
    
    The group name.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<ModifyGroupResult>): void
    - Parameters
      - res: AsyncResult<ModifyGroupResult>
      Returns void
Returns Promise<AsyncResult<ModifyGroupResult>>

muteGroupMember

muteGroupMember(this: Connection, params: { groupId: string; muteDuration: number; username: string | string[]; error?: any; success?: any }): Promise<AsyncResult<MuteGroupMemberResult[]>>

Mutes one or more group members. Only the group owner or admin can call this method. The muted member and other members will receive "operation:'muteMember'" in the callback of onGroupEvent.
```
connection.muteGroupMember({username: 'user1' || ['user1', 'user2'], muteDuration: -1, groupId: 'groupId'})
```
Parameters
- this: Connection
- params: { groupId: string; muteDuration: number; username: string | string[]; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - muteDuration: number
    
    The mute duration in milliseconds. The value -1 indicates that the member is muted permanently.
  - username: string | string[]
    
    The ID of the group member to mute.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<MuteGroupMemberResult[]>): void
    - Parameters
      - res: AsyncResult<MuteGroupMemberResult[]>
      Returns void
Returns Promise<AsyncResult<MuteGroupMemberResult[]>>

rejectGroupInvite

rejectGroupInvite(this: Connection, params: { groupId: string; invitee: string; error?: any; success?: any }): Promise<AsyncResult<Common.CommonRequestResult>>

Declines a group invitation. If a group member invites a user to join a group, the invitee can call this method to decline this invitation.
```
connection.rejectGroupInvite({invitee: 'myUserId', groupId: 'groupId'})
```
Parameters
- this: Connection
- params: { groupId: string; invitee: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - invitee: string
    
    The user ID of the invitee.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<Common.CommonRequestResult>): void
    - Parameters
      - res: AsyncResult<Common.CommonRequestResult>
      Returns void
Returns Promise<AsyncResult<Common.CommonRequestResult>>

rejectGroupJoinRequest

rejectGroupJoinRequest(this: Connection, params: { applicant: string; groupId: string; reason: string; error?: any; success?: any }): Promise<AsyncResult<Common.CommonRequestResult>>

Declines a group request. Only the group owner or admin can call this method.
```
connection.rejectGroupJoinRequest({applicant: 'user1', groupId: 'groupId', reason: 'I do not like you'})
```
Parameters
- this: Connection
- params: { applicant: string; groupId: string; reason: string; error?: any; success?: any }
  - applicant: string
    
    The ID of the user who sends the request to join the group.
  - groupId: string
    
    The group ID.
  - reason: string
    
    The reason of declining.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<Common.CommonRequestResult>): void
    - Parameters
      - res: AsyncResult<Common.CommonRequestResult>
      Returns void
Returns Promise<AsyncResult<Common.CommonRequestResult>>

removeGroupAdmin

removeGroupAdmin(this: Connection, params: { groupId: string; username: string; error?: any; success?: any }): Promise<AsyncResult<RemoveGroupAdminResult>>

Removes a group admin. Only the group owner can call this method. The user whose admin permissions are revoked will receive "operation: 'removeAdmin'" in the callback of onGroupEvent.
```
connection.removeGroupAdmin({groupId: 'groupId', username: 'user1'})
```
Parameters
- this: Connection
- params: { groupId: string; username: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - username: string
    
    The ID of the user with admin privileges revoked.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<RemoveGroupAdminResult>): void
    - Parameters
      - res: AsyncResult<RemoveGroupAdminResult>
      Returns void
Returns Promise<AsyncResult<RemoveGroupAdminResult>>

removeGroupAllowlistMember

removeGroupAllowlistMember(this: Connection, params: { groupId: string; userName: string; error?: any; success?: any }): Promise<AsyncResult<GroupRequestResult>>

Removes a member from the group allowlist. Only the group admin or above can call this method. The user that is removed from the group allowlist will receive "operation:'removeAllowlistMember'" in the callback of onGroupEvent.
```
connection.removeGroupAllowlistMember({groupId: 'groupId', userName: 'user1'})
```
Parameters
- this: Connection
- params: { groupId: string; userName: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - userName: string
    
    The ID of the member to be removed from the group allowlist.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<GroupRequestResult>): void
    - Parameters
      - res: AsyncResult<GroupRequestResult>
      Returns void
Returns Promise<AsyncResult<GroupRequestResult>>

removeGroupMember

removeGroupMember(this: Connection, params: { groupId: string; username: string; error?: any; success?: any }): Promise<AsyncResult<RemoveGroupMemberResult>>

Removes a member from the group. Only the group owner or admin can call this method. The removed member will receive "operation: 'removeMember'" in the callback of onGroupEvent, and other group members will receive "operation: 'memberAbsence' in the callback of onGroupEvent.
```
connection.removeGroupMember({groupId: 'groupId', username: 'user1'})
```
Parameters
- this: Connection
- params: { groupId: string; username: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - username: string
    
    The member ID to remove.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<RemoveGroupMemberResult>): void
    - Parameters
      - res: AsyncResult<RemoveGroupMemberResult>
      Returns void
Returns Promise<AsyncResult<RemoveGroupMemberResult>>

removeGroupMembers

removeGroupMembers(this: Connection, params: { groupId: string; users: string[]; error?: any; success?: any }): Promise<AsyncResult<RemoveGroupMemberResult[]>>

Removes members from the group. Only the group owner or admin can call this method. The removed members will receive "operation: 'removeMember'" in the callback of onGroupEvent, and other group members will receive "operation: 'memberAbsence'" in the callback of onGroupEvent.
```
connection.removeGroupMembers({groupId: 'groupId', users: ['user1', 'user2']})
```
Parameters
- this: Connection
- params: { groupId: string; users: string[]; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - users: string[]
    
    The array of member IDs to remove.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<RemoveGroupMemberResult[]>): void
    - Parameters
      - res: AsyncResult<RemoveGroupMemberResult[]>
      Returns void
Returns Promise<AsyncResult<RemoveGroupMemberResult[]>>

setGroupAdmin

setGroupAdmin(this: Connection, params: { groupId: string; username: string; error?: any; success?: any }): Promise<AsyncResult<SetGroupAdminResult>>

Sets a group admin. Only the group owner can call this method. The user set as an admin will receive "operation: 'setAdmin'" in the callback of onGroupEvent.
```
connection.setGroupAdmin({groupId: 'groupId', username: 'user1'})
```
Parameters
- this: Connection
- params: { groupId: string; username: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - username: string
    
    The ID of the user set as admin.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<SetGroupAdminResult>): void
    - Parameters
      - res: AsyncResult<SetGroupAdminResult>
      Returns void
Returns Promise<AsyncResult<SetGroupAdminResult>>

setGroupMemberAttributes

setGroupMemberAttributes(this: Connection, params: { groupId: string; memberAttributes: MemberAttributes; userId: string }): Promise<void>

Sets custom attributes of a group member. After custom attributes of a group member are set, other members in the group receive the operation: 'memberAttributesUpdate' in the onGroupEvent callback and the other devices of the group member receive the the operation: 'memberAttributesUpdate' in the onMultiDeviceEvent callback.
```
connection.setGroupMemberAttributes({groupId: 'groupId', userId: 'userId', memberAttributes: {key: 'value'}})
```
Parameters
- this: Connection
- params: { groupId: string; memberAttributes: MemberAttributes; userId: string }
  - groupId: string
    
    The group ID.
  - memberAttributes: MemberAttributes
    
    The custom attributes to set in key-value format. In a key-value pair, if the value is set to an empty string, the custom attribute will be deleted.
  - userId: string
    
    The user ID of the group member.
Returns Promise<void>

unblockGroupMember

unblockGroupMember(this: Connection, params: { groupId: string; username: string; error?: any; success?: any }): Promise<AsyncResult<GroupRequestResult>>

Removes a member from the group blocklist. Only the group admin can call this method. Members who are removed from the blocklist will receive "operation: 'unblockMember'" in the callback of onGroupEvent.
```
connection.unblockGroupMember({groupId: 'groupId'})
```
Parameters
- this: Connection
- params: { groupId: string; username: string; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - username: string
    
    The user ID of the member to be removed from the blocklist.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<GroupRequestResult>): void
    - Parameters
      - res: AsyncResult<GroupRequestResult>
      Returns void
Returns Promise<AsyncResult<GroupRequestResult>>

unblockGroupMembers

unblockGroupMembers(this: Connection, params: { groupId: string; usernames: string[]; error?: any; success?: any }): Promise<AsyncResult<GroupRequestResult[]>>

Removes members from the group blocklist in bulk. Only the group owner or admin can call this method. Members who are removed from the blocklist will receive "operation: 'unblockMember'" in the callback of onGroupEvent.
```
connection.unblockGroupMembers({groupId: 'groupId', usernames: ['user1', 'user2']})
```
Parameters
- this: Connection
- params: { groupId: string; usernames: string[]; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - usernames: string[]
    
    The array of members‘ user IDs to be removed from the group blocklist.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<GroupRequestResult[]>): void
    - Parameters
      - res: AsyncResult<GroupRequestResult[]>
      Returns void
Returns Promise<AsyncResult<GroupRequestResult[]>>

unmuteGroupMember

unmuteGroupMember(this: Connection, params: { groupId: string; username: string | string[]; error?: any; success?: any }): Promise<AsyncResult<UnmuteGroupMemberResult[]>>

Unmutes one or more group members. Only the group owner or admin can call this method. The unmuted member and other members will receive "operation: 'unmuteMember'" in the callback of onGroupEvent.
```
connection.unmuteGroupMember({groupId: 'groupId', username: 'user1' || ['user1', 'user2']})
```
Parameters
- this: Connection
- params: { groupId: string; username: string | string[]; error?: any; success?: any }
  - groupId: string
    
    The group ID.
  - username: string | string[]
    
    The group member ID to unmute.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<UnmuteGroupMemberResult[]>): void
    - Parameters
      - res: AsyncResult<UnmuteGroupMemberResult[]>
      Returns void
Returns Promise<AsyncResult<UnmuteGroupMemberResult[]>>

updateGroupAnnouncement

updateGroupAnnouncement(this: Connection, params: { announcement: string; groupId: string; error?: any; success?: any }): Promise<AsyncResult<UpdateGroupAnnouncementResult>>

Updates the group announcement.
```
connection.updateGroupAnnouncement({groupId: 'groupId', announcement: 'hello'})
```
Parameters
- this: Connection
- params: { announcement: string; groupId: string; error?: any; success?: any }
  - announcement: string
    
    The group announcement.
  - groupId: string
    
    The group ID.
  - error?:function
    - error(error: Common.ErrorEvent): void
    - Parameters
      - error: Common.ErrorEvent
      Returns void
  - success?:function
    - success(res: AsyncResult<UpdateGroupAnnouncementResult>): void
    - Parameters
      - res: AsyncResult<UpdateGroupAnnouncementResult>
      Returns void
Returns Promise<AsyncResult<UpdateGroupAnnouncementResult>>

uploadGroupSharedFile

uploadGroupSharedFile(this: Connection, params: { file: object; groupId: string; onFileUploadCanceled?: any; onFileUploadComplete?: any; onFileUploadError?: any; onFileUploadProgress?: any }): void

Uploads shared files to the group.
```
connection.uploadGroupSharedFile({groupId: 'groupId', file: 'file object', onFileUploadProgress: onFileUploadProgress, onFileUploadComplete: onFileUploadComplete,onFileUploadError:onFileUploadError,onFileUploadCanceled:onFileUploadCanceled})
```
Parameters
- this: Connection
- params: { file: object; groupId: string; onFileUploadCanceled?: any; onFileUploadComplete?: any; onFileUploadError?: any; onFileUploadProgress?: any }
  - file: object
    
    The shared file object to upload.
  - groupId: string
    
    The group ID.
  - onFileUploadCanceled?:function
    - onFileUploadCanceled(data: any): void
    - The upload cancellation callback.
      
      Parameters
      - data: any
      Returns void
  - onFileUploadComplete?:function
    - onFileUploadComplete(data: any): void
    - The upload completion callback.
      
      Parameters
      - data: any
      Returns void
  - onFileUploadError?:function
    - onFileUploadError(data: any): void
    - The upload failure callback.
      
      Parameters
      - data: any
      Returns void
  - onFileUploadProgress?:function
    - onFileUploadProgress(data: ProgressEvent<EventTarget>): void
    - The upload progress callback.
      
      Parameters
      - data: ProgressEvent<EventTarget>
      Returns void
Returns void

Index

Functions

Functions

acceptGroupInvite

Parameters

this: Connection

params: { groupId: string; invitee: string; error?: any; success?: any }

groupId: string

invitee: string

error?:function

Parameters

error: Common.ErrorEvent

Returns void

success?:function

Parameters

res: AsyncResult<Common.CommonRequestResult>

Returns void

Returns Promise<AsyncResult<Common.CommonRequestResult>>

acceptGroupJoinRequest

Parameters

this: Connection

params: { applicant: string; groupId: string; error?: any; success?: any }

applicant: string

groupId: string

error?:function

Parameters

error: Common.ErrorEvent

Returns void

success?:function

Parameters

res: AsyncResult<Common.CommonRequestResult>

Returns void

Returns Promise<AsyncResult<Common.CommonRequestResult>>

addUsersToGroupAllowlist

Parameters

this: Connection

params: { groupId: string; users: string[]; error?: any; success?: any }

groupId: string

users: string[]

error?:function

Parameters

error: Common.ErrorEvent

Returns void

success?:function

Parameters

res: AsyncResult<GroupRequestResult[]>

Returns void

Returns Promise<AsyncResult<GroupRequestResult[]>>

blockGroupMember

Parameters

this: Connection

params: { groupId: string; username: string; error?: any; success?: any }

groupId: string

username: string

error?:function

Parameters

error: Common.ErrorEvent

Returns void

success?:function

Parameters

res: AsyncResult<GroupRequestResult>

Returns void

Returns Promise<AsyncResult<GroupRequestResult>>

blockGroupMembers

Parameters

this: Connection

params: { groupId: string; usernames: string[]; error?: any; success?: any }

groupId: string

usernames: string[]

error?:function

Parameters

error: Common.ErrorEvent

Returns void

success?:function

Parameters

res: AsyncResult<GroupRequestResult[]>

Returns void

Returns Promise<AsyncResult<GroupRequestResult[]>>

blockGroupMessages

Parameters