javaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
V2NIMTeamListener listener = new V2NIMTeamListener() {
    @Override
    public void onSyncStarted() {
        // 开始同步群组信息
    }

    @Override
    public void onSyncFinished() {
        // 同步群组信息完成
    }

    @Override
    public void onSyncFailed(V2NIMError error) {
        // 同步群组信息失败
    }

    @Override
    public void onTeamCreated(V2NIMTeam team) {
        // 创建群组成功
    }

    @Override
    public void onTeamDismissed(V2NIMTeam team) {
        // 解散群组成功
    }

    @Override
    public void onTeamJoined(V2NIMTeam team) {
        // 加入群组成功
    }

    @Override
    public void onTeamLeft(V2NIMTeam team, boolean isKicked) {
        // 离开群组成功
    }

    @Override
    public void onTeamInfoUpdated(V2NIMTeam team) {
        // 群组信息更新回调
    }

    @Override
    public void onTeamMemberJoined(List<V2NIMTeamMember> teamMembers) {
        // 群组成员加入回调
    }

    @Override
    public void onTeamMemberKicked(String operatorAccountId, List<V2NIMTeamMember> teamMembers) {
        // 群组成员被踢回调
    }

    @Override
    public void onTeamMemberLeft(List<V2NIMTeamMember> teamMembers) {
        // 群组成员退出群组回调
    }

    @Override
    public void onTeamMemberInfoUpdated(List<V2NIMTeamMember> teamMembers) {
        // 群组成员信息更新回调
    }

    @Override
    public void onReceiveTeamJoinActionInfo(V2NIMTeamJoinActionInfo joinActionInfo) {
        // 入群操作回调
    }
};
v2TeamService.addTeamListener(listener);

objective-c[[[NIMSDK sharedSDK] v2TeamService] addTeamListener:self];

// 同步开始
- (void)onSyncStarted{};

// 同步完成
- (void)onSyncFinished{};

// 同步失败
- (void)onSyncFailed:(V2NIMError *)error{};

// 群组创建回调
- (void)onTeamCreated:(V2NIMTeam *)team{};

// 群组解散回调
- (void)onTeamDismissed:(V2NIMTeam *)team{};

// 加入群组回调
- (void)onTeamJoined:(V2NIMTeam *)team{};

// 离开群组回调
- (void)onTeamLeft:(V2NIMTeam *)team
          isKicked:(BOOL)isKicked{};

// 群组信息更新回调
- (void)onTeamInfoUpdated:(V2NIMTeam *)team{};

// 群组成员加入回调
- (void)onTeamMemberJoined:(NSArray<V2NIMTeamMember *> *)teamMembers{};

// 群组成员被踢回调
- (void)onTeamMemberKicked:(NSString *)operatorAccountId
               teamMembers:(NSArray<V2NIMTeamMember *> *)teamMembers{};

// 群组成员退出回调
- (void)onTeamMemberLeft:(NSArray<V2NIMTeamMember *> *)teamMembers{};

// 群组成员信息变更回调
- (void)onTeamMemberInfoUpdated:(NSArray<V2NIMTeamMember *> *)teamMembers{};

// 收到入群操作信息回调
- (void)onReceiveTeamJoinActionInfo:(V2NIMTeamJoinActionInfo *)joinActionInfo{};

cppV2NIMTeamListener listener;
listener.onSyncStarted = []() {
    // team sync started
};
listener.onSyncFinished = []() {
    // team sync finished
};
listener.onSyncFailed = [](V2NIMError error) {
    // team sync failed, handle error
};
listener.onTeamCreated = [](V2NIMTeam team) {
    // team created
};
listener.onTeamDismissed = [](nstd::vector<V2NIMTeam> teams) {
    // team dismissed
};
listener.onTeamJoined = [](V2NIMTeam team) {
    // team joined
};
listener.onTeamLeft = [](V2NIMTeam team, bool isKicked) {
    // team left
};
listener.onTeamInfoUpdated = [](V2NIMTeam team) {
    // team info updated
};
listener.onTeamMemberJoined = [](nstd::vector<V2NIMTeamMember> teamMembers) {
    // team member joined
};
listener.onTeamMemberKicked = [](nstd::string operateAccountId, nstd::vector<V2NIMTeamMember> teamMembers) {
    team member kicked
};
listener.onTeamMemberLeft = [](nstd::vector<V2NIMTeamMember> teamMembers) {
    // team member left
};
listener.onTeamMemberInfoUpdated = [](nstd::vector<V2NIMTeamMember> teamMembers) {
    // team member info updated
};
listener.onReceiveTeamJoinActionInfo = [](V2NIMTeamJoinActionInfo joinActionInfo) {
    // receive team join action info
};
teamService.addTeamListener(listener);

typescriptnim.V2NIMTeamService.on('onSyncStarted', () => { console.log("recv onSyncStarted") })
nim.V2NIMTeamService.on('onSyncFinished', () => { console.log("recv onSyncFinished") })
nim.V2NIMTeamService.on('onSyncFailed', (error) => { console.log("recv onSyncFailed", error) })
nim.V2NIMTeamService.on('onTeamCreated', (team) => { console.log("recv onTeamCreated", team) })
nim.V2NIMTeamService.on('onTeamJoined', (team) => { console.log("recv onTeamJoined", team) })
nim.V2NIMTeamService.on('onTeamLeft', (team, isKicked) => { console.log("recv onTeamLeft", team, isKicked) })
nim.V2NIMTeamService.on('onTeamInfoUpdated', (team) => { console.log("recv onTeamInfoUpdated", team) })
nim.V2NIMTeamService.on('onTeamMemberJoined', (teamMembers) => { console.log("recv onTeamMemberJoined", teamMembers) })
nim.V2NIMTeamService.on('onTeamMemberKicked', (operateAccountId, teamMembers) => { console.log("recv onTeamMemberKicked", operateAccountId, teamMembers) })
nim.V2NIMTeamService.on('onTeamMemberLeft', (teamMembers) => { console.log("recv onTeamMemberLeft", teamMembers) })
nim.V2NIMTeamService.on('onTeamMemberInfoUpdated', (teamMembers) => { console.log("recv onTeamMemberInfoUpdated", teamMembers) })
nim.V2NIMTeamService.on('onReceiveTeamJoinActionInfo', (joinActionInfo) => { console.log("recv onReceiveTeamJoinActionInfo", joinActionInfo) })

typescriptnim.teamService.on('onSyncStarted', () => { console.log("recv onSyncStarted") })
nim.teamService.on('onSyncFinished', () => { console.log("recv onSyncFinished") })
nim.teamService.on('onSyncFailed', (error) => { console.log("recv onSyncFailed", error) })
nim.teamService.on('onTeamCreated', (team) => { console.log("recv onTeamCreated", team) })
nim.teamService.on('onTeamDismissed', (team) => { console.log("recv onTeamDismissed", team) })
nim.teamService.on('onTeamJoined', (team) => { console.log("recv onTeamJoined", team) })
nim.teamService.on('onTeamLeft', (team, isKicked) => { console.log("recv onTeamLeft", team, isKicked) })
nim.teamService.on('onTeamInfoUpdated', (team) => { console.log("recv onTeamInfoUpdated", team) })
nim.teamService.on('onTeamMemberJoined', (teamMembers) => { console.log("recv onTeamMemberJoined", teamMembers) })
nim.teamService.on('onTeamMemberKicked', (operateAccountId, teamMembers) => { console.log("recv onTeamMemberKicked", operateAccountId, teamMembers) })
nim.teamService.on('onTeamMemberLeft', (teamMembers) => { console.log("recv onTeamMemberLeft", teamMembers) })
nim.teamService.on('onTeamMemberInfoUpdated', (teamMembers) => { console.log("recv onTeamMemberInfoUpdated", teamMembers) })
nim.teamService.on('onReceiveTeamJoinActionInfo', (joinActionInfo) => { console.log("recv onReceiveTeamJoinActionInfo", joinActionInfo) })

javaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
// 创建群组参数
V2NIMCreateTeamParams createTeamParams = new V2NIMCreateTeamParams();
createTeamParams.setName("test");
createTeamParams.setTeamType(V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL);
createTeamParams.setMemberLimit(100);
createTeamParams.setIntro("test");
createTeamParams.setAnnouncement("test");
createTeamParams.setAvatar("http://test.png");
createTeamParams.setServerExtension("test");
createTeamParams.setAgreeMode(V2NIMTeamAgreeMode.V2NIM_TEAM_AGREE_MODE_AUTH);
createTeamParams.setJoinMode(V2NIMTeamJoinMode.V2NIM_TEAM_JOIN_MODE_INVITE);
createTeamParams.setInviteMode(V2NIMTeamInviteMode.V2NIM_TEAM_INVITE_MODE_MANAGER);
createTeamParams.setUpdateInfoMode(V2NIMTeamUpdateInfoMode.V2NIM_TEAM_UPDATE_INFO_MODE_MANAGER);
createTeamParams.setUpdateExtensionMode(V2NIMTeamUpdateExtensionMode.V2NIM_TEAM_UPDATE_EXTENSION_MODE_MANAGER);
// 创建群组时，同时被邀请加入群的成员列表
List<String> inviteeAccountIds = new ArrayList<>();
inviteeAccountIds.add("test1");
inviteeAccountIds.add("test2");
String postscript = "test";
// 易盾反垃圾配置，如果不审核，该配置不需要配置；如果开启了安全通，默认采用安全通，该配置不需要配置；如果需要审核，且直接对接易盾，则配置该配置
V2NIMAntispamConfig antispamConfig = null;
v2TeamService.createTeam(createTeamParams, inviteeAccountIds, postscript, antispamConfig, result -> {
    // 创建群组成功
}, error -> {
    // 创建群组失败
});

objective-cV2NIMCreateTeamParams *teamParams = [V2NIMCreateTeamParams new];
    teamParams.name = @"test";
    teamParams.teamType = V2NIM_TEAM_TYPE_NORMAL;
    teamParams.memberLimit = 100;
    teamParams.intro = @"test";
    teamParams.announcement = @"test";
    teamParams.avatar = @"http://test.png";
    teamParams.agreeMode = V2NIM_TEAM_AGREE_MODE_AUTH;
    teamParams.joinMode = V2NIM_TEAM_JOIN_MODE_FREE;
    teamParams.inviteMode = V2NIM_TEAM_INVITE_MODE_MANAGER;
    teamParams.updateInfoMode = V2NIM_TEAM_UPDATE_INFO_MODE_MANAGER;
    teamParams.updateExtensionMode = V2NIM_TEAM_UPDATE_EXTENSION_MODE_MANAGER;
    V2NIMAntispamConfig *config = [V2NIMAntispamConfig new];
    [[[NIMSDK sharedSDK] v2TeamService] createTeam:teamParams inviteeAccountIds:@[@"test1",@"test2"] postscript:@"test" antispamConfig:config success:^(V2NIMCreateTeamResult * _Nonnull result) {
            // 群组创建成功
        } failure:^(V2NIMError * _Nonnull error) {
            // 群组创建失败
        }];

cppV2NIMCreateTeamParams createTeamParams;
createTeamParams.name = "teamName";
nstd::vector<nstd::string> inviteeAccountIds;
inviteeAccountIds.push_back("account1");
V2NIMAntispamConfig antispamConfig;
teamService.createTeam(
    createTeamParams,
    inviteeAccountIds,
    "postscript",
    antispamConfig,
    [](V2NIMCreateTeamResult result) {
        // do something
    },
    [](V2NIMError error) {
        // get message list failed, handle error
    });

typescriptawait nim.V2NIMTeamService.createTeam(
  {
    "name": "群名",
    "teamType": 1,
    "memberLimit": 200,
  }
)

typescripttry {  
    const params: V2NIMCreateTeamParams = {
    name: this.name,
    teamType: this.teamType,
    memberLimit: this.memberLimit,
    intro: this.intro,
    announcement: this.announcement,
    avatar: this.avatar,
    serverExtension: this.serverExtension,
    joinMode: this.joinMode,
    agreeMode: this.agreeMode,
    inviteMode: this.inviteMode,
    updateInfoMode: this.updateInfoMode,
    updateExtensionMode: this.updateExtensionMode,
    chatBannedMode: this.chatBannedMode
  }

  const result:V2NIMCreateTeamResult = await nim.teamService.createTeam(params, [], '')
  // success
} catch (error) {
  // fail
}

javaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
String teamId = "123456";
V2NIMTeamType teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL;
List<String> invitorAccountIds = new ArrayList<>();
invitorAccountIds.add("test1");
invitorAccountIds.add("test2");
String postscript = "test";
v2TeamService.inviteMember(teamId,teamType, invitorAccountIds, postscript, result -> {
    // 邀请成员加入群组成功
}, error -> {
    // 邀请成员加入群组失败
});

objective-c[[[NIMSDK sharedSDK] v2TeamService] inviteMember:@"teamId" teamType:V2NIM_TEAM_TYPE_NORMAL inviteeAccountIds:@[@"accountId1"] postscript:@"test" success:^(NSArray<NSString *> * _Nonnull failedList) {
        // 邀请成员加入群组成功
    } failure:^(V2NIMError * _Nonnull error) {
        // 邀请成员加入群组失败
    }];

cppnstd::vector<nstd::string> inviteeAccountIds;
inviteeAccountIds.push_back("account1");
teamService.inviteMember(
    "teamId",
    V2NIM_TEAM_TYPE_NORMAL,
    inviteeAccountIds,
    "postscript",
    [](nstd::vector<nstd::string> failedList) {
        // invite member success
    },
    [](V2NIMError error) {
        // invite member failed, handle error
    });

typescriptawait nim.V2NIMTeamService.inviteMember("123456", 1, ["accountId1"])

typescripttry {
  const teamId: string = "123456"
  const teamType: V2NIMTeamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL
  const inviteeAccountIds: string[] = ["acc1", "acc2"]
  const postscript: string | undefined = "postscript"

  const res = await teamService.inviteMember(teamId, teamType, inviteeAccountIds, postscript)
  // success
}
catch (err) {
  // fail
}

javaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
// 收到的邀请信息
V2NIMTeamJoinActionInfo invitationInfo = getInvitationInfo();
v2TeamService.acceptInvitation(invitationInfo, result -> {
    // 同意邀请入群成功
}, error -> {
    // 同意邀请入群失败
});

objective-c[[[NIMSDK sharedSDK] v2TeamService] acceptInvitation:invitationInfo success:^(V2NIMTeam * _Nonnull team) {
    // 同意邀请入群成功
} failure:^(V2NIMError * _Nonnull error) {
    // 同意邀请入群失败
}];

cppV2NIMTeamJoinActionInfo invitationInfo;
// get invitationInfo from notification or query
// ...
teamService.acceptInvitation(
    invitationInfo,
    [](V2NIMTeam team) {
        // accept invitation success
    },
    [](V2NIMError error) {
        // accept invitation failed, handle error
    });

typescriptawait nim.V2NIMTeamService.acceptInvitation(
  {
    "teamId": "123456",
    "teamType": 1,
    "operatorAccountId": "accountId1",
    "actionType": 2
  }
)

typescripttry{
  const invitationInfo: V2NIMTeamJoinActionInfo = {
    actionType: V2NIMTeamJoinActionType.V2NIM_TEAM_JOIN_ACTION_TYPE_INVITATION,
    teamId: "123456",
    teamType: V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL,
    operatorAccountId: "account1",
  }
  
  const team: V2NIMTeam = await nim.teamService.acceptInvitation(invitationInfo)
  // success
}
catch (err) {
  // fail
}

javaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
// 收到的邀请信息
V2NIMTeamJoinActionInfo invitationInfo = getInvitationInfo();
String postscript = "test";
v2TeamService.rejectInvitation(invitationInfo, postscript, result -> {
    // 拒绝邀请入群成功
}, error -> {
    // 拒绝邀请入群失败
});

objective-c[[[NIMSDK sharedSDK] v2TeamService] rejectInvitation:invitationInfo postscript:@"test" success:^{
    // 拒绝邀请入群成功
} failure:^(V2NIMError * _Nonnull error) {
    // 拒绝邀请入群失败
}];

cppV2NIMTeamJoinActionInfo invitationInfo;
// get invitationInfo from notification or query
// ...
teamService.rejectInvitation(
    invitationInfo,
    "postscript",
    []() {
        // reject invitation success
    },
    [](V2NIMError error) {
        // reject invitation failed, handle error
    });

typescriptawait nim.V2NIMTeamService.rejectInvitation(
  {
    "teamId": "123456",
    "teamType": 1,
    "operatorAccountId": "accountId1",
    "actionType": 2
  },
  "test postscript"
)

typescripttry{
  const invitationInfo: V2NIMTeamJoinActionInfo = {
    actionType: V2NIMTeamJoinActionType.V2NIM_TEAM_JOIN_ACTION_TYPE_INVITATION,
    teamId: "123456",
    teamType: V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL,
    operatorAccountId: "account1",
  }
  
  await nim.teamService.rejectInvitation(invitationInfo)
  // success
}
catch (err) {
  // fail
}

javaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
String teamId = "123456";
V2NIMTeamType teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL;
String postscript = "test";
v2TeamService.applyJoinTeam(teamId, teamType, postscript, result -> {
    // 申请加入群组成功
}, error -> {
    // 申请加入群组失败
});

objective-c[[[NIMSDK sharedSDK] v2TeamService] applyJoinTeam:@"teamId" teamType:V2NIM_TEAM_TYPE_NORMAL postscript:@"test" success:^(V2NIMTeam * _Nonnull team) {
    // 申请加入群组成功
} failure:^(V2NIMError * _Nonnull error) {
    // 申请加入群组失败
}];

cppteamService.applyJoinTeam(
    "teamId",
    V2NIM_TEAM_TYPE_NORMAL,
    "postscript",
    [](V2NIMTeam team) {
        // apply join team success
    },
    [](V2NIMError error) {
        // apply join team failed, handle error
    }
);

typescriptawait nim.V2NIMTeamService.applyJoinTeam("123456", 1, "test postscript")

typescripttry{
  const teamId = "123456",
  const teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL,
  const postscript = "postscript"
  
  await nim.teamService.applyJoinTeam(teamId, teamType, postscript)
  // success
}
catch (err) {
  // fail
}

javavoid acceptJoinApplication(V2NIMTeamJoinActionInfo applicationInfo,V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

objective-c- (void)acceptJoinApplication:(V2NIMTeamJoinActionInfo *)applicationInfo
                      success:(nullable V2NIMSuccessCallback)success
                      failure:(nullable V2NIMFailureCallback)failure;

cppvirtual void acceptJoinApplication(V2NIMTeamJoinActionInfo applicationInfo, V2NIMSuccessCallback<void> success, V2NIMFailureCallback failure) = 0;

typescriptacceptJoinApplication(applicationInfo: V2NIMTeamJoinActionInfo): Promise<void>

typescriptacceptJoinApplication(applicationInfo: V2NIMTeamJoinActionInfo): Promise<void>

javaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
// 收到的入群申请信息
V2NIMTeamJoinActionInfo applicationInfo = getApplicationInfo();
v2TeamService.acceptJoinApplication(applicationInfo, result -> {
    // 接受入群申请成功
}, error -> {
    // 接受入群申请失败
});

objective-c[[[NIMSDK sharedSDK] v2TeamService] acceptJoinApplication:info success:^{
    // 接受入群申请成功
} failure:^(V2NIMError * _Nonnull error) {
    // 接受入群申请失败
}];

cppV2NIMTeamJoinActionInfo applicationInfo;
// get applicationInfo from notification or query
// ...
teamService.acceptJoinApplication(
    applicationInfo,
    []() {
        // accept join application success
    },
    [](V2NIMError error) {
        // accept join application failed, handle error
    });

typescriptawait nim.V2NIMTeamService.acceptJoinApplication(
  {
    "teamId": "123456",
    "teamType": 1,
    "operatorAccountId": "accountId1",
    "actionType": 0
  }
)

typescripttry{
  const applicationInfo: V2NIMTeamJoinActionInfo = {
    actionType: V2NIMTeamJoinActionType.V2NIM_TEAM_JOIN_ACTION_TYPE_APPLICATION,
    teamId: "123456",
    teamType: V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL,
    operatorAccountId: "account1",
  }
  
  await nim.teamService.acceptJoinApplication(applicationInfo)
  // success
}
catch (err) {
  // fail
}

javaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
// 收到的入群申请信息
V2NIMTeamJoinActionInfo applicationInfo = getApplicationInfo();
String postscript = "test";
v2TeamService.rejectInvitation(applicationInfo, postscript, result -> {
    // 拒绝入群申请成功
}, error -> {
    // 拒绝入群申请失败
});

objective-c[[[NIMSDK sharedSDK] v2TeamService] rejectJoinApplication:@"teamId"
                                                teamType:V2NIM_TEAM_TYPE_NORMAL
                                         applyAccountId:@"accountId"
                                             postscript:@"test"
                                                 success:^{
                                                     // 拒绝入群申请成功
                                                 }
                                                 failure:^(V2NIMError * _Nonnull error) {
                                                     // 拒绝入群申请失败
                                                 }];

cppV2NIMTeamJoinActionInfo applicationInfo;
// get applicationInfo from notification or query
// ...
teamService.rejectJoinApplication(
    applicationInfo,
    "postscript",
    []() {
        // reject join application success
    },
    [](V2NIMError error) {
        // reject join application failed, handle error
    });

typescriptawait nim.V2NIMTeamService.rejectJoinApplication(
  {
    "teamId": "123456",
    "teamType": 1,
    "operatorAccountId": "accountId1",
    "actionType": 0
  },
  "test postscript"
)

typescripttry{
  const applicationInfo: V2NIMTeamJoinActionInfo = {
    actionType: V2NIMTeamJoinActionType.V2NIM_TEAM_JOIN_ACTION_TYPE_APPLICATION,
    teamId: "123456",
    teamType: V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL,
    operatorAccountId: "account1",
  }
  const postscript = "postscript"
  
  await nim.teamService.rejectJoinApplication(applicationInfo, postscript)
  // success
}
catch (err) {
  // fail
}

javaV2TeamService v2TeamService = NIMClient.getService(V2TeamService.class);
String teamId = "123456";
V2TeamType teamType = V2TeamType.NORMAL;
String account = "test";
boolean leave = false;
v2TeamService.transferTeamOwner(teamId, teamType, account, leave, result -> {
    // 转移群组群主成功
}, error -> {
    // 转移群组群主失败
});

objective-c[[[NIMSDK sharedSDK] v2TeamService] transferTeamOwner:@"teamId" teamType:V2NIM_TEAM_TYPE_NORMAL accountId:@"accountId" leave:YES success:^{
    // 转移群组群主成功
} failure:^(V2NIMError * _Nonnull error) {
    // 转移群组群主失败
}];

cppteamService.transferTeamOwner(
    "teamId",
    V2NIM_TEAM_TYPE_NORMAL,
    "accountId",
    false,
    []() {
        // transfer team owner success
    },
    [](V2NIMError error) {
        // transfer team owner failed, handle error
    });

typescriptawait nim.V2NIMTeamService.transferTeamOwner("123456", 1, "accountId1", true)

typescripttry {
  const teamId: string = "123456"
  const teamType: V2NIMTeamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL
  const newAccountId: string = "aaa"
  const isLeave: boolean = true

  await nim.teamService.transferTeamOwner(teamId, teamType, newAccountId, isLeave)
  // success
} catch (error) {
  // fail
}

javaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
String teamId = "123456";
V2NIMTeamType teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL;
List<String> memberAccountIds = new ArrayList<>();
memberAccountIds.add("test1");
memberAccountIds.add("test2");
v2TeamService.kickMember(teamId,teamType, memberAccountIds, result -> {
    // 踢出群组成员成功
}, error -> {
    // 踢出群组成员失败
});

objective-c[[[NIMSDK sharedSDK] v2TeamService] kickMember:@"teamId" teamType:V2NIM_TEAM_TYPE_NORMAL memberAccountIds:@[@"accountId1"] success:^{
    // 踢出群组成员成功
} failure:^(V2NIMError * _Nonnull error) {
    // 踢出群组成员失败
}];

cppnstd::vector<nstd::string> memberAccountIds;
memberAccountIds.push_back("account1");
teamService.kickMember(
    "teamId",
    V2NIM_TEAM_TYPE_NORMAL,
    memberAccountIds,
    []() {
        // kick member success
    },
    [](V2NIMError error) {
        // kick member failed, handle error
    });

typescriptawait nim.V2NIMTeamService.kickMember("123456", 1, ["accountId1"])

typescripttry{
  const teamId = "123456",
  const teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL,
  const accounts = ["aaa", "bbb"]
  
  await nim.teamService.kickMember(teamId, teamType, accounts)
  // success
}
catch (err) {
  // fail
}

javaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
String teamId = "123456";
V2NIMTeamType teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL;
v2TeamService.leaveTeam(teamId,teamType, result -> {
    // 离开群组成功
}, error -> {
    // 离开群组失败
});

objective-c[[[NIMSDK sharedSDK] v2TeamService] leaveTeam:@"teamId" teamType:V2NIM_TEAM_TYPE_NORMAL success:^{
        // 离开群组成功
    } failure:^(V2NIMError * _Nonnull error) {
        // 离开群组失败
    }];

cppteamService.leaveTeam(
    "teamId",
    V2NIM_TEAM_TYPE_NORMAL,
    []() {
        // leave team success
    },
    [](V2NIMError error) {
        // leave team failed, handle error
    }
);

typescriptawait nim.V2NIMTeamService.leaveTeam("123456", 1)

typescriptconst teamId = "123456"
const teamType: V2NIMTeamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL
try {
  await nim.teamService.leaveTeam(teamId, teamType)
  // success
} catch (error) {
  // fail
}

javaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
String teamId = "123456";
V2NIMTeamType teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL;
v2TeamService.dismissTeam(teamId,teamType, result -> {
    // 解散群组成功
}, error -> {
    // 解散群组失败
});

objective-c[[[NIMSDK sharedSDK] v2TeamService] dismissTeam:@"teamId" teamType:V2NIM_TEAM_TYPE_NORMAL success:^{
    // 解散群组成功
} failure:^(V2NIMError * _Nonnull error) {
    // 解散群组失败
}];

cppteamService.dismissTeam(
    "teamId",
    V2NIM_TEAM_TYPE_NORMAL,
    []() {
        // dismiss team success
    },
    [](V2NIMError error) {
        // dismiss team failed, handle error
    });

typescriptawait nim.V2NIMTeamService.dismissTeam("123456", 1)

typescriptconst teamId = "123456"
const teamType: V2NIMTeamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL
try {
  await nim.teamService.dismissTeam(teamId, teamType)
  // success
} catch (error) {
  // fail
}

javaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
String teamId = "123456";
V2NIMTeamType teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL;
V2NIMUpdateTeamInfoParams updateTeamInfoParams = new V2NIMUpdateTeamInfoParams();
updateTeamInfoParams.setName("test_update");
updateTeamInfoParams.setMemberLimit(100);
updateTeamInfoParams.setIntro("test");
updateTeamInfoParams.setAnnouncement("test");
updateTeamInfoParams.setAvatar("http://test.png");
updateTeamInfoParams.setServerExtension("test");
updateTeamInfoParams.setAgreeMode(V2NIMTeamAgreeMode.V2NIM_TEAM_AGREE_MODE_AUTH);
updateTeamInfoParams.setJoinMode(V2NIMTeamJoinMode.V2NIM_TEAM_JOIN_MODE_INVITE);
updateTeamInfoParams.setInviteMode(V2NIMTeamInviteMode.V2NIM_TEAM_INVITE_MODE_MANAGER);
updateTeamInfoParams.setUpdateInfoMode(V2NIMTeamUpdateInfoMode.V2NIM_TEAM_UPDATE_INFO_MODE_MANAGER);
updateTeamInfoParams.setUpdateExtensionMode(V2NIMTeamUpdateExtensionMode.V2NIM_TEAM_UPDATE_EXTENSION_MODE_MANAGER);
// 易盾反垃圾配置，如果不审核，该配置不需要配置；如果开启了安全通，默认采用安全通，该配置不需要配置；如果需要审核，且直接对接易盾，则配置该配置
V2NIMAntispamConfig antispamConfig = null;
v2TeamService.updateTeamInfo(teamId,teamType, updateTeamInfoParams, antispamConfig, result -> {
    // 修改群组信息成功
}, error -> {
    // 修改群组信息失败
});

objective-c[[[NIMSDK sharedSDK] v2TeamService] updateTeamInfo:@"teamId" teamType:V2NIM_TEAM_TYPE_NORMAL updateTeamInfoParams:infoParams antispamConfig:config success:^{
    // 修改群组信息成功
} failure:^(V2NIMError * _Nonnull error) {
    // 修改群组信息失败
}];

cppV2NIMUpdateTeamInfoParams updateTeamInfoParams;
updateTeamInfoParams.name = "new team name";
V2NIMAntispamConfig antispamConfig;
teamService.updateTeamInfo(
    "teamId",
    V2NIM_TEAM_TYPE_NORMAL,
    updateTeamInfoParams,
    antispamConfig,
    []() {
        // update team info success
    },
    [](V2NIMError error) {
        // update team info failed, handle error
    });

typescriptawait nim.V2NIMTeamService.updateTeamInfo(
  "123456",
  1,
  {
    "name": "群名1",
    "memberLimit": 200,
    "joinMode": 0,
    "agreeMode": 0,
    "inviteMode": 0,
    "updateInfoMode": 0,
    "updateExtensionMode": 0,
    "chatBannedMode": 0
  }
)

typescripttry {
  console.info(`-----------update team----------- \n`)
  const params: V2NIMUpdateTeamInfoParams = {
    name: this.name,
    memberLimit: this.memberLimit,
    intro: this.intro,
    announcement: this.announcement,
    avatar: this.avatar,
    serverExtension: this.serverExtension,
    joinMode: this.joinMode,
    agreeMode: this.agreeMode,
    inviteMode: this.inviteMode,
    updateInfoMode: this.updateInfoMode,
    updateExtensionMode: this.updateExtensionMode,
  }

  await nim.teamService.updateTeamInfo(this.teamId, this.teamType, params )
  // success
} catch (error) {
  // fail
}

javaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
List<V2NIMTeamType> teamTypes = new ArrayList<>();
teamTypes.add(V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL);
teamTypes.add(V2NIMTeamType.V2NIM_TEAM_TYPE_SUPER);
v2TeamService.getJoinedTeamList(teamTypes, result -> {
    // 获取当前已经加入的群组列表成功
}, error -> {
    // 获取当前已经加入的群组列表失败
});

objective-c[[[NIMSDK sharedSDK] v2TeamService] getJoinedTeamList:nil success:^(NSArray<V2NIMTeam *> * _Nonnull teamList) {
    // 获取当前已经加入的群组列表成功
} failure:^(V2NIMError * _Nonnull error) {
    // 获取当前已经加入的群组列表失败
}];

cppnstd::vector<V2NIMTeamType> teamTypes;
teamTypes.push_back(V2NIM_TEAM_TYPE_NORMAL);
teamService.getJoinedTeamList(
    teamTypes,
    [](nstd::vector<V2NIMTeam> teamList) {
        // get joined team list success
    },
    [](V2NIMError error) {
        // get joined team list failed, handle error
    }
);

typescriptawait nim.V2NIMTeamService.getJoinedTeamList([1])

typescripttry {
    const teamTypes: V2NIMTeamType[] = [V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL, V2NIMTeamType.V2NIM_TEAM_TYPE_SUPER]
    const teams: V2NIMTeam[] = await nim.teamService.getJoinedTeamList(this.teamType)
    // success
} catch (e) {
    // fail
}

javaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
List<V2NIMTeamType> teamTypes = new ArrayList<>();
teamTypes.add(V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL);
teamTypes.add(V2NIMTeamType.V2NIM_TEAM_TYPE_SUPER);
int joinedTeamCount = v2TeamService.getJoinedTeamCount(teamTypes);

objective-cNSInteger allJoinedTeamCount = [[[NIMSDK sharedSDK] v2TeamService] getJoinedTeamCount:nil];

cppnstd::vector<V2NIMTeamType> teamTypes;
teamTypes.push_back(V2NIM_TEAM_TYPE_NORMAL);
auto count = teamService.getJoinedTeamCount(teamTypes);

typescriptnim.V2NIMTeamService.getJoinedTeamCount([1])

typescripttry {
    const teamTypes: V2NIMTeamType[] = [V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL, V2NIMTeamType.V2NIM_TEAM_TYPE_SUPER]
    const count: number = await nim.teamService.getJoinedTeamCount(this.teamType)
    // success
} catch (e) {
    // fail
}

javaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
String teamId = "123456";
V2NIMTeamType teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL;
v2TeamService.getTeamInfo(teamId,teamType, result -> {
    // 获取群组信息成功
}, error -> {
    // 获取群组信息失败
});

objective-c[[[NIMSDK sharedSDK] v2TeamService] getTeamInfo:@"teamId" teamType:V2NIM_TEAM_TYPE_NORMAL success:^(V2NIMTeam * _Nonnull team) {
    // 获取群组信息成功
} failure:^(V2NIMError * _Nonnull error) {
    // 获取群组信息失败
}];

cppteamService.getTeamInfo(
    "teamId",
    V2NIM_TEAM_TYPE_NORMAL,
    [](V2NIMTeam team) {
        // get team info success
    },
    [](V2NIMError error) {
        // get team info failed, handle error
    });

typescriptawait nim.V2NIMTeamService.getTeamInfo("123456", 1)

typescriptconst teamId = "123456"
const teamType: V2NIMTeamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL
try {
  const team: V2NIMTeam = await nim.teamService.getTeamInfo(teamId, teamType)
  // success
} catch (error) {
  // fail
}

javaV2NIMTeamService v2TeamService = NIMClient.getService(V2NIMTeamService.class);
List<String> teamIds = new ArrayList<>();
teamIds.add("123456");
teamIds.add("654321");
V2NIMTeamType teamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL;
v2TeamService.getTeamInfoByIds(teamIds,teamType, result -> {
    // 根据群组ID获取群组信息成功
}, error -> {
    // 根据群组ID获取群组信息失败
});

objective-c[[[NIMSDK sharedSDK] v2TeamService]getTeamInfoByIds:@[@"teamId1",@"teamId2"] teamType:V2NIM_TEAM_TYPE_NORMAL success:^(NSArray<V2NIMTeam *> * _Nonnull teamList) {
        // 根据群组ID获取群组信息成功
    } failure:^(V2NIMError * _Nonnull error) {
        // 根据群组ID获取群组信息失败
    }];

cppnstd::vector<nstd::string> teamIds;
teamIds.push_back("teamId1");
teamIds.push_back("teamId2");
teamService.getTeamInfoByIds(
    teamIds,
    V2NIM_TEAM_TYPE_NORMAL,
    [](nstd::vector<V2NIMTeam> teamList) {
        // get team info success
    },
    [](V2NIMError error) {
        // get team info failed, handle error
    });

typescriptawait nim.V2NIMTeamService.getTeamInfoByIds(["123456"], 1)

typescriptconst teamIds = ["123456", "7890"]
const teamType: V2NIMTeamType = V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL
try {
  const teams: V2NIMTeam[] = await nim.teamService.getTeamInfoByIds(teamIds, teamType)
  // success
} catch (error) {
  // fail
}

JavaString keyword = "搜索关键字" ;
NIMClient.getService(V2NIMTeamService.class).searchTeamByKeyword(keyword,
        new V2NIMSuccessCallback<List<V2NIMTeam>>() {
            @Override
            public void onSuccess(List<V2NIMTeam> v2NIMTeams) {

            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {

            }
        });

Objective-C- (void)searchTeam
{
    [NIMSDK.sharedSDK.v2TeamService searchTeamByKeyword:@"keyword" success:^(NSArray<V2NIMTeam *> * _Nonnull teamList) {
        // result
    } failure:^(V2NIMError * _Nonnull error) {
        // error
    }];
}

c++teamService.searchTeamByKeyword(
    "keyword",
    [](nstd::vector<V2NIMTeam> teamList) {
        // search team by keyword success
    },
    [](V2NIMError error) {
        // search team by keyword failed, handle error
    });

TypeScriptconst teams = await nim.V2NIMTeamService.searchTeamByKeyword('keyword')