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 {
    // progress int
    // 进度回调 取值范围[0,100]，表示百分比
    // 100 表示上传成功
    // 0 表示未开始上传
    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

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
}

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

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

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

Javapublic interface V2NIMLoginClient {
    V2NIMLoginClientType getType();

    String getOs();

    long getTimestamp();

    String getCustomTag();

    int getCustomClientType();

    String getClientId();
}

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;

@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;
};

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

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

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

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
}

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
}

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;
    /// @internal
    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]
}

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 相关的事件

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[]
}

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[]
}

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();

    V2NIMMessage getLastMessage();

    int getUnreadCount();

    long getOrder();

    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) V2NIMMessage *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;
    nstd::optional<bool> mute;
    bool stickTop{false};
    nstd::vector<nstd::string> groupIds;
    nstd::string localExtension;
    nstd::string serverExtension;
    V2NIMMessage 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?: V2NIMMessage
  unreadCount: number
  sortOrder: number
  createTime: number
  updateTime: number
}

TypeScript/**
 * v2 会话结构
 */
export interface 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
}

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
}

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
}

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
}

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
  ]
}

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
}

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[]
}

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[]]
}

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 {

 /**
  * 生成会话 ID
  * @param targetId 目标 ID
  * @param type 会话类型
  * @return 会话 ID
  */
 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;
  }
 }

 /**
  * 生成 p2p 会话 ID
  * @param accountId 对方账号 ID
  * @return 会话 ID
  */
 public static String p2pConversationId(String accountId){
  return conversationId(accountId, V2NIMConversationType.V2NIM_CONVERSATION_TYPE_P2P);
 }

 /**
  * 生成 team 会话 ID
  * @param teamId 群 ID
  * @return 会话 ID
  */
 public static String teamConversationId(String teamId){
  return conversationId(teamId, V2NIMConversationType.V2NIM_CONVERSATION_TYPE_TEAM);
 }

 /**
  * 生成 superTeam 会话 ID
  * @param superTeamId 超大群 ID
  * @return 会话 ID
  */
 public static String superTeamConversationId(String superTeamId){
  return conversationId(superTeamId, V2NIMConversationType.V2NIM_CONVERSATION_TYPE_SUPER_TEAM);
 }

 /**
  * 根据会话 ID 返回会话类型
  * @param conversationId 会话 ID
  * @return 会话类型
  */
 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;
  }
 }

 /**
  * 根据会话 ID 返回会话对应目标 ID(accountId、teamId、superTeamId)
  * @param conversationId 会话 ID
  * @return 会话目标 ID
  */
 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];
 }

 /**
  * 会话 ID 是否合法
  * @param conversationId 会话 ID
  * @return 是否合法 true:合法 false:不合法
  */
 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

/**
 * 使用账号 ID 构造会话 ID
 *
 * @param accountId 账号 ID
 * @return 返回会话 ID
 * @discussion
 */
+ (nullable NSString *)p2pConversationId:(NSString *)accountId;
/**
 * 使用群 ID 构造会话 ID
 *
 * @param teamId 群 ID
 * @return 返回会话 ID
 * @discussion
 */
+ (nullable NSString *)teamConversationId:(NSString *)teamId;
/**
 * 使用群 ID 构造会话 ID（超大群）
 *
 * @param teamId 群 ID
 * @return 返回会话 ID
 * @discussion
 */
+ (nullable NSString *)superTeamConversationId:(NSString *)teamId;

/**
 * 从会话 ID 中获取会话类型
 *
 * @param conversationId 会话 ID
 * @return 返回会话类型
 * @discussion
 */
+ (V2NIMConversationType)conversationType:(NSString *)conversationId;
/**
 * 从会话 ID 中获取会话对象 ID
 *
 * @param conversationId 会话 ID
 * @return 返回会话对象 ID
 * @discussion
 */
+ (nullable NSString *)conversationTargetId:(NSString *)conversationId;

@end

C++class V2NIMConversationIdUtil {
public:
    /// @brief 获取点对点会话 ID
    /// @param accountId 账号 ID
    /// @return nstd::string
    /// @par 示例代码
    /// @code
    /// auto conversationId = V2NIMConversationIdUtil::p2pConversationId("target_account_id");
    /// @endcode
    static nstd::string p2pConversationId(const nstd::string& accountId);

    /// @brief 获取群组会话 ID
    /// @param teamId 群组 ID
    /// @return nstd::string
    /// @par 示例代码
    /// @code
    /// auto conversationId = V2NIMConversationIdUtil::teamConversationId("team_id");
    /// @endcode
    static nstd::string teamConversationId(const nstd::string& teamId);

    /// @brief 获取超级群会话 ID
    /// @param superTeamId 超级群 ID
    /// @return nstd::string
    /// @par 示例代码
    /// @code
    /// auto conversationId = V2NIMConversationIdUtil::superTeamConversationId("super_team_id");
    /// @endcode
    static nstd::string superTeamConversationId(const nstd::string& superTeamId);

    /// @brief 获取会话 ID 对应的会话类型
    /// @param conversationId 会话 ID
    /// @return V2NIMConversationType
    /// @par 示例代码
    /// @code
    /// auto conversationType = V2NIMConversationIdUtil::parseConversationType("conversation_id");
    /// @endcode
    static V2NIMConversationType parseConversationType(const nstd::string& conversationId);

    /// @brief 获取会话 ID 对应的目标 ID
    /// @param conversationId 会话 ID
    /// @return nstd::string
    /// @par 示例代码
    /// @code
    /// auto targetId = V2NIMConversationIdUtil::parseConversationTargetId("conversation_id");
    /// @endcode
    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 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[]]
}

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]
}

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
}

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 {

    /**
     * 获取消息发送错误码
     * @return 消息发送错误码
     */
    int getErrorCode();

    /**
     * 获取是否已经发送过已读回执请求
     * @return 是否已经发送过已读回执请求
     */
    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
}

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
}

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[]
}

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
}

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
}

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
}

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
}

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
}

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
}

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
}

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
}

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

    @Override
    public String toString() {
        return "V2NIMAddCollectionParams{" +
                "collectionType=" + collectionType +
                ", collectionData='" + collectionData + '\'' +
                ", serverExtension='" + serverExtension + '\'' +
                '}';
    }

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

TypeScriptexport interface V2NIMAddCollectionParams {

  collectionType: number

  collectionData: string

  serverExtension?: string

  uniqueId?: string
}

TypeScriptexport interface V2NIMAddCollectionParams {

  collectionType: number
  collectionData: string
  serverExtension?: 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);
        }
    }
}

Objective-C@interface V2NIMCollectionOption : NSObject

@property (nonatomic,assign) NSTimeInterval beginTime;

@property (nonatomic,assign) NSTimeInterval endTime;

@property (nonatomic,assign) V2NIMQueryDirection direction;

@property (nonatomic,strong) V2NIMCollection *anchorCollection;

@property (nonatomic,assign) int limit;

@property (nonatomic,assign) int collectionType;

@property (nonatomic,assign) NSInteger excludeId;

@end

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

TypeScriptexport interface V2NIMCollectionOption {

  beginTime?: number

  endTime?: number

  anchorCollection?: V2NIMCollection

  direction?: V2NIMQueryDirection

  limit?: number

  collectionType?: number
}

TypeScriptexport interface V2NIMCollectionOption {

  beginTime?: number
  endTime?: number
  anchorCollection?: V2NIMCollection
  direction?: V2NIMQueryDirection
  limit?: number
  collectionType?: number
}

Javapublic class V2NIMSendMessageParams {

    private final V2NIMMessageConfig messageConfig;
    private final V2NIMMessageRouteConfig routeConfig;
    private final V2NIMMessagePushConfig pushConfig;
    private final V2NIMMessageAntispamConfig antispamConfig;
    private final V2NIMMessageRobotConfig robotConfig;
    private final V2NIMMessageAIConfigParams    aiConfig;
    private final V2NIMMessageTargetConfig targetConfig;
    private final boolean clientAntispamEnabled;
    private final String clientAntispamReplace;
    private V2NIMSendMessageParams() {
        this(
                null,
                null,
                null,
                null,
                null,
                null,
                null,
                DEFAULT_CLIENT_ANTISPAM_ENABLED,
                DEFAULT_CLIENT_ANTISPAM_REPLACE);
    }

    private V2NIMSendMessageParams(V2NIMMessageConfig messageConfig, V2NIMMessageRouteConfig routeConfig, V2NIMMessagePushConfig pushConfig, V2NIMMessageAntispamConfig antispamConfig, V2NIMMessageRobotConfig robotConfig,V2NIMMessageAIConfigParams aiConfig, V2NIMMessageTargetConfig targetConfig, boolean clientAntispamEnabled, String clientAntispamReplace) {
        this.messageConfig = messageConfig;
        this.routeConfig = routeConfig;
        this.pushConfig = pushConfig;
        this.antispamConfig = antispamConfig;
        this.robotConfig = robotConfig;
        this.aiConfig = aiConfig;
        this.targetConfig = targetConfig;
        this.clientAntispamEnabled = clientAntispamEnabled;
        this.clientAntispamReplace = clientAntispamReplace;
    }

    public V2NIMMessageConfig getMessageConfig() {
        return messageConfig;
    }

    public V2NIMMessageRouteConfig getRouteConfig() {
        return routeConfig;
    }

    public V2NIMMessagePushConfig getPushConfig() {
        return pushConfig;
    }

    public V2NIMMessageAntispamConfig getAntispamConfig() {
        return antispamConfig;
    }

    public V2NIMMessageRobotConfig getRobotConfig() {
        return robotConfig;
    }

    public V2NIMMessageAIConfigParams getAIConfig() {
        return aiConfig;
    }

    public V2NIMMessageTargetConfig getTargetConfig() {
        return targetConfig;
    }

    public boolean isClientAntispamEnabled() {
        return clientAntispamEnabled;
    }

    public String getClientAntispamReplace() {
        return clientAntispamReplace;
    }

    @Override
    public String toString() {
        return "V2NIMSendMessageParams{" +
                "messageConfig=" + messageConfig +
                ", routeConfig=" + routeConfig +
                ", pushConfig=" + pushConfig +
                ", antispamConfig=" + antispamConfig +
                ", robotConfig=" + robotConfig +
                ", clientAntispamEnabled=" + clientAntispamEnabled +
                ", clientAntispamReplace='" + clientAntispamReplace + '\'' +
                '}';
    }

    private final static boolean DEFAULT_CLIENT_ANTISPAM_ENABLED = false;
    private final static String DEFAULT_CLIENT_ANTISPAM_REPLACE = "";

    /**
     * Builder for {@link V2NIMSendMessageParams}
     */
    public static final class V2NIMSendMessageParamsBuilder {
        private V2NIMMessageConfig messageConfig;
        private V2NIMMessageRouteConfig routeConfig;
        private V2NIMMessagePushConfig pushConfig;
        private V2NIMMessageAntispamConfig antispamConfig;
        private V2NIMMessageRobotConfig robotConfig;
        private V2NIMMessageAIConfigParams aiConfig;
        private V2NIMMessageTargetConfig targetConfig;
        private boolean clientAntispamEnabled = DEFAULT_CLIENT_ANTISPAM_ENABLED;
        private String clientAntispamReplace = DEFAULT_CLIENT_ANTISPAM_REPLACE;

        private V2NIMSendMessageParamsBuilder() {
        }

        /**
         * Create a new {@link V2NIMSendMessageParamsBuilder} instance
         * @return
         */
        public static V2NIMSendMessageParamsBuilder builder() {
            return new V2NIMSendMessageParamsBuilder();
        }

        /**
         * Set the message config
         * @param messageConfig the message config
         * @return V2NIMSendMessageParamsBuilder
         */
        public V2NIMSendMessageParamsBuilder withMessageConfig(V2NIMMessageConfig messageConfig) {
            this.messageConfig = messageConfig;
            return this;
        }

        /**
         * Set the route config
         * @param routeConfig the route config
         * @return V2NIMSendMessageParamsBuilder
         */
        public V2NIMSendMessageParamsBuilder withRouteConfig(V2NIMMessageRouteConfig routeConfig) {
            this.routeConfig = routeConfig;
            return this;
        }
        /**
         * Set the push config
         * @param pushConfig the push config
         * @return V2NIMSendMessageParamsBuilder
         */
        public V2NIMSendMessageParamsBuilder withPushConfig(V2NIMMessagePushConfig pushConfig) {
            this.pushConfig = pushConfig;
            return this;
        }
        /**
         * Set the antispam config
         * @param antispamConfig the antispam config
         * @return V2NIMSendMessageParamsBuilder
         */
        public V2NIMSendMessageParamsBuilder withAntispamConfig(V2NIMMessageAntispamConfig antispamConfig) {
            this.antispamConfig = antispamConfig;
            return this;
        }
        /**
         * Set the robot config
         * @param robotConfig the robot config
         * @return V2NIMSendMessageParamsBuilder
         */
        public V2NIMSendMessageParamsBuilder withRobotConfig(V2NIMMessageRobotConfig robotConfig) {
            this.robotConfig = robotConfig;
            return this;
        }
        /**
         * Set the client antispam enabled
         * @param clientAntispamEnabled the client antispam enabled
         * @return V2NIMSendMessageParamsBuilder
         */
        public V2NIMSendMessageParamsBuilder withClientAntispamEnabled(boolean clientAntispamEnabled) {
            this.clientAntispamEnabled = clientAntispamEnabled;
            return this;
        }
        /**
         * Set the client antispam replace
         * @param clientAntispamReplace the client antispam replace
         * @return V2NIMSendMessageParamsBuilder
         */
        public V2NIMSendMessageParamsBuilder withClientAntispamReplace(String clientAntispamReplace) {
            this.clientAntispamReplace = clientAntispamReplace;
            return this;
        }
        /**
         * Set the AI config
         * @param aiConfig the AI config
         * @return V2NIMSendMessageParamsBuilder
         */
        public V2NIMSendMessageParamsBuilder withAIConfig(V2NIMMessageAIConfigParams aiConfig) {
            this.aiConfig = aiConfig;
            return this;
        }
        /**
         * Set the target config
         * @param targetConfig the target config
         * @return V2NIMSendMessageParamsBuilder
         */
        public V2NIMSendMessageParamsBuilder withTargetConfig(V2NIMMessageTargetConfig targetConfig) {
            this.targetConfig = targetConfig;
            return this;
        }

        public V2NIMSendMessageParams build() {
            return new V2NIMSendMessageParams(messageConfig, routeConfig, pushConfig, antispamConfig, robotConfig,aiConfig,targetConfig, clientAntispamEnabled, clientAntispamReplace);
        }
    }
}