im

type AddBlackList struct{}

type AddBlackListBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 需要加入黑名单的 UserId 及每个用户对应的扩展信息，一次最多添加 10 个用户至黑名单
	BlackListInfos []AddBlackListBodyBlackListInfosItem `json:"BlackListInfos"`

	// REQUIRED; 用户 ID
	UserID int64 `json:"UserId"`

	// 信箱，用做逻辑隔离。默认值为 0
	InboxType *int32 `json:"InboxType,omitempty"`
}

type AddBlackListBodyBlackListInfosItem struct {
	// REQUIRED; 加入黑名单的用户 ID
	BlackListUserID int64 `json:"BlackListUserId"`

	// 黑名单用户扩展字段
	BlackListUserExt map[string]string `json:"BlackListUserExt,omitempty"`
}

type AddBlackListQuery struct{}

type AddBlackListReq struct {
	*AddBlackListQuery
	*AddBlackListBody
}

type AddBlackListRes struct {
	// REQUIRED
	ResponseMetadata AddBlackListResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result AddBlackListResResult `json:"Result"`
}

type AddBlackListResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                `json:"Version"`
	Error   *AddBlackListResResponseMetadataError `json:"Error,omitempty"`
}

type AddBlackListResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type AddBlackListResResult struct {
	// REQUIRED; 添加黑名单失败的用户信息
	FailedInfos []AddBlackListResResultFailedInfosItem `json:"FailedInfos"`
}

type AddBlackListResResultFailedInfosItem struct {
	// REQUIRED; 错误码 [https://www.volcengine.com/docs/6348/412253]
	Code string `json:"Code"`

	// REQUIRED; 错误信息 [https://www.volcengine.com/docs/6348/412253]
	Message string `json:"Message"`

	// REQUIRED; 添加黑名单失败的用户的 ID
	UserID int64 `json:"UserId"`
}

type AddFriend struct{}

type AddFriendBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 好友 UserId，一次最多添加 10 个好友
	FriendUserIDs []int64 `json:"FriendUserIds"`

	// REQUIRED; 用户 UserId
	UserID int64 `json:"UserId"`

	// 好友扩展字段
	Ext map[string]string `json:"Ext,omitempty"`

	// 信箱，用做逻辑隔离。默认值为 0
	InboxType *int32 `json:"InboxType,omitempty"`
}

type AddFriendQuery struct{}

type AddFriendReq struct {
	*AddFriendQuery
	*AddFriendBody
}

type AddFriendRes struct {
	// REQUIRED
	ResponseMetadata AddFriendResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result AddFriendResResult `json:"Result"`
}

type AddFriendResResponseMetadata struct {
	// REQUIRED
	Action string `json:"Action"`

	// REQUIRED
	Region string `json:"Region"`

	// REQUIRED
	RequestID string `json:"RequestId"`

	// REQUIRED
	Service string `json:"Service"`

	// REQUIRED
	Version string                             `json:"Version"`
	Error   *AddFriendResResponseMetadataError `json:"Error,omitempty"`
}

type AddFriendResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type AddFriendResResult struct {
	// 添加失败的好友信息
	FailedInfos []AddFriendResResultFailedInfosItem `json:"FailedInfos"`
}

type AddFriendResResultFailedInfosItem struct {
	// REQUIRED; 错误码 [https://www.volcengine.com/docs/6348/412253]
	Code string `json:"Code"`

	// REQUIRED; 错误信息 [https://www.volcengine.com/docs/6348/412253]
	Message string `json:"Message"`

	// REQUIRED; 好友 UserId
	UserID int64 `json:"UserId"`
}

type BatchAddBlockParticipants struct{}

type BatchAddBlockParticipantsBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; key 为群成员 ID，类型：String，只能传userId，value 为禁言或者拉黑时长，类型：int，单位为秒。
	ParticipantBlockInfos map[string]int64 `json:"ParticipantBlockInfos"`

	// 与 ParticipantBlockInfos 字段含义相同，若用户 ID 为字符串类型，使用该字段
	ParticipantBlockInfosStr map[string]int64 `json:"ParticipantBlockInfosStr,omitempty"`

	// 操作行为
	// * 0：禁言。用户无法在直播群中发言。
	// * 1：拉黑。用户无法加入直播群。
	// 默认值为 0
	BlockAction *int32 `json:"BlockAction,omitempty"`
}

type BatchAddBlockParticipantsQuery struct{}

type BatchAddBlockParticipantsReq struct {
	*BatchAddBlockParticipantsQuery
	*BatchAddBlockParticipantsBody
}

type BatchAddBlockParticipantsRes struct {
	// REQUIRED
	ResponseMetadata BatchAddBlockParticipantsResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result BatchAddBlockParticipantsResResult `json:"Result"`
}

type BatchAddBlockParticipantsResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                             `json:"Version"`
	Error   *BatchAddBlockParticipantsResResponseMetadataError `json:"Error,omitempty"`
}

type BatchAddBlockParticipantsResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type BatchAddBlockParticipantsResResult struct {
	// REQUIRED; 禁言或者拉黑失败的会话成员 UserId
	FailedParticipantUserIDs []int64 `json:"FailedParticipantUserIds"`

	// 与 FailedParticipantUserIDs 字段含义相同，若用户 ID 为字符串类型，使用该字段
	FailedParticipantUserIDsStr []string `json:"FailedParticipantUserIdsStr,omitempty"`
}

type BatchAddConversationParticipant struct{}

type BatchAddConversationParticipantBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 执行加群操作人的 UserId
	Operator int64 `json:"Operator"`

	// REQUIRED; 群成员信息
	ParticipantInfos []BatchAddConversationParticipantBodyParticipantInfosItem `json:"ParticipantInfos"`

	// 是否开启屏障。如设置屏障，新加入用户无法看到历史会话消息。
	// * false：不开启。
	// * true：开启。
	// 默认值为false。
	Barrier *bool `json:"Barrier,omitempty"`
}

type BatchAddConversationParticipantBodyParticipantInfosItem struct {
	// REQUIRED; 添加成员所属 UserId，UserId 必须大于 0。
	ParticipantUserID int64 `json:"ParticipantUserId"`

	// 成员扩展字段
	Ext map[string]string `json:"Ext,omitempty"`

	// 成员等级
	Level *int32 `json:"Level,omitempty"`

	// 成员昵称
	NickName *string `json:"NickName,omitempty"`

	// 成员已读位置点
	ReadIndex *int64 `json:"ReadIndex,omitempty"`

	// 成员身份，可取值为：0，1，2。
	// * 0：普通成员。
	// * 1：群主。添加群主时，需确保会话中的 ownerUid 与群主的 UserId 相同。
	// * 2：群管理员。
	// 默认值为0，值不合法时自动调整为默认值。
	Role *int64 `json:"Role,omitempty"`
}

type BatchAddConversationParticipantQuery struct{}

type BatchAddConversationParticipantReq struct {
	*BatchAddConversationParticipantQuery
	*BatchAddConversationParticipantBody
}

type BatchAddConversationParticipantRes struct {
	// REQUIRED
	ResponseMetadata BatchAddConversationParticipantResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result BatchAddConversationParticipantResResult `json:"Result"`
}

type BatchAddConversationParticipantResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                                   `json:"Version"`
	Error   *BatchAddConversationParticipantResResponseMetadataError `json:"Error,omitempty"`
}

type BatchAddConversationParticipantResResponseMetadataError struct {
	// REQUIRED; 错误码
	Code string `json:"Code"`

	// REQUIRED; 错误信息
	Message string `json:"Message"`
}

type BatchAddConversationParticipantResResult struct {
	// REQUIRED; 成功时为空，失败时返回失败用户 ID
	FailedUserIDs []int64 `json:"FailedUserIds"`
}

type BatchAddManager struct{}

type BatchAddManagerBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 要添加为管理员的群成员 UserId
	ManagerUserIDs []int64 `json:"ManagerUserIds"`

	// 与 ManagerUserIDs 字段含义相同，若用户 ID 为字符串类型，使用该字段
	ManagerUserIDsStr []string `json:"ManagerUserIdsStr,omitempty"`

	// REQUIRED; 操作人 UserId
	Operator int64 `json:"Operator"`

	// 与 Operator 字段含义相同，若用户 ID 为字符串类型，使用该字段
	OperatorStr *string `json:"OperatorStr,omitempty"`
}

type BatchAddManagerQuery struct{}

type BatchAddManagerReq struct {
	*BatchAddManagerQuery
	*BatchAddManagerBody
}

type BatchAddManagerRes struct {
	// REQUIRED
	ResponseMetadata BatchAddManagerResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result BatchAddManagerResResult `json:"Result"`
}

type BatchAddManagerResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                   `json:"Version"`
	Error   *BatchAddManagerResResponseMetadataError `json:"Error,omitempty"`
}

type BatchAddManagerResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type BatchAddManagerResResult struct {
	// REQUIRED; 添加失败的 UserId
	FailedManagerUserIDs []int64 `json:"FailedManagerUserIds"`

	// 与 FailedManagerUserIDs 字段含义相同，若用户 ID 为字符串类型，使用该字段
	FailedManagerUserIDsStr []string `json:"FailedManagerUserIdsStr,omitempty"`
}

type BatchAddWhitelistParticipant struct{}

type BatchAddWhitelistParticipantBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 操作人 UserId
	Operator int64 `json:"Operator"`

	// 与 Operator 字段含义相同，若用户 ID 为字符串类型，使用该字段
	OperatorStr *string `json:"OperatorStr,omitempty"`

	// REQUIRED; 要添加白名单成员 UserId
	ParticipantUserIDs []int64 `json:"ParticipantUserIds"`

	// 与 ParticipantUserIDs 字段含义相同，若用户 ID 为字符串类型，使用该字段
	ParticipantUserIDsStr []string `json:"ParticipantUserIdsStr,omitempty"`
}

type BatchAddWhitelistParticipantQuery struct{}

type BatchAddWhitelistParticipantReq struct {
	*BatchAddWhitelistParticipantQuery
	*BatchAddWhitelistParticipantBody
}

type BatchAddWhitelistParticipantRes struct {
	// REQUIRED
	ResponseMetadata BatchAddWhitelistParticipantResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result BatchAddWhitelistParticipantResResult `json:"Result"`
}

type BatchAddWhitelistParticipantResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                                `json:"Version"`
	Error   *BatchAddWhitelistParticipantResResponseMetadataError `json:"Error,omitempty"`
}

type BatchAddWhitelistParticipantResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type BatchAddWhitelistParticipantResResult struct {
	// REQUIRED; 添加失败的 UserId
	FailedUserIDs []int64 `json:"FailedUserIds"`

	// 与 FailedUserIDs 字段含义相同，若用户 ID 为字符串类型，使用该字段
	FailedUserIDsStr []string `json:"FailedUserIdsStr,omitempty"`
}

type BatchDeleteBlockParticipants struct{}

type BatchDeleteBlockParticipantsBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 取消禁言或者取消拉黑的会员成员 UserId 列表
	ParticipantUserIDs []int64 `json:"ParticipantUserIds"`

	// 与 ParticipantUserIDs 字段含义相同，若用户 ID 为字符串类型，使用该字段
	ParticipantUserIDsStr []string `json:"ParticipantUserIdsStr,omitempty"`

	// 操作行为。
	// * 0：取消禁言。
	// * 1：取消拉黑。
	// 默认值为 0。
	BlockAction *int32 `json:"BlockAction,omitempty"`
}

type BatchDeleteBlockParticipantsQuery struct{}

type BatchDeleteBlockParticipantsReq struct {
	*BatchDeleteBlockParticipantsQuery
	*BatchDeleteBlockParticipantsBody
}

type BatchDeleteBlockParticipantsRes struct {
	// REQUIRED
	ResponseMetadata BatchDeleteBlockParticipantsResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result BatchDeleteBlockParticipantsResResult `json:"Result"`
}

type BatchDeleteBlockParticipantsResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                                `json:"Version"`
	Error   *BatchDeleteBlockParticipantsResResponseMetadataError `json:"Error,omitempty"`
}

type BatchDeleteBlockParticipantsResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type BatchDeleteBlockParticipantsResResult struct {
	// REQUIRED; 取消禁言或者取消拉黑失败的会话成员 UserId
	FailedParticipantUserIDs []int64 `json:"FailedParticipantUserIds"`

	// 与 FailedParticipantUserIDs 字段含义相同，若用户 ID 为字符串类型，使用该字段
	FailedParticipantUserIDsStr []string `json:"FailedParticipantUserIdsStr,omitempty"`
}

type BatchDeleteConversationParticipant struct{}

type BatchDeleteConversationParticipantBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 执行删除群成员操作人的 UserId
	Operator int64 `json:"Operator"`

	// REQUIRED; 需要删除群成员的 UserId
	ParticipantUserIDs []int64 `json:"ParticipantUserIds"`
}

type BatchDeleteConversationParticipantQuery struct{}

type BatchDeleteConversationParticipantReq struct {
	*BatchDeleteConversationParticipantQuery
	*BatchDeleteConversationParticipantBody
}

type BatchDeleteConversationParticipantRes struct {
	// REQUIRED
	ResponseMetadata BatchDeleteConversationParticipantResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result BatchDeleteConversationParticipantResResult `json:"Result"`
}

type BatchDeleteConversationParticipantResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                                      `json:"Version"`
	Error   *BatchDeleteConversationParticipantResResponseMetadataError `json:"Error,omitempty"`
}

type BatchDeleteConversationParticipantResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type BatchDeleteConversationParticipantResResult struct {
	// REQUIRED; 成功时为空，失败时返回失败用户 ID
	FailedUserIDs []int64 `json:"FailedUserIds"`
}

type BatchGetBlockParticipants struct{}

type BatchGetBlockParticipantsBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 分批起始位置
	Cursor int64 `json:"Cursor"`

	// REQUIRED; 每批查询条数，最大值为 20。
	Limit int64 `json:"Limit"`

	// 操作行为
	// * 0：获取禁言列表
	// * 1：获取拉黑列表
	// 默认为 0。
	BlockAction *int32 `json:"BlockAction,omitempty"`
}

type BatchGetBlockParticipantsQuery struct{}

type BatchGetBlockParticipantsReq struct {
	*BatchGetBlockParticipantsQuery
	*BatchGetBlockParticipantsBody
}

type BatchGetBlockParticipantsRes struct {
	// REQUIRED
	ResponseMetadata BatchGetBlockParticipantsResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result BatchGetBlockParticipantsResResult `json:"Result"`
}

type BatchGetBlockParticipantsResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                             `json:"Version"`
	Error   *BatchGetBlockParticipantsResResponseMetadataError `json:"Error,omitempty"`
}

type BatchGetBlockParticipantsResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type BatchGetBlockParticipantsResResult struct {
	// REQUIRED; 是否还有更多数据
	HasMore bool `json:"HasMore"`

	// REQUIRED; 下一批数据起始位置
	NextCursor int64 `json:"NextCursor"`

	// REQUIRED; 禁言/拉黑成员列表
	Participants []BatchGetBlockParticipantsResResultParticipantsItem `json:"Participants"`
}

type BatchGetBlockParticipantsResResultParticipantsItem struct {
	// REQUIRED; 禁言/拉黑成员头像
	AvatarURL string `json:"AvatarUrl"`

	// REQUIRED; 禁言/拉黑到何时对应时间戳，单位为秒
	BlockTime int64 `json:"BlockTime"`

	// REQUIRED; 禁言/拉黑设置对应的时间戳，单位为秒
	CreateTime int64 `json:"CreateTime"`

	// REQUIRED; 禁言/拉黑成员扩展字段。key 的类型为 string，value 的类型为 string。
	Ext map[string]string `json:"Ext"`

	// REQUIRED; 直播群群成员标记
	Marks []string `json:"Marks"`

	// REQUIRED; 禁言/拉黑成员昵称
	NickName string `json:"NickName"`

	// REQUIRED; 群成员 ID
	ParticipantUserID int64 `json:"ParticipantUserId"`

	// 与 ParticipantUserID 字段含义相同，若用户 ID 为字符串类型，使用该字段
	ParticipantUserIDStr *string `json:"ParticipantUserIdStr,omitempty"`
}

type BatchGetConversationParticipant struct{}

type BatchGetConversationParticipantBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 需要查询会话成员的 UserId
	ParticipantUserIDs []int64 `json:"ParticipantUserIds"`
}

type BatchGetConversationParticipantQuery struct{}

type BatchGetConversationParticipantReq struct {
	*BatchGetConversationParticipantQuery
	*BatchGetConversationParticipantBody
}

type BatchGetConversationParticipantRes struct {
	// REQUIRED
	ResponseMetadata BatchGetConversationParticipantResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result BatchGetConversationParticipantResResult `json:"Result"`
}

type BatchGetConversationParticipantResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                                   `json:"Version"`
	Error   *BatchGetConversationParticipantResResponseMetadataError `json:"Error,omitempty"`
}

type BatchGetConversationParticipantResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type BatchGetConversationParticipantResResult struct {
	// REQUIRED; 成功时返回查询会话成员信息，失败时为空。
	Participants []BatchGetConversationParticipantResResultParticipantsItem `json:"Participants"`
}

type BatchGetConversationParticipantResResultParticipantsItem struct {
	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 操作人对应的 UserId
	Operator int64 `json:"Operator"`

	// REQUIRED; 群成员 ID
	ParticipantUserID int64 `json:"ParticipantUserId"`

	// REQUIRED; 成员身份。
	// * 0：普通成员。
	// * 1：群主。
	// * 2：群管理员。
	Role int64 `json:"Role"`

	// 禁言时间戳，单位为秒。0表示不禁言
	BlockTime *int64 `json:"BlockTime,omitempty"`

	// 成员进群时间对应时间戳，单位为秒
	CreateTime *int64 `json:"CreateTime,omitempty"`

	// 成员的扩展字段
	Ext map[string]string `json:"Ext,omitempty"`

	// 成员等级
	Level *int32 `json:"Level,omitempty"`

	// 成员昵称
	NickName *string `json:"NickName,omitempty"`

	// 成员状态。
	// * 0：正常
	// * 1：退出
	Status *int32 `json:"Status,omitempty"`
}

type BatchGetConversations struct{}

type BatchGetConversationsBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID []int64 `json:"ConversationShortId"`

	// 是否忽略获取会话成员数。
	// * true： 忽略。
	// * false：不忽略。
	// 默认值为 true。
	SkipMemberCount *bool `json:"SkipMemberCount,omitempty"`
}

type BatchGetConversationsQuery struct{}

type BatchGetConversationsReq struct {
	*BatchGetConversationsQuery
	*BatchGetConversationsBody
}

type BatchGetConversationsRes struct {
	// REQUIRED
	ResponseMetadata BatchGetConversationsResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result BatchGetConversationsResResult `json:"Result"`
}

type BatchGetConversationsResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                         `json:"Version"`
	Error   *BatchGetConversationsResResponseMetadataError `json:"Error,omitempty"`
}

type BatchGetConversationsResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type BatchGetConversationsResResult struct {
	// REQUIRED; 会话详细信息
	ConversationCoreInfos []BatchGetConversationsResResultConversationCoreInfosItem `json:"ConversationCoreInfos"`
}

type BatchGetConversationsResResultConversationCoreInfosItem struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 会话Id，字符串类型，含义跟ConversationShortId一样，用来定位唯一的一个会话，历史原因，目前大部分接口都在使用ConversationShortId，但是仍然有比较比较老的接口会使用到ConversationId，如果目前您接入的功能没有使用到ConversationId直接忽略即可
	ConversationID string `json:"ConversationId"`

	// REQUIRED; 会话类型。 1：单聊 2:群聊 100:直播群
	ConversationType int32 `json:"ConversationType"`

	// REQUIRED; 群聊创建时间戳，单位为秒
	CreateTime int64 `json:"CreateTime"`

	// REQUIRED; 创群人 UserId
	CreatorUserID int64 `json:"CreatorUserId"`

	// 与 CreatorUserID 字段含义相同，若用户 ID 为字符串类型，使用该字段
	CreatorUserIDStr *string `json:"CreatorUserIdStr,omitempty"`

	// REQUIRED; 信箱,用于逻辑隔离
	InboxType int32 `json:"InboxType"`

	// REQUIRED; 修改时间戳，单位为秒
	ModifyTime int64 `json:"ModifyTime"`

	// REQUIRED; 群主 UserId
	OwnerUserID int64 `json:"OwnerUserId"`

	// 与 OwnerUserID 字段含义相同，若用户 ID 为字符串类型，使用该字段
	OwnerUserIDStr *string `json:"OwnerUserIdStr,omitempty"`

	// 群头像 url
	AvatarURL *string `json:"AvatarUrl,omitempty"`

	// 群描述
	Description *string `json:"Description,omitempty"`

	// 会话的扩展字段。
	Ext map[string]string `json:"Ext,omitempty"`

	// 会话成员数
	MemberCount *int64 `json:"MemberCount,omitempty"`

	// 群名
	Name *string `json:"Name,omitempty"`

	// 群公告
	Notice *string `json:"Notice,omitempty"`

	// 直播群在线人数。
	OnlineCount *int64 `json:"OnlineCount,omitempty"`

	// 单聊会话另一个 UserId
	OtherUserID *int64 `json:"OtherUserId,omitempty"`

	// 与 OtherUserID 字段含义相同，若用户 ID 为字符串类型，使用该字段
	OtherUserIDStr *string `json:"OtherUserIdStr,omitempty"`

	// 会话状态。 0：正常 1：已解散
	Status *int32 `json:"Status,omitempty"`
}

type BatchGetUser struct{}

type BatchGetUserBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 查询用户 UserId，一次最多查询50个用户
	UserIDs []int64 `json:"UserIds"`
}

type BatchGetUserQuery struct{}

type BatchGetUserReq struct {
	*BatchGetUserQuery
	*BatchGetUserBody
}

type BatchGetUserRes struct {
	// REQUIRED
	ResponseMetadata BatchGetUserResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result BatchGetUserResResult `json:"Result"`
}

type BatchGetUserResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                `json:"Version"`
	Error   *BatchGetUserResResponseMetadataError `json:"Error,omitempty"`
}

type BatchGetUserResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type BatchGetUserResResult struct {
	// REQUIRED; 未查到的用户uid，原因：未注册或者已注销
	NotFoundUsers []int64 `json:"NotFoundUsers"`

	// REQUIRED; 用户详细信息
	Users []BatchGetUserResResultUsersItem `json:"Users"`
}

type BatchGetUserResResultUsersItem struct {
	// REQUIRED; 用户所属应用
	AppID int32 `json:"AppId"`

	// REQUIRED; 用户注册时间戳，单位为毫秒
	CreateTime int64 `json:"CreateTime"`

	// REQUIRED; map[string]string
	Ext map[string]string `json:"Ext"`

	// REQUIRED; 更新时间戳，单位为毫秒
	ModifyTime int64 `json:"ModifyTime"`

	// REQUIRED; 用户昵称
	NickName string `json:"NickName"`

	// REQUIRED; 用户头像
	Portrait string `json:"Portrait"`

	// REQUIRED; 用户 UserId
	UserID int64 `json:"UserId"`

	// []string
	Tags []string `json:"Tags,omitempty"`

	// 用户是否为机器人
	IsRobot bool `json:"IsRobot,omitempty"`
}

type BatchGetWhitelistParticipant struct{}

type BatchGetWhitelistParticipantBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 查询起始位置
	Cursor int64 `json:"Cursor"`

	// REQUIRED; 每批查询条数。最大值为20。
	Limit int64 `json:"Limit"`
}

type BatchGetWhitelistParticipantQuery struct{}

type BatchGetWhitelistParticipantReq struct {
	*BatchGetWhitelistParticipantQuery
	*BatchGetWhitelistParticipantBody
}

type BatchGetWhitelistParticipantRes struct {
	// REQUIRED
	ResponseMetadata BatchGetWhitelistParticipantResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result BatchGetWhitelistParticipantResResult `json:"Result"`
}

type BatchGetWhitelistParticipantResResponseMetadata struct {
	// REQUIRED
	Action string `json:"Action"`

	// REQUIRED
	Region string `json:"Region"`

	// REQUIRED
	RequestID string `json:"RequestId"`

	// REQUIRED
	Service string `json:"Service"`

	// REQUIRED
	Version string                                                `json:"Version"`
	Error   *BatchGetWhitelistParticipantResResponseMetadataError `json:"Error,omitempty"`
}

type BatchGetWhitelistParticipantResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type BatchGetWhitelistParticipantResResult struct {
	// REQUIRED; 是否还有更多数据
	HasMore bool `json:"HasMore"`

	// REQUIRED; 下一批数据起始位置。-1表示无更多数据。
	NextCursor int64 `json:"NextCursor"`

	// REQUIRED; 白名单成员信息
	Participants []BatchGetWhitelistParticipantResResultParticipantsItem `json:"Participants"`
}

type BatchGetWhitelistParticipantResResultParticipantsItem struct {
	// REQUIRED; 白名单成员头像
	AvatarURL string `json:"AvatarUrl"`

	// REQUIRED; 用户加入白名单时间，单位为秒
	CreateTime int64 `json:"CreateTime"`

	// REQUIRED; 白名单成员扩展字段。key 的类型为 string，value 的类型为 string。
	Ext map[string]string `json:"Ext"`

	// REQUIRED; 白名单成员昵称
	NickName string `json:"NickName"`

	// REQUIRED; 执行加入白名单操作操作人 UserId
	Operator int64 `json:"Operator"`

	// REQUIRED; 白名单成员 UserId
	ParticipantUserID int64 `json:"ParticipantUserId"`

	// 直播群群成员标记
	Marks []string `json:"Marks,omitempty"`
}

type BatchModifyConversationParticipant struct{}

type BatchModifyConversationParticipantBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 执行修改群成员信息操作人的 UserId
	Operator int64 `json:"Operator"`

	// REQUIRED; 群成员信息
	ParticipantInfos []BatchModifyConversationParticipantBodyParticipantInfosItem `json:"ParticipantInfos"`
}

type BatchModifyConversationParticipantBodyParticipantInfosItem struct {
	// REQUIRED; 进行修改的群成员的 UserId，UserId 必须大于 0。
	ParticipantUserID int64 `json:"ParticipantUserId"`

	// 禁言时间戳，表示禁言到何时，单位为秒。0表示未禁言。
	BlockTime *int64 `json:"BlockTime,omitempty"`

	// 成员扩展字段
	Ext map[string]string `json:"Ext,omitempty"`

	// 成员等级
	Level *int32 `json:"Level,omitempty"`

	// 成员昵称
	NickName *string `json:"NickName,omitempty"`

	// 成员身份，可取值为：0，1，2。
	// * 0：普通成员。
	// * 1：群主。
	// * 2：群管理员。
	// 默认值为0，值不合法时自动调整为默认值。
	Role *int64 `json:"Role,omitempty"`
}

type BatchModifyConversationParticipantQuery struct{}

type BatchModifyConversationParticipantReq struct {
	*BatchModifyConversationParticipantQuery
	*BatchModifyConversationParticipantBody
}

type BatchModifyConversationParticipantRes struct {
	// REQUIRED
	ResponseMetadata BatchModifyConversationParticipantResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result BatchModifyConversationParticipantResResult `json:"Result"`
}

type BatchModifyConversationParticipantResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                                      `json:"Version"`
	Error   *BatchModifyConversationParticipantResResponseMetadataError `json:"Error,omitempty"`
}

type BatchModifyConversationParticipantResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type BatchModifyConversationParticipantResResult struct {
	// REQUIRED; 成功时为空，失败时返回失败用户 ID
	FailedUserIDs []int64 `json:"FailedUserIds"`
}

type BatchRemoveManager struct{}

type BatchRemoveManagerBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 操作人 UserId
	Operator int64 `json:"Operator"`

	// 与 Operator 字段含义相同，若用户 ID 为字符串类型，使用该字段
	OperatorStr *string `json:"OperatorStr,omitempty"`

	// REQUIRED; 要移除的管理员 UserId
	RemoveManagerUserIDs []int64 `json:"RemoveManagerUserIds"`

	// 与 RemoveManagerUserIDs 字段含义相同，若用户 ID 为字符串类型，使用该字段
	RemoveManagerUserIDsStr []string `json:"RemoveManagerUserIdsStr,omitempty"`
}

type BatchRemoveManagerQuery struct{}

type BatchRemoveManagerReq struct {
	*BatchRemoveManagerQuery
	*BatchRemoveManagerBody
}

type BatchRemoveManagerRes struct {
	// REQUIRED
	ResponseMetadata BatchRemoveManagerResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result BatchRemoveManagerResResult `json:"Result"`
}

type BatchRemoveManagerResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                      `json:"Version"`
	Error   *BatchRemoveManagerResResponseMetadataError `json:"Error,omitempty"`
}

type BatchRemoveManagerResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type BatchRemoveManagerResResult struct {
	// REQUIRED; 移除失败的管理员 UserId
	FailedManagerUserIDs []int64 `json:"FailedManagerUserIds"`

	// 与 FailedManagerUserIDs 字段含义相同，若用户 ID 为字符串类型，使用该字段
	FailedManagerUserIDsStr []string `json:"FailedManagerUserIdsStr,omitempty"`
}

type BatchRemoveWhitelistParticipant struct{}

type BatchRemoveWhitelistParticipantBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 操作人 UserId
	Operator int64 `json:"Operator"`

	// 与 Operator 字段含义相同，若用户 ID 为字符串类型，使用该字段
	OperatorStr *string `json:"OperatorStr,omitempty"`

	// REQUIRED; 要移除白名单用户 UserId
	ParticipantUserIDs []int64 `json:"ParticipantUserIds"`

	// 与 ParticipantUserIDs 字段含义相同，若用户 ID 为字符串类型，使用该字段
	ParticipantUserIDsStr []string `json:"ParticipantUserIdsStr,omitempty"`
}

type BatchRemoveWhitelistParticipantQuery struct{}

type BatchRemoveWhitelistParticipantReq struct {
	*BatchRemoveWhitelistParticipantQuery
	*BatchRemoveWhitelistParticipantBody
}

type BatchRemoveWhitelistParticipantRes struct {
	// REQUIRED
	ResponseMetadata BatchRemoveWhitelistParticipantResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result BatchRemoveWhitelistParticipantResResult `json:"Result"`
}

type BatchRemoveWhitelistParticipantResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                                   `json:"Version"`
	Error   *BatchRemoveWhitelistParticipantResResponseMetadataError `json:"Error,omitempty"`
}

type BatchRemoveWhitelistParticipantResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type BatchRemoveWhitelistParticipantResResult struct {
	// REQUIRED; 移除失败的 UserId
	FailedUserIDs []int64 `json:"FailedUserIds"`

	// 与 ParticipantUserIDs 字段含义相同，若用户 ID 为字符串类型，使用该字段
	FailedUserIDsStr []string `json:"FailedUserIdsStr,omitempty"`
}

type BatchSendMessage struct{}

type BatchSendMessageBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 消息内容。当你给客户端发消息时，Content 内容需符合客户端格式，详细信息请参看消息格式
	Content string `json:"Content"`

	// REQUIRED; 消息类型
	MsgType int32 `json:"MsgType"`

	// REQUIRED; 消息接收人 UserId 列表
	Receiver []int64 `json:"Receiver"`

	// REQUIRED; 消息发送人 UserId
	Sender int64 `json:"Sender"`

	// 消息的扩展字段，key 的数据类型为 String，value 的数据类型为 String
	Ext map[string]string `json:"Ext,omitempty"`

	// 信箱，用做逻辑隔离 默认值为 0
	InboxType *int32 `json:"InboxType,omitempty"`
}

type BatchSendMessageQuery struct{}

type BatchSendMessageReq struct {
	*BatchSendMessageQuery
	*BatchSendMessageBody
}

type BatchSendMessageRes struct {
	// REQUIRED
	ResponseMetadata BatchSendMessageResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result BatchSendMessageResResult `json:"Result"`
}

type BatchSendMessageResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                    `json:"Version"`
	Error   *BatchSendMessageResResponseMetadataError `json:"Error,omitempty"`
}

type BatchSendMessageResResponseMetadataError struct {
	// REQUIRED
	Code string `json:"Code"`

	// REQUIRED
	Message string `json:"Message"`
}

type BatchSendMessageResResult struct {
	// REQUIRED; 消息Id列表，key为用户UserId，value为消息Id
	UserMessageID map[string]int64 `json:"UserMessageId"`
}

type BatchUpdateLiveParticipants struct{}

type BatchUpdateLiveParticipantsBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 需要更新的成员资料。一次最多支持 10 个成员。
	ParticipantInfos []BatchUpdateLiveParticipantsBodyParticipantInfosItem `json:"ParticipantInfos"`

	// 更新群成员标记。默认值为 1。1：添加2：删除
	MarkAction *int32 `json:"MarkAction,omitempty"`
}

type BatchUpdateLiveParticipantsBodyParticipantInfosItem struct {
	// REQUIRED; 群成员用户 ID
	UserID int64 `json:"UserId"`

	// 与 UserID 字段含义相同，若用户 ID 为字符串类型，使用该字段
	UserIDStr *string `json:"UserIdStr,omitempty"`

	// 群成员头像。AvatarUrl、NickName和Ext均为非必填参数，但是至少需要填一个，否则服务端会报错。
	AvatarURL *string `json:"AvatarUrl,omitempty"`

	// 群成员扩展字段。key 的类型为 String，value 的类型为 String。
	Ext map[string]string `json:"Ext,omitempty"`

	// 群成员标记
	Marks []string `json:"Marks,omitempty"`

	// 群成员昵称
	NickName *string `json:"NickName,omitempty"`
}

type BatchUpdateLiveParticipantsQuery struct{}

type BatchUpdateLiveParticipantsReq struct {
	*BatchUpdateLiveParticipantsQuery
	*BatchUpdateLiveParticipantsBody
}

type BatchUpdateLiveParticipantsRes struct {
	// REQUIRED
	ResponseMetadata BatchUpdateLiveParticipantsResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result BatchUpdateLiveParticipantsResResult `json:"Result"`
}

type BatchUpdateLiveParticipantsResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                               `json:"Version"`
	Error   *BatchUpdateLiveParticipantsResResponseMetadataError `json:"Error,omitempty"`
}

type BatchUpdateLiveParticipantsResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type BatchUpdateLiveParticipantsResResult struct {
	// 更新资料失败的群成员信息
	FailedInfos []*BatchUpdateLiveParticipantsResResultFailedInfosItem `json:"FailedInfos,omitempty"`
}

type BatchUpdateLiveParticipantsResResultFailedInfosItem struct {
	// REQUIRED; 错误码 [https://www.volcengine.com/docs/6348/412253]
	Code string `json:"Code"`

	// REQUIRED; 错误描述
	Message string `json:"Message"`

	// REQUIRED; 更新资料失败的群成员的 UserId
	UserID int64 `json:"UserId"`

	// 与 UserID 字段含义相同，若用户 ID 为字符串类型，使用该字段
	UserIDStr *string `json:"UserIdStr,omitempty"`
}

type BatchUpdateUser struct{}

type BatchUpdateUserBody struct {
	// REQUIRED; 用户的唯一标识
	AppID int32 `json:"AppId"`

	// REQUIRED; 用户资料。一次最多 10 个用户
	Users []BatchUpdateUserBodyUsersItem `json:"Users"`
}

type BatchUpdateUserBodyUsersItem struct {
	// REQUIRED; 扩展字段。key 的类型为 string，value 的类型为 string。
	Ext map[string]string `json:"Ext"`

	// REQUIRED; 昵称
	NickName string `json:"NickName"`

	// REQUIRED; 头像 url
	Portrait string `json:"Portrait"`

	// REQUIRED; 标签
	Tags []string `json:"Tags"`

	// REQUIRED; 用户id
	UserID int64 `json:"UserId"`
}

type BatchUpdateUserQuery struct{}

type BatchUpdateUserReq struct {
	*BatchUpdateUserQuery
	*BatchUpdateUserBody
}

type BatchUpdateUserRes struct {
	// REQUIRED
	ResponseMetadata BatchUpdateUserResResponseMetadata `json:"ResponseMetadata"`

	// 视请求的接口而定
	Result *BatchUpdateUserResResult `json:"Result,omitempty"`
}

type BatchUpdateUserResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                   `json:"Version"`
	Error   *BatchUpdateUserResResponseMetadataError `json:"Error,omitempty"`
}

type BatchUpdateUserResResponseMetadataError struct {
	// REQUIRED; 错误码 [https://www.volcengine.com/docs/6348/412253]
	Code string `json:"Code"`

	// REQUIRED; 错误信息 [https://www.volcengine.com/docs/6348/412253]
	Message string `json:"Message"`
}

type BatchUpdateUserResResult struct {
	// REQUIRED; 更新失败的用户信息
	FailedInfos []BatchUpdateUserResResultFailedInfosItem `json:"FailedInfos"`
}

type BatchUpdateUserResResultFailedInfosItem struct {
	// REQUIRED; 错误码。参考错误码 [https://www.volcengine.com/docs/6348/412253]
	Code string `json:"Code"`

	// REQUIRED; 错误信息。
	Message string `json:"Message"`

	// REQUIRED; 更新失败的用户 UserId
	UserID int64 `json:"UserId"`
}

type BatchUpdateUserTags struct{}

type BatchUpdateUserTagsBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 标签更新方式。 0：对于重复 key，覆盖 value，对于新 key，进行添加 1：删除重复 key 默认值为 0。
	Op int32 `json:"Op"`

	// REQUIRED; 用户标签
	Tags []string `json:"Tags"`

	// REQUIRED; 用户userId列表
	UserIDs []int64 `json:"UserIds"`
}

type BatchUpdateUserTagsQuery struct{}

type BatchUpdateUserTagsReq struct {
	*BatchUpdateUserTagsQuery
	*BatchUpdateUserTagsBody
}

type BatchUpdateUserTagsRes struct {
	// REQUIRED
	ResponseMetadata BatchUpdateUserTagsResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result BatchUpdateUserTagsResResult `json:"Result"`
}

type BatchUpdateUserTagsResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                       `json:"Version"`
	Error   *BatchUpdateUserTagsResResponseMetadataError `json:"Error,omitempty"`
}

type BatchUpdateUserTagsResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type BatchUpdateUserTagsResResult struct {
	// REQUIRED; 更新失败的用户信息
	FailedInfos []BatchUpdateUserTagsResResultFailedInfosItem `json:"FailedInfos"`
}

type BatchUpdateUserTagsResResultFailedInfosItem struct {
	// REQUIRED; 错误码。参考:错误码 [https://www.volcengine.com/docs/6348/412253]
	Code string `json:"Code"`

	// REQUIRED; 错误信息。
	Message string `json:"Message"`

	// REQUIRED; 用户 UserId
	UserID int64 `json:"UserId"`
}

type CreateConversation struct{}

type CreateConversationBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话详细信息
	ConversationCoreInfo CreateConversationBodyConversationCoreInfo `json:"ConversationCoreInfo"`

	// REQUIRED; 会话成员 UserId
	OwnerUserID int64 `json:"OwnerUserId"`

	// 与 OwnerUserID 字段含义相同，若用户 ID 为字符串类型，使用该字段
	OwnerUserIDStr *string `json:"OwnerUserIdStr,omitempty"`

	// 幂等id，如果创建时指定了此字段，并且数据库中存在此 id 对应的会话，则不会重复创建，并且接口返回的Exist字段为true。
	IdempotentID *string `json:"IdempotentId,omitempty"`

	// 信箱，用做逻辑隔离 默认值为 0
	InboxType *int32 `json:"InboxType,omitempty"`

	// 另一个成员的 UserId， 创建单聊必填
	OtherUserID *int64 `json:"OtherUserId,omitempty"`

	// 与 OtherUserID 字段含义相同，若用户 ID 为字符串类型，使用该字段
	OtherUserIDStr *string `json:"OtherUserIdStr,omitempty"`
}

type CreateConversationBodyConversationCoreInfo struct {
	// REQUIRED; 会话类型
	// * 1：单聊
	// * 2：群聊
	// * 100：直播群
	ConversationType int32 `json:"ConversationType"`

	// 会话头像 url
	AvatarURL *string `json:"AvatarUrl,omitempty"`

	// 会话描述
	Description *string `json:"Description,omitempty"`

	// map 扩展字段
	Ext map[string]string `json:"Ext,omitempty"`

	// 会话名称
	Name *string `json:"Name,omitempty"`

	// 会话公告
	Notice *string `json:"Notice,omitempty"`
}

type CreateConversationQuery struct{}

type CreateConversationReq struct {
	*CreateConversationQuery
	*CreateConversationBody
}

type CreateConversationRes struct {
	// REQUIRED
	ResponseMetadata CreateConversationResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result CreateConversationResResult `json:"Result"`
}

type CreateConversationResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                      `json:"Version"`
	Error   *CreateConversationResResponseMetadataError `json:"Error,omitempty"`
}

type CreateConversationResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type CreateConversationResResult struct {
	// REQUIRED; 会话详细信息
	ConversationInfo CreateConversationResResultConversationInfo `json:"ConversationInfo"`

	// REQUIRED; 会话Id，字符串类型，含义跟ConversationShortId一样，用来定位唯一的一个会话，历史原因，目前大部分接口都在使用ConversationShortId，但是仍然有比较比较老的接口会使用到ConversationId，如果目前您接入的功能没有使用到ConversationId直接忽略即可
	ConversationID string `json:"ConversationId"`

	// REQUIRED; 会话id
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 会话是否存在
	Exist bool `json:"Exist"`
}

type CreateConversationResResultConversationInfo struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 会话Id，字符串类型，含义跟ConversationShortId一样，用来定位唯一的一个会话，历史原因，目前大部分接口都在使用ConversationShortId，但是仍然有比较比较老的接口会使用到ConversationId，如果目前您接入的功能没有使用到ConversationId直接忽略即可
	ConversationID string `json:"ConversationId"`

	// REQUIRED; 会话类型。
	// * 1：单聊
	// * 2：群聊
	ConversationType int32 `json:"ConversationType"`

	// REQUIRED; 信箱，用于逻辑隔离
	InboxType int32 `json:"InboxType"`

	// 群头像 url
	AvatarURL *string `json:"AvatarUrl,omitempty"`

	// 群聊创建时间戳，单位为秒
	CreateTime *int64 `json:"CreateTime,omitempty"`

	// 创群人 UserId
	CreatorUserID *int64 `json:"CreatorUserId,omitempty"`

	// 与 CreatorUserID 字段含义相同，若用户 ID 为字符串类型，使用该字段
	CreatorUserIDStr *string `json:"CreatorUserIdStr,omitempty"`

	// 群描述
	Description *string `json:"Description,omitempty"`

	// 会话的扩展字段。
	Ext map[string]string `json:"Ext,omitempty"`

	// 会话成员数
	MemberCount *int64 `json:"MemberCount,omitempty"`

	// 修改时间戳，单位为秒
	ModifyTime *int64 `json:"ModifyTime,omitempty"`

	// 群名
	Name *string `json:"Name,omitempty"`

	// 群公告
	Notice *string `json:"Notice,omitempty"`

	// 直播群在线人数
	OnlineCount *int64 `json:"OnlineCount,omitempty"`

	// 单聊另一个成员的 UserId
	OtherUserID *int64 `json:"OtherUserId,omitempty"`

	// 与 OtherUserID 字段含义相同，若用户 ID 为字符串类型，使用该字段
	OtherUserIDStr *string `json:"OtherUserIdStr,omitempty"`

	// 群主 UserId
	OwnerUserID *int64 `json:"OwnerUserId,omitempty"`

	// 与 CreatorUserID 字段含义相同，若用户 ID 为字符串类型，使用该字段
	OwnerUserIDStr *string `json:"OwnerUserIdStr,omitempty"`

	// 会话状态。
	// * 0：正常
	// * 1：已解散
	Status *int32 `json:"Status,omitempty"`
}

type DeleteConversationMessage struct{}

type DeleteConversationMessageBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 消息 ID
	MessageID int64 `json:"MessageId"`

	// 删除方式。
	// * 0：全部用户不可见。
	// * 1：仅发送人自己可见。
	// 默认值为0。 直播群只允许传 0。
	DeleteType *int32 `json:"DeleteType,omitempty"`
}

type DeleteConversationMessageQuery struct{}

type DeleteConversationMessageReq struct {
	*DeleteConversationMessageQuery
	*DeleteConversationMessageBody
}

type DeleteConversationMessageRes struct {
	// REQUIRED
	ResponseMetadata DeleteConversationMessageResResponseMetadata `json:"ResponseMetadata"`

	// 空。此接口无需关注
	Result interface{} `json:"Result,omitempty"`
}

type DeleteConversationMessageResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                             `json:"Version"`
	Error   *DeleteConversationMessageResResponseMetadataError `json:"Error,omitempty"`
}

type DeleteConversationMessageResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type DeleteFriend struct{}

type DeleteFriendBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 要删除的好友 UserId，一次最多删除 10 个好友
	DeleteUserIDs []int64 `json:"DeleteUserIds"`

	// REQUIRED; 用户 UserId
	UserID int64 `json:"UserId"`

	// 信箱，用做逻辑隔离。默认值为 0
	InboxType *int32 `json:"InboxType,omitempty"`
}

type DeleteFriendQuery struct{}

type DeleteFriendReq struct {
	*DeleteFriendQuery
	*DeleteFriendBody
}

type DeleteFriendRes struct {
	// REQUIRED
	ResponseMetadata DeleteFriendResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result DeleteFriendResResult `json:"Result"`
}

type DeleteFriendResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                `json:"Version"`
	Error   *DeleteFriendResResponseMetadataError `json:"Error,omitempty"`
}

type DeleteFriendResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type DeleteFriendResResult struct {
	// 删除失败的好友信息
	FailedInfos []DeleteFriendResResultFailedInfosItem `json:"FailedInfos,omitempty"`
}

type DeleteFriendResResultFailedInfosItem struct {
	// REQUIRED; 错误码 [https://www.volcengine.com/docs/6348/412253]
	Code string `json:"Code"`

	// REQUIRED; 错误信息 [https://www.volcengine.com/docs/6348/412253]
	Message string `json:"Message"`

	// REQUIRED; 好友 UserId
	UserID int64 `json:"UserId"`
}

type DeleteMessage struct{}

type DeleteMessageBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 消息 ID
	MessageID int64 `json:"MessageId"`

	// REQUIRED; 群成员 ID
	ParticipantUserID int64 `json:"ParticipantUserId"`
}

type DeleteMessageQuery struct{}

type DeleteMessageReq struct {
	*DeleteMessageQuery
	*DeleteMessageBody
}

type DeleteMessageRes struct {
	// REQUIRED
	ResponseMetadata DeleteMessageResResponseMetadata `json:"ResponseMetadata"`

	// 空。此接口无需关注
	Result interface{} `json:"Result,omitempty"`
}

type DeleteMessageResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                 `json:"Version"`
	Error   *DeleteMessageResResponseMetadataError `json:"Error,omitempty"`
}

type DeleteMessageResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type DestroyConversation struct{}

type DestroyConversationBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 群主 UserId
	OwnerUserID int64 `json:"OwnerUserId"`

	// 与 OwnerUserID 字段含义相同，若用户 ID 为字符串类型，使用该字段
	OwnerUserIDStr *string `json:"OwnerUserIdStr,omitempty"`
}

type DestroyConversationQuery struct{}

type DestroyConversationReq struct {
	*DestroyConversationQuery
	*DestroyConversationBody
}

type DestroyConversationRes struct {
	// REQUIRED
	ResponseMetadata DestroyConversationResResponseMetadata `json:"ResponseMetadata"`

	// 空，此接口可忽略此字段。
	Result interface{} `json:"Result,omitempty"`
}

type DestroyConversationResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                       `json:"Version"`
	Error   *DestroyConversationResResponseMetadataError `json:"Error,omitempty"`
}

type DestroyConversationResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type GetAppToken struct{}

type GetAppTokenBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; Token过期时间 单位毫秒
	ExpireTime int64 `json:"ExpireTime"`

	// REQUIRED; 用户UserId
	UserID int64 `json:"UserId"`

	// 与 UserID 字段含义相同，若用户 ID 为字符串类型，使用该字段
	UserIDStr *string `json:"UserIdStr,omitempty"`
}

type GetAppTokenQuery struct{}

type GetAppTokenReq struct {
	*GetAppTokenQuery
	*GetAppTokenBody
}

type GetAppTokenRes struct {
	// REQUIRED
	ResponseMetadata GetAppTokenResResponseMetadata `json:"ResponseMetadata"`

	// 视请求的接口而定
	Result *GetAppTokenResResult `json:"Result,omitempty"`
}

type GetAppTokenResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                               `json:"Version"`
	Error   *GetAppTokenResResponseMetadataError `json:"Error,omitempty"`
}

type GetAppTokenResResponseMetadataError struct {
	// REQUIRED; 错误码 [https://www.volcengine.com/docs/6348/412253]
	Code string `json:"Code"`

	// REQUIRED; 错误信息 [https://www.volcengine.com/docs/6348/412253]
	Message string `json:"Message"`
}

type GetAppTokenResResult struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 生成的Token
	Token string `json:"Token"`

	// REQUIRED; 用户UserId
	UserID int64 `json:"UserId"`

	// 字符串类型的 UserId，若用户 ID 为字符串类型，使用该字段
	UserIDStr *string `json:"UserIdStr,omitempty"`
}

type GetBlackList struct{}

type GetBlackListBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 查询起始位置，按照添加顺序逆序查询。默认值为 0，即最后一个添加至黑名单的用户。
	Cursor int64 `json:"Cursor"`

	// REQUIRED; 查询条数，每次最多查询 20 位用户。
	Limit int64 `json:"Limit"`

	// REQUIRED; 被查询用户的 UserId
	UserID int64 `json:"UserId"`

	// 信箱，用做逻辑隔离。默认值为 0
	InboxType *int32 `json:"InboxType,omitempty"`

	// 是否需要黑名单用户总数。
	// * false：不需要。
	// * true：需要。
	// 默认值为 false。
	NeedTotal *bool `json:"NeedTotal,omitempty"`
}

type GetBlackListQuery struct{}

type GetBlackListReq struct {
	*GetBlackListQuery
	*GetBlackListBody
}

type GetBlackListRes struct {
	// REQUIRED
	ResponseMetadata GetBlackListResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result GetBlackListResResult `json:"Result"`
}

type GetBlackListResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                `json:"Version"`
	Error   *GetBlackListResResponseMetadataError `json:"Error,omitempty"`
}

type GetBlackListResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type GetBlackListResResult struct {
	// REQUIRED; 黑名单用户详细信息
	BlackListInfos []GetBlackListResResultBlackListInfosItem `json:"BlackListInfos"`

	// REQUIRED; 是否还有下一页
	HasMore bool `json:"HasMore"`

	// REQUIRED; 下一页起始下标。为负时表示后续没有成员数据
	NextCursor int64 `json:"NextCursor"`

	// REQUIRED; 黑名单用户总数
	TotalCount int64 `json:"TotalCount"`
}

type GetBlackListResResultBlackListInfosItem struct {
	// REQUIRED; 黑名单用户 ID
	BlackListUserID int64 `json:"BlackListUserId"`

	// REQUIRED; 加入黑名单的时间
	CreateTime int64 `json:"CreateTime"`

	// REQUIRED; 黑名单更新时间
	ModifyTime int64 `json:"ModifyTime"`

	// 黑名单用户扩展字段
	BlackListUserExt map[string]string `json:"BlackListUserExt,omitempty"`

	// 好友信息。若黑名单用户并不是查询用户好友则不返回此字段。
	FriendUserInfo *GetBlackListResResultBlackListInfosItemFriendUserInfo `json:"FriendUserInfo,omitempty"`
}

type GetBlackListResResultBlackListInfosItemFriendUserInfo struct {
	// REQUIRED; 好友备注
	Alias string `json:"Alias"`

	// REQUIRED; 发起好友申请时间
	ApplyTime int64 `json:"ApplyTime"`

	// REQUIRED; 成为好友的时间
	CreateTime int64 `json:"CreateTime"`

	// REQUIRED; 好友扩展字段
	Ext map[string]string `json:"Ext"`

	// REQUIRED; 好友 UserId
	FriendUserID int64 `json:"FriendUserId"`

	// REQUIRED; 好友更新时间
	ModifyTime int64 `json:"ModifyTime"`
}

type GetConversationMarks struct{}

type GetConversationMarksBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`
}

type GetConversationMarksQuery struct{}

type GetConversationMarksReq struct {
	*GetConversationMarksQuery
	*GetConversationMarksBody
}

type GetConversationMarksRes struct {
	// REQUIRED
	ResponseMetadata GetConversationMarksResResponseMetadata `json:"ResponseMetadata"`
	Result           *GetConversationMarksResResult          `json:"Result,omitempty"`
}

type GetConversationMarksResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                        `json:"Version"`
	Error   *GetConversationMarksResResponseMetadataError `json:"Error,omitempty"`
}

type GetConversationMarksResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type GetConversationMarksResResult struct {
	// REQUIRED; 标记类型
	MarkTypes []string `json:"MarkTypes"`
}

type GetConversationMessages struct{}

type GetConversationMessagesBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 查询起始位置，即查询起始消息的 Index
	Cursor int64 `json:"Cursor"`

	// REQUIRED; 查询条数
	Limit int64 `json:"Limit"`

	// 查询方向。
	// * 0：正向查询
	// * 1：反向查询
	// 默认值为 0。值不合法时自动调整为默认值。 直播群只能取 1。
	Reverse *int32 `json:"Reverse,omitempty"`
}

type GetConversationMessagesQuery struct{}

type GetConversationMessagesReq struct {
	*GetConversationMessagesQuery
	*GetConversationMessagesBody
}

type GetConversationMessagesRes struct {
	// REQUIRED
	ResponseMetadata GetConversationMessagesResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result GetConversationMessagesResResult `json:"Result"`
}

type GetConversationMessagesResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                           `json:"Version"`
	Error   *GetConversationMessagesResResponseMetadataError `json:"Error,omitempty"`
}

type GetConversationMessagesResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type GetConversationMessagesResResult struct {
	// REQUIRED; 是否还有下一页
	HasMore bool `json:"HasMore"`

	// REQUIRED; 消息详细信息
	Messages []GetConversationMessagesResResultMessagesItem `json:"Messages"`

	// REQUIRED; 下一页起始位置
	NewCursor int64 `json:"NewCursor"`
}

type GetConversationMessagesResResultMessagesItem struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 消息内容
	Content string `json:"Content"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 会话类型
	// * 1：单聊。
	// * 2：群聊。
	ConversationType int32 `json:"ConversationType"`

	// REQUIRED; 消息创建时间戳，单位为毫秒
	CreateTime int64 `json:"CreateTime"`

	// REQUIRED; 消息 ID
	MessageID int64 `json:"MessageId"`

	// REQUIRED; 消息类型。
	// * 10001：文本。
	// * 10003：图片。
	// * 10004：视频
	// * 10005：文件
	// * 10006：音频
	// * 10012：自定义消息
	MsgType int32 `json:"MsgType"`

	// REQUIRED; 消息发送人 UserId
	Sender int64 `json:"Sender"`

	// 与 Sender 字段含义相同，若用户 ID 为字符串类型，使用该字段
	SenderStr *string `json:"SenderStr,omitempty"`

	// REQUIRED; 消息状态，取值为0，表示消息可见。
	Status int32 `json:"Status"`

	// 消息的扩展字段
	Ext map[string]string `json:"Ext,omitempty"`

	// 消息在会话中的位置
	IndexInConversation *int64 `json:"IndexInConversation,omitempty"`

	// 引用消息
	RefMsgInfo *GetConversationMessagesResResultMessagesItemRefMsgInfo `json:"RefMsgInfo,omitempty"`
}

type GetConversationMessagesResResultMessagesItemRefMsgInfo struct {
	// REQUIRED; 消息引用时展示的文本内容
	Hint string `json:"Hint"`

	// REQUIRED; 被引用的消息 ID
	ReferencedMessageID int64 `json:"ReferencedMessageId"`

	// REQUIRED; 被引用的消息类型
	// * 10001：文本。
	// * 10003：图片。
	// * 10004：视频
	// * 10005：文件
	// * 10006：音频
	// * 10012：自定义消息
	ReferencedMessageType int32 `json:"ReferencedMessageType"`

	// REQUIRED; 被引用的消息状态
	// * 0：消息可见
	// * 1：消息已过期
	// * 2：消息（对用户）不可见
	// * 3：消息被撤回
	// * 4：消息本身可见，后因删除不可见
	Status int32 `json:"Status"`
}

type GetConversationSetting struct{}

type GetConversationSettingBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 会话成员 UserId，UserId 必须大于 0。
	ParticipantUserID int64 `json:"ParticipantUserId"`

	// 与 ParticipantUserID 字段含义相同，若用户 ID 为字符串类型，使用该字段
	ParticipantUserIDStr *string `json:"ParticipantUserIdStr,omitempty"`

	// 是否需要该成员在会话中的已读位置。
	// * true：不需要。
	// * false：需要。
	NoReadIndex *bool `json:"NoReadIndex,omitempty"`
}

type GetConversationSettingQuery struct{}

type GetConversationSettingReq struct {
	*GetConversationSettingQuery
	*GetConversationSettingBody
}

type GetConversationSettingRes struct {
	// REQUIRED
	ResponseMetadata GetConversationSettingResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result GetConversationSettingResResult `json:"Result"`
}

type GetConversationSettingResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                          `json:"Version"`
	Error   *GetConversationSettingResResponseMetadataError `json:"Error,omitempty"`
}

type GetConversationSettingResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type GetConversationSettingResResult struct {
	// REQUIRED; 用户会话设置
	ConversationSettingInfo GetConversationSettingResResultConversationSettingInfo `json:"ConversationSettingInfo"`
}

type GetConversationSettingResResultConversationSettingInfo struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 会话Id，字符串类型，含义跟ConversationShortId一样，用来定位唯一的一个会话，历史原因，目前大部分接口都在使用ConversationShortId，但是仍然有比较比较老的接口会使用到ConversationId，如果目前您接入的功能没有使用到ConversationId直接忽略即可
	ConversationID string `json:"ConversationId"`

	// REQUIRED; 会话类型。
	// * 1：单聊
	// * 2：群聊
	ConversationType int32 `json:"ConversationType"`

	// REQUIRED; 信箱，用于逻辑隔离
	InboxType int32 `json:"InboxType"`

	// REQUIRED; 群成员UserId
	ParticipantUserID int64 `json:"ParticipantUserId"`

	// 与 ParticipantUserID 字段含义相同，若用户 ID 为字符串类型，使用该字段
	ParticipantUserIDStr *string `json:"ParticipantUserIdStr,omitempty"`

	// REQUIRED; 用户已读位置
	ReadIndex int64 `json:"ReadIndex"`

	// REQUIRED; 置顶时间，单位为毫秒。0表示未置顶
	StickTopTime int64 `json:"StickTopTime"`

	// 扩展字段。 key 的数据类型为 String，value 的数据类型为 String。
	Ext map[string]string `json:"Ext,omitempty"`

	// 是否开启免打扰。
	// * true：开启。
	// * false：不开启
	IsMute *bool `json:"IsMute,omitempty"`

	// 是否收藏。
	// * true：收藏。
	// * false：不收藏
	IsSetFavorite *bool `json:"IsSetFavorite,omitempty"`

	// 是否置顶。
	// * true：置顶。
	// * false：不置顶
	IsStickTop *bool `json:"IsStickTop,omitempty"`

	// 收藏时间，单位为毫秒。0表示未收藏
	SetFavoriteTime *int64 `json:"SetFavoriteTime,omitempty"`
}

type GetConversationUserCount struct{}

type GetConversationUserCountBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`
}

type GetConversationUserCountQuery struct{}

type GetConversationUserCountReq struct {
	*GetConversationUserCountQuery
	*GetConversationUserCountBody
}

type GetConversationUserCountRes struct {
	// REQUIRED
	ResponseMetadata GetConversationUserCountResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result GetConversationUserCountResResult `json:"Result"`
}

type GetConversationUserCountResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                            `json:"Version"`
	Error   *GetConversationUserCountResResponseMetadataError `json:"Error,omitempty"`
}

type GetConversationUserCountResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type GetConversationUserCountResResult struct {
	// REQUIRED; 会话成员数量
	Count int64 `json:"Count"`
}

type GetMessages struct{}

type GetMessagesBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 消息 ID
	MessageIDs []int64 `json:"MessageIds"`
}

type GetMessagesQuery struct{}

type GetMessagesReadReceipt struct{}

type GetMessagesReadReceiptBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话Id
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 消息Id
	MessageIDs []int64 `json:"MessageIds"`
}

type GetMessagesReadReceiptQuery struct{}

type GetMessagesReadReceiptReq struct {
	*GetMessagesReadReceiptQuery
	*GetMessagesReadReceiptBody
}

type GetMessagesReadReceiptRes struct {
	// REQUIRED
	ResponseMetadata GetMessagesReadReceiptResResponseMetadata `json:"ResponseMetadata"`

	// 视请求的接口而定
	Result *GetMessagesReadReceiptResResult `json:"Result,omitempty"`
}

type GetMessagesReadReceiptResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                          `json:"Version"`
	Error   *GetMessagesReadReceiptResResponseMetadataError `json:"Error,omitempty"`
}

type GetMessagesReadReceiptResResponseMetadataError struct {
	// REQUIRED
	Code string `json:"Code"`

	// REQUIRED
	Message string `json:"Message"`
}

type GetMessagesReadReceiptResResult struct {
	// REQUIRED; 已读回执详情
	ReadReceipt []GetMessagesReadReceiptResResultReadReceiptItem `json:"ReadReceipt"`
}

type GetMessagesReadReceiptResResultReadReceiptItem struct {
	// REQUIRED; 会话Id
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 消息Id
	MessageID int64 `json:"MessageId"`

	// REQUIRED; 消息已读的UserId列表
	ReadUserIDs []int64 `json:"ReadUserIds"`

	// 与 ReadUserIDs 字段含义相同，若用户 ID 为字符串类型，使用该字段
	ReadUserIDsStr []string `json:"ReadUserIdsStr,omitempty"`

	// REQUIRED; 单聊中消息的接收方是否已读（只有单聊会话这个字段才有意义）
	ReceiverIsRead bool `json:"ReceiverIsRead"`

	// REQUIRED; 消息未读的UserId列表
	UnReadUserIDs []int64 `json:"UnReadUserIds"`

	// 与 UnReadUserIDs 字段含义相同，若用户 ID 为字符串类型，使用该字段
	UnReadUserIDsStr []string `json:"UnReadUserIdsStr,omitempty"`
}

type GetMessagesReq struct {
	*GetMessagesQuery
	*GetMessagesBody
}

type GetMessagesRes struct {
	// REQUIRED
	ResponseMetadata GetMessagesResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result GetMessagesResResult `json:"Result"`
}

type GetMessagesResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                               `json:"Version"`
	Error   *GetMessagesResResponseMetadataError `json:"Error,omitempty"`
}

type GetMessagesResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type GetMessagesResResult struct {
	// REQUIRED; 消息详细信息
	Messages []GetMessagesResResultMessagesItem `json:"Messages"`
}

type GetMessagesResResultMessagesItem struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 消息内容
	Content string `json:"Content"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 会话类型
	// * 1：单聊。
	// * 2：群聊。
	ConversationType int32 `json:"ConversationType"`

	// REQUIRED; 消息创建时间戳，单位为毫秒
	CreateTime int64 `json:"CreateTime"`

	// REQUIRED; 消息 ID
	MessageID int64 `json:"MessageId"`

	// REQUIRED; 消息类型。
	// * 10001：文本。
	// * 10003：图片。
	// * 10004：视频
	// * 10005：文件
	// * 10006：音频
	// * 10012：自定义消息
	MsgType int32 `json:"MsgType"`

	// REQUIRED; 消息发送人 UserId
	Sender int64 `json:"Sender"`

	// 与 Sender 字段含义相同，若用户 ID 为字符串类型，使用该字段
	SenderStr *string `json:"SenderStr,omitempty"`

	// REQUIRED; 消息状态，取值为0，表示消息可见。
	Status int32 `json:"Status"`

	// 消息的扩展字段
	Ext map[string]string `json:"Ext,omitempty"`

	// 消息在会话中的位置
	IndexInConversation *int64 `json:"IndexInConversation,omitempty"`

	// 引用消息
	RefMsgInfo *GetMessagesResResultMessagesItemRefMsgInfo `json:"RefMsgInfo,omitempty"`
}

type GetMessagesResResultMessagesItemRefMsgInfo struct {
	// REQUIRED; 消息引用时展示的文本内容
	Hint string `json:"Hint"`

	// REQUIRED; 被引用的消息 ID
	ReferencedMessageID int64 `json:"ReferencedMessageId"`

	// REQUIRED; 被引用的消息类型
	// * 10001：文本。
	// * 10003：图片。
	// * 10004：视频
	// * 10005：文件
	// * 10006：音频
	// * 10012：自定义消息
	ReferencedMessageType int32 `json:"ReferencedMessageType"`

	// REQUIRED; 被引用的消息状态
	// * 0：消息可见
	// * 1：消息已过期
	// * 2：消息（对用户）不可见
	// * 3：消息被撤回
	// * 4：消息本身可见，后因删除不可见
	Status int32 `json:"Status"`
}

type GetParticipantReadIndex struct{}

type GetParticipantReadIndexBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`
}

type GetParticipantReadIndexQuery struct{}

type GetParticipantReadIndexReq struct {
	*GetParticipantReadIndexQuery
	*GetParticipantReadIndexBody
}

type GetParticipantReadIndexRes struct {
	// REQUIRED
	ResponseMetadata GetParticipantReadIndexResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result GetParticipantReadIndexResResult `json:"Result"`
}

type GetParticipantReadIndexResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                           `json:"Version"`
	Error   *GetParticipantReadIndexResResponseMetadataError `json:"Error,omitempty"`
}

type GetParticipantReadIndexResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type GetParticipantReadIndexResResult struct {
	// REQUIRED; 会话成员信息
	ReadIndexes []GetParticipantReadIndexResResultReadIndexesItem `json:"ReadIndexes"`
}

type GetParticipantReadIndexResResultReadIndexesItem struct {
	// REQUIRED; 会话成员 UserId
	ParticipantUserID int64 `json:"ParticipantUserId"`

	// 与 ParticipantUserID 字段含义相同，若用户 ID 为字符串类型，使用该字段
	ParticipantUserIDStr *string `json:"ParticipantUserIdStr,omitempty"`

	// REQUIRED; 成员已读位置。若没有返回某个成员的 ReadIndex，则表示该成员的 ReadIndex 为 0。
	ReadIndex int64 `json:"ReadIndex"`
}

type GetUserConversations struct{}

type GetUserConversationsBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 查询起始位置
	Cursor int64 `json:"Cursor"`

	// REQUIRED; 查询数量。最大值为 20。
	Limit int64 `json:"Limit"`

	// REQUIRED; 查询用户 UserId
	ParticipantUserID int64 `json:"ParticipantUserId"`

	// REQUIRED; 查询用户 UserId，字符串类型
	ParticipantUserIDStr *string `json:"ParticipantUserIdStr,omitempty"`

	// 数据来源。
	// * 0：从缓存中拉取，按会话最近活跃排序。
	// * 1：从数据库中拉取，按照创建时间正序排序。
	// * 2：拉取用户创建的直播群会话，按照创建时间逆序排序
	DataType *int32 `json:"DataType,omitempty"`

	// 信箱，用于逻辑隔离。 默认值为 0。
	InboxType *int32 `json:"InboxType,omitempty"`

	// 是否忽略会话成员数。
	// * true：忽略。
	// * false：不忽略。 默认值为 false。
	SkipMemberCount *bool `json:"SkipMemberCount,omitempty"`
}

type GetUserConversationsQuery struct{}

type GetUserConversationsReq struct {
	*GetUserConversationsQuery
	*GetUserConversationsBody
}

type GetUserConversationsRes struct {
	// REQUIRED
	ResponseMetadata GetUserConversationsResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result GetUserConversationsResResult `json:"Result"`
}

type GetUserConversationsResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                        `json:"Version"`
	Error   *GetUserConversationsResResponseMetadataError `json:"Error,omitempty"`
}

type GetUserConversationsResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type GetUserConversationsResResult struct {
	// REQUIRED; 会话详细信息
	ConversationInfos []GetUserConversationsResResultConversationInfosItem `json:"ConversationInfos"`

	// REQUIRED; 是否还有更多的数据
	HasMore bool `json:"HasMore"`

	// REQUIRED; 下一批数据起始位置
	NextCursor int64 `json:"NextCursor"`
}

type GetUserConversationsResResultConversationInfosItem struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话Id，字符串类型，含义跟ConversationShortId一样，用来定位唯一的一个会话，历史原因，目前大部分接口都在使用ConversationShortId，但是仍然有比较比较老的接口会使用到ConversationId，如果目前您接入的功能没有使用到ConversationId直接忽略即可
	ConversationID string `json:"ConversationId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 会话类型。
	// * 1：单聊
	// * 2：群聊
	ConversationType int32 `json:"ConversationType"`

	// REQUIRED; 群聊创建时间戳，单位为秒
	CreateTime int64 `json:"CreateTime"`

	// REQUIRED; 创群人 UserId
	CreatorUserID int64 `json:"CreatorUserId"`

	// 与 CreatorUserID 字段含义相同，若用户 ID 为字符串类型，使用该字段
	CreatorUserIDStr *string `json:"CreatorUserIdStr,omitempty"`

	// REQUIRED; 信箱，用于逻辑隔离
	InboxType int32 `json:"InboxType"`

	// REQUIRED; 修改时间戳，单位为秒
	ModifyTime int64 `json:"ModifyTime"`

	// REQUIRED; 群主 UserId
	OwnerUserID int64 `json:"OwnerUserId"`

	// 与 OwnerUserID 字段含义相同，若用户 ID 为字符串类型，使用该字段
	OwnerUserIDStr *string `json:"OwnerUserIdStr,omitempty"`

	// 群头像 url
	AvatarURL *string `json:"AvatarUrl,omitempty"`

	// 群描述
	Description *string `json:"Description,omitempty"`

	// 会话的扩展字段。
	Ext map[string]string `json:"Ext,omitempty"`

	// 会话成员数
	MemberCount *int64 `json:"MemberCount,omitempty"`

	// 群名
	Name *string `json:"Name,omitempty"`

	// 群公告
	Notice *string `json:"Notice,omitempty"`

	// 直播群在线人数。
	OnlineCount *int64 `json:"OnlineCount,omitempty"`

	// 单聊会话另一个 UserId
	OtherUserID *int64 `json:"OtherUserId,omitempty"`

	// 与 OtherUserID 字段含义相同，若用户 ID 为字符串类型，使用该字段
	OtherUserIDStr *string `json:"OtherUserIdStr,omitempty"`

	// 会话状态。
	// * 0：正常
	// * 1：已解散
	Status *int32 `json:"Status,omitempty"`
}

type Im struct {
	*common.Client
}

type IsFriend struct{}

type IsFriendBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 需要校验用户的 UserId，一次最多检验 10 个用户
	FriendUserIDs []int64 `json:"FriendUserIds"`

	// REQUIRED; 用户 UserId
	UserID int64 `json:"UserId"`

	// 信箱，用做逻辑隔离。默认值为 0
	InboxType *int32 `json:"InboxType,omitempty"`
}

type IsFriendQuery struct{}

type IsFriendReq struct {
	*IsFriendQuery
	*IsFriendBody
}

type IsFriendRes struct {
	// REQUIRED
	ResponseMetadata IsFriendResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result IsFriendResResult `json:"Result"`
}

type IsFriendResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                            `json:"Version"`
	Error   *IsFriendResResponseMetadataError `json:"Error,omitempty"`
}

type IsFriendResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type IsFriendResResult struct {
	// REQUIRED; 好友关系详情
	Infos []IsFriendResResultInfosItem `json:"Infos"`
}

type IsFriendResResultInfosItem struct {
	// REQUIRED; 校验好友的 UserId
	FriendUserID int64 `json:"FriendUserId"`

	// REQUIRED; 是否是好友。
	// * true：是。
	// * false：否
	IsFriend bool `json:"IsFriend"`
}

type IsInBlackList struct{}

type IsInBlackListBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 需要校验的用户的 UserId，一次最多校验 10 个用户
	BlackListUserIDs []int64 `json:"BlackListUserIds"`

	// REQUIRED; 用户 ID
	UserID int64 `json:"UserId"`

	// 信箱，用做逻辑隔离。默认值为 0
	InboxType *int32 `json:"InboxType,omitempty"`
}

type IsInBlackListQuery struct{}

type IsInBlackListReq struct {
	*IsInBlackListQuery
	*IsInBlackListBody
}

type IsInBlackListRes struct {
	// REQUIRED
	ResponseMetadata IsInBlackListResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result IsInBlackListResResult `json:"Result"`
}

type IsInBlackListResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                 `json:"Version"`
	Error   *IsInBlackListResResponseMetadataError `json:"Error,omitempty"`
}

type IsInBlackListResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type IsInBlackListResResult struct {
	// REQUIRED; 校验结果。key 为 uid，value 为 true：在黑名单中。 value 为 false：不在黑名单中
	IsInBlackListInfos map[string]bool `json:"IsInBlackListInfos"`
}

type IsUserInConversation struct{}

type IsUserInConversationBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 查询用户 UserId
	ParticipantUserID int64 `json:"ParticipantUserId"`
}

type IsUserInConversationQuery struct{}

type IsUserInConversationReq struct {
	*IsUserInConversationQuery
	*IsUserInConversationBody
}

type IsUserInConversationRes struct {
	// REQUIRED
	ResponseMetadata IsUserInConversationResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result IsUserInConversationResResult `json:"Result"`
}

type IsUserInConversationResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                                        `json:"Version"`
	Error   *IsUserInConversationResResponseMetadataError `json:"Error,omitempty"`
}

type IsUserInConversationResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}

type IsUserInConversationResResult struct {
	// REQUIRED; 用户是否在会话中。
	// * true：是。
	// * false：否。
	IsUserInConversation bool `json:"IsUserInConversation"`
}

type ListFriend struct{}

type ListFriendBody struct {
	// REQUIRED; 应用的唯一标志
	AppID int32 `json:"AppId"`

	// REQUIRED; 查询用户 UserId
	UserID int64 `json:"UserId"`

	// 查询起始位置，默认值为 0，即第一个添加的好友。
	Cursor *int64 `json:"Cursor,omitempty"`

	// 信箱，用做逻辑隔离。默认值为 0
	InboxType *int32 `json:"InboxType,omitempty"`

	// 查询条数，每次最多查询 20 位好友。默认值为 20。
	Limit *int64 `json:"Limit,omitempty"`

	// 是否需要好友总数。
	// * false：不需要。
	// * true：需要。
	// 默认值为 false。
	NeedTotal *bool `json:"NeedTotal,omitempty"`
}

type ListFriendQuery struct{}

type ListFriendReq struct {
	*ListFriendQuery
	*ListFriendBody
}

type ListFriendRes struct {
	// REQUIRED
	ResponseMetadata ListFriendResResponseMetadata `json:"ResponseMetadata"`

	// REQUIRED
	Result ListFriendResResult `json:"Result"`
}

type ListFriendResResponseMetadata struct {
	// REQUIRED; 请求的接口名，属于请求的公共参数。
	Action string `json:"Action"`

	// REQUIRED; 请求的Region，例如：cn-north-1
	Region string `json:"Region"`

	// REQUIRED; RequestID为每次API请求的唯一标识。
	RequestID string `json:"RequestId"`

	// REQUIRED; 请求的服务，属于请求的公共参数。
	Service string `json:"Service"`

	// REQUIRED; 请求的版本号，属于请求的公共参数。
	Version string                              `json:"Version"`
	Error   *ListFriendResResponseMetadataError `json:"Error,omitempty"`
}

type ListFriendResResponseMetadataError struct {
	// REQUIRED; 错误码。参考:https://www.volcengine.com/docs/6348/412253
	Code string `json:"Code"`

	// REQUIRED; 错误信息。参考：https://www.volcengine.com/docs/6348/412253
	Message string `json:"Message"`
}