v2_nim_def_struct.hpp

浏览该文件的文档.

#ifndef V2_NIM_DEF_STRUCT_H
#define V2_NIM_DEF_STRUCT_H
#include "v2_nim_def_enum.hpp"
 
namespace v2 {
 
struct V2NIMError {
    uint32_t code{V2NIM_ERROR_CODE_UNKNOWN};
    nstd::string desc;
    nstd::map<nstd::string, nstd::string> detail;
    V2NIMError() = default;
    V2NIMError(uint32_t code, nstd::Pair<nstd::string, nstd::string> pair = {});
    nstd::string& operator[](const nstd::string& key);
};
 
struct V2NIMSize {
    int32_t width{0};
    int32_t height{0};
};
 
struct V2NIMTransportLayerSecurityOption {
    bool sslConnection{true};
    bool allowSelfSignedCert{false};
    bool skipHostCertCheck{false};
    nstd::optional<nstd::string> clientCAFilePath;
};
 
struct V2NIMLinkOption {
    uint64_t linkTimeout{DEFAULT_LINK_TIMEOUT};
    uint64_t protocolTimeout{DEFAULT_PROTOCOL_TIMEOUT};
    V2NIMHandShakeType handShakeType{V2NIM_HANDSHAKE_TYPE_DEFAULT};
    V2NIMAsymmetricEncryptionAlgorithm asymmetricEncryptionAlgorithm{V2NIM_ASYMMETRIC_ENCRYPTION_ALGORITHM_RSA};
    V2NIMSymmetricEncryptionAlgorithm symmetricEncryptionAlgorithm{V2NIM_SYMMETRIC_ENCRYPTION_ALGORITHM_RC4};
    V2NIMTransportLayerSecurityOption tlsOption;
};
 
struct V2NIMFCSOption {
    V2NIMFCSAuthType fcsAuthType{V2NIM_FCS_AUTH_TYPE_NONE};
    nstd::string customAuthRefer;
    nstd::string customAuthUA;
};
 
struct V2NIMPrivateServerOption {
    V2NIMIPProtocolVersion ipProtocolVersion{V2NIM_IP_PROTOCOL_VERSION_IPV4};
    nstd::vector<nstd::string> lbsAddresses;
    nstd::string nosLbsAddress;
    nstd::string defaultLinkAddress;
    nstd::string defaultLinkAddressIpv6;
    nstd::string defaultNosUploadAddress;
    nstd::string defaultNosUploadHost;
    nstd::string nosDownloadAddress;
    nstd::vector<nstd::string> nosAccelerateHosts;
    nstd::string nosAccelerateAddress;
    uint64_t nosMaxUploadPartSize{V2NIM_DEFAULT_UPLOAD_PART_SIZE};
    nstd::string probeIpv4Url;
    nstd::string probeIpv6Url;
    nstd::string asymmetricEncryptionKeyA;
    nstd::string asymmetricEncryptionKeyB;
    uint32_t asymmetricEncryptionKeyVersion{0};
};
 
struct V2NIMDatabaseOption {
    nstd::string encryptionKey;
    bool enableBackup{true};
    bool enableRestore{false};
    nstd::string backupFolder;
    V2NIMSQLCipherVersion sqlcipherVersion{V2NIM_SQLCIPHER_VERSION_4};
    uint64_t backupIntervalTimeInSeconds{0};
};
 
struct V2NIMBasicOption {
    bool useHttps{true};
    bool useHttpdns{true};
    bool enableCloudConversation{false};
    uint32_t customClientType{0};
    nstd::string customTag;
    uint32_t logReserveDays{V2NIM_DEFAULT_LOG_RESERVE_DAYS};
    V2NIMSDKLogLevel sdkLogLevel{V2NIM_SDK_LOG_LEVEL_APP};
    nstd::optional<nstd::string> customizeLogCollectionDirectory;
    bool disableAppNap{true};
    bool enableCompass{true};
    nstd::optional<bool> teamNotificationBadge;
    bool reduceUnreadOnMessageRecall{false};
    bool conversationSnapshot{true};
    nstd::optional<nstd::string> compassDataEndpoint;
    uint32_t sdkType{0};
    nstd::function<void(nstd::string log)> logCallback;
};
 
struct V2NIMRouteConfig {
    bool routeEnabled{true};
    nstd::optional<nstd::string> routeEnvironment;
};
 
struct V2NIMInitOption {
    nstd::string appkey;
    nstd::string appDataPath;
    V2NIMBasicOption basicOption;
    V2NIMLinkOption linkOption;
    V2NIMDatabaseOption databaseOption;
    V2NIMFCSOption fcsOption;
    V2NIMRouteConfig routeConfig;
    nstd::optional<V2NIMPrivateServerOption> privateServerOption;
};
 
struct V2NIMStorageScene {
    nstd::string sceneName;
    uint64_t expireTime{0};
};
 
struct V2NIMChatroomEnterInfo {
    nstd::string roomNick;
    nstd::string roomAvatar;
    uint64_t enterTime{0};
    uint32_t clientType{0};
};
 
struct V2NIMChatroomMember {
    nstd::string roomId;
    nstd::string accountId;
    V2NIMChatroomMemberRole memberRole{V2NIM_CHATROOM_MEMBER_ROLE_NORMAL};
    nstd::optional<uint32_t> memberLevel;
    nstd::optional<nstd::string> roomNick;
    nstd::optional<nstd::string> roomAvatar;
    nstd::optional<nstd::string> serverExtension;
    bool isOnline{true};
    bool blocked{false};
    bool chatBanned{false};
    bool tempChatBanned{false};
    uint64_t tempChatBannedDuration{0};
    nstd::vector<nstd::string> tags;
    nstd::string notifyTargetTags;
    uint64_t enterTime{0};
    uint64_t updateTime{0};
    bool valid{true};
    nstd::vector<V2NIMChatroomEnterInfo> multiEnterInfo;
};
 
struct V2NIMChatroomUpdateParams {
    nstd::optional<nstd::string> roomName;
    nstd::optional<nstd::string> announcement;
    nstd::optional<nstd::string> liveUrl;
    nstd::optional<nstd::string> serverExtension;
    bool notificationEnabled{true};
    nstd::string notificationExtension;
    nstd::optional<V2NIMChatroomQueueLevelMode> queueLevelMode;
};
 
struct V2NIMUpdateTeamInfoParams {
    nstd::optional<nstd::string> name;
    nstd::optional<uint32_t> memberLimit;
    nstd::optional<nstd::string> intro;
    nstd::optional<nstd::string> announcement;
    nstd::optional<nstd::string> avatar;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<V2NIMTeamJoinMode> joinMode;
    nstd::optional<V2NIMTeamAgreeMode> agreeMode;
    nstd::optional<V2NIMTeamInviteMode> inviteMode;
    nstd::optional<V2NIMTeamUpdateInfoMode> updateInfoMode;
    nstd::optional<V2NIMTeamUpdateExtensionMode> updateExtensionMode;
};
 
struct V2NIMUpdatedTeamInfo : V2NIMUpdateTeamInfoParams {
    nstd::optional<V2NIMTeamChatBannedMode> chatBannedMode;
    nstd::optional<nstd::string> customerExtension;
};
 
struct V2NIMMessageCallDuration {
    nstd::string accountId;
    uint32_t duration;
};
 
struct V2NIMChatroomQueueElement {
    nstd::string key;
    nstd::string value;
    nstd::optional<nstd::string> accountId;
    nstd::optional<nstd::string> nick;
    nstd::optional<nstd::string> extension;
};
 
// noreflection
struct V2NIMMessageAttachment {
    nstd::string raw;
    V2NIMMessageAttachmentType attachmentType{V2NIM_MESSAGE_ATTACHMENT_TYPE_UNIVERSAL};
    virtual ~V2NIMMessageAttachment() = default;
};
 
// noreflection
struct V2NIMMessageFileAttachment : public V2NIMMessageAttachment {
    V2NIMMessageFileAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_FILE; }
    uint64_t size{0};
    nstd::string md5;
    nstd::string url;
    nstd::string name;
    nstd::string path;
    nstd::string ext;
    nstd::string sceneName{V2NIM_STORAGE_SCENE_NAME_DEFAULT_IM};
    V2NIMMessageAttachmentUploadState uploadState{V2NIM_MESSAGE_ATTACHMENT_UPLOAD_STATE_UNKNOWN};
};
 
// noreflection
struct V2NIMMessageImageAttachment : public V2NIMMessageFileAttachment {
    V2NIMMessageImageAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_IMAGE; }
    uint32_t width{0};
    uint32_t height{0};
};
 
// noreflection
struct V2NIMMessageAudioAttachment : public V2NIMMessageFileAttachment {
    V2NIMMessageAudioAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_AUDIO; }
    uint32_t duration{0};
};
 
// noreflection
struct V2NIMMessageVideoAttachment : public V2NIMMessageFileAttachment {
    V2NIMMessageVideoAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_VIDEO; }
    uint32_t duration{0};
    uint32_t width{0};
    uint32_t height{0};
};
 
// noreflection
struct V2NIMMessageLocationAttachment : public V2NIMMessageAttachment {
    V2NIMMessageLocationAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_LOCATION; }
    double latitude{0};
    double longitude{0};
    nstd::string address;
};
 
// noreflection
struct V2NIMMessageCallAttachment : V2NIMMessageAttachment {
    V2NIMMessageCallAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_CALL; }
    int32_t type{0};
    nstd::string channelId;
    int32_t status{0};
    nstd::vector<V2NIMMessageCallDuration> durations;
};
 
// noreflection
struct V2NIMMessageTeamNotificationAttachment : public V2NIMMessageAttachment {
    V2NIMMessageTeamNotificationAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_TEAM_NOTIFICATION; }
    V2NIMMessageNotificationType type{V2NIM_MESSAGE_NOTIFICATION_TYPE_TEAM_INVITE};
    nstd::optional<nstd::string> serverExtension;
    nstd::vector<nstd::string> targetIds;
    bool chatBanned{false};
    nstd::optional<V2NIMUpdatedTeamInfo> updatedTeamInfo;
};
 
// noreflection
struct V2NIMChatroomNotificationAttachment : public V2NIMMessageAttachment {
    V2NIMChatroomNotificationAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_CHATROOM_NOTIFICATION; }
    V2NIMChatroomMessageNotificationType type{V2NIM_CHATROOM_MESSAGE_NOTIFICATION_TYPE_MEMBER_ENTER};
    nstd::vector<nstd::string> targetIds;
    nstd::vector<nstd::string> targetNicks;
    nstd::optional<nstd::string> targetTag;
    nstd::string operatorId;
    nstd::string operatorNick;
    nstd::optional<nstd::string> notificationExtension;
    nstd::vector<nstd::string> tags;
    nstd::optional<V2NIMChatroomUpdateParams> chatroomUpdateParams;
    nstd::optional<V2NIMChatroomMember> chatroomMember;
};
 
// noreflection
struct V2NIMChatroomMessageRevokeNotificationAttachment : public V2NIMChatroomNotificationAttachment {
    V2NIMChatroomMessageRevokeNotificationAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_CHATROOM_MESSAGE_REVOKE_NOTIFICATION; }
    nstd::string messageClientId;
    uint64_t messageTime{0};
};
 
// noreflection
struct V2NIMChatroomQueueNotificationAttachment : public V2NIMChatroomNotificationAttachment {
    V2NIMChatroomQueueNotificationAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_CHATROOM_QUEUE_NOTIFICATION; }
    nstd::vector<V2NIMChatroomQueueElement> elements;
    V2NIMChatroomQueueChangeType queueChangeType;
};
 
// noreflection
struct V2NIMChatroomChatBannedNotificationAttachment : public V2NIMChatroomNotificationAttachment {
    V2NIMChatroomChatBannedNotificationAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_CHATROOM_CHAT_BANNED_NOTIFICATION; }
    bool chatBanned{false};
    bool tempChatBanned{false};
    uint64_t tempChatBannedDuration{0};
};
 
// noreflection
struct V2NIMChatroomMemberEnterNotificationAttachment : public V2NIMChatroomNotificationAttachment {
    V2NIMChatroomMemberEnterNotificationAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_CHATROOM_MEMBER_ENTER_NOTIFICATION; }
    bool chatBanned{false};
    bool tempChatBanned{false};
    uint64_t tempChatBannedDuration{0};
};
 
// noreflection
struct V2NIMChatroomMemberRoleUpdateAttachment : public V2NIMChatroomNotificationAttachment {
    V2NIMChatroomMemberRoleUpdateAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_CHATROOM_MEMBER_ROLE_UPDATE_NOTIFICATION; }
    V2NIMChatroomMemberRole previousRole{V2NIM_CHATROOM_MEMBER_ROLE_NORMAL};
    V2NIMChatroomMember currentMember;
};
 
struct V2NIMMessagePushConfig {
    bool pushEnabled{true};
    bool pushNickEnabled{true};
    nstd::string pushContent;
    nstd::string pushPayload;
    bool forcePush{false};
    nstd::string forcePushContent;
    nstd::vector<nstd::string> forcePushAccountIds;
};
 
struct V2NIMNotificationPushConfig {
    bool pushEnabled{true};
    bool pushNickEnabled{true};
    nstd::string pushContent;
    nstd::string pushPayload;
    bool forcePush{false};
    nstd::string forcePushContent;
    nstd::vector<nstd::string> forcePushAccountIds;
};
 
struct V2NIMMessageAntispamConfig {
    bool antispamEnabled{true};
    nstd::optional<nstd::string> antispamBusinessId;
    nstd::optional<nstd::string> antispamCustomMessage;
    nstd::optional<nstd::string> antispamCheating;
    nstd::optional<nstd::string> antispamExtension;
};
 
struct V2NIMNotificationAntispamConfig {
    bool antispamEnabled{true};
    nstd::optional<nstd::string> antispamCustomMessage;
};
 
struct V2NIMMessageRobotConfig {
    nstd::optional<nstd::string> accountId;
    nstd::optional<nstd::string> topic;
    nstd::optional<nstd::string> function;
    nstd::optional<nstd::string> customContent;
};
 
struct V2NIMMessageRouteConfig {
    bool routeEnabled{true};
    nstd::optional<nstd::string> routeEnvironment;
};
 
struct V2NIMNotificationRouteConfig {
    bool routeEnabled{true};
    nstd::optional<nstd::string> routeEnvironment;
};
 
struct V2NIMMessageConfig {
    bool readReceiptEnabled{false};
    bool lastMessageUpdateEnabled{true};
    bool historyEnabled{true};
    bool roamingEnabled{true};
    bool onlineSyncEnabled{true};
    bool offlineEnabled{true};
    bool unreadEnabled{true};
};
 
struct V2NIMNotificationConfig {
    bool offlineEnabled{true};
    bool unreadEnabled{true};
    nstd::optional<nstd::string> clientNotificationId;
};
 
struct V2NIMMessageRefer {
    nstd::string senderId;
    nstd::string receiverId;
    nstd::string messageClientId;
    nstd::string messageServerId;
    V2NIMConversationType conversationType{V2NIM_CONVERSATION_TYPE_UNKNOWN};
    nstd::string conversationId;
    uint64_t createTime{0};
};
 
struct V2NIMThreadMessageListOption {
    V2NIMMessageRefer messageRefer;
    nstd::optional<uint64_t> beginTime;
    nstd::optional<uint64_t> endTime;
    nstd::optional<nstd::string> excludeMessageServerId;
    nstd::optional<uint32_t> limit;
    nstd::optional<V2NIMQueryDirection> direction{V2NIM_QUERY_DIRECTION_DESC};
};
 
struct V2NIMMessageQueryTime {
    uint64_t begin{0};
    uint64_t end{0};
    bool includeBegin{true};
    bool includeEnd{false};
};
 
struct V2NIMMessageStatus {
    V2NIMErrorCode errorCode{V2NIM_ERROR_CODE_UNKNOWN};
    bool readReceiptSent{false};
};
 
struct V2NIMAIModelCallContent {
    nstd::string msg;
    int32_t type{0};
};
 
struct V2NIMAIModelCallMessage {
    V2NIMAIModelRoleType role;
    nstd::string msg;
    int32_t type{0};
};
 
struct V2NIMAIModelConfigParams {
    nstd::optional<nstd::string> prompt;
    nstd::optional<int32_t> maxTokens;
    nstd::optional<double> topP;
    nstd::optional<double> temperature;
};
 
struct V2NIMAIRAGInfo {
    nstd::string name;
    nstd::string description;
    nstd::string icon;
    nstd::string url;
    nstd::string title;
    time_t time{0};
};
 
struct V2NIMMessageAIStreamChunk {
    nstd::string content;
    time_t messageTime{0};
    time_t chunkTime{0};
    int type{0};
    uint32_t index{0};
};
 
struct V2NIMMessageAIConfig {
    nstd::string accountId;
    V2NIMMessageAIStatus aiStatus{V2NIM_MESSAGE_AI_STATUS_UNKNOWN};
    bool aiStream{false};
    V2NIMMessageAIStreamStatus aiStreamStatus{V2NIM_MESSAGE_AI_STREAM_STATUS_NONE};
    nstd::optional<nstd::vector<V2NIMAIRAGInfo>> aiRAGs;
    nstd::optional<V2NIMMessageAIStreamChunk> aiStreamLastChunk;
};
 
struct V2NIMMessageAIConfigParams {
    nstd::string accountId;
    bool aiStream{false};
    nstd::optional<V2NIMAIModelCallContent> content;
    nstd::optional<nstd::vector<V2NIMAIModelCallMessage>> messages;
    nstd::optional<nstd::string> promptVariables;
    nstd::optional<V2NIMAIModelConfigParams> modelConfigParams;
};
 
struct V2NIMMessageStreamChunk {
    nstd::string content;
    time_t messageTime{0};
    time_t chunkTime{0};
    int type{0};
    uint32_t index{0};
};
 
struct V2NIMMessageStreamConfig {
    V2NIMMessageStreamStatus status{V2NIM_MESSAGE_STREAM_STATUS_NONE};
    nstd::optional<nstd::vector<V2NIMAIRAGInfo>> rags;
    nstd::optional<V2NIMMessageStreamChunk> lastChunk;
};
 
struct V2NIMMessage {
    nstd::string messageClientId;
    nstd::string messageServerId;
    uint64_t createTime{0};
    nstd::string senderId;
    nstd::string senderName;
    nstd::string receiverId;
    V2NIMConversationType conversationType{V2NIM_CONVERSATION_TYPE_UNKNOWN};
    nstd::string conversationId;
    V2NIMMessageType messageType{V2NIM_MESSAGE_TYPE_TEXT};
    uint32_t subType{0};
    uint32_t audioState{0};
    nstd::string text;
    nstd::shared_ptr<V2NIMMessageAttachment> attachment;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<nstd::string> localExtension;
    nstd::optional<nstd::string> callbackExtension;
    nstd::optional<V2NIMMessageSendingState> sendingState;
    nstd::optional<V2NIMMessageAttachmentUploadState> attachmentUploadState;
    V2NIMMessageStatus messageStatus;
    V2NIMMessageConfig messageConfig;
    V2NIMMessagePushConfig pushConfig;
    V2NIMMessageRouteConfig routeConfig;
    V2NIMMessageAntispamConfig antispamConfig;
    V2NIMMessageRobotConfig robotConfig;
    nstd::optional<V2NIMMessageRefer> threadRoot;
    nstd::optional<V2NIMMessageRefer> threadReply;
    bool isSelf{false};
    bool isDeleted{false};
    nstd::optional<V2NIMMessageAIConfig> aiConfig;
    nstd::optional<V2NIMMessageStreamConfig> streamConfig;
    nstd::optional<uint64_t> modifyTime;
    nstd::optional<nstd::string> modifyAccountId;
    V2NIMMessageSource messageSource{V2NIM_MESSAGE_SOURCE_UNKNOWN};
    operator V2NIMMessageRefer() const {
        V2NIMMessageRefer messageRefer;
        messageRefer.senderId = senderId;
        messageRefer.receiverId = receiverId;
        messageRefer.messageClientId = messageClientId;
        messageRefer.messageServerId = messageServerId;
        messageRefer.conversationType = conversationType;
        messageRefer.conversationId = conversationId;
        messageRefer.createTime = createTime;
        return messageRefer;
    }
};
 
struct V2NIMModifyMessageParams {
    nstd::optional<uint32_t> subType;
    nstd::optional<nstd::string> text;
    nstd::shared_ptr<V2NIMMessageAttachment> attachment;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<V2NIMMessageAntispamConfig> antispamConfig;
    nstd::optional<V2NIMMessageRouteConfig> routeConfig;
    nstd::optional<V2NIMMessagePushConfig> pushConfig;
    bool clientAntispamEnabled{false};
    nstd::optional<nstd::string> clientAntispamReplace;
};
 
struct V2NIMThreadMessageListResult {
    V2NIMMessage message;
    uint64_t timestamp{0};
    uint32_t replyCount{0};
    nstd::vector<V2NIMMessage> replyList;
};
 
struct V2NIMCustomNotification {
    nstd::string senderId;
    nstd::string receiverId;
    V2NIMConversationType conversationType{V2NIM_CONVERSATION_TYPE_UNKNOWN};
    uint64_t timestamp{0};
    nstd::string content;
    V2NIMNotificationConfig notificationConfig;
    V2NIMNotificationPushConfig pushConfig;
    V2NIMNotificationAntispamConfig antispamConfig;
    V2NIMNotificationRouteConfig routeConfig;
};
 
struct V2NIMBroadcastNotification {
    uint64_t id;
    nstd::string senderId;
    uint64_t timestamp;
    nstd::string content;
};
 
struct V2NIMAIModelCallResult {
    uint32_t code{V2NIM_ERROR_CODE_SUCCESS};
    nstd::string accountId;
    nstd::string requestId;
    nstd::optional<V2NIMAIModelCallContent> content;
    nstd::optional<nstd::vector<V2NIMAIRAGInfo>> aiRAGs;
    time_t timestamp{0};
    bool aiStream{false};
    V2NIMAIModelStreamCallStatus aiStreamStatus{V2NIM_AI_MODEL_STREAM_CALL_STATUS_NONE};
};
 
struct V2NIMProxyAICallAntispamConfig {
    nstd::optional<bool> antispamEnabled{true};
    nstd::optional<nstd::string> antispamBusinessId;
};
 
struct V2NIMProxyAIModelCallParams {
    nstd::string accountId;
    nstd::string requestId;
    V2NIMAIModelCallContent content;
    nstd::optional<nstd::vector<V2NIMAIModelCallMessage>> messages;
    nstd::optional<nstd::string> promptVariables;
    nstd::optional<V2NIMAIModelConfigParams> modelConfigParams;
    nstd::optional<V2NIMProxyAICallAntispamConfig> antispamConfig;
    bool aiStream{false};
};
 
struct V2NIMMessageAIModelCallParams {
    nstd::string accountId;
    V2NIMAIModelCallContent aiModelCallParams;
    nstd::optional<nstd::vector<V2NIMMessage>> messages;
    nstd::optional<nstd::string> promptVariables;
    nstd::optional<V2NIMAIModelConfigParams> modelConfigParams;
};
 
struct V2NIMMessageTargetConfig {
    bool inclusive{true};
    nstd::vector<nstd::string> receiverIds;
    bool newMemberVisible{false};
};
 
struct V2NIMSendMessageParams {
    V2NIMMessageConfig messageConfig;
    V2NIMMessageRouteConfig routeConfig;
    V2NIMMessagePushConfig pushConfig;
    V2NIMMessageAntispamConfig antispamConfig;
    V2NIMMessageRobotConfig robotConfig;
    bool clientAntispamEnabled{false};
    nstd::string clientAntispamReplace;
    nstd::optional<V2NIMMessageAIConfigParams> aiConfig;
    nstd::optional<V2NIMMessageTargetConfig> targetConfig;
};
 
struct V2NIMMessageRevokeParams {
    nstd::optional<nstd::string> postscript;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<nstd::string> pushContent;
    nstd::optional<nstd::string> pushPayload;
    nstd::optional<nstd::string> env;
};
 
struct V2NIMMessageRevokeNotification {
    V2NIMMessageRefer messageRefer;
    nstd::optional<V2NIMMessage> message;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<nstd::string> postscript;
    nstd::string revokeAccountId;
    V2NIMMessageRevokeType revokeType{V2NIM_MESSAGE_REVOKE_TYPE_UNDEFINED};
    nstd::optional<nstd::string> callbackExtension;
};
 
struct V2NIMMessagePin {
    V2NIMMessageRefer messageRefer;
    nstd::string operatorId;
    nstd::optional<nstd::string> serverExtension;
    uint64_t createTime{0};
    uint64_t updateTime{0};
};
 
struct V2NIMMessagePinNotification {
    V2NIMMessagePinState pinState{V2NIM_MESSAGE_PIN_STEATE_NOT_PINNED};
    V2NIMMessagePin pin;
};
 
struct V2NIMSendCustomNotificationParams {
    V2NIMNotificationConfig notificationConfig;
    V2NIMNotificationPushConfig pushConfig;
    V2NIMNotificationAntispamConfig antispamConfig;
    V2NIMNotificationRouteConfig routeConfig;
};
 
struct V2NIMClientAntispamResult {
    V2NIMClientAntispamOperateType operateType{V2NIM_CLIENT_ANTISPAM_OPERATE_NONE};
    nstd::string replacedText;
};
 
struct V2NIMSendMessageResult {
    V2NIMMessage message;
    nstd::optional<nstd::string> antispamResult;
    nstd::optional<V2NIMClientAntispamResult> clientAntispamResult;
};
 
struct V2NIMModifyMessageResult {
    V2NIMMessage message;
    int32_t errorCode{V2NIM_ERROR_CODE_SUCCESS};
    nstd::string antispamResult;
    V2NIMClientAntispamResult clientAntispamResult;
};
 
struct V2NIMTeamMessageReadReceipt {
    nstd::string conversationId;
    nstd::string messageServerId;
    nstd::string messageClientId;
    uint32_t readCount{0};
    uint32_t unreadCount{0};
    nstd::optional<nstd::string> latestReadAccount;
};
 
struct V2NIMTeamMessageReadReceiptDetail {
    V2NIMTeamMessageReadReceipt readReceipt;
    nstd::vector<nstd::string> readAccountList;
    nstd::vector<nstd::string> unreadAccountList;
};
 
struct V2NIMP2PMessageReadReceipt {
    nstd::string conversationId;
    uint64_t timestamp{0};
};
 
struct V2NIMMessageClientAntispamResult {
    V2NIMMessageClientAntispamOperatorType operateType{V2NIM_MESSAGE_CLIENT_ANTISPAM_OPERATOR_NONE};
    nstd::string replaceContent;
};
 
struct V2NIMMessageListOption {
    nstd::vector<V2NIMMessageType> messageTypes;
    nstd::string conversationId;
    uint64_t beginTime{0};
    uint64_t endTime{0};
    uint32_t limit{V2NIM_DEFAULT_MESSAGE_LIST_LIMIT};
    nstd::optional<V2NIMMessage> anchorMessage;
    bool reverse{false};
    V2NIMQueryDirection direction{V2NIM_QUERY_DIRECTION_DESC};
    bool strictMode{false};
    bool onlyQueryLocal{false};
};
 
struct V2NIMCloudMessageListOption {
    nstd::string conversationId;
    time_t beginTime{0};
    time_t endTime{0};
    uint32_t limit{V2NIM_DEFAULT_MESSAGE_LIST_LIMIT};
    V2NIMQueryDirection direction{V2NIM_QUERY_DIRECTION_DESC};
    nstd::vector<V2NIMMessageType> messageTypes;
    nstd::optional<V2NIMMessage> anchorMessage;
};
 
struct V2NIMMessageListResult {
    nstd::vector<V2NIMMessage> messages;
    nstd::optional<V2NIMMessage> anchorMessage;
};
 
struct V2NIMClearHistoryMessageOption {
    nstd::string conversationId;
    bool deleteRoam{true};
    bool onlineSync{false};
    nstd::optional<nstd::string> serverExtension;
    V2NIMClearHistoryMode clearMode{V2NIM_CLEAR_HISTORY_MODE_ALL};
};
 
struct V2NIMMessageQuickCommentPushConfig {
    bool needPush{true};
    bool needBadge{true};
    nstd::string pushTitle;
    nstd::string pushContent;
    nstd::string pushPayload;
};
 
struct V2NIMMessageQuickComment {
    V2NIMMessageRefer messageRefer;
    nstd::string operatorId;
    uint64_t index{0};
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<uint64_t> createTime;
};
 
struct V2NIMMessageQuickCommentNotification {
    V2NIMMessageQuickCommentType operationType{V2NIM_MESSAGE_QUICK_COMMENT_TYPE_ADD};
    V2NIMMessageQuickComment quickComment;
};
 
struct V2NIMMessageDeletedNotification {
    V2NIMMessageRefer messageRefer;
    nstd::optional<V2NIMMessage> message;
    uint64_t deleteTime{0};
    nstd::optional<nstd::string> serverExtension;
};
 
struct V2NIMClearHistoryNotification {
    nstd::string conversationId;
    uint64_t deleteTime{0};
    nstd::optional<nstd::string> serverExtension;
};
 
struct V2NIMCollection {
    nstd::string collectionId;
    uint32_t collectionType{0};
    nstd::string collectionData;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<nstd::string> uniqueId;
    uint64_t createTime{0};
    uint64_t updateTime{0};
};
 
struct V2NIMAddCollectionParams {
    uint32_t collectionType{0};
    nstd::string collectionData;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<nstd::string> uniqueId;
};
 
struct V2NIMCollectionOption {
    uint64_t beginTime{0};
    uint64_t endTime{0};
    nstd::optional<V2NIMCollection> anchorCollection;
    V2NIMQueryDirection direction{V2NIM_QUERY_DIRECTION_DESC};
    uint32_t limit{V2NIM_DEFAULT_COLLECTION_LIST_LIMIT};
    uint32_t collectionType{0};
};
 
struct V2NIMCollectionListResult {
    uint32_t totalCount{0};
    nstd::vector<V2NIMCollection> collectionList;
};
 
using V2NIMTokenProvider = nstd::function<nstd::optional<nstd::string>(nstd::string accountId)>;
 
using V2NIMLoginExtensionProvider = nstd::function<nstd::optional<nstd::string>(nstd::string accountId)>;
 
using V2NIMChatroomTokenProvider = nstd::function<nstd::optional<nstd::string>(nstd::string roomId, nstd::string account)>;
 
using V2NIMChatroomLoginExtensionProvider = nstd::function<nstd::optional<nstd::string>(nstd::string roomId, nstd::string account)>;
 
using V2NIMChatroomLinkProvider = nstd::function<nstd::vector<nstd::string>(nstd::string roomId, nstd::string account)>;
 
struct V2NIMLoginOption {
    uint32_t retryCount{3};
    uint64_t timeout{V2NIM_DEFAULT_LOGIN_TIMEOUT};
    bool forceMode{true};
    V2NIMLoginAuthType authType{V2NIM_LOGIN_AUTH_TYPE_DEFAULT};
    V2NIMTokenProvider tokenProvider{nullptr};
    V2NIMLoginExtensionProvider loginExtensionProvider{nullptr};
    V2NIMDataSyncLevel syncLevel{V2NIM_DATA_SYNC_LEVEL_FULL};
    V2NIMRouteConfig routeConfig;
};
 
struct V2NIMLoginClient {
    V2NIMLoginClientType type{V2NIM_LOGIN_CLIENT_TYPE_UNKNOWN};
    nstd::string os;
    uint64_t timestamp{0};
    nstd::string customTag;
    uint32_t customClientType{0};
    nstd::string clientId;
    nstd::string clientIP;
};
 
struct V2NIMKickedOfflineDetail {
    V2NIMKickedOfflineReason reason{V2NIM_KICKED_OFFLINE_REASON_CLIENT_EXCLUSIVE};
    nstd::string reasonDesc;
    V2NIMLoginClientType clientType{V2NIM_LOGIN_CLIENT_TYPE_UNKNOWN};
    uint32_t customClientType{0};
};
 
struct V2NIMDataSyncDetail {
    V2NIMDataSyncType type{V2NIM_DATA_SYNC_MAIN};
    V2NIMDataSyncState state{V2NIM_DATA_SYNC_STATE_WAITING};
};
 
struct V2NIMLastMessage {
    V2NIMLastMessageState lastMessageState{V2NIM_MESSAGE_STATE_DEFAULT};
    nstd::optional<V2NIMMessageRefer> messageRefer;
    nstd::optional<V2NIMMessageType> messageType;
    nstd::optional<uint32_t> subType;
    nstd::optional<V2NIMMessageSendingState> sendingState;
    nstd::string text;
    nstd::shared_ptr<V2NIMMessageAttachment> attachment;
    nstd::optional<nstd::string> revokeAccountId;
    nstd::optional<V2NIMMessageRevokeType> revokeType;
    nstd::optional<nstd::string> senderId;
    nstd::optional<nstd::string> senderName;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<nstd::string> callbackExtension;
};
 
struct V2NIMConversation {
    nstd::string conversationId;
    V2NIMConversationType type{V2NIM_CONVERSATION_TYPE_UNKNOWN};
    nstd::optional<nstd::string> name;
    nstd::optional<nstd::string> avatar;
    bool mute{false};
    bool stickTop{false};
    nstd::vector<nstd::string> groupIds;
    nstd::optional<nstd::string> localExtension;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<V2NIMLastMessage> lastMessage;
    uint32_t unreadCount{0};
    uint64_t sortOrder{0};
    uint64_t createTime{0};
    uint64_t updateTime{0};
    uint64_t lastReadTime{0};
};
 
struct V2NIMConversationResult {
    uint64_t offset{0};
    bool finished{false};
    nstd::vector<V2NIMConversation> conversationList;
};
 
struct V2NIMConversationOperationResult {
    nstd::string conversationId;
    V2NIMError error;
};
 
struct V2NIMConversationUpdate {
    nstd::optional<nstd::string> serverExtension;
};
 
struct V2NIMConversationOption {
    nstd::vector<V2NIMConversationType> conversationTypes;
    nstd::optional<nstd::vector<nstd::string>> conversationGroupIds;
    bool onlyUnread{false};
};
 
struct V2NIMConversationFilter {
    nstd::set<V2NIMConversationType> conversationTypes;
    nstd::string conversationGroupId;
    bool ignoreMuted{false};
};
 
struct V2NIMConversationGroup {
    nstd::string groupId;
    nstd::string name;
    nstd::optional<nstd::string> serverExtension;
    uint64_t createTime{0};
    uint64_t updateTime{0};
};
 
struct V2NIMConversationGroupResult {
    V2NIMConversationGroup group;
    nstd::vector<V2NIMConversationOperationResult> failedList;
};
 
struct V2NIMMessageSearchParams {
    nstd::string keyword;
    uint64_t beginTime{0};
    uint64_t endTime{0};
    uint32_t conversationLimit{0};
    uint32_t messageLimit{V2NIM_DEFAULT_SEARCH_MESSAGE_LIST_LIMIT};
    V2NIMSortOrder sortOrder{V2NIM_SORT_ORDER_DESC};
    nstd::vector<nstd::string> p2pAccountIds;
    nstd::vector<nstd::string> teamIds;
    nstd::vector<nstd::string> senderAccountIds;
    nstd::vector<V2NIMMessageType> messageTypes;
    nstd::vector<uint32_t> messageSubTypes;
};
 
struct V2NIMVoiceToTextParams {
    nstd::string voicePath;
    nstd::string voiceUrl;
    nstd::string mimeType;
    nstd::string sampleRate;
    uint64_t duration{0};
    nstd::string sceneName;
};
 
struct V2NIMTeamRefer {
    nstd::string teamId;
    V2NIMTeamType teamType{V2NIM_TEAM_TYPE_NORMAL};
    bool operator<(const V2NIMTeamRefer& other) const;
    bool operator==(const V2NIMTeamRefer& other) const;
 
    static std::string referToKey(V2NIMTeamRefer refer);
    static V2NIMTeamRefer keyToRefer(std::string key);
    // 添加 hash_value 方法
    size_t hash_value() const { return std::hash<std::string>()(teamId) ^ (std::hash<int>()(static_cast<int>(teamType)) << 1); }
};
 
struct V2NIMTeam {
    nstd::string teamId;
    V2NIMTeamType teamType{V2NIM_TEAM_TYPE_NORMAL};
    nstd::string name;
    nstd::string ownerAccountId;
    uint32_t memberLimit{0};
    uint32_t memberCount{0};
    uint64_t createTime{0};
    uint64_t updateTime{0};
    nstd::optional<nstd::string> intro;
    nstd::optional<nstd::string> announcement;
    nstd::optional<nstd::string> avatar;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<nstd::string> customerExtension;
    V2NIMTeamJoinMode joinMode{V2NIM_TEAM_JOIN_MODE_APPLY};
    V2NIMTeamAgreeMode agreeMode{V2NIM_TEAM_AGREE_MODE_AUTH};
    V2NIMTeamInviteMode inviteMode{V2NIM_TEAM_INVITE_MODE_MANAGER};
    V2NIMTeamUpdateInfoMode updateInfoMode{V2NIM_TEAM_UPDATE_INFO_MODE_MANAGER};
    V2NIMTeamUpdateExtensionMode updateExtensionMode{V2NIM_TEAM_UPDATE_EXTENSION_MODE_MANAGER};
    V2NIMTeamChatBannedMode chatBannedMode{V2NIM_TEAM_CHAT_BANNED_MODE_NONE};
    bool isValidTeam{true};
    bool isTeamEffective{true};
    uint32_t bits{0};
    nstd::optional<uint64_t> teamMemberTime;
    operator V2NIMTeamRefer() const {
        V2NIMTeamRefer teamRefer;
        teamRefer.teamId = teamId;
        teamRefer.teamType = teamType;
        return teamRefer;
    }
};
 
struct V2NIMTeamMember {
    nstd::string teamId;
    V2NIMTeamType teamType{V2NIM_TEAM_TYPE_NORMAL};
    nstd::string accountId;
    nstd::optional<V2NIMTeamMemberRole> memberRole;
    nstd::optional<nstd::string> teamNick;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<uint64_t> joinTime;
    nstd::optional<uint64_t> updateTime;
    nstd::optional<nstd::string> invitorAccountId;
    nstd::optional<bool> inTeam;
    nstd::optional<bool> chatBanned;
    nstd::vector<nstd::string> followAccountIds;
    nstd::optional<uint64_t> bits;
};
 
// @internal
struct V2NIMTeamMemberUpdateParams {
    nstd::string teamId;
    V2NIMTeamType teamType{V2NIM_TEAM_TYPE_NORMAL};
    nstd::string accountId;
    nstd::optional<V2NIMTeamMemberRole> memberRole;
    nstd::optional<nstd::string> teamNick;
    nstd::optional<uint64_t> bits;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<uint64_t> joinTime;
    nstd::optional<uint64_t> updateTime;
    nstd::optional<nstd::string> invitorAccountId;
    nstd::optional<bool> inTeam;
    nstd::optional<bool> chatBanned;
};
 
struct V2NIMCreateTeamParams {
    nstd::string name;
    V2NIMTeamType teamType{V2NIM_TEAM_TYPE_NORMAL};
    nstd::optional<uint32_t> memberLimit;
    nstd::optional<nstd::string> intro;
    nstd::optional<nstd::string> announcement;
    nstd::optional<nstd::string> avatar;
    nstd::optional<nstd::string> serverExtension;
    V2NIMTeamJoinMode joinMode{V2NIM_TEAM_JOIN_MODE_APPLY};
    V2NIMTeamAgreeMode agreeMode{V2NIM_TEAM_AGREE_MODE_AUTH};
    V2NIMTeamInviteMode inviteMode{V2NIM_TEAM_INVITE_MODE_MANAGER};
    V2NIMTeamUpdateInfoMode updateInfoMode{V2NIM_TEAM_UPDATE_INFO_MODE_MANAGER};
    V2NIMTeamUpdateExtensionMode updateExtensionMode{V2NIM_TEAM_UPDATE_EXTENSION_MODE_MANAGER};
    V2NIMTeamChatBannedMode chatBannedMode{V2NIM_TEAM_CHAT_BANNED_MODE_NONE};
};
 
struct V2NIMTeamMemberQueryOption {
    nstd::optional<V2NIMTeamMemberRoleQueryType> roleQueryType;
    bool onlyChatBanned{false};
    V2NIMQueryDirection direction{V2NIM_QUERY_DIRECTION_DESC};
    nstd::string nextToken;
    uint32_t limit{V2NIM_DEFAULT_TEAM_MEMBER_LIST_LIMIT};
};
 
struct V2NIMCreateTeamResult {
    V2NIMTeam team;
    nstd::vector<nstd::string> failedList;
};
 
struct V2NIMTeamSearchParams {
    nstd::vector<nstd::string> keywordList;
    nstd::optional<V2NIMSearchKeywordMathType> keywordMatchType{V2NIM_SEARCH_KEYWORD_MATH_TYPE_OR};
    nstd::optional<nstd::vector<V2NIMTeamType>> teamTypes;
    nstd::optional<uint32_t> limit{V2NIM_DEFAULT_SEARCH_LOCAL_TEAM_LIST_LIMIT};
    nstd::optional<nstd::string> nextToken;
};
 
struct V2NIMSearchTeamMemberParams {
    nstd::vector<nstd::string> keywordList;
    nstd::optional<V2NIMSearchKeywordMathType> keywordMatchType{V2NIM_SEARCH_KEYWORD_MATH_TYPE_OR};
    nstd::optional<nstd::vector<V2NIMTeamRefer>> teamRefers;
    bool searchAccountId{false};
    bool searchTeamNick{true};
    nstd::optional<uint32_t> limit{V2NIM_DEFAULT_SEARCH_LOCAL_TEAM_MEMBER_LIST_LIMIT};
    nstd::optional<nstd::string> nextToken;
};
 
struct V2NIMAntispamConfig {
    nstd::string antispamBusinessId;
};
 
struct V2NIMUpdateSelfMemberInfoParams {
    nstd::optional<nstd::string> teamNick;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<V2NIMAntispamConfig> antispamConfig;
};
 
struct V2NIMUpdateMemberNickParams {
    nstd::string accountId;
    nstd::string teamNick;
    nstd::optional<V2NIMAntispamConfig> antispamConfig;
};
 
struct V2NIMTeamMemberListResult {
    bool finished{false};
    nstd::string nextToken;
    nstd::vector<V2NIMTeamMember> memberList;
};
 
struct V2NIMTeamInviteParams {
    nstd::vector<nstd::string> inviteeAccountIds;
    nstd::optional<nstd::string> postscript;
    nstd::optional<nstd::string> serverExtension;
};
 
struct V2NIMTeamJoinActionInfo {
    V2NIMTeamJoinActionType actionType{V2NIM_TEAM_JOIN_ACTION_TYPE_APPLICATION};
    nstd::string teamId;
    V2NIMTeamType teamType{V2NIM_TEAM_TYPE_NORMAL};
    nstd::string operatorAccountId;
    nstd::optional<nstd::string> postscript;
    uint64_t timestamp{0};
    V2NIMTeamJoinActionStatus actionStatus{V2NIM_TEAM_JOIN_ACTION_STATUS_INIT};
    nstd::optional<nstd::string> serverExtension;
    bool read{false};
};
 
struct V2NIMUser {
    nstd::string accountId;
    nstd::optional<nstd::string> name;
    nstd::optional<nstd::string> avatar;
    nstd::optional<nstd::string> sign;
    nstd::optional<nstd::string> email;
    nstd::optional<nstd::string> birthday;
    nstd::optional<nstd::string> mobile;
    nstd::optional<uint32_t> gender;
    nstd::optional<nstd::string> serverExtension;
    uint64_t createTime{0};
    uint64_t updateTime{0};
};
 
struct V2NIMUserUpdateParams {
    nstd::optional<nstd::string> name;
    nstd::optional<nstd::string> avatar;
    nstd::optional<nstd::string> sign;
    nstd::optional<nstd::string> email;
    nstd::optional<nstd::string> birthday;
    nstd::optional<nstd::string> mobile;
    nstd::optional<uint32_t> gender;
    nstd::optional<nstd::string> serverExtension;
};
 
struct V2NIMUserSearchOption {
    nstd::string keyword;
    bool searchName{true};
    bool searchAccountId{false};
    bool searchMobile{false};
};
 
struct V2NIMFriend {
    nstd::string accountId;
    nstd::optional<nstd::string> alias;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<nstd::string> customerExtension;
    nstd::optional<uint64_t> createTime;
    nstd::optional<uint64_t> updateTime;
    V2NIMUser userProfile;
    nstd::optional<uint32_t> flag;
    nstd::optional<uint32_t> beflag;
};
 
struct V2NIMFriendAddParams {
    V2NIMFriendAddMode addMode{V2NIM_FRIEND_MODE_TYPE_ADD};
    nstd::optional<nstd::string> postscript;
};
 
struct V2NIMFriendAddApplication {
    nstd::string applicantAccountId;
    nstd::string recipientAccountId;
    nstd::string operatorAccountId;
    nstd::optional<nstd::string> postscript;
    V2NIMFriendAddApplicationStatus status{V2NIM_FRIEND_ADD_APPLICATION_STATUS_INIT};
    uint64_t timestamp{0};
    bool read{false};
};
 
struct V2NIMFriendDeleteParams {
    bool deleteAlias{false};
};
 
struct V2NIMFriendSetParams {
    nstd::optional<nstd::string> alias;
    nstd::optional<nstd::string> serverExtension;
};
 
struct V2NIMFriendSearchOption {
    nstd::string keyword;
    bool searchAlias{true};
    bool searchAccountId{false};
};
 
struct V2NIMTeamJoinActionInfoQueryOption {
    nstd::vector<V2NIMTeamJoinActionType> types;
    uint64_t offset;
    uint32_t limit{V2NIM_DEFAULT_JOIN_ACTION_QUERY_LIMIT};
    nstd::vector<V2NIMTeamJoinActionStatus> status;
};
 
struct V2NIMTeamMemberSearchOption {
    nstd::string keyword;
    V2NIMTeamType teamType{V2NIM_TEAM_TYPE_NORMAL};
    nstd::optional<nstd::string> teamId;
    bool searchAccountId{false};
    // 起始位置，首次传空， 后续传上次返回的 nextToken
    nstd::string nextToken;
    V2NIMSortOrder order{V2NIM_SORT_ORDER_DESC};
    uint32_t limit{V2NIM_DEFAULT_SEARCH_MESSAGE_LIST_LIMIT};
};
 
struct V2NIMTeamJoinActionInfoResult {
    nstd::vector<V2NIMTeamJoinActionInfo> infos;
    uint64_t offset{0};
    bool finished{false};
};
 
struct V2NIMFriendAddApplicationQueryOption {
    uint64_t offset;
    uint32_t limit{V2NIM_DEFAULT_FRIEND_APPLICATION_QUERY_LIMIT};
    nstd::vector<V2NIMFriendAddApplicationStatus> status;
};
 
struct V2NIMFriendAddApplicationResult {
    nstd::vector<V2NIMFriendAddApplication> infos;
    uint64_t offset{0};
    bool finished{false};
};
 
struct V2NIMDndConfig {
    bool showDetail{false};
    bool dndOn{false};
    uint32_t fromH{0};
    uint32_t fromM{0};
    uint32_t toH{0};
    uint32_t toM{0};
};
 
struct V2NIMChatroomLoginOption {
    V2NIMLoginAuthType authType{V2NIM_LOGIN_AUTH_TYPE_DEFAULT};
    V2NIMChatroomTokenProvider tokenProvider{nullptr};
    V2NIMChatroomLoginExtensionProvider loginExtensionProvider{nullptr};
    V2NIMRouteConfig routeConfig;
};
 
struct V2NIMChatroomTagConfig {
    nstd::vector<nstd::string> tags;
    nstd::string notifyTargetTags;
};
 
struct V2NIMLocationInfo {
    nstd::optional<double> x;
    nstd::optional<double> y;
    nstd::optional<double> z;
};
 
struct V2NIMChatroomLocationConfig {
    V2NIMLocationInfo locationInfo;
    nstd::optional<double> distance;
};
 
struct V2NIMChatroomEnterParams {
    nstd::string accountId;
    nstd::string token;
    nstd::optional<nstd::string> roomNick;
    nstd::optional<nstd::string> roomAvatar;
    uint64_t timeout{V2NIM_DEFAULT_LOGIN_TIMEOUT};
    V2NIMChatroomLoginOption loginOption;
    bool anonymousMode{false};
    V2NIMChatroomLinkProvider linkProvider{nullptr};
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<nstd::string> notificationExtension;
    V2NIMChatroomTagConfig tagConfig;
    nstd::optional<V2NIMChatroomLocationConfig> locationConfig;
    V2NIMAntispamConfig antispamConfig;
};
 
struct V2NIMChatroomInfo {
    nstd::string roomId;
    nstd::string roomName;
    nstd::string announcement;
    nstd::string liveUrl;
    bool isValidRoom{true};
    nstd::string serverExtension;
    V2NIMChatroomQueueLevelMode queueLevelMode{V2NIM_CHATROOM_QUEUE_LEVEL_MODE_ANY};
    nstd::string creatorAccountId;
    uint32_t onlineUserCount{0};
    bool chatBanned{false};
};
 
struct V2NIMChatroomCdnInfo {
    bool enabled{false};
    nstd::vector<nstd::string> cdnUrls;
    uint64_t timestamp;
    uint64_t pollingInterval;  // seconds
    uint32_t decryptType;
    nstd::string decryptKey;
    uint64_t pollingTimeout;  // milliseconds
};
 
struct V2NIMChatroomEnterResult {
    V2NIMChatroomInfo chatroom;
    V2NIMChatroomMember selfMember;
};
 
struct V2NIMChatroomKickedInfo {
    V2NIMChatroomKickedReason kickedReason{V2NIM_CHATROOM_KICKED_REASON_UNKNOWN};
    nstd::string serverExtension;
};
 
struct V2NIMUserInfoConfig {
    uint64_t userInfoTimestamp{0};
    nstd::string senderNick;
    nstd::string senderAvatar;
    nstd::string senderExtension;
};
 
struct V2NIMChatroomMessageConfig {
    bool historyEnabled{true};
    bool highPriority{false};
};
 
struct V2NIMChatroomMessage {
    nstd::string messageClientId;
    V2NIMLoginClientType senderClientType{V2NIM_LOGIN_CLIENT_TYPE_UNKNOWN};
    uint64_t createTime{0};
    nstd::string senderId;
    nstd::string roomId;
    bool isSelf{false};
    V2NIMMessageAttachmentUploadState attachmentUploadState{V2NIM_MESSAGE_ATTACHMENT_UPLOAD_STATE_UNKNOWN};
    V2NIMMessageSendingState sendingState{V2NIM_MESSAGE_SENDING_STATE_UNKNOWN};
    V2NIMMessageType messageType{V2NIM_MESSAGE_TYPE_TEXT};
    uint32_t subType{0};
    nstd::string text;
    nstd::shared_ptr<V2NIMMessageAttachment> attachment;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<nstd::string> callbackExtension;
    V2NIMMessageRouteConfig routeConfig;
    V2NIMMessageAntispamConfig antispamConfig;
    nstd::string notifyTargetTags;
    V2NIMChatroomMessageConfig messageConfig;
    V2NIMUserInfoConfig userInfoConfig;
    nstd::optional<V2NIMLocationInfo> locationInfo;
};
 
struct V2NIMSendChatroomMessageParams {
    V2NIMChatroomMessageConfig messageConfig;
    V2NIMMessageRouteConfig routeConfig;
    V2NIMMessageAntispamConfig antispamConfig;
    bool clientAntispamEnabled{false};
    nstd::string clientAntispamReplace;
    nstd::vector<nstd::string> receiverIds;
    nstd::string notifyTargetTags;
    nstd::optional<V2NIMLocationInfo> locationInfo;
};
 
struct V2NIMSendChatroomMessageResult {
    V2NIMChatroomMessage message;
    nstd::string antispamResult;
    nstd::optional<V2NIMClientAntispamResult> clientAntispamResult;
};
 
struct V2NIMChatroomMemberQueryOption {
    nstd::vector<V2NIMChatroomMemberRole> memberRoles;
    bool onlyBlocked{false};
    bool onlyChatBanned{false};
    bool onlyOnline{false};
    nstd::string pageToken;
    uint32_t limit{V2NIM_DEFAULT_CHATROOM_QUERY_LIMIT};
};
 
struct V2NIMChatroomMemberListResult {
    nstd::string pageToken;
    bool finished{false};
    nstd::vector<V2NIMChatroomMember> memberList;
};
 
struct V2NIMChatroomMessageListOption {
    V2NIMQueryDirection direction{V2NIM_QUERY_DIRECTION_DESC};
    nstd::vector<V2NIMMessageType> messageTypes;
    uint64_t beginTime{0};
    uint32_t limit{V2NIM_DEFAULT_CHATROOM_QUERY_LIMIT};
};
 
struct V2NIMChatroomMemberRoleUpdateParams {
    V2NIMChatroomMemberRole memberRole{V2NIM_CHATROOM_MEMBER_ROLE_NORMAL};
    nstd::optional<uint32_t> memberLevel;
    nstd::optional<nstd::string> notificationExtension;
};
 
struct V2NIMChatroomSelfMemberUpdateParams {
    nstd::optional<nstd::string> roomNick;
    nstd::optional<nstd::string> roomAvatar;
    nstd::optional<nstd::string> serverExtension;
    bool notificationEnabled{true};
    nstd::string notificationExtension;
    bool persistence{false};
};
 
struct V2NIMChatroomTagTempChatBannedParams {
    nstd::string targetTag;
    nstd::string notifyTargetTags;
    uint64_t duration{0};
    bool notificationEnabled{true};
    nstd::string notificationExtension;
};
 
struct V2NIMChatroomTagsUpdateParams {
    nstd::optional<nstd::vector<nstd::string>> tags;
    nstd::optional<nstd::string> notifyTargetTags;
    bool notificationEnabled{true};
    nstd::string notificationExtension;
};
 
struct V2NIMChatroomTagMemberOption {
    nstd::string tag;
    nstd::string pageToken;
    uint32_t limit{V2NIM_DEFAULT_CHATROOM_QUERY_LIMIT};
};
 
struct V2NIMChatroomTagMessageOption {
    nstd::vector<nstd::string> tags;
    nstd::vector<V2NIMMessageType> messageTypes;
    uint64_t beginTime{0};
    uint64_t endTime{0};
    uint32_t limit{V2NIM_DEFAULT_CHATROOM_QUERY_LIMIT};
    V2NIMQueryDirection direction{V2NIM_QUERY_DIRECTION_DESC};
};
 
struct V2NIMChatRoomMessageCustomAttachmentParser {
    virtual nstd::shared_ptr<V2NIMMessageAttachment> parse(const nstd::string& attach, const int32_t& subType) = 0;
    virtual ~V2NIMChatRoomMessageCustomAttachmentParser() = default;
};
 
struct V2NIMClientAntispamThesaurusItem {
    nstd::string key;
    V2NIMClientAntispamThesaurusMatchType matchType{V2NIM_CLIENT_ANTISPAM_THESAURUS_MATCH_TYPE_WORD};
    V2NIMClientAntispamOperateType operateType{V2NIM_CLIENT_ANTISPAM_OPERATE_NONE};
    nstd::string config;
};
 
struct V2NIMClientAntispamThesaurus {
    nstd::string name;
    nstd::string config;
    nstd::vector<V2NIMClientAntispamThesaurusItem> items;
};
 
struct V2NIMChatroomQueueOfferParams {
    nstd::string elementKey;
    nstd::string elementValue;
    bool transient{false};
    nstd::optional<nstd::string> elementOwnerAccountId;
};
 
struct V2NIMUploadFileParams {
    nstd::string filePath;
    nstd::string sceneName;
};
 
struct V2NIMUploadFileTask {
    nstd::string taskId;
    V2NIMUploadFileParams uploadParams;
};
 
struct V2NIMAIModelConfig {
    nstd::string model;
    nstd::string prompt;
    nstd::optional<nstd::vector<nstd::string>> promptKeys;
    nstd::optional<uint32_t> maxTokens;
    nstd::optional<nstd::string> topP;
    nstd::optional<nstd::string> temperature;
};
 
struct V2NIMAIUser : public V2NIMUser {
    V2NIMAIModelType modelType;
    int aiModelType{0};
    V2NIMAIModelConfig modelConfig;
};
 
struct V2NIMDownloadMessageAttachmentParams {
    nstd::shared_ptr<V2NIMMessageAttachment> attachment;
    V2NIMDownloadAttachmentType type{V2NIM_DOWNLOAD_ATTACHMENT_TYPE_SOURCE};
    nstd::optional<V2NIMSize> thumbSize;
    nstd::optional<nstd::string> messageClientId;
    nstd::optional<nstd::string> saveAs;
};
 
struct V2NIMGetMediaResourceInfoResult {
    nstd::string url;
    nstd::map<nstd::string, nstd::string> authHeaders;
};
 
struct V2NIMSignallingConfig {
    nstd::optional<bool> offlineEnabled;
    nstd::optional<bool> unreadEnabled;
    nstd::optional<int64_t> selfUid;
};
 
struct V2NIMSignallingPushConfig {
    bool pushEnabled{false};
    nstd::optional<nstd::string> pushTitle;
    nstd::optional<nstd::string> pushContent;
    nstd::optional<nstd::string> pushPayload;
};
 
struct V2NIMSignallingRtcConfig {
    nstd::optional<nstd::string> rtcChannelName;
    nstd::optional<uint32_t> rtcTokenTtl;
    nstd::optional<nstd::string> rtcParams;
};
 
struct V2NIMSignallingCallParams {
    nstd::string calleeAccountId;
    nstd::string requestId;
    V2NIMSignallingChannelType channelType{V2NIM_SIGNALLING_CHANNEL_TYPE_UNKNOWN};
    nstd::optional<nstd::string> channelName;
    nstd::optional<nstd::string> channelExtension;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<V2NIMSignallingConfig> signallingConfig;
    nstd::optional<V2NIMSignallingPushConfig> pushConfig;
    nstd::optional<V2NIMSignallingRtcConfig> rtcConfig;
};
 
struct V2NIMSignallingChannelInfo {
    nstd::string channelId;
    V2NIMSignallingChannelType channelType;
    nstd::optional<nstd::string> channelName;
    nstd::optional<nstd::string> channelExtension;
    time_t createTime{0};
    time_t expireTime{0};
    nstd::string creatorAccountId;
    bool channelValid{false};
};
 
struct V2NIMSignallingMember {
    nstd::string accountId;
    int64_t uid{0};
    time_t joinTime{0};
    time_t expireTime{0};
    nstd::string deviceId;
};
 
struct V2NIMSignallingRoomInfo {
    V2NIMSignallingChannelInfo channelInfo;
    nstd::vector<V2NIMSignallingMember> members;
};
 
struct V2NIMSignallingRtcInfo {
    nstd::optional<nstd::string> rtcToken;
    nstd::optional<uint32_t> rtcTokenTtl;
    nstd::optional<nstd::string> rtcParams;
};
 
struct V2NIMSignallingJoinResult {
    V2NIMSignallingRoomInfo roomInfo;
    nstd::optional<V2NIMSignallingRtcInfo> rtcInfo;
};
 
struct V2NIMSignallingCallResult {
    V2NIMSignallingRoomInfo roomInfo;
    nstd::optional<V2NIMSignallingRtcInfo> rtcInfo;
    int32_t callStatus{0};
};
 
struct V2NIMSignallingCallSetupParams {
    nstd::string channelId;
    nstd::string callerAccountId;
    nstd::string requestId;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<V2NIMSignallingConfig> signallingConfig;
    nstd::optional<V2NIMSignallingRtcConfig> rtcConfig;
};
 
struct V2NIMSignallingCallSetupResult {
    V2NIMSignallingRoomInfo roomInfo;
    nstd::optional<V2NIMSignallingRtcInfo> rtcInfo;
    nstd::optional<uint32_t> callStatus;
};
 
struct V2NIMSignallingJoinParams {
    nstd::string channelId;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<V2NIMSignallingConfig> signallingConfig;
    nstd::optional<V2NIMSignallingRtcConfig> rtcConfig;
};
 
struct V2NIMSignallingInviteParams {
    nstd::string channelId;
    nstd::string inviteeAccountId;
    nstd::string requestId;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<V2NIMSignallingConfig> signallingConfig;
    nstd::optional<V2NIMSignallingPushConfig> pushConfig;
};
 
struct V2NIMSignallingCancelInviteParams {
    nstd::string channelId;
    nstd::string inviteeAccountId;
    nstd::string requestId;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<bool> offlineEnabled;
    nstd::optional<V2NIMSignallingPushConfig> pushConfig;
};
 
struct V2NIMSignallingRejectInviteParams {
    nstd::string channelId;
    nstd::string inviterAccountId;
    nstd::string requestId;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<bool> offlineEnabled;
};
 
struct V2NIMSignallingAcceptInviteParams {
    nstd::string channelId;
    nstd::string inviterAccountId;
    nstd::string requestId;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<bool> offlineEnabled;
};
 
struct V2NIMSignallingEvent {
    V2NIMSignallingEventType eventType;
    V2NIMSignallingChannelInfo channelInfo;
    nstd::string operatorAccountId;
    nstd::optional<nstd::string> serverExtension;
    uint64_t time;
    nstd::optional<nstd::string> inviteeAccountId;
    nstd::optional<nstd::string> inviterAccountId;
    nstd::string requestId;
    nstd::optional<V2NIMSignallingPushConfig> pushConfig;
    nstd::optional<bool> unreadEnabled;
    nstd::optional<V2NIMSignallingMember> member;
};
 
struct V2NIMSubscribeUserStatusOption {
    nstd::vector<nstd::string> accountIds;
    uint32_t duration{V2NIM_DEFAULT_SUBSCRIBE_DURATION};
    bool immediateSync{false};
};
 
struct V2NIMUnsubscribeUserStatusOption {
    nstd::optional<nstd::vector<nstd::string>> accountIds;
};
 
struct V2NIMCustomUserStatusParams {
    uint32_t statusType{0};
    uint32_t duration{V2NIM_DEFAULT_SUBSCRIBE_DURATION};
    nstd::optional<nstd::string> extension;
    bool onlineOnly{true};
    bool multiSync{false};
};
 
struct V2NIMCustomUserStatusPublishResult {
    nstd::string uniqueId;
    nstd::string serverId;
    time_t publishTime;
};
 
struct V2NIMUserStatusSubscribeResult {
    nstd::string accountId;
    uint32_t duration;
    time_t subscribeTime;
};
 
struct V2NIMUserStatus {
    nstd::string accountId;
    uint32_t statusType{0};
    V2NIMLoginClientType clientType{V2NIM_LOGIN_CLIENT_TYPE_UNKNOWN};
    time_t publishTime{0};
    nstd::optional<nstd::string> uniqueId;
    nstd::optional<uint32_t> duration;
    nstd::optional<nstd::string> extension;
    nstd::optional<nstd::string> serverExtension;
};
 
struct V2NIMMessageCustomAttachment : public V2NIMMessageAttachment {
    V2NIMMessageCustomAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_CUSTOM; }
    virtual void parse(const nstd::string& attach) = 0;
};
 
struct V2NIMMessageCustomAttachmentParser {
    virtual nstd::shared_ptr<V2NIMMessageAttachment> parse(const nstd::string& attach, const int32_t& subType) = 0;
    virtual ~V2NIMMessageCustomAttachmentParser() = default;
};
 
struct V2NIMProxyRequest {
    nstd::string path;
    V2NIMProxyRequestMethod method;
    nstd::optional<nstd::string> zone;
    nstd::optional<nstd::string> header;
    nstd::optional<nstd::string> body;
};
 
struct V2NIMProxyResponse {
    nstd::string header;
    nstd::string body;
};
 
struct V2NIMProxyNotify {
    nstd::string fromAccountId;
    nstd::string body;
    time_t time;
};
 
struct V2NIMMessageSearchExParams {
    nstd::optional<nstd::string> conversationId;
    nstd::optional<nstd::vector<nstd::string>> keywordList;
    V2NIMSearchKeywordMathType keywordMatchType{V2NIM_SEARCH_KEYWORD_MATH_TYPE_OR};
    nstd::optional<nstd::vector<nstd::string>> senderAccountIds;
    nstd::optional<nstd::vector<V2NIMMessageType>> messageTypes;
    nstd::optional<nstd::vector<int32_t>> messageSubtypes;
    time_t searchStartTime{0};
    int64_t searchTimePeriod{0};
    V2NIMSearchDirection direction{V2NIM_SEARCH_DIRECTION_BACKWARD};
    V2NIMSearchStrategy strategy{V2NIM_SEARCH_STRATEGY_FTS};
    uint32_t limit{V2NIM_DEFAULT_SEARCH_LOCAL_MESSAGE_LIST_LIMIT};
    nstd::optional<nstd::string> pageToken;
    bool totalCount{true};
};
 
struct V2NIMMessageSearchItem {
    nstd::string conversationId;
    nstd::vector<V2NIMMessage> messages;
    uint32_t count{0};
};
 
struct V2NIMMessageSearchResult {
    uint32_t count{0};
    nstd::vector<V2NIMMessageSearchItem> items;
    nstd::string nextPageToken;
};
 
struct V2NIMLocalConversation {
    nstd::string conversationId;
    V2NIMConversationType type{V2NIM_CONVERSATION_TYPE_UNKNOWN};
    nstd::optional<nstd::string> name;
    nstd::optional<nstd::string> avatar;
    bool mute{false};
    bool stickTop{false};
    nstd::optional<nstd::string> localExtension;
    nstd::optional<V2NIMLastMessage> lastMessage;
    uint32_t unreadCount{0};
    uint64_t sortOrder{0};
    uint64_t createTime{0};
    uint64_t updateTime{0};
};
 
struct V2NIMLocalConversationResult {
    uint32_t offset{0};
    bool finished{false};
    nstd::vector<V2NIMLocalConversation> conversationList;
};
 
struct V2NIMLocalConversationOption {
    nstd::vector<V2NIMConversationType> conversationTypes;
    bool onlyUnread{false};
};
 
struct V2NIMLocalConversationFilter {
    nstd::vector<V2NIMConversationType> conversationTypes;
    bool ignoreMuted{false};
};
 
using V2NIMLocalConversationOperationResult = V2NIMConversationOperationResult;
 
struct V2NIMMessageAIStreamStopParams {
    V2NIMMessageAIStreamStopOpType operationType{V2NIM_MESSAGE_AI_STREAM_STOP_OP_DEFAULT};
    nstd::optional<nstd::string> updateContent;
};
 
struct V2NIMMessageAIRegenParams {
    V2NIMMessageAIRegenOpType operationType{V2NIM_MESSAGE_AI_REGEN_OP_UPDATE};
};
 
struct V2NIMAIModelStreamCallChunk {
    nstd::string content;
    time_t chunkTime{0};
    int type{0};
    uint32_t index{0};
};
 
struct V2NIMAIModelStreamCallContent {
    nstd::string msg;
    int type{0};
    V2NIMAIModelStreamCallChunk lastChunk;
};
 
struct V2NIMAIModelStreamCallResult {
    int code{0};
    nstd::string accountId;
    nstd::string requestId;
    nstd::optional<V2NIMAIModelStreamCallContent> content;
    nstd::optional<nstd::vector<V2NIMAIRAGInfo>> aiRAGs;
    time_t timestamp{0};
};
 
struct V2NIMAIModelStreamCallStopParams {
    nstd::string accountId;
    nstd::string requestId;
};
 
struct V2NIMMessageFilter {
    nstd::function<bool(const V2NIMMessage&)> shouldIgnore;
};
 
struct V2NIMUpdateLocalMessageParams {
    nstd::optional<uint32_t> subType;
    nstd::optional<nstd::string> text;
    nstd::shared_ptr<V2NIMMessageAttachment> attachment;
    nstd::optional<nstd::string> localExtension;
    nstd::optional<V2NIMMessageSendingState> sendingState;
};
 
struct V2NIMDatabaseInfo {
    nstd::string path;
    nstd::string name;
    uint64_t size;
};
 
}  // namespace v2
 
#endif