Javapublic interface V2NIMSuccessCallback<T> {
    void onSuccess(T t);
}

Objective-Ctypedef void (^V2NIMSuccessCallback)(void);

C++template <typename T>
class V2NIMSuccessCallback : public nstd::function<void(T)> {
public:
    using nstd::function<void(T)>::function;
    using nstd::function<void(T)>::operator=;
    using nstd::function<void(T)>::operator();
    V2NIMSuccessCallback<T>(nstd::function<void(T)> func)
        : nstd::function<void(T)>(func) {}
};

template <>
class V2NIMSuccessCallback<void> : public nstd::function<void()> {
public:
    using nstd::function<void()>::function;
    using nstd::function<void()>::operator=;
    using nstd::function<void()>::operator();
    V2NIMSuccessCallback<void>(nstd::function<void()> func)
        : nstd::function<void()>(func) {}
};

Javapublic interface V2NIMFailureCallback {
    void onFailure(V2NIMError error);
}

Objective-Ctypedef void (^V2NIMFailureCallback)(V2NIMError *error);

C++using V2NIMFailureCallback = nstd::function<void(V2NIMError error)>;

Javapublic interface V2NIMProgressCallback {
    void onProgress(int progress);
}

Objective-Ctypedef void (^V2NIMProgressCallback)(NSUInteger);

C++using V2NIMProgressCallback = nstd::function<void(uint32_t progress)>;

TypeScriptexport type V2NIMProgressCallback = (progress: { [key: string]: any }) => void

TypeScriptV2NIMProgressCallback: ((progress: number) => void)

TypeScriptexport type V2NIMProgressCallback = (progress: number) => void

Javapublic class V2NIMLoginOption {
    public Integer getRetryCount() {
        return retryCount;
    }
    public void setRetryCount(Integer retryCount) {
        this.retryCount = retryCount;
    }
    public long getTimeout() {
        return timeout;
    }
    public void setTimeout(long timeout) {
        this.timeout = timeout;
    }
    public boolean getForceMode() {
        return forceMode;
    }
    public void setForceMode(boolean forceMode) {
        this.forceMode = forceMode;
    }
    public V2NIMLoginAuthType getAuthType() {
        return authType;
    }
    public void setAuthType(V2NIMLoginAuthType authType) {
        this.authType = authType;
    }
    public V2NIMTokenProvider getTokenProvider() {
        return tokenProvider;
    }
    public void setTokenProvider(V2NIMTokenProvider tokenProvider) {
        this.tokenProvider = tokenProvider;
    }
    public V2NIMLoginExtensionProvider getLoginExtensionProvider() {
        return loginExtensionProvider;
    }
    public void setLoginExtensionProvider(V2NIMLoginExtensionProvider loginExtensionProvider) {
        this.loginExtensionProvider = loginExtensionProvider;
    }
    public V2NIMDataSyncLevel getSyncLevel() {
        return syncLevel;
    }
    public void setSyncLevel(V2NIMDataSyncLevel syncLevel) {
        this.syncLevel = syncLevel;
    }
}

Objective-C@interface V2NIMLoginOption : NSObject
@property(nonatomic,assign) NSInteger retryCount;
@property(nonatomic,assign) NSInteger timeout;
@property(nonatomic,assign) BOOL forceMode;
@property(nonatomic,assign) V2NIMLoginAuthType authType;
@property(nullable,nonatomic,strong) id<V2NIMTokenProvider> tokenProvider;
@property(nullable,nonatomic,strong) id<V2NIMLoginExtensionProvider> loginExtensionProvider;
@property(nonatomic,assign) V2NIMDataSyncLevel syncLevel;
@end

C++struct V2NIMLoginOption {
    uint32_t retryCount{3};
    uint64_t timeout{V2NIM_DEFAULT_LOGIN_TIMEOUT};
    bool forceMode{false};
    V2NIMLoginAuthType authType{V2NIM_LOGIN_AUTH_TYPE_DEFAULT};
    V2NIMTokenProvider tokenProvider{nullptr};
    V2NIMLoginExtensionProvider loginExtensionProvider{nullptr};
    V2NIMDataSyncLevel syncLevel{V2NIM_DATA_SYNC_LEVEL_FULL};
};

TypeScriptexport type V2NIMLoginOption = {
  retryCount?: number
  timeout?: number
  forceMode?: boolean
  authType?: V2NIMLoginAuthType
  loginExtensionProvider?: (accountId: string) => Promise<string> | string
  tokenProvider?: (accountId: string) => Promise<string> | string
  syncLevel?: V2NIMDataSyncLevel
}

TypeScriptinterface V2NIMLoginOption {
    retryCount?: number;
    timeout?: number;
    forceMode?: boolean;
    authType?: V2NIMLoginAuthType;
    tokenProvider?: V2NIMTokenProvider;
    loginExtensionProvider?: V2NIMLoginExtensionProvider;
    syncLevel?: V2NIMDataSyncLevel;
}

TypeScriptexport interface V2NIMLoginOption {
  retryCount?: number
  timeout?: number
  forceMode?: boolean
  authType?: V2NIMLoginAuthType
  loginExtensionProvider?: V2NIMLoginExtensionProvider
  tokenProvider?: V2NIMTokenProvider
  syncLevel?: V2NIMDataSyncLevel
}

Javapublic interface V2NIMTokenProvider {
    String getToken(String account);
}

Objective-C@protocol V2NIMTokenProvider <NSObject>
- (nullable NSString *)getToken:(NSString *)accountId;
@end

C++using V2NIMTokenProvider = nstd::function<nstd::optional<nstd::string>(nstd::string accountId)>;

TypeScriptexport type V2NIMTokenProvider = (accountId: string) => Promise<string> | string

TypeScriptV2NIMTokenProvider: ((accountId: string) => string)

TypeScriptexport type V2NIMTokenProvider = (accountId: string) => Promise<string> | string

Javapublic interface V2NIMLoginExtensionProvider {
    String getLoginExtension(String accountId);
}

Objective-C@protocol V2NIMLoginExtensionProvider <NSObject>
- (nullable NSString *)getLoginExtension:(NSString *)accountId;
@end

C++using V2NIMLoginExtensionProvider = nstd::function<nstd::optional<nstd::string>(nstd::string accountId)>;

TypeScriptexport type V2NIMLoginExtensionProvider = (accountId: string) => Promise<string> | string

TypeScriptV2NIMLoginExtensionProvider: ((accountId: string) => string)

TypeScriptexport type V2NIMLoginExtensionProvider = (accountId: string) => Promise<string> | string

Javapublic interface V2NIMLoginClient {
    V2NIMLoginClientType getType();
    String getOs();
    long getTimestamp();
    String getCustomTag();
    int getCustomClientType();
    String getClientId();
    String getClientIP();
}

Objective-C@interface V2NIMLoginClient : NSObject
@property(nonatomic,assign,readonly) V2NIMLoginClientType type;
@property(nullable,nonatomic,copy,readonly) NSString *os;
@property(nonatomic,assign,readonly) NSTimeInterval timestamp;
@property(nullable,nonatomic,copy,readonly) NSString *customTag;
@property(nonatomic,assign,readonly) NSInteger customClientType;
@property(nullable,nonatomic,copy,readonly) NSString *clientId;
@property(nullable,nonatomic,copy,readonly) NSString *clientIp;
@end

C++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;
    ne_std::string ip;
};

TypeScriptexport type V2NIMLoginClient = {
  type: V2NIMLoginClientType
  os: string
  timestamp: number
  customTag?: string
  customClientType?: number
  clientId: string
  clientIP?: string
}

TypeScriptinterface V2NIMLoginClient {
    type?: V2NIMLoginClientType;
    os?: string;
    timestamp?: number;
    customTag?: string;
    customClientType?: number;
    clientId?: string;
    clientIP?: string;
}

TypeScriptinterface V2NIMLoginClient {
    clientId: string;
    clientIP?: string;
    customClientType?: number;
    customTag?: string;
    os: string;
    timestamp: number;
    type: V2NIMLoginClientType;
}

Javapublic interface V2NIMReconnectDelayProvider {
    long getReconnectDelay(long delay);
}

Objective-C@protocol V2NIMReconnectDelayProvider <NSObject>
- (nullable uint32_t *)getReconnectDelay:(uint32_t *)delay;
@end

C++using V2NIMReconnectDelayProvider = nstd::function<nstd::optional<nstd::int>(nstd::int delay)>;

TypeScriptexport type V2NIMReconnectDelayProvider = (delay: number) => number

TypeScriptV2NIMReconnectDelayProvider: ((defaultDelay: number) => number)

TypeScriptexport type V2NIMReconnectDelayProvider = (delay: number) => number

Javapublic interface V2NIMKickedOfflineDetail {
    V2NIMKickedOfflineReason getReason();
    String getReasonDesc();
    V2NIMLoginClientType getClientType();
    Integer getCustomClientType();
}

Objective-C@interface V2NIMKickedOfflineDetail : NSObject
@property(nonatomic,assign,readonly) V2NIMKickedOfflineReason reason;
@property(nullable,nonatomic,copy,readonly) NSString *reasonDesc;
@property(nonatomic,assign,readonly) V2NIMLoginClientType clientType;
@property(nonatomic,assign,readonly) NSInteger customClientType;

@end

C++struct V2NIMKickedOfflineDetail {
    V2NIMKickedOfflineReason reason{V2NIM_KICKED_OFFLINE_REASON_CLIENT_EXCLUSIVE};
    nstd::string reasonDesc;
    V2NIMLoginClientType clientType{V2NIM_LOGIN_CLIENT_TYPE_UNKNOWN};
    uint32_t customClientType{0};
};

TypeScriptexport type V2NIMKickedOfflineDetail = {
  reason: V2NIMKickedOfflineReason
  reasonDesc: string
  clientType: V2NIMLoginClientType
  customClientType: number
}

TypeScriptinterface V2NIMKickedOfflineDetail {
    reason?: V2NIMKickedOfflineReason;
    reasonDesc?: string;
    clientType?: V2NIMLoginClientType;
    customClientType?: number;
}

TypeScriptexport interface V2NIMKickedOfflineDetail {
  reason: V2NIMKickedOfflineReason
  reasonDesc: string
  clientType: V2NIMLoginClientType
  customClientType: number
}

Javapublic interface V2NIMDataSyncDetail {
    V2NIMDataSyncType getType();
    V2NIMDataSyncState getState();
}

Objective-C@interface V2NIMDataSyncDetail : NSObject
@property(nonatomic,assign,readonly) V2NIMDataSyncType type;
@property(nonatomic,assign,readonly) V2NIMDataSyncState state;

@end

C++struct V2NIMDataSyncDetail {
    V2NIMDataSyncType type{V2NIM_DATA_SYNC_MAIN};
    V2NIMDataSyncState state{V2NIM_DATA_SYNC_STATE_WAITING};
};

TypeScriptexport type V2NIMDataSyncDetail = {

  type: V2NIMDataSyncType
  state: V2NIMDataSyncState
}

TypeScriptinterface V2NIMDataSyncDetail {
    type?: V2NIMDataSyncType;
    state?: V2NIMDataSyncState;
}

TypeScriptexport interface V2NIMDataSyncDetail {
  type: V2NIMDataSyncType
  state: V2NIMDataSyncState
}

Javapublic interface V2NIMLoginListener {
    void onLoginStatus(V2NIMLoginStatus status);
    void onLoginFailed(V2NIMError error);
    void onKickedOffline(V2NIMKickedOfflineDetail detail);
    void onLoginClientChanged(V2NIMLoginClientChange change, List<V2NIMLoginClient> clients);
}

Objective-C@protocol V2NIMLoginListener <NSObject>
@optional
- (void)onLoginStatus:(V2NIMLoginStatus)status;
- (void)onLoginFailed:(V2NIMError *)error;
- (void)onKickedOffline:(V2NIMKickedOfflineDetail *)detail;
- (void)onLoginClientChanged:(V2NIMLoginClientChange)change
                     clients:(nullable NSArray<V2NIMLoginClient *> *)clients;
@end

C++struct V2NIMLoginListener {
    nstd::function<void(V2NIMLoginStatus)> onLoginStatus;
    nstd::function<void(V2NIMError)> onLoginFailed;
    nstd::function<void(V2NIMKickedOfflineDetail)> onKickedOffline;
    nstd::function<void(V2NIMLoginClientChange, nstd::vector<V2NIMLoginClient>)> onLoginClientChanged;
    bool operator==(const V2NIMLoginListener& other) const {
        return onLoginStatus == other.onLoginStatus && onLoginFailed == other.onLoginFailed && onKickedOffline == other.onKickedOffline &&
               onLoginClientChanged == other.onLoginClientChanged;
    }
};

TypeScriptexport type V2NIMLoginListener = {
  onLoginStatus: [status: V2NIMLoginStatus]
  onLoginFailed: [error: V2NIMError]
  onKickedOffline: [detail: V2NIMKickedOfflineDetail]
  onLoginClientChanged: [change: V2NIMLoginClientChange, clients: V2NIMLoginClient[]]
  onConnectStatus: [status: V2NIMConnectStatus]
  onDisconnected: [error: V2NIMError]
  onConnectFailed: [error: V2NIMError]
  onDataSync: [type: V2NIMDataSyncType, state: V2NIMDataSyncState, error?: V2NIMError]
}

TypeScriptinterface V2NIMLoginListener {
    loginStatus: [V2NIMLoginStatus];
    loginFailed: [V2NIMError];
    kickedOffline: [V2NIMKickedOfflineDetail];
    loginClientChanged: [V2NIMLoginClientChange, V2NIMLoginClient[]];
    connectStatus: [V2NIMConnectStatus];
    disconnected: [null | V2NIMError];
    connectFailed: [V2NIMError];
    dataSync: [V2NIMDataSyncType, V2NIMDataSyncState, null | V2NIMError];
}

TypeScriptexport interface V2NIMLoginListener extends NIMEBaseListener {
  onLoginStatus: [status: V2NIMLoginStatus]
  onLoginFailed: [error: V2NIMError]
  onKickedOffline: [detail: V2NIMKickedOfflineDetail]
  onLoginClientChanged: [change: V2NIMLoginClientChange, clients: V2NIMLoginClient[]]
  onConnectStatus: [status: V2NIMConnectStatus]
  onDisconnected: [error: V2NIMError]
  onConnectFailed: [error: V2NIMError]
  onDataSync: [type: V2NIMDataSyncType, state: V2NIMDataSyncState, error?: V2NIMError]
}

Javapublic interface V2NIMLoginDetailListener {
    void onConnectStatus(V2NIMConnectStatus status);
    void onDisconnected(V2NIMError error);
    void onConnectFailed(V2NIMError error);
    void onDataSync(V2NIMDataSyncType type, V2NIMDataSyncState state, V2NIMError error);
}

Objective-C@protocol V2NIMLoginDetailListener <NSObject>
@optional
- (void)onConnectStatus:(V2NIMConnectStatus)status;
- (void)onDisconnected:(nullable V2NIMError *)error;
- (void)onConnectFailed:(nullable V2NIMError *)error;
- (void)onDataSync:(V2NIMDataSyncType)type
             state:(V2NIMDataSyncState)state
             error:(nullable V2NIMError *)error;
@end

C++struct V2NIMLoginDetailListener {
    nstd::function<void(V2NIMConnectStatus)> onConnectStatus;
    nstd::function<void(nstd::optional<V2NIMError>)> onDisconnected;
    nstd::function<void(V2NIMError)> onConnectFailed;
    nstd::function<void(V2NIMDataSyncType, V2NIMDataSyncState, nstd::optional<V2NIMError>)> onDataSync;
    bool operator==(const V2NIMLoginDetailListener& other) const {
        return onConnectStatus == other.onConnectStatus && onDisconnected == other.onDisconnected && onConnectFailed == other.onConnectFailed &&
               onDataSync == other.onDataSync;
    }
};

Web 端不区分 detail 事件，所以上文的 V2NIMLoginListener 包含 detail 相关的事件

Node.js/Electron 端不区分 detail 事件，所以上文的 V2NIMLoginListener 包含 detail 相关的事件

HarmonyOS 不区分 detail 事件，所以上文的 V2NIMLoginListener 包含 detail 相关的事件

Javapublic class V2NIMConversationOption {
    private List<V2NIMConversationType> conversationTypes = null;
    private boolean onlyUnread = false;
    private List<String> conversationGroupIds = null;
    public V2NIMConversationOption() {}
    public V2NIMConversationOption(List<V2NIMConversationType> conversationTypes) {
        this.conversationTypes = conversationTypes;
    }
    public V2NIMConversationOption(List<V2NIMConversationType> conversationTypes, boolean onlyUnread) {
        this.conversationTypes = conversationTypes;
        this.onlyUnread = onlyUnread;
    }
}
    public V2NIMConversationOption(List<V2NIMConversationType> conversationTypes, boolean onlyUnread, List<String> conversationGroupIds) {
        this.conversationTypes = conversationTypes;
        this.onlyUnread = onlyUnread;
        this.conversationGroupIds = conversationGroupIds;
    }
    public List<V2NIMConversationType> getConversationTypes() {
        return conversationTypes;
    }
    public void setConversationTypes(List<V2NIMConversationType> conversationTypes) {
        this.conversationTypes = conversationTypes;
    }
    public boolean isOnlyUnread() {
        return onlyUnread;
    }
    public void setOnlyUnread(boolean onlyUnread) {
        this.onlyUnread = onlyUnread;
    }
    public List<String> getConversationGroupIds() {
        return conversationGroupIds;
    }
    public void setConversationGroupIds(List<String> conversationGroupIds) {
        this.conversationGroupIds = conversationGroupIds;
    }
    public void setOnlyUnread(boolean onlyUnread) {
        this.onlyUnread = onlyUnread;
    }
    public List<String> getConversationGroupIds() {
        return conversationGroupIds;
    }
    @Override
    public String toString() {
        return "V2NIMConversationOption{" +
                "conversationTypes=" + conversationTypes +
                ", onlyUnread=" + onlyUnread +
                ", conversationGroupIds=" + conversationGroupIds +
                '}';
    }
}

Objective-C@interface V2NIMConversationOption : NSObject
@property(nullable,nonatomic,copy,readwrite) NSArray<NSNumber *> *conversationTypes;
@property(nonatomic,assign,readwrite) BOOL onlyUnread;
@property(nullable,nonatomic,copy,readwrite) NSArray<NSString *> *conversationGroupIds;
@end

C++struct V2NIMConversationOption {
    nstd::vector<V2NIMConversationType> conversationTypes;
    nstd::optional<nstd::vector<nstd::string>> conversationGroupIds;
    bool onlyUnread{false};
};

TypeScriptexport type V2NIMConversationOption = {
  conversationTypes?: V2NIMConversationType[]
  onlyUnread?: boolean
  conversationGroupIds?: string[]
}

TypeScriptinterface V2NIMConversationOption {
    conversationTypes?: V2NIMConversationType[];
    conversationGroupIds?: string[];
    onlyUnread?: boolean;
}

TypeScriptexport interface V2NIMConversationOption {
  conversationTypes?: V2NIMConversationType[]
  onlyUnread?: boolean
  conversationGroupIds?: string[]
}

Javapublic interface V2NIMConversationResult extends Serializable {
    long getOffset();
    boolean isFinished();
    List<V2NIMConversation> getConversationList();
}

Objective-C@interface V2NIMConversationResult : NSObject
@property(nonatomic,assign,readonly) long long cursor;
@property(nonatomic,assign,readonly) BOOL finished;
@property(nullable,nonatomic,copy,readonly) NSArray<V2NIMConversation *> *conversationList;
@end

C++struct V2NIMConversationResult {
    uint64_t offset{0};
    bool finished{false};
    V2NIMConversationList conversationList;
};

TypeScriptexport type V2NIMConversationResult = {
  offset: number
  finished: boolean
  conversationList: V2NIMConversation[]
}

TypeScriptinterface V2NIMConversationResult {
    offset?: number;
    finished?: boolean;
    conversationList?: V2NIMConversation[];
}

TypeScriptexport interface V2NIMConversationResult {
  offset: number
  finished: boolean
  conversationList: V2NIMConversation[]
}

Javapublic interface V2NIMConversation extends Serializable {
    String getConversationId();
    V2NIMConversationType getType();
    String getName();
    String getAvatar();
    boolean isMute();
    boolean isStickTop();
    List<String> getGroupIds();
    String getLocalExtension();
    String getServerExtension();
    V2NIMLastMessage getLastMessage();
    int getUnreadCount();
    long getSortOrder();
    long getCreateTime();
    long getUpdateTime();
}

Objective-C@interface V2NIMConversation : NSObject <NSCopying>
@property(nonatomic,copy,readonly) NSString *conversationId;
@property(nonatomic,assign,readonly) V2NIMConversationType type;
@property(nullable,nonatomic,copy,readonly) NSString *name;
@property(nullable,nonatomic,copy,readonly) NSString *avatar;
@property(nonatomic,assign,readonly) BOOL mute;
@property(nonatomic,assign,readonly) BOOL stickTop;
@property(nullable,nonatomic,copy,readonly) NSArray<NSString *> *grpupIds;
@property(nullable,nonatomic,copy,readonly) NSString *localExtension;
@property(nullable,nonatomic,copy,readonly) NSString *serverExtension;
@property(nullable,nonatomic,copy,readonly) V2NIMLastMessage *lastMessage;
@property(nonatomic,assign,readonly) NSInteger unreadCount;
@property(nonatomic,assign,readonly) NSTimeInterval orderTime;
@property(nonatomic,assign,readonly) NSTimeInterval createTime;
@property(nonatomic,assign,readonly) NSTimeInterval updateTime;
@end

C++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};
};

TypeScriptexport type V2NIMConversation = {
  conversationId: string
  type: V2NIMConversationType
  name?: string
  avatar?: string
  mute?: boolean
  stickTop: boolean
  groupIds?: string[]
  localExtension: string
  serverExtension: string
  lastMessage?: V2NIMLastMessage
  unreadCount: number
  sortOrder: number
  createTime: number
  updateTime: number
}

TypeScriptinterface V2NIMConversation {
    conversationId?: string;
    type?: V2NIMConversationType;
    name?: string;
    avatar?: string;
    mute?: boolean;
    stickTop?: boolean;
    groupIds?: string[];
    localExtension?: string;
    serverExtension?: string;
    lastMessage?: V2NIMLastMessage;
    unreadCount?: number;
    sortOrder?: number;
    createTime?: number;
    updateTime?: number;
}

TypeScriptinterface V2NIMConversation {
    avatar?: string;
    conversationId: string;
    createTime: number;
    groupIds?: string[];
    lastMessage?: V2NIMLastMessage;
    localExtension?: string;
    mute?: boolean;
    name?: string;
    serverExtension: string;
    sortOrder: number;
    stickTop: boolean;
    type: V2NIMConversationType;
    unreadCount: number;
    updateTime: number;
}

Javapublic class V2NIMConversationFilter {
    private List<V2NIMConversationType> conversationTypes = null;
    private String conversationGroupId = null;
    private boolean ignoreMuted = false;
    private Set<V2NIMConversationType> conversationTypeSet = null;
    public V2NIMConversationFilter() {
    }
    public V2NIMConversationFilter(List<V2NIMConversationType> types) {
        this.conversationTypes = types;
        if (types != null) {
            this.conversationTypeSet = new HashSet<>(types);
        }
    }
}
public class V2NIMConversationFilter {
    private List<V2NIMConversationType> conversationTypes;
    private Set<V2NIMConversationType> conversationTypeSet;
    private String conversationGroupId;
    private boolean ignoreMuted;
    public V2NIMConversationFilter(List<V2NIMConversationType> types, String groupId) {
        this.conversationTypes = types;
        if (types != null) {
            this.conversationTypeSet = new HashSet<>(types);
        }
        this.conversationGroupId = groupId;
    }
    public V2NIMConversationFilter(List<V2NIMConversationType> types, String groupId, boolean ignoreMuted) {
        this.conversationTypes = types;
        if (types != null) {
            this.conversationTypeSet = new HashSet<>(types);
        }
        this.conversationGroupId = groupId;
        this.ignoreMuted = ignoreMuted;
    }
    public List<V2NIMConversationType> getConversationTypes() {
        return conversationTypes;
    }
}
    public Set<V2NIMConversationType> getConversationTypeSet() {
        if(CollectionUtil.isNotEmpty(conversationTypes) && CollectionUtil.isEmpty(conversationTypeSet)) {
            conversationTypeSet = new HashSet<>(conversationTypes);
        }
        return conversationTypeSet;
    }
    public void setConversationTypes(List<V2NIMConversationType> conversationTypes) {
        this.conversationTypes = conversationTypes;
    }
    public String getConversationGroupId() {
        return conversationGroupId;
    }
    public void setConversationGroupId(String conversationGroupId) {
        this.conversationGroupId = conversationGroupId;
    }
    public boolean isIgnoreMuted() {
        return ignoreMuted;
    }
    public void setIgnoreMuted(boolean ignoreMuted) {
        this.ignoreMuted = ignoreMuted;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof V2NIMConversationFilter)) {
            return false;
        }
        V2NIMConversationFilter that = (V2NIMConversationFilter) o;
        return ignoreMuted == that.ignoreMuted && Objects.equals(conversationGroupId, that.conversationGroupId) && Objects.equals(getConversationTypeSet(), that.getConversationTypeSet());
    }
    @Override
    public int hashCode() {
        return Objects.hash(conversationGroupId, ignoreMuted, getConversationTypeSet());
    }
    @Override
    public String toString() {
        return "V2NIMConversationFilter{" +
                "conversationTypes=" + conversationTypes +
                ", conversationGroupId='" + conversationGroupId + '\'' +
                ", ignoreMuted=" + ignoreMuted +
                '}';
    }
    public boolean isValid() {
        return !CollectionUtil.isEmpty(conversationTypes) || !TextUtils.isEmpty(conversationGroupId) || ignoreMuted;
    }
}

Objective-C@interface V2NIMConversationFilter : NSObject <NSCopying>
@property(nullable,nonatomic,copy,readwrite) NSArray<NSNumber *> *conversationTypes;
@property(nullable,nonatomic,copy,readwrite) NSArray<NSString *> *conversationGroupIds;
@end

C++struct V2NIMConversationFilter {
    nstd::set<V2NIMConversationType> conversationTypes;
    nstd::string conversationGroupId;
    bool ignoreMuted{false};
};

TypeScriptexport type V2NIMConversationFilter = {
  conversationTypes?: V2NIMConversationType[]
  conversationGroupId?: string
  ignoreMuted?: boolean
}

TypeScriptinterface V2NIMConversationFilter {
    conversationTypes?: V2NIMConversationType[];
    conversationGroupId?: string;
    ignoreMuted?: boolean;
}

TypeScriptexport interface V2NIMConversationFilter {
  conversationTypes?: V2NIMConversationType[]
  conversationGroupId?: string
  ignoreMuted?: boolean
}

Javapublic interface V2NIMConversationOperationResult {
    String getConversationId();
    V2NIMError getError();
}

C++struct V2NIMConversationOperationResult {
    nstd::string conversationId;
    V2NIMError error;
};

TypeScriptexport type V2NIMConversationOperationResult = {
  conversationId: string
  error: V2NIMError
}

TypeScriptinterface V2NIMConversationOperationResult {
    conversationId?: string;
    error?: V2NIMError;
}

TypeScriptexport interface V2NIMConversationOperationResult {
  conversationId: string
  error: V2NIMError
}

Javapublic class V2NIMConversationUpdate {
    private String serverExtension;
    public V2NIMConversationUpdate() {
    }
    public V2NIMConversationUpdate(String serverExtension) {
        this.serverExtension = serverExtension;
    }
    public String getServerExtension() {
        return serverExtension;
    }
    public void setServerExtension(String serverExtension) {
        this.serverExtension = serverExtension;
    }
}

Objective-C@interface V2NIMConversationUpdate : NSObject
@property(nullable,nonatomic,copy,readwrite) NSString *serverExtension;
@end

C++struct V2NIMConversationUpdate {
    nstd::optional<nstd::string> serverExtension;
};

TypeScriptexport type V2NIMConversationUpdate = {
  serverExtension?: string
}

TypeScriptinterface V2NIMConversationUpdate {
    serverExtension?: string;
}

TypeScriptexport interface V2NIMConversationUpdate {
  serverExtension?: string
}

Javapublic interface V2NIMConversationListener {
    void onSyncStarted();
    void onSyncFinished();
    void onSyncFailed(V2NIMError error);
    void onConversationCreated(V2NIMConversation conversation);
    void onConversationDeleted(List<String> conversationIds);
    void onConversationChanged(List<V2NIMConversation> conversationList);
    void onTotalUnreadCountChanged(int unreadCount);
    void onUnreadCountChangedByFilter(V2NIMConversationFilter filter, int unreadCount);
    void onConversationReadTimeUpdated(String conversationId, long readTime);
}

Objective-C@protocol V2NIMConversationListener
@optional
- (void)onSyncStarted;
- (void)onSyncFinished;
- (void)onSyncFailed:(V2NIMError *)error;
- (void)onConversationCreated:(V2NIMConversation *)conversation;
- (void)onConversationDeleted:(NSArray<NSString *> *)conversationIds;
- (void)onConversationChanged:(NSArray<V2NIMConversation *> *)conversations;
- (void)onTotalUnreadCountChanged:(NSInteger)unreadCount;
- (void)onUnreadCountChangedByFilter:(V2NIMConversationFilter *)filter
                         unreadCount:(NSInteger)unreadCount;
- (void)onConversationReadTimeUpdated:(NSString *)conversationId
                             readTime:(NSTimeInterval)readTime;
@end

C++struct V2NIMConversationListener {
    nstd::function<void()> onSyncStarted;
    nstd::function<void()> onSyncFinished;
    nstd::function<void(V2NIMError error)> onSyncFailed;
    nstd::function<void(V2NIMConversation conversation)> onConversationCreated;
    nstd::function<void(nstd::vector<nstd::string> conversationIds)> onConversationDeleted;
    nstd::function<void(nstd::vector<V2NIMConversation> conversationList)> onConversationChanged;
    nstd::function<void(uint32_t unreadCount)> onTotalUnreadCountChanged;
    nstd::function<void(V2NIMConversationFilter filter, uint32_t unreadCount)> onUnreadCountChangedByFilter;
    nstd::function<void(const nstd::string& conversationId, time_t readTime)> onConversationReadTimeUpdated;
};
};

TypeScriptexport type V2NIMConversationListener = {
  onSyncStarted: []
  onSyncFinished: []
  onSyncFailed: [error: V2NIMError]
  onConversationCreated: [conversation: V2NIMConversation]
  onConversationDeleted: [conversationIds: string[]]
  onConversationChanged: [conversationList: V2NIMConversation[]]
  onTotalUnreadCountChanged: [unreadCount: number]
  onUnreadCountChangedByFilter: [
    filter: V2NIMConversationFilter & {
      equals: (filter: V2NIMConversationFilter) => boolean
    },
    unreadCount: number
  ]
}

TypeScriptinterface V2NIMConversationListener {
    syncStarted: [];
    syncFinished: [];
    syncFailed: [V2NIMError];
    conversationCreated: [V2NIMConversation];
    conversationDeleted: [string[]];
    conversationChanged: [V2NIMConversation[]];
    totalUnreadCountChanged: [number];
    unreadCountChangedByFilter: [V2NIMConversationFilter, number];
    conversationReadTimeUpdated: [string, number];
}

TypeScriptexport interface V2NIMConversationListener extends NIMEBaseListener {
  onSyncStarted: []
  onSyncFinished: []
  onSyncFailed: [error: V2NIMError]
  onConversationCreated: [conversation: V2NIMConversation]
  onConversationDeleted: [conversationIds: string[]]
  onConversationChanged: [conversationList: V2NIMConversation[]]
  onTotalUnreadCountChanged: [unreadCount: number]
  onUnreadCountChangedByFilter: [
    filter: V2NIMConversationUnreadCountChangedFilter,
    unreadCount: number
  ]
}

Javapublic interface V2NIMConversationGroup extends Serializable {
    String getGroupId();
    String getName();
    String getServerExtension();
    long getCreateTime();
    long getUpdateTime();
}

Objective-C@interface V2NIMConversationGroup : NSObject <NSCopying>
@property(nullable,nonatomic,copy,readonly) NSString *groupId;
@property(nullable,nonatomic,copy,readonly) NSString *name;
@property(nullable,nonatomic,copy,readonly) NSString *serverExtension;
@property(nonatomic,assign,readonly) NSTimeInterval createTime;
@property(nonatomic,assign,readonly) NSTimeInterval updateTime;
@end

C++struct V2NIMConversationGroup {
    nstd::string groupId;
    nstd::string name;
    nstd::optional<nstd::string> serverExtension;
    uint64_t createTime{0};
    uint64_t updateTime{0};
};

TypeScriptexport type V2NIMConversationGroup = {
  groupId: string
  name: string
  serverExtension: string
  createTime: number
  updateTime: number
}

TypeScriptinterface V2NIMConversationGroup {
    groupId?: string;
    name?: string;
    serverExtension?: string;
    createTime?: number;
    updateTime?: number;
}

TypeScriptexport type V2NIMConversationGroup = {
  groupId: string
  name: string
  serverExtension: string
  createTime: number
  updateTime: number
}

Javapublic interface V2NIMConversationGroupResult {
    V2NIMConversationGroup getGroup();
    List<V2NIMConversationOperationResult> getFailedList();
}

Objective-C@interface V2NIMConversationGroupResult : NSObject
@property(nullable,nonatomic,copy,readonly) V2NIMConversationGroup *group;
@property(nullable,nonatomic,copy,readonly) NSArray<V2NIMConversationOperationResult *> *failedList;
@end

C++struct V2NIMConversationGroupResult {
    V2NIMConversationGroup group;
    nstd::vector<V2NIMConversationOperationResult> failedList;
};

TypeScriptexport type V2NIMConversationGroupResult = {
  group: V2NIMConversationGroup
  failedList: V2NIMConversationOperationResult[]
}

TypeScriptinterface V2NIMConversationGroupResult {
  group: V2NIMConversationGroup
  failedList: V2NIMConversationOperationResult[]
}

TypeScriptexport type V2NIMConversationGroupResult = {
  group: V2NIMConversationGroup
  failedList: V2NIMConversationOperationResult[]
}

Javapublic interface V2NIMConversationGroupListener {
    void onConversationGroupCreated(V2NIMConversationGroup conversationGroup, List<V2NIMConversation> conversations);
    void onConversationGroupDeleted(String groupId);
    void onConversationGroupChanged(V2NIMConversationGroup group);
    void onConversationsAddedToGroup(String groupId, List<V2NIMConversation> conversations);
    void onConversationsRemovedFromGroup(String groupId, List<String> conversationIds);
}

Objective-C@protocol V2NIMConversationGroupListener
@optional
- (void)onConversationGroupCreated:(V2NIMConversationGroup *)conversationGroup;
- (void)onConversationGroupDeleted:(NSString *)groupId;
- (void)onConversationGroupChanged:(V2NIMConversationGroup *)conversationGroup;
- (void)onConversationsAddedToGroup:(NSString *)groupId
                      conversations:(NSArray<V2NIMConversation *> *)conversations;
- (void)onConversationsRemovedFromGroup:(NSString *)groupId
                        conversationIds:(NSArray<NSString *> *)conversationIds;
@end

C++struct V2NIMConversationGroupListener {
    nstd::function<void(V2NIMConversationGroup conversationGroup)> onConversationGroupCreated;
    nstd::function<void(nstd::string groupId)> onConversationGroupDeleted;
    nstd::function<void(V2NIMConversationGroup conversationGroup)> onConversationGroupChanged;
    nstd::function<void(nstd::string groupId, V2NIMConversationList conversationList)> onConversationsAddedToGroup;
    nstd::function<void(nstd::string groupId, nstd::vector<nstd::string> conversationIds)> onConversationsRemovedFromGroup;
};

TypeScriptexport type V2NIMConversationGroupListener = {
  onConversationGroupCreated: [conversationGroup: V2NIMConversationGroup]
  onConversationGroupDeleted: [groupId: string]
  onConversationGroupChanged: [conversationGroup: V2NIMConversationGroup]
  onConversationsAddedToGroup: [groupId: string, list: V2NIMConversation[]]
  onConversationsRemovedFromGroup: [groupId: string, list: string[]]
}

TypeScriptinterface V2NIMConversationGroupListener {
    conversationGroupCreated: [V2NIMConversationGroup];
    conversationGroupDeleted: [string];
    conversationGroupChanged: [V2NIMConversationGroup];
    conversationsAddedToGroup: [string, V2NIMConversation[]];
    conversationsRemovedFromGroup: [string, string[]];
}

TypeScriptexport interface V2NIMConversationGroupListener extends NIMEBaseListener {
  onConversationGroupCreated: [conversationGroup: V2NIMConversationGroup]
  onConversationGroupDeleted: [groupId: string]
  onConversationGroupChanged: [conversationGroup: V2NIMConversationGroup]
  onConversationsAddedToGroup: [groupId: string, list: V2NIMConversation[]]
  onConversationsRemovedFromGroup: [groupId: string, list: string[]]
}

Javapublic final class V2NIMConversationIdUtil {
 public static String conversationId(String targetId, V2NIMConversationType type) {
  if(!SDKCache.isV2Api())
  {
   return null;
  }
  if (TextUtils.isEmpty(targetId) || type == null) {
   return null;
  }
  String account = SDKCacheUI.getAccount();
  if(TextUtils.isEmpty(account))
  {
   return null;
  }
  return String.format(Locale.ENGLISH,CONVERSATION_ID_FORMAT, account, type.getValue(), targetId);
 }
 public static String conversationId(String sessionId, SessionTypeEnum type) {
  switch (type){
   case P2P:
    return p2pConversationId(sessionId);
   case Team:
    return teamConversationId(sessionId);
   case SUPER_TEAM:
    return superTeamConversationId(sessionId);
   default:
    return null;
  }
 }
 public static String p2pConversationId(String accountId){
  return conversationId(accountId, V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P);
 }
 public static String teamConversationId(String teamId){
  return conversationId(teamId, V2NIMConversationType.V2NIM_CONVERSATION_TYPE_TEAM);
 }
 public static String superTeamConversationId(String superTeamId){
  return conversationId(superTeamId, V2NIMConversationType.V2NIM_CONVERSATION_TYPE_SUPER_TEAM);
 }
 public static V2NIMConversationType conversationType(String conversationId) {
  if (TextUtils.isEmpty(conversationId)) {
   return V2NIMConversationType.V2NIM_CONVERSATION_TYPE_UNKNOWN;
  }
  String[] components = conversationId.split(CONVERSATION_ID_SPLIT);
  // 3 parts
  if (components.length != 3) {
   return V2NIMConversationType.V2NIM_CONVERSATION_TYPE_UNKNOWN;
  }
  // account and target
  if (TextUtils.isEmpty(components[0]) || TextUtils.isEmpty(components[2])) {
   return V2NIMConversationType.V2NIM_CONVERSATION_TYPE_UNKNOWN;
  }
  try {
   int type = Integer.parseInt(components[1]);
   return V2NIMConversationType.typeOfValue(type);
  }
  catch (Throwable e) {
   NimLog.e(TAG, "conversationType error, conversationId=" + conversationId + ", e=" + e.getMessage());
   return V2NIMConversationType.V2NIM_CONVERSATION_TYPE_UNKNOWN;
  }
 }
 public static String conversationTargetId(String conversationId) {
  if (TextUtils.isEmpty(conversationId)) {
   return null;
  }
  String[] components = conversationId.split(CONVERSATION_ID_SPLIT);
  // 3 parts
  if (components.length != 3) {
   return null;
  }
  // account and target
  if (TextUtils.isEmpty(components[0])  || TextUtils.isEmpty(components[2])) {
   return null;
  }
  return components[2];
 }
 public static boolean isConversationIdValid(String conversationId){
  if (TextUtils.isEmpty(conversationId)) {
   return false;
  }
  String[] components = conversationId.split(CONVERSATION_ID_SPLIT);
  // 3 parts
  if (components.length != 3) {
   return false;
  }
  String account = SDKCacheUI.getAccount();
  if(account != null && !account.equals(components[0]))
  {
   return false;
  }
  if(TextUtils.isEmpty(components[0]))
  {
   return false;
  }
  V2NIMConversationType type;
  try {
   int typeInt = Integer.parseInt(components[1]);
   type = V2NIMConversationType.typeOfValue(typeInt);
  }
  catch (NumberFormatException e) {
   return false;
  }
  if(type == V2NIMConversationType.V2NIM_CONVERSATION_TYPE_UNKNOWN)
  {
   return false;
  }
  if(TextUtils.isEmpty(components[2]))
  {
   return false;
  }
  return true;
 }
 @Nullable
 public static SessionTypeEnum sessionTypeV1(@Nullable V2NIMConversationType conversationType) {
  if (conversationType == null) {
   return null;
  }
  switch (conversationType) {
   case V2NIM_CONVERSATION_TYPE_P2P:
    return SessionTypeEnum.P2P;
   case V2NIM_CONVERSATION_TYPE_TEAM:
    return SessionTypeEnum.Team;
   case V2NIM_CONVERSATION_TYPE_SUPER_TEAM:
    return SessionTypeEnum.SUPER_TEAM;
   default:
    return SessionTypeEnum.None;
  }
 }
}

Objective-C@interface V2NIMConversationIdUtil : NSObject
+ (nullable NSString *)p2pConversationId:(NSString *)accountId;
+ (nullable NSString *)teamConversationId:(NSString *)teamId;
+ (nullable NSString *)superTeamConversationId:(NSString *)teamId;
+ (V2NIMConversationType)conversationType:(NSString *)conversationId;
+ (nullable NSString *)conversationTargetId:(NSString *)conversationId;

@end

C++class V2NIMConversationIdUtil {
public:
    static nstd::string p2pConversationId(const nstd::string& accountId);
    static nstd::string teamConversationId(const nstd::string& teamId);
    static nstd::string superTeamConversationId(const nstd::string& superTeamId);
    static V2NIMConversationType parseConversationType(const nstd::string& conversationId);
    static nstd::string parseConversationTargetId(const nstd::string& conversationId);
};

TypeScriptconst p2pConversationId = nim.V2NIMConversationIdUtil.p2pConversationId('ACCOUND_ID')
const teamConversationId = nim.V2NIMConversationIdUtil.teamConversationId('TEAM_ID')
const superTeamConversationId = nim.V2NIMConversationIdUtil.superTeamConversationId('SUPER_TEAM_ID')
const conversationType = nim.V2NIMConversationIdUtil.parseConversationType('CONVERSATION_ID')
const targetId = nim.V2NIMConversationIdUtil.parseConversationTargetId('CONVERSATION_ID')

TypeScriptconst conversationId = v2.conversationIdUtil.p2pConversationId(accountId)
const conversationId = v2.conversationIdUtil.teamConversationId(teamId)
const conversationId = v2.conversationIdUtil.superTeamConversationId(superTeamId)
const conversationType = v2.conversationIdUtil.parseConversationType(conversationId)
const targetId = v2.conversationIdUtil.parseConversationTargetId(conversationId)

TypeScriptconst p2pConversationId = nim.conversationIdUtil.p2pConversationId('ACCOUND_ID')
const teamConversationId = nim.conversationIdUtil.teamConversationId('TEAM_ID')
const superTeamConversationId = nim.conversationIdUtil.superTeamConversationId('SUPER_TEAM_ID')
const conversationType = nim.conversationIdUtil.parseConversationType('CONVERSATION_ID')
const targetId = nim.conversationIdUtil.parseConversationTargetId('CONVERSATION_ID')

Javapublic interface V2NIMMessageListener {
    void onSendMessage(V2NIMMessage message);
    void onReceiveMessages(List<V2NIMMessage> messages);
    void onReceiveP2PMessageReadReceipts(List<V2NIMP2PMessageReadReceipt> readReceipts);
    void onReceiveTeamMessageReadReceipts(List<V2NIMTeamMessageReadReceipt> readReceipts);
    void onMessageRevokeNotifications(List<V2NIMMessageRevokeNotification> revokeNotifications);
    void onMessagePinNotification(V2NIMMessagePinNotification pinNotification);
    void onMessageQuickCommentNotification(V2NIMMessageQuickCommentNotification quickCommentNotification);
    void onMessageDeletedNotifications(List<V2NIMMessageDeletedNotification> messageDeletedNotifications);
    void onClearHistoryNotifications(List<V2NIMClearHistoryNotification> clearHistoryNotifications);
    void onReceiveMessagesModified(List<V2NIMMessage> messages);
}

Objective-C@protocol V2NIMMessageListener <NSObject>
- (void)onSendMessage:(V2NIMMessage *)message;
- (void)onReceiveMessages:(NSArray <V2NIMMessage *> *)messages;
- (void)onReceiveP2PMessageReadReceipts:(NSArray <V2NIMP2PMessageReadReceipt *>*)readReceipts;
- (void)onReceiveTeamMessageReadReceipts:(NSArray <V2NIMTeamMessageReadReceipt *>*)readReceipts;
- (void)onMessageRevokeNotifications:(V2NIMMessageRevokeNotification *)revokeNotification;
- (void)onMessagePinNotification:(V2NIMMessagePinNotification *)pinNotification;
- (void)onMessageQuickCommentNotification:(V2NIMMessageQuickCommentNotification *)notification;
- (void)onMessageDeletedNotifications:(NSArray<V2NIMMessageDeletedNotification *> *)messageDeletedNotification;
- (void)onClearHistoryNotifications:(NSArray<V2NIMClearHistoryNotification *> *)clearHistoryNotification;
- (void)onReceiveMessagesModified:(NSArray <V2NIMMessage *>*)messages;
@end

C++struct V2NIMMessageListener {
    nstd::function<void(nstd::vector<V2NIMMessage> messages)> onReceiveMessages;
    nstd::function<void(nstd::vector<V2NIMP2PMessageReadReceipt> readReceipts)> onReceiveP2PMessageReadReceipts;
    nstd::function<void(nstd::vector<V2NIMTeamMessageReadReceipt> readReceipts)> onReceiveTeamMessageReadReceipts;
    nstd::function<void(nstd::vector<V2NIMMessageRevokeNotification> revokeNotifications)> onMessageRevokeNotifications;
    nstd::function<void(V2NIMMessagePinNotification pinNotification)> onMessagePinNotification;
    nstd::function<void(V2NIMMessageQuickCommentNotification quickCommentNotification)> onMessageQuickCommentNotification;
    nstd::function<void(nstd::vector<V2NIMMessageDeletedNotification> messageDeletedNotification)> onMessageDeletedNotifications;
    nstd::function<void(nstd::vector<V2NIMClearHistoryNotification> clearHistoryNotification)> onClearHistoryNotifications;
    nstd::function<void(const V2NIMMessage &message)> onSendMessage;
    nstd::function<void(nstd::vector<V2NIMMessage> messages)> onReceiveMessagesModified;
};

TypeScriptexport type V2NIMMessageListener = {
  onSendMessage: [message: V2NIMMessage]
  onReceiveMessages: [messages: V2NIMMessage[]]
  onReceiveP2PMessageReadReceipts: [readReceipts: V2NIMP2PMessageReadReceipt[]]
  onReceiveTeamMessageReadReceipts: [readReceipts: V2NIMTeamMessageReadReceipt[]]
  onMessageRevokeNotifications: [notification: V2NIMMessageRevokeNotification[]]
  onMessageDeletedNotifications: [notification: V2NIMMessageDeletedNotification[]]
  onClearHistoryNotifications: [notification: V2NIMClearHistoryNotification[]]
  onMessagePinNotification: [notification: V2NIMMessagePinNotification]
  onMessageQuickCommentNotification: [notification: V2NIMMessageQuickCommentNotification]
  onReceiveMessagesModified: [messages: V2NIMMessage[]]
}

TypeScriptinterface V2NIMMessageListener {
    receiveMessages: [V2NIMMessage[]];
    receiveP2PMessageReadReceipts: [V2NIMP2PMessageReadReceipt[]];
    receiveTeamMessageReadReceipts: [V2NIMTeamMessageReadReceipt[]];
    messageRevokeNotifications: [V2NIMMessageRevokeNotification[]];
    messagePinNotification: [V2NIMMessagePinNotification];
    messageQuickCommentNotification: [V2NIMMessageQuickCommentNotification];
    messageDeletedNotifications: [V2NIMMessageDeletedNotification[]];
    clearHistoryNotifications: [V2NIMClearHistoryNotification[]];
    sendMessage: [V2NIMMessage];
    receiveMessagesModified: [V2NIMMessage[]];
}

TypeScriptexport type V2NIMMessageListener = {
  onReceiveMessages: [messages: V2NIMMessage[]]
  onReceiveP2PMessageReadReceipts: [readReceipts: V2NIMP2PMessageReadReceipt[]]
  onReceiveTeamMessageReadReceipts: [readReceipts: V2NIMTeamMessageReadReceipt[]]
  onMessageRevokeNotifications: [notification: V2NIMMessageRevokeNotification[]]
  onMessageDeletedNotifications: [notification: V2NIMMessageDeletedNotification[]]
  onClearHistoryNotifications: [notification: V2NIMClearHistoryNotification[]]
  onMessagePinNotification: [notification: V2NIMMessagePinNotification]
  onMessageQuickCommentNotification: [notification: V2NIMMessageQuickCommentNotification]
  onSendMessage: [message: V2NIMMessage]
}

Javapublic interface V2NIMMessage extends V2NIMMessageRefer, Serializable {
    String getMessageClientId();
    String getMessageServerId();
    long getCreateTime();
    String getSenderId();
    V2NIMConversationType getConversationType();
    String getReceiverId();
    V2NIMMessageType getMessageType();
    int getSubType();
    String getText();
    V2NIMMessageAttachment getAttachment();
    String getServerExtension();
    String getLocalExtension();
    String getCallbackExtension();
    V2NIMMessageConfig getMessageConfig();
    V2NIMMessagePushConfig getPushConfig();
    V2NIMMessageRouteConfig getRouteConfig();
    V2NIMMessageAntispamConfig getAntispamConfig();
    V2NIMMessageRobotConfig getRobotConfig();
    V2NIMMessageRefer getThreadRoot();
    V2NIMMessageRefer getThreadReply();
    V2NIMMessageStatus getMessageStatus();
    String getConversationId();
    boolean isSelf();
    V2NIMMessageAttachmentUploadState getAttachmentUploadState();
    V2NIMMessageSendingState getSendingState();
    void setSubType(int subType);
    void setText(String text);
    void setAttachment(V2NIMMessageAttachment attachment);
    void setServerExtension(String serverExtension);
    void setLocalExtension(String localExtension);
    V2NIMMessageAIConfig getAIConfig();
    void setAIConfig(V2NIMMessageAIConfig aiConfig);
    long getModifyTime();
    String getModifyAccountId();
}

Objective-C@interface V2NIMMessage : V2NIMMessageRefer <NSCopying>
@property(nonatomic,assign,readonly) BOOL isSelf;
@property(nonatomic,assign,readonly) V2NIMMessageAttachmentUploadState attachmentUploadState;
@property(nonatomic,assign,readonly) V2NIMMessageSendingState sendingState;
@property(nonatomic,assign) V2NIMMessageType messageType;
@property(nonatomic,assign) NSInteger subType;
@property(nullable,nonatomic,strong) NSString *text;
@property(nullable,nonatomic,strong) V2NIMMessageAttachment *attachment;
@property(nullable,nonatomic,strong) NSString *serverExtension;
@property(nullable,nonatomic,strong) NSString *localExtension;
@property(nullable,nonatomic,strong,readonly) NSString *callbackExtension;
@property(nullable,nonatomic,strong,readonly) V2NIMMessageConfig *messageConfig;
@property(nullable,nonatomic,strong,readonly) V2NIMMessagePushConfig *pushConfig;
@property(nullable,nonatomic,strong,readonly) V2NIMMessageRouteConfig *routeConfig;
@property(nullable,nonatomic,strong,readonly) V2NIMMessageAntispamConfig *antispamConfig;
@property(nullable,nonatomic,strong,readonly) V2NIMMessageRobotConfig *robotConfig;
@property(nullable,nonatomic,strong,readwrite) V2NIMMessageRefer *threadRoot;
@property(nullable,nonatomic,strong,readonly) V2NIMMessageRefer *threadReply;
@property(nullable,nonatomic,strong,readwrite) V2NIMMessageAIConfig *aiConfig;
@property(nonnull,nonatomic,strong, readonly) V2NIMMessageStatus *messageStatus;
@property(nonatomic,assign, readonly) NSTimeInterval modifyTime;
@property(nullable,nonatomic,copy, readonly) NSString *modifyAccountId;
@end

C++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};
    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;
    nstd::optional<V2NIMMessageAIConfig> aiConfig;
    nstd::optional<uint64_t> modifyTime;
    nstd::optional<nstd::string> modifyAccountId;
    bool isSelf{false};
    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;
    }
};

TypeScriptexport type V2NIMMessage = {
  messageClientId: string
  messageServerId: string
  createTime: number
  senderId: string
  receiverId: string
  conversationType: V2NIMConversationType
  conversationId: string
  isSelf: boolean
  attachmentUploadState?: V2NIMMessageAttachmentUploadState
  sendingState: V2NIMMessageSendingState
  messageType: V2NIMMessageType
  subType?: number
  text?: string
  attachment?: V2NIMMessageAttachment
  serverExtension?: string
  callbackExtension?: string
  messageConfig?: V2NIMMessageConfig
  pushConfig?: V2NIMMessagePushConfig
  routeConfig?: V2NIMMessageRouteConfig
  antispamConfig?: V2NIMMessageAntispamConfig
  robotConfig?: V2NIMMessageRobotConfig
  threadRoot?: V2NIMMessageRefer
  threadReply?: V2NIMMessageRefer
  messageStatus: V2NIMMessageStatus
  aiConfig?: V2NIMMessageAIConfig
  modifyTime?: number
  modifyAccountId?: string
}

TypeScriptinterface V2NIMMessage {
    messageClientId?: string;
    messageServerId?: string;
    createTime?: number;
    senderId?: string;
    receiverId?: string;
    conversationType?: V2NIMConversationType;
    conversationId?: string;
    messageType?: V2NIMMessageType;
    subType?: number;
    text?: string;
    attachment?: V2NIMMessageAttachment;
    serverExtension?: string;
    localExtension?: string;
    callbackExtension?: string;
    sendingState?: V2NIMMessageSendingState;
    attachmentUploadState?: V2NIMMessageAttachmentUploadState;
    messageStatus?: V2NIMMessageStatus;
    messageConfig?: V2NIMMessageConfig;
    pushConfig?: V2NIMMessagePushConfig;
    routeConfig?: V2NIMMessageRouteConfig;
    antispamConfig?: V2NIMMessageAntispamConfig;
    robotConfig?: V2NIMMessageRobotConfig;
    threadRoot?: V2NIMMessageRefer;
    threadReply?: V2NIMMessageRefer;
    isSelf?: boolean;
    aiConfig?: V2NIMAIModelConfig;
    modifyTime?: number;
    modifyAccountId?: string;
}

TypeScriptexport type V2NIMMessage = {
  messageClientId: string
  messageServerId: string
  createTime: number
  senderId: string
  receiverId: string
  conversationType: V2NIMConversationType
  conversationId: string
  isSelf: boolean
  sendingState: V2NIMMessageSendingState
  messageType: V2NIMMessageType
  subType?: number
  text?: string
  attachment?:
    | V2NIMMessageAttachment
    | Partial<V2NIMMessageFileAttachment>
    | Partial<V2NIMMessagImageAttachment>
    | Partial<V2NIMMessageAudioAttachment>
    | Partial<V2NIMMessageVideoAttachment>
    | Partial<V2NIMMessageLocationAttachment>
    | Partial<V2NIMMessageNotificationAttachment>
    | V2NIMMessageNotificationAttachment
  serverExtension?: string
  callbackExtension?: string
  messageConfig?: V2NIMMessageConfig
  pushConfig?: V2NIMMessagePushConfig
  routeConfig?: V2NIMMessageRouteConfig
  antispamConfig?: V2NIMMessageAntispamConfig
  robotConfig?: V2NIMMessageRobotConfig
  threadRoot?: V2NIMMessageRefer
  threadReply?: V2NIMMessageRefer
}

Javapublic interface V2NIMMessageStatus {
    int getErrorCode();
    boolean getReadReceiptSent();
}

Objective-C@interface V2NIMMessageStatus : NSObject<NSCopying>
@property(nonatomic,assign,readwrite) NSInteger errorCode;
@property(nonatomic,assign,readwrite) BOOL readReceiptSent;
@end

C++struct V2NIMMessageStatus {
    V2NIMErrorCode errorCode{V2NIM_ERROR_CODE_UNKNOWN};
    bool readReceiptSent{false};
};

TypeScriptexport type V2NIMMessageStatus = {
  errorCode: number
}

TypeScriptinterface V2NIMMessageStatus {
    errorCode?: number;
    readReceiptSent?: boolean;
}

TypeScriptinterface V2NIMMessageStatus {
    errorCode: number;
}

Javapublic class V2NIMMessageConfig implements Serializable {
    public boolean isReadReceiptEnabled() {
        return readReceiptEnabled;
    }
    public boolean isLastMessageUpdateEnabled() {
        return lastMessageUpdateEnabled;
    }
    public boolean isHistoryEnabled() {
        return historyEnabled;
    }
    public boolean isRoamingEnabled() {
        return roamingEnabled;
    }
    public boolean isOnlineSyncEnabled() {
        return onlineSyncEnabled;
    }
    public boolean isOfflineEnabled() {
        return offlineEnabled;
    }
    public boolean isUnreadEnabled() {
        return unreadEnabled;
    }
    @Override
    public String toString() {
        return "V2NIMMessageConfig{" +
                "readReceiptEnabled=" + readReceiptEnabled +
                ", lastMessageUpdateEnabled=" + lastMessageUpdateEnabled +
                ", historyEnabled=" + historyEnabled +
                ", roamingEnabled=" + roamingEnabled +
                ", onlineSyncEnabled=" + onlineSyncEnabled +
                ", offlineEnabled=" + offlineEnabled +
                ", unreadEnabled=" + unreadEnabled +
                '}';
    }
    public static final boolean DEFAULT_READ_RECEIPT_ENABLED = false;
    public static final boolean DEFAULT_CONVERSATION_UPDATE_ENABLED = true;
    public static final boolean DEFAULT_HISTORY_ENABLED = true;
    public static final boolean DEFAULT_ROAMING_ENABLED = true;
    public static final boolean DEFAULT_ONLINE_SYNC_ENABLED = true;
    public static final boolean DEFAULT_OFFLINE_ENABLED = true;
    public static final boolean DEFAULT_UNREAD_ENABLED = true;
    public static final class V2NIMMessageConfigBuilder {
        public static V2NIMMessageConfigBuilder builder() {
            return new V2NIMMessageConfigBuilder();
        }
        public V2NIMMessageConfigBuilder withReadReceiptEnabled(boolean readReceiptEnabled) {
            this.readReceiptEnabled = readReceiptEnabled;
            return this;
        }
        public V2NIMMessageConfigBuilder withLastMessageUpdateEnabled(boolean lastMessageUpdateEnabled) {
            this.lastMessageUpdateEnabled = lastMessageUpdateEnabled;
            return this;
        }
        public V2NIMMessageConfigBuilder withHistoryEnabled(boolean historyEnabled) {
            this.historyEnabled = historyEnabled;
            return this;
        }
        public V2NIMMessageConfigBuilder withRoamingEnabled(boolean roamingEnabled) {
            this.roamingEnabled = roamingEnabled;
            return this;
        }
        public V2NIMMessageConfigBuilder withOnlineSyncEnabled(boolean onlineSyncEnabled) {
            this.onlineSyncEnabled = onlineSyncEnabled;
            return this;
        }
        public V2NIMMessageConfigBuilder withOfflineEnabled(boolean offlineEnabled) {
            this.offlineEnabled = offlineEnabled;
            return this;
        }
        public V2NIMMessageConfigBuilder withUnreadEnabled(boolean unreadEnabled) {
            this.unreadEnabled = unreadEnabled;
            return this;
        }
        public V2NIMMessageConfig build() {
            return new V2NIMMessageConfig(readReceiptEnabled, lastMessageUpdateEnabled, historyEnabled, roamingEnabled, onlineSyncEnabled, offlineEnabled, unreadEnabled);
        }
    }
}

Objective-C@interface V2NIMMessageConfig : NSObject <NSCopying>
@property(nonatomic,assign,readwrite) BOOL readReceiptEnabled;
@property(nonatomic,assign,readwrite) BOOL lastMessageUpdateEnabled;
@property(nonatomic,assign,readwrite) BOOL historyEnabled;
@property(nonatomic,assign,readwrite) BOOL roamingEnabled;
@property(nonatomic,assign,readwrite) BOOL onlineSyncEnabled;
@property(nonatomic,assign,readwrite) BOOL offlineEnabled;
@property(nonatomic,assign,readwrite) BOOL unreadEnabled;
@end

C++struct V2NIMMessageConfig {
    bool readReceiptEnabled{false};
    bool lastMessageUpdateEnabled{true};
    bool historyEnabled{true};
    bool roamingEnabled{true};
    bool onlineSyncEnabled{true};
    bool offlineEnabled{true};
    bool unreadEnabled{true};
};

TypeScriptexport type V2NIMMessageConfig = {
  readReceiptEnabled?: boolean
  lastMessageUpdateEnabled?: boolean
  historyEnabled?: boolean
  roamingEnabled?: boolean
  onlineSyncEnabled?: boolean
  offlineEnabled?: boolean
  unreadEnabled?: boolean
}

TypeScriptinterface V2NIMMessageConfig {
    readReceiptEnabled?: boolean;
    lastMessageUpdateEnabled?: boolean;
    historyEnabled?: boolean;
    roamingEnabled?: boolean;
    onlineSyncEnabled?: boolean;
    offlineEnabled?: boolean;
    unreadEnabled?: boolean;
}

TypeScriptexport type V2NIMMessageConfig = {
  readReceiptEnabled?: boolean
  lastMessageUpdateEnabled?: boolean
  historyEnabled?: boolean
  roamingEnabled?: boolean
  onlineSyncEnabled?: boolean
  offlineEnabled?: boolean
  unreadEnabled?: boolean
}

Javapublic class V2NIMMessagePushConfig implements Serializable {
    public boolean isPushEnabled() {
        return pushEnabled;
    }
    public boolean isPushNickEnabled() {
        return pushNickEnabled;
    }
    public String getPushContent() {
        return pushContent;
    }
    public String getPushPayload() {
        return pushPayload;
    }
    public boolean isForcePush() {
        return forcePush;
    }
    public String getForcePushContent() {
        return forcePushContent;
    }
    public List<String> getForcePushAccountIds() {
        return forcePushAccountIds;
    }
    @Override
    public String toString() {
        return "V2NIMMessagePushConfig{" +
                "pushEnabled=" + pushEnabled +
                ", pushNickEnabled=" + pushNickEnabled +
                ", content='" + pushContent + '\'' +
                ", payload='" + pushPayload + '\'' +
                ", forcePush=" + forcePush +
                ", forcePushContent='" + forcePushContent + '\'' +
                ", forcePushAccountIds=" + forcePushAccountIds +
                '}';
    }
    public static final boolean DEFAULT_PUSH_ENABLE = true;
    public static final boolean DEFAULT_PUSH_NICK_ENABLE = true;
    public static final class V2NIMMessagePushConfigBuilder {
        public static V2NIMMessagePushConfigBuilder builder() {
            return new V2NIMMessagePushConfigBuilder();
        }
        public V2NIMMessagePushConfigBuilder withPushEnabled(boolean pushEnabled) {
            this.pushEnabled = pushEnabled;
            return this;
        }
        public V2NIMMessagePushConfigBuilder withPushNickEnabled(boolean pushNickEnabled) {
            this.pushNickEnabled = pushNickEnabled;
            return this;
        }
        public V2NIMMessagePushConfigBuilder withContent(String content) {
            this.content = content;
            return this;
        }
        public V2NIMMessagePushConfigBuilder withPayload(String payload) {
            this.payload = payload;
            return this;
        }
        public V2NIMMessagePushConfigBuilder withForcePush(boolean forcePush) {
            this.forcePush = forcePush;
            return this;
        }
        public V2NIMMessagePushConfigBuilder withForcePushContent(String forcePushContent) {
            this.forcePushContent = forcePushContent;
            return this;
        }
        public V2NIMMessagePushConfigBuilder withForcePushAccountIds(List<String> forcePushAccountIds) {
            this.forcePushAccountIds = forcePushAccountIds;
            return this;
        }
        public V2NIMMessagePushConfig build() {
            return new V2NIMMessagePushConfig(pushEnabled, pushNickEnabled, content, payload, forcePush, forcePushContent, forcePushAccountIds);
        }
    }
}

Objective-C@interface V2NIMMessagePushConfig : NSObject <NSCopying>
@property(nonatomic,assign,readwrite) BOOL pushEnabled;
@property(nonatomic,assign,readwrite) BOOL pushNickEnabled;
@property(nullable,nonatomic,strong,readwrite) NSString *pushContent;
@property(nullable,nonatomic,strong,readwrite) NSString *pushPayload;
@property(nonatomic,assign,readwrite) BOOL forcePush;
@property(nullable,nonatomic,strong,readwrite) NSString *forcePushContent;
@property(nullable,nonatomic,strong,readwrite) NSArray<NSString *> *forcePushAccountIds;
@end

C++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;
};

TypeScriptexport interface V2NIMMessagePushConfig {
  pushEnabled?: boolean
  pushNickEnabled?: boolean
  pushContent?: string
  pushPayload?: string
  forcePush?: boolean
  forcePushContent?: string
  forcePushAccountIds?: string[]
}

TypeScriptinterface V2NIMMessagePushConfig {
    pushEnabled?: boolean;
    pushNickEnabled?: boolean;
    pushContent?: string;
    pushPayload?: string;
    forcePush?: boolean;
    forcePushContent?: string;
    forcePushAccountIds?: string[];
}

TypeScriptexport interface V2NIMMessagePushConfig {
  pushEnabled?: boolean
  pushNickEnabled?: boolean
  pushContent?: string
  pushPayload?: string
  forcePush?: boolean
  forcePushContent?: string
  forcePushAccountIds?: string[]
}

Javapublic class V2NIMMessageRouteConfig implements Serializable {
    public boolean isRouteEnabled() {
        return routeEnabled;
    }
    public String getRouteEnvironment() {
        return routeEnvironment;
    }
    @Override
    public String toString() {
        return "V2NIMMessageRouteConfig{" +
                "routeEnabled=" + routeEnabled +
                ", routeEnvironment='" + routeEnvironment + '\'' +
                '}';
    }
    public static final boolean DEFAULT_ROUTE_ENABLE = true;
    public static final class V2NIMMessageRouteConfigBuilder {
        public static V2NIMMessageRouteConfigBuilder builder() {
            return new V2NIMMessageRouteConfigBuilder();
        }
        public V2NIMMessageRouteConfigBuilder withRouteEnabled(boolean routeEnabled) {
            this.routeEnabled = routeEnabled;
            return this;
        }
        public V2NIMMessageRouteConfigBuilder withRouteEnvironment(String routeEnvironment) {
            this.routeEnvironment = routeEnvironment;
            return this;
        }
        public V2NIMMessageRouteConfig build() {
            return new V2NIMMessageRouteConfig(routeEnabled, routeEnvironment);
        }
    }
}

Objective-C@interface V2NIMMessageRouteConfig : NSObject <NSCopying>
@property(nonatomic,assign,readwrite) BOOL routeEnabled;
@property(nullable,nonatomic,strong,readwrite) NSString *routeEnvironment;
@end

C++struct V2NIMMessageRouteConfig {
    bool routeEnabled{true};
    nstd::optional<nstd::string> routeEnvironment;
};

TypeScriptexport interface V2NIMMessageRouteConfig {
  routeEnabled?: boolean
  routeEnvironment?: string
}

TypeScriptinterface V2NIMMessageRouteConfig {
    routeEnabled?: boolean;
    routeEnvironment?: string;
}

TypeScriptexport interface V2NIMMessageRouteConfig {
  routeEnabled?: boolean
  routeEnvironment?: string
}

Javapublic class V2NIMMessageAntispamConfig implements Serializable {
    public boolean isAntispamEnabled() {
        return antispamEnabled;
    }
    public String getAntispamBusinessId() {
        return antispamBusinessId;
    }
    public String getAntispamCustomMessage() {
        return antispamCustomMessage;
    }
    public String getAntispamCheating() {
        return antispamCheating;
    }
    public String getAntispamExtension() {
        return antispamExtension;
    }
    @Override
    public String toString() {
        return "V2NIMMessageAntispamConfig{" +
                "antispamEnabled=" + antispamEnabled +
                ", antispamBusinessId='" + antispamBusinessId + '\'' +
                ", antispamCustomMessage='" + antispamCustomMessage + '\'' +
                ", antispamCheating='" + antispamCheating + '\'' +
                ", antispamExtension='" + antispamExtension + '\'' +
                '}';
    }
    public static final class V2NIMMessageAntispamConfigBuilder {
        private boolean antispamEnabled = DEFAULT_ANTISPAM_ENABLED;
        private String antispamBusinessId;
        private String antispamCustomMessage;
        private String antispamCheating;
        private String antispamExtension;
        public static V2NIMMessageAntispamConfigBuilder builder() {
            return new V2NIMMessageAntispamConfigBuilder();
        }
        public V2NIMMessageAntispamConfigBuilder withAntispamEnabled(boolean antispamEnabled) {
            this.antispamEnabled = antispamEnabled;
            return this;
        }
        public V2NIMMessageAntispamConfigBuilder withAntispamBusinessId(String antispamBusinessId) {
            this.antispamBusinessId = antispamBusinessId;
            return this;
        }
        public V2NIMMessageAntispamConfigBuilder withAntispamCustomMessage(String antispamCustomMessage) {
            this.antispamCustomMessage = antispamCustomMessage;
            return this;
        }
        public V2NIMMessageAntispamConfigBuilder withAntispamCheating(String antispamCheating) {
            this.antispamCheating = antispamCheating;
            return this;
        }
        public V2NIMMessageAntispamConfigBuilder withAntispamExtension(String antispamExtension) {
            this.antispamExtension = antispamExtension;
            return this;
        }
        public V2NIMMessageAntispamConfig build() {
            return new V2NIMMessageAntispamConfig(antispamEnabled, antispamBusinessId, antispamCustomMessage, antispamCheating, antispamExtension);
        }
    }
}

Objective-C@interface V2NIMMessageAntispamConfig : NSObject <NSCopying>
@property(nonatomic, assign, readwrite) BOOL antispamEnabled;
@property(nullable,nonatomic,strong,readwrite) NSString *antispamBusinessId;
@property(nullable,nonatomic,strong,readwrite) NSString *antispamCustomMessage;
@property(nullable,nonatomic,strong,readwrite) NSString *antispamCheating;
@property(nullable,nonatomic,strong,readwrite) NSString *antispamExtension;
@end

C++struct V2NIMMessageAntispamConfig {
    nstd::optional<bool> antispamEnabled;
    nstd::optional<nstd::string> antispamBusinessId;
    nstd::optional<nstd::string> antispamCustomMessage;
    nstd::optional<nstd::string> antispamCheating;
    nstd::optional<nstd::string> antispamExtension;
};

TypeScriptexport interface V2NIMMessageAntispamConfig {
  antispamEnabled?: boolean
  antispamBusinessId?: string
  antispamCustomMessage?: string
  antispamCheating?: string
  antispamExtension?: string
}

TypeScriptinterface V2NIMMessageAntispamConfig {
    antispamEnabled?: boolean;
    antispamBusinessId?: string;
    antispamCustomMessage?: string;
    antispamCheating?: string;
    antispamExtension?: string;
}

TypeScriptexport interface V2NIMMessageAntispamConfig {
  antispamEnabled?: boolean
  antispamBusinessId?: string
  antispamCustomMessage?: string
  antispamCheating?: string
  antispamExtension?: string
}

Javapublic class V2NIMMessageRobotConfig implements Serializable {
    public String getAccountId() {
        return accountId;
    }
    public String getTopic() {
        return topic;
    }
    public String getFunction() {
        return function;
    }
    public String getCustomContent() {
        return customContent;
    }
    @Override
    public String toString() {
        return "V2NIMMessageRobotConfig{" +
                "accountId='" + accountId + '\'' +
                ", topic='" + topic + '\'' +
                ", function='" + function + '\'' +
                ", customContent='" + customContent + '\'' +
                '}';
    }
    public static final class V2NIMMessageRobotConfigBuilder {
        public static V2NIMMessageRobotConfigBuilder builder() {
            return new V2NIMMessageRobotConfigBuilder();
        }
        public V2NIMMessageRobotConfigBuilder withAccountId(String accountId) {
            this.accountId = accountId;
            return this;
        }
        public V2NIMMessageRobotConfigBuilder withTopic(String topic) {
            this.topic = topic;
            return this;
        }
        public V2NIMMessageRobotConfigBuilder withFunction(String function) {
            this.function = function;
            return this;
        }
        public V2NIMMessageRobotConfigBuilder withCustomContent(String customContent) {
            this.customContent = customContent;
            return this;
        }
        public V2NIMMessageRobotConfig build() {
            return new V2NIMMessageRobotConfig(accountId, topic, function, customContent);
        }
    }
}

Objective-C@interface V2NIMMessageRobotConfig : NSObject<NSCopying>
@property(nullable,nonatomic,strong,readwrite) NSString *accountId;
@property(nullable,nonatomic,strong,readwrite) NSString *topic;
@property(nullable,nonatomic,strong,readwrite) NSString *function;
@property(nullable,nonatomic,strong,readwrite) NSString *customContent;
@end

C++struct V2NIMMessageRobotConfig {
    nstd::optional<nstd::string> accountId;
    nstd::optional<nstd::string> topic;
    nstd::optional<nstd::string> function;
    nstd::optional<nstd::string> customContent;
};

TypeScriptexport interface V2NIMMessageRobotConfig {
  accountId?: string
  topic?: string
  function?: string
  customContent?: string
}

TypeScriptinterface V2NIMMessageRobotConfig {
    accountId?: string;
    topic?: string;
    function?: string;
    customContent?: string;
}

TypeScriptexport interface V2NIMMessageRobotConfig {
  accountId?: string
  topic?: string
  function?: string
  customContent?: string
}

Javapublic interface V2NIMLastMessage extends Serializable {
    V2NIMLastMessageState getLastMessageState();
    V2NIMMessageRefer getMessageRefer();
    V2NIMMessageType getMessageType();
    int getSubType();
    V2NIMMessageSendingState getSendingState();
    String getText();
    V2NIMMessageAttachment getAttachment();
    String getRevokeAccountId();
    V2NIMMessageRevokeType getRevokeType();
    String getServerExtension();
    String getCallbackExtension();
    String getSenderName();
}

Objective-C@interface V2NIMLastMessage : NSObject <NSCopying>
@property(nonatomic,assign,readonly) V2NIMLastMessageState lastMessageState;
@property(nonatomic,strong,readonly) V2NIMMessageRefer *messageRefer;
@property(nonatomic,assign,readonly) V2NIMMessageType messageType;
@property(nonatomic,assign,readonly) NSInteger subType;
@property(nonatomic,assign,readonly) V2NIMMessageSendingState sendingState;
@property(nullable,nonatomic,strong,readonly) NSString *text;
@property(nullable,nonatomic,strong,readonly) V2NIMMessageAttachment *attachment;
@property(nullable,nonatomic,strong,readonly) NSString *revokeAccountId;
@property(nonatomic,assign,readonly) V2NIMMessageRevokeType revokeType;
@property(nullable,nonatomic,strong,readonly) NSString *serverExtension;
@property(nullable,nonatomic,strong,readonly) NSString *callbackExtension;
@property(nullable,nonatomic,strong,readonly) NSString *senderName;
@end

C++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;
};

TypeScriptexport type V2NIMLastMessage = {
  lastMessageState: V2NIMLastMessageState
  messageRefer: V2NIMMessageRefer
  messageType?: V2NIMMessageType
  subType?: number
  sendingState?: V2NIMMessageSendingState
  text?: string
  attachment?: Partial<V2NIMMessageAttachment>
  revokeAccountId?: string
  revokeType?: V2NIMMessageRevokeType
  serverExtension?: string
  callbackExtension?: string
  senderName?: string
}

TypeScriptinterface V2NIMLastMessage {
    lastMessageState?: V2NIMLastMessageState;
    messageRefer?: V2NIMMessageRefer;
    messageType?: V2NIMMessageType;
    subType?: number;
    sendingState?: V2NIMMessageSendingState;
    text?: string;
    attachment?: V2NIMMessageAttachment;
    revokeAccountId?: string;
    revokeType?: V2NIMMessageRevokeType;
    senderName?: string;
    serverExtension?: string;
    callbackExtension?: string;
}

TypeScriptexport interface V2NIMLastMessage {
  lastMessageState: V2NIMLastMessageState
  messageRefer: V2NIMMessageRefer
  messageType?: V2NIMMessageType
  subType?: number
  sendingState?: V2NIMMessageSendingState
  text?: string
  attachment?: Partial<V2NIMMessageAttachment>
  revokeAccountId?: string
  revokeType?: V2NIMMessageRevokeType
  serverExtension?: string
  callbackExtension?: string
  senderName?: string
}

Javapublic interface V2NIMMessageQuickComment {
    V2NIMMessageRefer getMessageRefer();
    String getOperatorId();
    long getIndex();
    long getCreateTime();
    String getServerExtension();
}

Objective-C@interface V2NIMMessageQuickComment : NSObject
@property(nonatomic,strong,readwrite) V2NIMMessageRefer *messageRefer;
@property(nonatomic,strong,readwrite) NSString *operatorId;
@property(nonatomic,assign,readwrite) NSTimeInterval index;
@property(nonatomic,assign,readwrite) NSTimeInterval createTime;
@property(nonatomic,strong,readwrite) NSString *serverExtension;
@end

C++struct V2NIMMessageQuickComment {
    V2NIMMessageRefer messageRefer;
    nstd::string operatorId;
    uint64_t index{0};
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<uint64_t> createTime;

TypeScriptexport interface V2NIMMessageQuickComment {
  messageRefer: V2NIMMessageRefer
  operatorId: string
  index: number
  serverExtension: string
  createTime: number
  pushConfig?: V2NIMMessageQuickCommentPushConfig
}

TypeScriptinterface V2NIMMessageQuickComment {
    messageRefer?: V2NIMMessageRefer;
    operatorId?: string;
    index?: number;
    serverExtension?: string;
    createTime?: number;
}

TypeScriptexport interface V2NIMMessageQuickComment {
  messageRefer: V2NIMMessageRefer
  operatorId: string
  index: number
  serverExtension: string
  createTime: number
  pushConfig?: V2NIMMessageQuickCommentPushConfig
}

Javapublic class V2NIMMessageQuickCommentPushConfig {
    private final boolean pushEnabled;
    private final boolean needBadge;
    private final String pushTitle;
    private final String pushContent;
    private final String pushPayload;
    private V2NIMMessageQuickCommentPushConfig() {
        this(DEFAULT_PUSH_ENABLED, DEFAULT_NEED_BADGE, null, null, null);
    }
    private V2NIMMessageQuickCommentPushConfig(boolean pushEnabled, boolean needBadge, String pushTitle, String pushContent, String pushPayload) {
        this.pushEnabled = pushEnabled;
        this.needBadge = needBadge;
        this.pushTitle = pushTitle;
        this.pushContent = pushContent;
        this.pushPayload = pushPayload;
    }
    public boolean getPushEnabled() {
        return pushEnabled;
    }
    public boolean getNeedBadge() {
        return needBadge;
    }
    public String getPushTitle() {
        return pushTitle;
    }
    public String getPushContent() {
        return pushContent;
    }
    public String getPushPayload() {
        return pushPayload;
    }
    private static final boolean DEFAULT_PUSH_ENABLED = true;
    private static final boolean DEFAULT_NEED_BADGE = true;
    public static final class V2NIMMessageQuickCommentPushConfigBuilder {
        private boolean pushEnabled = DEFAULT_PUSH_ENABLED;
        private boolean needBadge = DEFAULT_NEED_BADGE;
        private String pushTitle;
        private String pushContent;
        private String pushPayload;
        private V2NIMMessageQuickCommentPushConfigBuilder() {
        }
        public static V2NIMMessageQuickCommentPushConfigBuilder builder() {
            return new V2NIMMessageQuickCommentPushConfigBuilder();
        }
        public V2NIMMessageQuickCommentPushConfigBuilder withPushEnabled(boolean pushEnabled) {
            this.pushEnabled = pushEnabled;
            return this;
        }
        public V2NIMMessageQuickCommentPushConfigBuilder withNeedBadge(boolean needBadge) {
            this.needBadge = needBadge;
            return this;
        }
        public V2NIMMessageQuickCommentPushConfigBuilder withPushTitle(String title) {
            this.pushTitle = title;
            return this;
        }
        public V2NIMMessageQuickCommentPushConfigBuilder withPushContent(String content) {
            this.pushContent = content;
            return this;
        }
        public V2NIMMessageQuickCommentPushConfigBuilder withPushPayload(String payload) {
            this.pushPayload = payload;
            return this;
        }
        public V2NIMMessageQuickCommentPushConfig build() {
            return new V2NIMMessageQuickCommentPushConfig(pushEnabled, needBadge, pushTitle, pushContent, pushPayload);
        }
    }
}

Objective-C@interface V2NIMMessageQuickCommentPushConfig : NSObject
@property(nonatomic,assign,readwrite) BOOL pushEnabled;
@property(nonatomic,assign,readwrite) BOOL needBadge;
@property(nonatomic,strong,readwrite) NSString *title;
@property(nonatomic,strong,readwrite) NSString *pushContent;
@property(nonatomic,strong,readwrite) NSString *pushPayload;
@end

C++struct V2NIMMessageQuickCommentPushConfig {
    bool needPush{true};
    bool needBadge{true};
    nstd::string pushTitle;
    nstd::string pushContent;
    nstd::string pushPayload;
};

TypeScriptexport interface V2NIMMessageQuickCommentPushConfig {
  pushEnabled?: boolean
  needBadge?: boolean
  title?: string
  pushContent?: string
  pushPayload?: string
}

TypeScriptinterface V2NIMMessageQuickCommentPushConfig {
    needPush?: boolean;
    needBadge?: boolean;
    pushTitle?: string;
    pushContent?: string;
    pushPayload?: string;
}

TypeScriptexport interface V2NIMMessageQuickCommentPushConfig {
  pushEnabled?: boolean
  needBadge?: boolean
  title?: string
  pushContent?: string
  pushPayload?: string
}

Javapublic interface V2NIMMessagePin {
    V2NIMMessageRefer getMessageRefer();
    String getOperatorId();
    String getServerExtension();
    long getCreateTime();
    long getUpdateTime();
}

Objective-C@interface V2NIMMessagePin : NSObject
@property (nullable,nonatomic,strong) V2NIMMessageRefer *messageRefer;
@property (nonatomic,strong) NSString *operatorId;
@property (nonatomic,strong) NSString *serverExtension;
@property (nonatomic,assign) NSTimeInterval createTime;
@property (nonatomic,assign) NSTimeInterval updateTime;
@end

C++struct V2NIMMessagePin {
    V2NIMMessageRefer messageRefer;
    nstd::string operatorId;
    nstd::optional<nstd::string> serverExtension;
    uint64_t createTime{0};
    uint64_t updateTime{0};
};

TypeScriptexport interface V2NIMMessagePin {
  messageRefer: V2NIMMessageRefer
  opeartorId: string
  serverExtension?: string
  createTime: number
  updateTime: number
}

TypeScriptinterface V2NIMMessagePin {
    messageRefer?: V2NIMMessageRefer;
    operatorId?: string;
    serverExtension?: string;
    createTime?: number;
    updateTime?: number;
}

TypeScriptexport interface V2NIMMessagePin {
  messageRefer: V2NIMMessageRefer
  opeartorId: string
  serverExtension?: string
  createTime: number
  updateTime: number
}

Javapublic interface V2NIMCollection {
    String getCollectionId();
    int getCollectionType();
    String getCollectionData();
    String getServerExtension();
    long getCreateTime();
    long getUpdateTime();
    String getUniqueId();
}

Objective-C@interface V2NIMCollection : NSObject
@property (nullable,nonatomic,strong) NSString *collectionId;
@property (nonatomic,assign) int collectionType;
@property (nullable,nonatomic,strong,readonly) NSString *collectionData;
@property (nullable,nonatomic,strong) NSString *serverExtension;
@property (nonatomic,assign) NSTimeInterval createTime;
@property (nonatomic,assign) NSTimeInterval updateTime;
@property (nullable,nonatomic,strong) NSString *uniqueId;
@end

C++struct V2NIMCollection {
    nstd::string collectionId;
    uint32_t collectionType{0};
    nstd::string collectionData;
    nstd::optional<nstd::string> serverExtension;
    uint64_t createTime{0};
    uint64_t updateTime{0};
};

TypeScriptexport interface V2NIMCollection {
  collectionId: string
  collectionType: number
  collectionData: string
  serverExtension?: string
  createTime: number
  updateTime: number
  uniqueId?: string
}

TypeScriptinterface V2NIMCollection {
    collectionId?: string;
    collectionType?: number;
    collectionData?: string;
    serverExtension?: string;
    uniqueId?: string;
    createTime?: number;
    updateTime?: number;
}

TypeScriptexport interface V2NIMCollection {
  collectionId: string
  collectionType: number
  collectionData: string
  serverExtension?: string
  createTime: number
  updateTime: number
}

Javapublic class V2NIMAddCollectionParams {
    public int getCollectionType() {
        return collectionType;
    }
    public String getCollectionData() {
        return collectionData;
    }
    public String getServerExtension() {
        return serverExtension;
    }
    public String getUniqueId() {
        return uniqueId;
    }
    @Override
    public String toString() {
        return "V2NIMAddCollectionParams{" +
                "collectionType=" + collectionType +
                ", collectionData='" + collectionData + '\'' +
                ", serverExtension='" + serverExtension + '\'' +
                ", uniqueId='" + uniqueId + '\'' +
                '}';
    }
    public static final class V2NIMAddCollectionParamsBuilder {
        public static V2NIMAddCollectionParamsBuilder builder(int collectionType, String collectionData) {
            return new V2NIMAddCollectionParamsBuilder(collectionType, collectionData);
        }
        public V2NIMAddCollectionParamsBuilder withServerExtension(String serverExtension) {
            this.serverExtension = serverExtension;
            return this;
        }
        public V2NIMAddCollectionParams build() {
            return new V2NIMAddCollectionParams(collectionType, collectionData, serverExtension);
        }
    }
}

Objective-C@interface V2NIMAddCollectionParams : NSObject
@property (nonatomic,assign) int collectionType;
@property (nonnull,nonatomic,strong) NSString *collectionData;
@property (nonnull,nonatomic,strong) NSString *serverExtension;
@property (nullable,nonatomic,strong) NSString *uniqueId;
@end

C++struct V2NIMAddCollectionParams {
    uint32_t collectionType{0};
    nstd::string collectionData;
    nstd::optional<nstd::string> serverExtension;
    nstd::optional<nstd::string> uniqueId;
};

TypeScriptexport interface V2NIMAddCollectionParams {
  collectionType: number
  collectionData: string
  serverExtension?: string
  uniqueId?: string
}

TypeScriptinterface V2NIMAddCollectionParams {
    collectionType?: number;
    collectionData?: string;
    serverExtension?: string;
    uniqueId?: string;
}

TypeScriptexport interface V2NIMAddCollectionParams {
  collectionType: number
  collectionData: string
  serverExtension?: string
  uniqueId?: string
}

Javapublic class V2NIMCollectionOption {
    public long getBeginTime() {
        return beginTime;
    }
    public long getEndTime() {
        return endTime;
    }
    public V2NIMCollection getAnchorCollection() {
        return anchorCollection;
    }
    public V2NIMQueryDirection getDirection() {
        if (direction == null) {
            return DEFAULT_DIRECTION;
        } else {
            return direction;
        }
    }
    public int getLimit() {
        return limit;
    }
    public int getCollectionType() {
        return collectionType;
    }
    @Override
    public String toString() {
        return "V2NIMCollectionOption{" +
                "beginTime=" + beginTime +
                ", endTime=" + endTime +
                ", anchorCollection=" + anchorCollection +
                ", direction=" + direction +
                ", limit=" + limit +
                ", collectionType=" + collectionType +
                '}';
    }
        public static V2NIMCollectionOptionBuilder builder() {
            return new V2NIMCollectionOptionBuilder();
        }
        public V2NIMCollectionOptionBuilder withBeginTime(long beginTime) {
            this.beginTime = beginTime;
            return this;
        }
        public V2NIMCollectionOptionBuilder withEndTime(long endTime) {
            this.endTime = endTime;
            return this;
        }
        public V2NIMCollectionOptionBuilder withDirection(V2NIMQueryDirection direction) {
            this.direction = direction;
            return this;
        }
        public V2NIMCollectionOptionBuilder withAnchorCollection(V2NIMCollection anchorCollection) {
            this.anchorCollection = anchorCollection;
            return this;
        }
        public V2NIMCollectionOptionBuilder withLimit(int limit) {
            this.limit = limit;
            return this;
        }
        public V2NIMCollectionOptionBuilder withCollectionType(int collectionType) {
            this.collectionType = collectionType;
            return this;
        }
        public V2NIMCollectionOption build() {
            return new V2NIMCollectionOption(beginTime, endTime, anchorCollection, direction, limit, collectionType);
        }
    }
}