im

package
v1.0.164 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 27, 2024 License: Apache-2.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	ServiceName    = "rtc"
	DefaultTimeout = 10 * time.Second
)

Variables

View Source 
var (
	ServiceInfoMap = map[string]common.ServiceInfo{
		"cn-north-1": {
			Timeout: DefaultTimeout,
			Scheme:  "https",
			Host:    "rtc.volcengineapi.com",
			Header: http.Header{
				"Accept": []string{"application/json"},
			},
			Credentials: common.Credentials{
				Region:  "cn-north-1",
				Service: ServiceName,
			},
		},
		"ap-southeast-1": {
			Timeout: DefaultTimeout,
			Scheme:  "https",
			Host:    "rtc.volcengineapi.com",
			Header: http.Header{
				"Accept": []string{"application/json"},
			},
			Credentials: common.Credentials{
				Region:  "ap-southeast-1",
				Service: ServiceName,
			},
		},
	}
	ApiListInfo = map[string]*common.ApiInfo{

		"GetConversationMarks": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"GetConversationMarks"},
				"Version": []string{"2020-12-01"},
			},
		},
		"MarkConversation": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"MarkConversation"},
				"Version": []string{"2020-12-01"},
			},
		},
		"ModifyParticipantReadIndex": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"ModifyParticipantReadIndex"},
				"Version": []string{"2020-12-01"},
			},
		},
		"ScanConversationParticipantList": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"ScanConversationParticipantList"},
				"Version": []string{"2020-12-01"},
			},
		},
		"BatchGetBlockParticipants": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"BatchGetBlockParticipants"},
				"Version": []string{"2020-12-01"},
			},
		},
		"IsUserInConversation": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"IsUserInConversation"},
				"Version": []string{"2020-12-01"},
			},
		},
		"BatchModifyConversationParticipant": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"BatchModifyConversationParticipant"},
				"Version": []string{"2020-12-01"},
			},
		},
		"BatchDeleteConversationParticipant": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"BatchDeleteConversationParticipant"},
				"Version": []string{"2020-12-01"},
			},
		},
		"BatchDeleteBlockParticipants": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"BatchDeleteBlockParticipants"},
				"Version": []string{"2020-12-01"},
			},
		},
		"BatchGetConversationParticipant": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"BatchGetConversationParticipant"},
				"Version": []string{"2020-12-01"},
			},
		},
		"BatchGetWhitelistParticipant": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"BatchGetWhitelistParticipant"},
				"Version": []string{"2020-12-01"},
			},
		},
		"BatchAddWhitelistParticipant": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"BatchAddWhitelistParticipant"},
				"Version": []string{"2020-12-01"},
			},
		},
		"BatchAddManager": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"BatchAddManager"},
				"Version": []string{"2020-12-01"},
			},
		},
		"BatchAddConversationParticipant": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"BatchAddConversationParticipant"},
				"Version": []string{"2020-12-01"},
			},
		},
		"BatchAddBlockParticipants": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"BatchAddBlockParticipants"},
				"Version": []string{"2020-12-01"},
			},
		},
		"BatchRemoveWhitelistParticipant": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"BatchRemoveWhitelistParticipant"},
				"Version": []string{"2020-12-01"},
			},
		},
		"BatchRemoveManager": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"BatchRemoveManager"},
				"Version": []string{"2020-12-01"},
			},
		},
		"BatchUpdateLiveParticipants": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"BatchUpdateLiveParticipants"},
				"Version": []string{"2020-12-01"},
			},
		},
		"GetParticipantReadIndex": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"GetParticipantReadIndex"},
				"Version": []string{"2020-12-01"},
			},
		},
		"GetConversationUserCount": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"GetConversationUserCount"},
				"Version": []string{"2020-12-01"},
			},
		},
		"QueryLiveParticipantStatus": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"QueryLiveParticipantStatus"},
				"Version": []string{"2020-12-01"},
			},
		},
		"ModifyConversation": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"ModifyConversation"},
				"Version": []string{"2020-12-01"},
			},
		},
		"ModifyConversationSetting": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"ModifyConversationSetting"},
				"Version": []string{"2020-12-01"},
			},
		},
		"CreateConversation": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"CreateConversation"},
				"Version": []string{"2020-12-01"},
			},
		},
		"BatchGetConversations": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"BatchGetConversations"},
				"Version": []string{"2020-12-01"},
			},
		},
		"GetConversationSetting": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"GetConversationSetting"},
				"Version": []string{"2020-12-01"},
			},
		},
		"GetUserConversations": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"GetUserConversations"},
				"Version": []string{"2020-12-01"},
			},
		},
		"DestroyConversation": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"DestroyConversation"},
				"Version": []string{"2020-12-01"},
			},
		},
		"ModifyMessage": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"ModifyMessage"},
				"Version": []string{"2020-12-01"},
			},
		},
		"GetConversationMessages": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"GetConversationMessages"},
				"Version": []string{"2020-12-01"},
			},
		},
		"DeleteConversationMessage": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"DeleteConversationMessage"},
				"Version": []string{"2020-12-01"},
			},
		},
		"DeleteMessage": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"DeleteMessage"},
				"Version": []string{"2020-12-01"},
			},
		},
		"SendMessage": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"SendMessage"},
				"Version": []string{"2020-12-01"},
			},
		},
		"GetMessages": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"GetMessages"},
				"Version": []string{"2020-12-01"},
			},
		},
		"RecallMessage": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"RecallMessage"},
				"Version": []string{"2020-12-01"},
			},
		},
		"BatchSendMessage": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"BatchSendMessage"},
				"Version": []string{"2020-12-01"},
			},
		},
		"GetMessagesReadReceipt": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"GetMessagesReadReceipt"},
				"Version": []string{"2020-12-01"},
			},
		},
		"DeleteFriend": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"DeleteFriend"},
				"Version": []string{"2020-12-01"},
			},
		},
		"UpdateFriend": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"UpdateFriend"},
				"Version": []string{"2020-12-01"},
			},
		},
		"UpdateBlackList": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"UpdateBlackList"},
				"Version": []string{"2020-12-01"},
			},
		},
		"ListFriend": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"ListFriend"},
				"Version": []string{"2020-12-01"},
			},
		},
		"QueryOnlineStatus": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"QueryOnlineStatus"},
				"Version": []string{"2020-12-01"},
			},
		},
		"GetBlackList": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"GetBlackList"},
				"Version": []string{"2020-12-01"},
			},
		},
		"IsFriend": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"IsFriend"},
				"Version": []string{"2020-12-01"},
			},
		},
		"IsInBlackList": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"IsInBlackList"},
				"Version": []string{"2020-12-01"},
			},
		},
		"AddFriend": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"AddFriend"},
				"Version": []string{"2020-12-01"},
			},
		},
		"AddBlackList": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"AddBlackList"},
				"Version": []string{"2020-12-01"},
			},
		},
		"GetAppToken": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"GetAppToken"},
				"Version": []string{"2020-12-01"},
			},
		},
		"RemoveBlackList": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"RemoveBlackList"},
				"Version": []string{"2020-12-01"},
			},
		},
		"UserBroadcast": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"UserBroadcast"},
				"Version": []string{"2020-12-01"},
			},
		},
		"BatchUpdateUserTags": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"BatchUpdateUserTags"},
				"Version": []string{"2020-12-01"},
			},
		},
		"RegisterUsers": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"RegisterUsers"},
				"Version": []string{"2020-12-01"},
			},
		},
		"UnRegisterUsers": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"UnRegisterUsers"},
				"Version": []string{"2020-12-01"},
			},
		},
		"BatchUpdateUser": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"BatchUpdateUser"},
				"Version": []string{"2020-12-01"},
			},
		},
		"BatchGetUser": {
			Method: http.MethodPost,
			Path:   "/",
			Query: url.Values{
				"Action":  []string{"BatchGetUser"},
				"Version": []string{"2020-12-01"},
			},
		},
	}
)

Functions

This section is empty.

Types

type AddBlackList 

type AddBlackList struct{}

type AddBlackListBody 

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 

type AddBlackListBodyBlackListInfosItem struct {

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

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

type AddBlackListQuery 

type AddBlackListQuery struct{}

type AddBlackListReq 

type AddBlackListReq struct {
	*AddBlackListQuery
	*AddBlackListBody
}

type AddBlackListRes 

type AddBlackListRes struct {

	// REQUIRED
	ResponseMetadata AddBlackListResResponseMetadata `json:"ResponseMetadata"`

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

type AddBlackListResResponseMetadata 

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 

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 

type AddBlackListResResult struct {

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

type AddBlackListResResultFailedInfosItem 

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 

type AddFriend struct{}

type AddFriendBody 

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 

type AddFriendQuery struct{}

type AddFriendReq 

type AddFriendReq struct {
	*AddFriendQuery
	*AddFriendBody
}

type AddFriendRes 

type AddFriendRes struct {

	// REQUIRED
	ResponseMetadata AddFriendResResponseMetadata `json:"ResponseMetadata"`

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

type AddFriendResResponseMetadata 

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 

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 

type AddFriendResResult struct {

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

type AddFriendResResultFailedInfosItem 

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 

type BatchAddBlockParticipants struct{}

type BatchAddBlockParticipantsBody 

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"`

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

type BatchAddBlockParticipantsQuery 

type BatchAddBlockParticipantsQuery struct{}

type BatchAddBlockParticipantsReq 

type BatchAddBlockParticipantsReq struct {
	*BatchAddBlockParticipantsQuery
	*BatchAddBlockParticipantsBody
}

type BatchAddBlockParticipantsRes 

type BatchAddBlockParticipantsRes struct {

	// REQUIRED
	ResponseMetadata BatchAddBlockParticipantsResResponseMetadata `json:"ResponseMetadata"`

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

type BatchAddBlockParticipantsResResponseMetadata 

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 

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 

type BatchAddBlockParticipantsResResult struct {

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

type BatchAddConversationParticipant 

type BatchAddConversationParticipant struct{}

type BatchAddConversationParticipantBody 

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 

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 

type BatchAddConversationParticipantQuery struct{}

type BatchAddConversationParticipantReq 

type BatchAddConversationParticipantReq struct {
	*BatchAddConversationParticipantQuery
	*BatchAddConversationParticipantBody
}

type BatchAddConversationParticipantRes 

type BatchAddConversationParticipantRes struct {

	// REQUIRED
	ResponseMetadata BatchAddConversationParticipantResResponseMetadata `json:"ResponseMetadata"`

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

type BatchAddConversationParticipantResResponseMetadata 

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 

type BatchAddConversationParticipantResResponseMetadataError struct {

	// REQUIRED; 错误码
	Code string `json:"Code"`

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

type BatchAddConversationParticipantResResult 

type BatchAddConversationParticipantResResult struct {

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

type BatchAddManager 

type BatchAddManager struct{}

type BatchAddManagerBody 

type BatchAddManagerBody struct {

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

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

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

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

type BatchAddManagerQuery 

type BatchAddManagerQuery struct{}

type BatchAddManagerReq 

type BatchAddManagerReq struct {
	*BatchAddManagerQuery
	*BatchAddManagerBody
}

type BatchAddManagerRes 

type BatchAddManagerRes struct {

	// REQUIRED
	ResponseMetadata BatchAddManagerResResponseMetadata `json:"ResponseMetadata"`

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

type BatchAddManagerResResponseMetadata 

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 

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 

type BatchAddManagerResResult struct {

	// REQUIRED; 添加失败的 UserId
	FailedManagerUserIDs []int64 `json:"FailedManagerUserIds"`
}

type BatchAddWhitelistParticipant 

type BatchAddWhitelistParticipant struct{}

type BatchAddWhitelistParticipantBody 

type BatchAddWhitelistParticipantBody 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 BatchAddWhitelistParticipantQuery 

type BatchAddWhitelistParticipantQuery struct{}

type BatchAddWhitelistParticipantReq 

type BatchAddWhitelistParticipantReq struct {
	*BatchAddWhitelistParticipantQuery
	*BatchAddWhitelistParticipantBody
}

type BatchAddWhitelistParticipantRes 

type BatchAddWhitelistParticipantRes struct {

	// REQUIRED
	ResponseMetadata BatchAddWhitelistParticipantResResponseMetadata `json:"ResponseMetadata"`

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

type BatchAddWhitelistParticipantResResponseMetadata 

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 

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 

type BatchAddWhitelistParticipantResResult struct {

	// REQUIRED; 添加失败的 UserId
	FailedUserIDs []int64 `json:"FailedUserIds"`
}

type BatchDeleteBlockParticipants 

type BatchDeleteBlockParticipants struct{}

type BatchDeleteBlockParticipantsBody 

type BatchDeleteBlockParticipantsBody struct {

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

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

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

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

type BatchDeleteBlockParticipantsQuery 

type BatchDeleteBlockParticipantsQuery struct{}

type BatchDeleteBlockParticipantsReq 

type BatchDeleteBlockParticipantsReq struct {
	*BatchDeleteBlockParticipantsQuery
	*BatchDeleteBlockParticipantsBody
}

type BatchDeleteBlockParticipantsRes 

type BatchDeleteBlockParticipantsRes struct {

	// REQUIRED
	ResponseMetadata BatchDeleteBlockParticipantsResResponseMetadata `json:"ResponseMetadata"`

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

type BatchDeleteBlockParticipantsResResponseMetadata 

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 

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 

type BatchDeleteBlockParticipantsResResult struct {

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

type BatchDeleteConversationParticipant 

type BatchDeleteConversationParticipant struct{}

type BatchDeleteConversationParticipantBody 

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 

type BatchDeleteConversationParticipantQuery struct{}

type BatchDeleteConversationParticipantReq 

type BatchDeleteConversationParticipantReq struct {
	*BatchDeleteConversationParticipantQuery
	*BatchDeleteConversationParticipantBody
}

type BatchDeleteConversationParticipantRes 

type BatchDeleteConversationParticipantRes struct {

	// REQUIRED
	ResponseMetadata BatchDeleteConversationParticipantResResponseMetadata `json:"ResponseMetadata"`

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

type BatchDeleteConversationParticipantResResponseMetadata 

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 

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 

type BatchDeleteConversationParticipantResResult struct {

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

type BatchGetBlockParticipants 

type BatchGetBlockParticipants struct{}

type BatchGetBlockParticipantsBody 

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 

type BatchGetBlockParticipantsQuery struct{}

type BatchGetBlockParticipantsReq 

type BatchGetBlockParticipantsReq struct {
	*BatchGetBlockParticipantsQuery
	*BatchGetBlockParticipantsBody
}

type BatchGetBlockParticipantsRes 

type BatchGetBlockParticipantsRes struct {

	// REQUIRED
	ResponseMetadata BatchGetBlockParticipantsResResponseMetadata `json:"ResponseMetadata"`

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

type BatchGetBlockParticipantsResResponseMetadata 

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 

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 

type BatchGetBlockParticipantsResResult struct {

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

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

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

type BatchGetBlockParticipantsResResultParticipantsItem 

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"`
}

type BatchGetConversationParticipant 

type BatchGetConversationParticipant struct{}

type BatchGetConversationParticipantBody 

type BatchGetConversationParticipantBody struct {

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

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

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

type BatchGetConversationParticipantQuery 

type BatchGetConversationParticipantQuery struct{}

type BatchGetConversationParticipantReq 

type BatchGetConversationParticipantReq struct {
	*BatchGetConversationParticipantQuery
	*BatchGetConversationParticipantBody
}

type BatchGetConversationParticipantRes 

type BatchGetConversationParticipantRes struct {

	// REQUIRED
	ResponseMetadata BatchGetConversationParticipantResResponseMetadata `json:"ResponseMetadata"`

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

type BatchGetConversationParticipantResResponseMetadata 

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 

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 

type BatchGetConversationParticipantResResult struct {

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

type BatchGetConversationParticipantResResultParticipantsItem 

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 

type BatchGetConversations struct{}

type BatchGetConversationsBody 

type BatchGetConversationsBody struct {

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

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

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

type BatchGetConversationsQuery 

type BatchGetConversationsQuery struct{}

type BatchGetConversationsReq 

type BatchGetConversationsReq struct {
	*BatchGetConversationsQuery
	*BatchGetConversationsBody
}

type BatchGetConversationsRes 

type BatchGetConversationsRes struct {

	// REQUIRED
	ResponseMetadata BatchGetConversationsResResponseMetadata `json:"ResponseMetadata"`

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

type BatchGetConversationsResResponseMetadata 

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 

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 

type BatchGetConversationsResResult struct {

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

type BatchGetConversationsResResultConversationCoreInfosItem 

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"`

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

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

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

	// 群头像 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"`

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

type BatchGetUser added in v1.0.143 

type BatchGetUser struct{}

type BatchGetUserBody added in v1.0.143 

type BatchGetUserBody struct {

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

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

type BatchGetUserQuery added in v1.0.143 

type BatchGetUserQuery struct{}

type BatchGetUserReq added in v1.0.143 

type BatchGetUserReq struct {
	*BatchGetUserQuery
	*BatchGetUserBody
}

type BatchGetUserRes added in v1.0.143 

type BatchGetUserRes struct {

	// REQUIRED
	ResponseMetadata BatchGetUserResResponseMetadata `json:"ResponseMetadata"`

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

type BatchGetUserResResponseMetadata added in v1.0.143 

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 added in v1.0.143 

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 added in v1.0.143 

type BatchGetUserResResult struct {

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

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

type BatchGetUserResResultUsersItem added in v1.0.143 

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"`
}

type BatchGetWhitelistParticipant 

type BatchGetWhitelistParticipant struct{}

type BatchGetWhitelistParticipantBody 

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 

type BatchGetWhitelistParticipantQuery struct{}

type BatchGetWhitelistParticipantReq 

type BatchGetWhitelistParticipantReq struct {
	*BatchGetWhitelistParticipantQuery
	*BatchGetWhitelistParticipantBody
}

type BatchGetWhitelistParticipantRes 

type BatchGetWhitelistParticipantRes struct {

	// REQUIRED
	ResponseMetadata BatchGetWhitelistParticipantResResponseMetadata `json:"ResponseMetadata"`

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

type BatchGetWhitelistParticipantResResponseMetadata 

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 

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 

type BatchGetWhitelistParticipantResResult struct {

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

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

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

type BatchGetWhitelistParticipantResResultParticipantsItem 

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 

type BatchModifyConversationParticipant struct{}

type BatchModifyConversationParticipantBody 

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 

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 

type BatchModifyConversationParticipantQuery struct{}

type BatchModifyConversationParticipantReq 

type BatchModifyConversationParticipantReq struct {
	*BatchModifyConversationParticipantQuery
	*BatchModifyConversationParticipantBody
}

type BatchModifyConversationParticipantRes 

type BatchModifyConversationParticipantRes struct {

	// REQUIRED
	ResponseMetadata BatchModifyConversationParticipantResResponseMetadata `json:"ResponseMetadata"`

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

type BatchModifyConversationParticipantResResponseMetadata 

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 

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 

type BatchModifyConversationParticipantResResult struct {

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

type BatchRemoveManager 

type BatchRemoveManager struct{}

type BatchRemoveManagerBody 

type BatchRemoveManagerBody struct {

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

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

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

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

type BatchRemoveManagerQuery 

type BatchRemoveManagerQuery struct{}

type BatchRemoveManagerReq 

type BatchRemoveManagerReq struct {
	*BatchRemoveManagerQuery
	*BatchRemoveManagerBody
}

type BatchRemoveManagerRes 

type BatchRemoveManagerRes struct {

	// REQUIRED
	ResponseMetadata BatchRemoveManagerResResponseMetadata `json:"ResponseMetadata"`

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

type BatchRemoveManagerResResponseMetadata 

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 

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 

type BatchRemoveManagerResResult struct {

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

type BatchRemoveWhitelistParticipant 

type BatchRemoveWhitelistParticipant struct{}

type BatchRemoveWhitelistParticipantBody 

type BatchRemoveWhitelistParticipantBody 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 BatchRemoveWhitelistParticipantQuery 

type BatchRemoveWhitelistParticipantQuery struct{}

type BatchRemoveWhitelistParticipantReq 

type BatchRemoveWhitelistParticipantReq struct {
	*BatchRemoveWhitelistParticipantQuery
	*BatchRemoveWhitelistParticipantBody
}

type BatchRemoveWhitelistParticipantRes 

type BatchRemoveWhitelistParticipantRes struct {

	// REQUIRED
	ResponseMetadata BatchRemoveWhitelistParticipantResResponseMetadata `json:"ResponseMetadata"`

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

type BatchRemoveWhitelistParticipantResResponseMetadata 

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 

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 

type BatchRemoveWhitelistParticipantResResult struct {

	// REQUIRED; 移除失败的 UserId
	FailedUserIDs []int64 `json:"FailedUserIds"`
}

type BatchSendMessage added in v1.0.159 

type BatchSendMessage struct{}

type BatchSendMessageBody added in v1.0.159 

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 added in v1.0.159 

type BatchSendMessageQuery struct{}

type BatchSendMessageReq added in v1.0.159 

type BatchSendMessageReq struct {
	*BatchSendMessageQuery
	*BatchSendMessageBody
}

type BatchSendMessageRes added in v1.0.159 

type BatchSendMessageRes struct {

	// REQUIRED
	ResponseMetadata BatchSendMessageResResponseMetadata `json:"ResponseMetadata"`

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

type BatchSendMessageResResponseMetadata added in v1.0.159 

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 added in v1.0.159 

type BatchSendMessageResResponseMetadataError struct {

	// REQUIRED
	Code string `json:"Code"`

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

type BatchSendMessageResResult added in v1.0.159 

type BatchSendMessageResResult struct {

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

type BatchUpdateLiveParticipants added in v1.0.143 

type BatchUpdateLiveParticipants struct{}

type BatchUpdateLiveParticipantsBody 

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 

type BatchUpdateLiveParticipantsBodyParticipantInfosItem struct {

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

	// 群成员头像。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 added in v1.0.143 

type BatchUpdateLiveParticipantsQuery struct{}

type BatchUpdateLiveParticipantsReq added in v1.0.143 

type BatchUpdateLiveParticipantsReq struct {
	*BatchUpdateLiveParticipantsQuery
	*BatchUpdateLiveParticipantsBody
}

type BatchUpdateLiveParticipantsRes 

type BatchUpdateLiveParticipantsRes struct {

	// REQUIRED
	ResponseMetadata BatchUpdateLiveParticipantsResResponseMetadata `json:"ResponseMetadata"`

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

type BatchUpdateLiveParticipantsResResponseMetadata 

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 

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 

type BatchUpdateLiveParticipantsResResult struct {

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

type BatchUpdateLiveParticipantsResResultFailedInfosItem 

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"`
}

type BatchUpdateUser added in v1.0.143 

type BatchUpdateUser struct{}

type BatchUpdateUserBody added in v1.0.143 

type BatchUpdateUserBody struct {

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

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

type BatchUpdateUserBodyUsersItem added in v1.0.143 

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 added in v1.0.143 

type BatchUpdateUserQuery struct{}

type BatchUpdateUserReq added in v1.0.143 

type BatchUpdateUserReq struct {
	*BatchUpdateUserQuery
	*BatchUpdateUserBody
}

type BatchUpdateUserRes added in v1.0.143 

type BatchUpdateUserRes struct {

	// REQUIRED
	ResponseMetadata BatchUpdateUserResResponseMetadata `json:"ResponseMetadata"`

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

type BatchUpdateUserResResponseMetadata added in v1.0.143 

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 added in v1.0.143 

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 added in v1.0.143 

type BatchUpdateUserResResult struct {

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

BatchUpdateUserResResult - 视请求的接口而定

type BatchUpdateUserResResultFailedInfosItem added in v1.0.143 

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 added in v1.0.143 

type BatchUpdateUserTags struct{}

type BatchUpdateUserTagsBody added in v1.0.143 

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 added in v1.0.143 

type BatchUpdateUserTagsQuery struct{}

type BatchUpdateUserTagsReq added in v1.0.143 

type BatchUpdateUserTagsReq struct {
	*BatchUpdateUserTagsQuery
	*BatchUpdateUserTagsBody
}

type BatchUpdateUserTagsRes added in v1.0.143 

type BatchUpdateUserTagsRes struct {

	// REQUIRED
	ResponseMetadata BatchUpdateUserTagsResResponseMetadata `json:"ResponseMetadata"`

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

type BatchUpdateUserTagsResResponseMetadata added in v1.0.143 

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 added in v1.0.143 

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 added in v1.0.143 

type BatchUpdateUserTagsResResult struct {

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

type BatchUpdateUserTagsResResultFailedInfosItem added in v1.0.143 

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 

type CreateConversation struct{}

type CreateConversationBody 

type CreateConversationBody struct {

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

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

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

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

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

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

type CreateConversationBodyConversationCoreInfo 

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"`
}

CreateConversationBodyConversationCoreInfo - 会话详细信息

type CreateConversationQuery 

type CreateConversationQuery struct{}

type CreateConversationReq 

type CreateConversationReq struct {
	*CreateConversationQuery
	*CreateConversationBody
}

type CreateConversationRes 

type CreateConversationRes struct {

	// REQUIRED
	ResponseMetadata CreateConversationResResponseMetadata `json:"ResponseMetadata"`

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

type CreateConversationResResponseMetadata 

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 

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 

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 

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"`

	// 群描述
	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"`

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

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

CreateConversationResResultConversationInfo - 会话详细信息

type DeleteConversationMessage 

type DeleteConversationMessage struct{}

type DeleteConversationMessageBody 

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 

type DeleteConversationMessageQuery struct{}

type DeleteConversationMessageReq 

type DeleteConversationMessageReq struct {
	*DeleteConversationMessageQuery
	*DeleteConversationMessageBody
}

type DeleteConversationMessageRes 

type DeleteConversationMessageRes struct {

	// REQUIRED
	ResponseMetadata DeleteConversationMessageResResponseMetadata `json:"ResponseMetadata"`

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

type DeleteConversationMessageResResponseMetadata 

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 

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 

type DeleteFriend struct{}

type DeleteFriendBody 

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 

type DeleteFriendQuery struct{}

type DeleteFriendReq 

type DeleteFriendReq struct {
	*DeleteFriendQuery
	*DeleteFriendBody
}

type DeleteFriendRes 

type DeleteFriendRes struct {

	// REQUIRED
	ResponseMetadata DeleteFriendResResponseMetadata `json:"ResponseMetadata"`

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

type DeleteFriendResResponseMetadata 

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 

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 

type DeleteFriendResResult struct {

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

type DeleteFriendResResultFailedInfosItem 

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 

type DeleteMessage struct{}

type DeleteMessageBody 

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 

type DeleteMessageQuery struct{}

type DeleteMessageReq 

type DeleteMessageReq struct {
	*DeleteMessageQuery
	*DeleteMessageBody
}

type DeleteMessageRes 

type DeleteMessageRes struct {

	// REQUIRED
	ResponseMetadata DeleteMessageResResponseMetadata `json:"ResponseMetadata"`

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

type DeleteMessageResResponseMetadata 

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 

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 

type DestroyConversation struct{}

type DestroyConversationBody 

type DestroyConversationBody struct {

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

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

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

type DestroyConversationQuery 

type DestroyConversationQuery struct{}

type DestroyConversationReq 

type DestroyConversationReq struct {
	*DestroyConversationQuery
	*DestroyConversationBody
}

type DestroyConversationRes 

type DestroyConversationRes struct {

	// REQUIRED
	ResponseMetadata DestroyConversationResResponseMetadata `json:"ResponseMetadata"`

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

type DestroyConversationResResponseMetadata 

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 

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 added in v1.0.143 

type GetAppToken struct{}

type GetAppTokenBody added in v1.0.143 

type GetAppTokenBody struct {

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

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

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

type GetAppTokenQuery added in v1.0.143 

type GetAppTokenQuery struct{}

type GetAppTokenReq added in v1.0.143 

type GetAppTokenReq struct {
	*GetAppTokenQuery
	*GetAppTokenBody
}

type GetAppTokenRes added in v1.0.143 

type GetAppTokenRes struct {

	// REQUIRED
	ResponseMetadata GetAppTokenResResponseMetadata `json:"ResponseMetadata"`

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

type GetAppTokenResResponseMetadata added in v1.0.143 

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 added in v1.0.143 

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 added in v1.0.143 

type GetAppTokenResResult struct {

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

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

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

GetAppTokenResResult - 视请求的接口而定

type GetBlackList 

type GetBlackList struct{}

type GetBlackListBody 

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 

type GetBlackListQuery struct{}

type GetBlackListReq 

type GetBlackListReq struct {
	*GetBlackListQuery
	*GetBlackListBody
}

type GetBlackListRes 

type GetBlackListRes struct {

	// REQUIRED
	ResponseMetadata GetBlackListResResponseMetadata `json:"ResponseMetadata"`

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

type GetBlackListResResponseMetadata 

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 

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 

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 

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 

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"`
}

GetBlackListResResultBlackListInfosItemFriendUserInfo - 好友信息。若黑名单用户并不是查询用户好友则不返回此字段。

type GetConversationMarks added in v1.0.143 

type GetConversationMarks struct{}

type GetConversationMarksBody added in v1.0.143 

type GetConversationMarksBody struct {

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

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

type GetConversationMarksQuery added in v1.0.143 

type GetConversationMarksQuery struct{}

type GetConversationMarksReq added in v1.0.143 

type GetConversationMarksReq struct {
	*GetConversationMarksQuery
	*GetConversationMarksBody
}

type GetConversationMarksRes added in v1.0.143 

type GetConversationMarksRes struct {

	// REQUIRED
	ResponseMetadata GetConversationMarksResResponseMetadata `json:"ResponseMetadata"`
	Result           *GetConversationMarksResResult          `json:"Result,omitempty"`
}

type GetConversationMarksResResponseMetadata added in v1.0.143 

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 added in v1.0.143 

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 added in v1.0.143 

type GetConversationMarksResResult struct {

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

type GetConversationMessages 

type GetConversationMessages struct{}

type GetConversationMessagesBody 

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 

type GetConversationMessagesQuery struct{}

type GetConversationMessagesReq 

type GetConversationMessagesReq struct {
	*GetConversationMessagesQuery
	*GetConversationMessagesBody
}

type GetConversationMessagesRes 

type GetConversationMessagesRes struct {

	// REQUIRED
	ResponseMetadata GetConversationMessagesResResponseMetadata `json:"ResponseMetadata"`

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

type GetConversationMessagesResResponseMetadata 

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 

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 

type GetConversationMessagesResResult struct {

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

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

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

type GetConversationMessagesResResultMessagesItem 

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"`

	// 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 

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"`
}

GetConversationMessagesResResultMessagesItemRefMsgInfo - 引用消息

type GetConversationSetting 

type GetConversationSetting struct{}

type GetConversationSettingBody 

type GetConversationSettingBody struct {

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

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

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

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

type GetConversationSettingQuery 

type GetConversationSettingQuery struct{}

type GetConversationSettingReq 

type GetConversationSettingReq struct {
	*GetConversationSettingQuery
	*GetConversationSettingBody
}

type GetConversationSettingRes 

type GetConversationSettingRes struct {

	// REQUIRED
	ResponseMetadata GetConversationSettingResResponseMetadata `json:"ResponseMetadata"`

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

type GetConversationSettingResResponseMetadata 

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 

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 

type GetConversationSettingResResult struct {

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

type GetConversationSettingResResultConversationSettingInfo 

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"`

	// 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"`
}

GetConversationSettingResResultConversationSettingInfo - 用户会话设置

type GetConversationUserCount 

type GetConversationUserCount struct{}

type GetConversationUserCountBody 

type GetConversationUserCountBody struct {

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

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

type GetConversationUserCountQuery 

type GetConversationUserCountQuery struct{}

type GetConversationUserCountReq 

type GetConversationUserCountReq struct {
	*GetConversationUserCountQuery
	*GetConversationUserCountBody
}

type GetConversationUserCountRes 

type GetConversationUserCountRes struct {

	// REQUIRED
	ResponseMetadata GetConversationUserCountResResponseMetadata `json:"ResponseMetadata"`

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

type GetConversationUserCountResResponseMetadata 

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 

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 

type GetConversationUserCountResResult struct {

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

type GetMessages 

type GetMessages struct{}

type GetMessagesBody 

type GetMessagesBody struct {

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

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

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

type GetMessagesQuery 

type GetMessagesQuery struct{}

type GetMessagesReadReceipt added in v1.0.146 

type GetMessagesReadReceipt struct{}

type GetMessagesReadReceiptBody added in v1.0.146 

type GetMessagesReadReceiptBody struct {

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

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

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

type GetMessagesReadReceiptQuery added in v1.0.146 

type GetMessagesReadReceiptQuery struct{}

type GetMessagesReadReceiptReq added in v1.0.146 

type GetMessagesReadReceiptReq struct {
	*GetMessagesReadReceiptQuery
	*GetMessagesReadReceiptBody
}

type GetMessagesReadReceiptRes added in v1.0.146 

type GetMessagesReadReceiptRes struct {

	// REQUIRED
	ResponseMetadata GetMessagesReadReceiptResResponseMetadata `json:"ResponseMetadata"`

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

type GetMessagesReadReceiptResResponseMetadata added in v1.0.146 

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 added in v1.0.146 

type GetMessagesReadReceiptResResponseMetadataError struct {

	// REQUIRED
	Code string `json:"Code"`

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

type GetMessagesReadReceiptResResult added in v1.0.146 

type GetMessagesReadReceiptResResult struct {

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

GetMessagesReadReceiptResResult - 视请求的接口而定

type GetMessagesReadReceiptResResultReadReceiptItem added in v1.0.146 

type GetMessagesReadReceiptResResultReadReceiptItem struct {

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

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

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

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

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

type GetMessagesReq 

type GetMessagesReq struct {
	*GetMessagesQuery
	*GetMessagesBody
}

type GetMessagesRes 

type GetMessagesRes struct {

	// REQUIRED
	ResponseMetadata GetMessagesResResponseMetadata `json:"ResponseMetadata"`

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

type GetMessagesResResponseMetadata 

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 

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 

type GetMessagesResResult struct {

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

type GetMessagesResResultMessagesItem 

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"`

	// 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 

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"`
}

GetMessagesResResultMessagesItemRefMsgInfo - 引用消息

type GetParticipantReadIndex 

type GetParticipantReadIndex struct{}

type GetParticipantReadIndexBody 

type GetParticipantReadIndexBody struct {

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

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

type GetParticipantReadIndexQuery 

type GetParticipantReadIndexQuery struct{}

type GetParticipantReadIndexReq 

type GetParticipantReadIndexReq struct {
	*GetParticipantReadIndexQuery
	*GetParticipantReadIndexBody
}

type GetParticipantReadIndexRes 

type GetParticipantReadIndexRes struct {

	// REQUIRED
	ResponseMetadata GetParticipantReadIndexResResponseMetadata `json:"ResponseMetadata"`

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

type GetParticipantReadIndexResResponseMetadata 

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 

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 

type GetParticipantReadIndexResResult struct {

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

type GetParticipantReadIndexResResultReadIndexesItem 

type GetParticipantReadIndexResResultReadIndexesItem struct {

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

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

type GetUserConversations 

type GetUserConversations struct{}

type GetUserConversationsBody 

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"`

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

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

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

type GetUserConversationsQuery 

type GetUserConversationsQuery struct{}

type GetUserConversationsReq 

type GetUserConversationsReq struct {
	*GetUserConversationsQuery
	*GetUserConversationsBody
}

type GetUserConversationsRes 

type GetUserConversationsRes struct {

	// REQUIRED
	ResponseMetadata GetUserConversationsResResponseMetadata `json:"ResponseMetadata"`

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

type GetUserConversationsResResponseMetadata 

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 

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 

type GetUserConversationsResResult struct {

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

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

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

type GetUserConversationsResResultConversationInfosItem 

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"`

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

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

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

	// 群头像 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"`

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

type Im 

type Im struct {
	*common.Client
}

func NewInstance 

func NewInstance() *Im

func NewInstanceWithRegion 

func NewInstanceWithRegion(region string) *Im

func (*Im) AddBlackList 

func (c *Im) AddBlackList(ctx context.Context, arg *AddBlackListBody) (*AddBlackListRes, error)

func (*Im) AddFriend 

func (c *Im) AddFriend(ctx context.Context, arg *AddFriendBody) (*AddFriendRes, error)

func (*Im) BatchAddBlockParticipants 

func (c *Im) BatchAddBlockParticipants(ctx context.Context, arg *BatchAddBlockParticipantsBody) (*BatchAddBlockParticipantsRes, error)

func (*Im) BatchAddConversationParticipant 

func (c *Im) BatchAddConversationParticipant(ctx context.Context, arg *BatchAddConversationParticipantBody) (*BatchAddConversationParticipantRes, error)

func (*Im) BatchAddManager 

func (c *Im) BatchAddManager(ctx context.Context, arg *BatchAddManagerBody) (*BatchAddManagerRes, error)

func (*Im) BatchAddWhitelistParticipant 

func (c *Im) BatchAddWhitelistParticipant(ctx context.Context, arg *BatchAddWhitelistParticipantBody) (*BatchAddWhitelistParticipantRes, error)

func (*Im) BatchDeleteBlockParticipants 

func (c *Im) BatchDeleteBlockParticipants(ctx context.Context, arg *BatchDeleteBlockParticipantsBody) (*BatchDeleteBlockParticipantsRes, error)

func (*Im) BatchDeleteConversationParticipant 

func (c *Im) BatchDeleteConversationParticipant(ctx context.Context, arg *BatchDeleteConversationParticipantBody) (*BatchDeleteConversationParticipantRes, error)

func (*Im) BatchGetBlockParticipants 

func (c *Im) BatchGetBlockParticipants(ctx context.Context, arg *BatchGetBlockParticipantsBody) (*BatchGetBlockParticipantsRes, error)

func (*Im) BatchGetConversationParticipant 

func (c *Im) BatchGetConversationParticipant(ctx context.Context, arg *BatchGetConversationParticipantBody) (*BatchGetConversationParticipantRes, error)

func (*Im) BatchGetConversations 

func (c *Im) BatchGetConversations(ctx context.Context, arg *BatchGetConversationsBody) (*BatchGetConversationsRes, error)

func (*Im) BatchGetUser added in v1.0.143 

func (c *Im) BatchGetUser(ctx context.Context, arg *BatchGetUserBody) (*BatchGetUserRes, error)

func (*Im) BatchGetWhitelistParticipant 

func (c *Im) BatchGetWhitelistParticipant(ctx context.Context, arg *BatchGetWhitelistParticipantBody) (*BatchGetWhitelistParticipantRes, error)

func (*Im) BatchModifyConversationParticipant 

func (c *Im) BatchModifyConversationParticipant(ctx context.Context, arg *BatchModifyConversationParticipantBody) (*BatchModifyConversationParticipantRes, error)

func (*Im) BatchRemoveManager 

func (c *Im) BatchRemoveManager(ctx context.Context, arg *BatchRemoveManagerBody) (*BatchRemoveManagerRes, error)

func (*Im) BatchRemoveWhitelistParticipant 

func (c *Im) BatchRemoveWhitelistParticipant(ctx context.Context, arg *BatchRemoveWhitelistParticipantBody) (*BatchRemoveWhitelistParticipantRes, error)

func (*Im) BatchSendMessage added in v1.0.159 

func (c *Im) BatchSendMessage(ctx context.Context, arg *BatchSendMessageBody) (*BatchSendMessageRes, error)

func (*Im) BatchUpdateLiveParticipants 

func (c *Im) BatchUpdateLiveParticipants(ctx context.Context, arg *BatchUpdateLiveParticipantsBody) (*BatchUpdateLiveParticipantsRes, error)

func (*Im) BatchUpdateUser added in v1.0.143 

func (c *Im) BatchUpdateUser(ctx context.Context, arg *BatchUpdateUserBody) (*BatchUpdateUserRes, error)

func (*Im) BatchUpdateUserTags added in v1.0.143 

func (c *Im) BatchUpdateUserTags(ctx context.Context, arg *BatchUpdateUserTagsBody) (*BatchUpdateUserTagsRes, error)

func (*Im) CreateConversation 

func (c *Im) CreateConversation(ctx context.Context, arg *CreateConversationBody) (*CreateConversationRes, error)

func (*Im) DeleteConversationMessage 

func (c *Im) DeleteConversationMessage(ctx context.Context, arg *DeleteConversationMessageBody) (*DeleteConversationMessageRes, error)

func (*Im) DeleteFriend 

func (c *Im) DeleteFriend(ctx context.Context, arg *DeleteFriendBody) (*DeleteFriendRes, error)

func (*Im) DeleteMessage 

func (c *Im) DeleteMessage(ctx context.Context, arg *DeleteMessageBody) (*DeleteMessageRes, error)

func (*Im) DestroyConversation 

func (c *Im) DestroyConversation(ctx context.Context, arg *DestroyConversationBody) (*DestroyConversationRes, error)

func (*Im) GetAppToken added in v1.0.143 

func (c *Im) GetAppToken(ctx context.Context, arg *GetAppTokenBody) (*GetAppTokenRes, error)

func (*Im) GetBlackList 

func (c *Im) GetBlackList(ctx context.Context, arg *GetBlackListBody) (*GetBlackListRes, error)

func (*Im) GetConversationMarks added in v1.0.143 

func (c *Im) GetConversationMarks(ctx context.Context, arg *GetConversationMarksBody) (*GetConversationMarksRes, error)

func (*Im) GetConversationMessages 

func (c *Im) GetConversationMessages(ctx context.Context, arg *GetConversationMessagesBody) (*GetConversationMessagesRes, error)

func (*Im) GetConversationSetting 

func (c *Im) GetConversationSetting(ctx context.Context, arg *GetConversationSettingBody) (*GetConversationSettingRes, error)

func (*Im) GetConversationUserCount 

func (c *Im) GetConversationUserCount(ctx context.Context, arg *GetConversationUserCountBody) (*GetConversationUserCountRes, error)

func (*Im) GetMessages 

func (c *Im) GetMessages(ctx context.Context, arg *GetMessagesBody) (*GetMessagesRes, error)

func (*Im) GetMessagesReadReceipt added in v1.0.146 

func (c *Im) GetMessagesReadReceipt(ctx context.Context, arg *GetMessagesReadReceiptBody) (*GetMessagesReadReceiptRes, error)

func (*Im) GetParticipantReadIndex 

func (c *Im) GetParticipantReadIndex(ctx context.Context, arg *GetParticipantReadIndexBody) (*GetParticipantReadIndexRes, error)

func (*Im) GetUserConversations 

func (c *Im) GetUserConversations(ctx context.Context, arg *GetUserConversationsBody) (*GetUserConversationsRes, error)

func (*Im) IsFriend 

func (c *Im) IsFriend(ctx context.Context, arg *IsFriendBody) (*IsFriendRes, error)

func (*Im) IsInBlackList 

func (c *Im) IsInBlackList(ctx context.Context, arg *IsInBlackListBody) (*IsInBlackListRes, error)

func (*Im) IsUserInConversation 

func (c *Im) IsUserInConversation(ctx context.Context, arg *IsUserInConversationBody) (*IsUserInConversationRes, error)

func (*Im) ListFriend 

func (c *Im) ListFriend(ctx context.Context, arg *ListFriendBody) (*ListFriendRes, error)

func (*Im) MarkConversation added in v1.0.143 

func (c *Im) MarkConversation(ctx context.Context, arg *MarkConversationBody) (*MarkConversationRes, error)

func (*Im) ModifyConversation 

func (c *Im) ModifyConversation(ctx context.Context, arg *ModifyConversationBody) (*ModifyConversationRes, error)

func (*Im) ModifyConversationSetting 

func (c *Im) ModifyConversationSetting(ctx context.Context, arg *ModifyConversationSettingBody) (*ModifyConversationSettingRes, error)

func (*Im) ModifyMessage 

func (c *Im) ModifyMessage(ctx context.Context, arg *ModifyMessageBody) (*ModifyMessageRes, error)

func (*Im) ModifyParticipantReadIndex 

func (c *Im) ModifyParticipantReadIndex(ctx context.Context, arg *ModifyParticipantReadIndexBody) (*ModifyParticipantReadIndexRes, error)

func (*Im) QueryLiveParticipantStatus 

func (c *Im) QueryLiveParticipantStatus(ctx context.Context, arg *QueryLiveParticipantStatusBody) (*QueryLiveParticipantStatusRes, error)

func (*Im) QueryOnlineStatus 

func (c *Im) QueryOnlineStatus(ctx context.Context, arg *QueryOnlineStatusBody) (*QueryOnlineStatusRes, error)

func (*Im) RecallMessage 

func (c *Im) RecallMessage(ctx context.Context, arg *RecallMessageBody) (*RecallMessageRes, error)

func (*Im) RegisterUsers added in v1.0.143 

func (c *Im) RegisterUsers(ctx context.Context, arg *RegisterUsersBody) (*RegisterUsersRes, error)

func (*Im) RemoveBlackList 

func (c *Im) RemoveBlackList(ctx context.Context, arg *RemoveBlackListBody) (*RemoveBlackListRes, error)

func (*Im) ScanConversationParticipantList 

func (c *Im) ScanConversationParticipantList(ctx context.Context, arg *ScanConversationParticipantListBody) (*ScanConversationParticipantListRes, error)

func (*Im) SendMessage 

func (c *Im) SendMessage(ctx context.Context, arg *SendMessageBody) (*SendMessageRes, error)

func (*Im) UnRegisterUsers added in v1.0.143 

func (c *Im) UnRegisterUsers(ctx context.Context, arg *UnRegisterUsersBody) (*UnRegisterUsersRes, error)

func (*Im) UpdateBlackList 

func (c *Im) UpdateBlackList(ctx context.Context, arg *UpdateBlackListBody) (*UpdateBlackListRes, error)

func (*Im) UpdateFriend 

func (c *Im) UpdateFriend(ctx context.Context, arg *UpdateFriendBody) (*UpdateFriendRes, error)

func (*Im) UserBroadcast added in v1.0.143 

func (c *Im) UserBroadcast(ctx context.Context, arg *UserBroadcastBody) (*UserBroadcastRes, error)

type IsFriend 

type IsFriend struct{}

type IsFriendBody 

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 

type IsFriendQuery struct{}

type IsFriendReq 

type IsFriendReq struct {
	*IsFriendQuery
	*IsFriendBody
}

type IsFriendRes 

type IsFriendRes struct {

	// REQUIRED
	ResponseMetadata IsFriendResResponseMetadata `json:"ResponseMetadata"`

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

type IsFriendResResponseMetadata 

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 

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 

type IsFriendResResult struct {

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

type IsFriendResResultInfosItem 

type IsFriendResResultInfosItem struct {

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

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

type IsInBlackList 

type IsInBlackList struct{}

type IsInBlackListBody 

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 

type IsInBlackListQuery struct{}

type IsInBlackListReq 

type IsInBlackListReq struct {
	*IsInBlackListQuery
	*IsInBlackListBody
}

type IsInBlackListRes 

type IsInBlackListRes struct {

	// REQUIRED
	ResponseMetadata IsInBlackListResResponseMetadata `json:"ResponseMetadata"`

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

type IsInBlackListResResponseMetadata 

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 

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 

type IsInBlackListResResult struct {

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

type IsUserInConversation 

type IsUserInConversation struct{}

type IsUserInConversationBody 

type IsUserInConversationBody struct {

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

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

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

type IsUserInConversationQuery 

type IsUserInConversationQuery struct{}

type IsUserInConversationReq 

type IsUserInConversationReq struct {
	*IsUserInConversationQuery
	*IsUserInConversationBody
}

type IsUserInConversationRes 

type IsUserInConversationRes struct {

	// REQUIRED
	ResponseMetadata IsUserInConversationResResponseMetadata `json:"ResponseMetadata"`

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

type IsUserInConversationResResponseMetadata 

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 

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 

type IsUserInConversationResResult struct {

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

type ListFriend 

type ListFriend struct{}

type ListFriendBody 

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 

type ListFriendQuery struct{}

type ListFriendReq 

type ListFriendReq struct {
	*ListFriendQuery
	*ListFriendBody
}

type ListFriendRes 

type ListFriendRes struct {

	// REQUIRED
	ResponseMetadata ListFriendResResponseMetadata `json:"ResponseMetadata"`

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

type ListFriendResResponseMetadata 

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 

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"`
}

type ListFriendResResult 

type ListFriendResResult struct {

	// REQUIRED; 好友详细信息
	FriendInfos []ListFriendResResultFriendInfosItem `json:"FriendInfos"`

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

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

	// REQUIRED; 好友总数
	TotalCount int64 `json:"TotalCount"`
}

type ListFriendResResultFriendInfosItem 

type ListFriendResResultFriendInfosItem struct {

	// REQUIRED; 好友备注
	Alias string `json:"Alias"`

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

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

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

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

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

type MarkConversation added in v1.0.143 

type MarkConversation struct{}

type MarkConversationBody added in v1.0.143 

type MarkConversationBody struct {

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

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

	// REQUIRED; 标记类型
	MarkTypes []string `json:"MarkTypes"`

	// 操作类型。默认值为 1。
	// * 1:新增
	// * 2:删除。
	MarkAction *int32 `json:"MarkAction,omitempty"`

	// 操作人UserId
	Operator *int64 `json:"Operator,omitempty"`
}

type MarkConversationQuery added in v1.0.143 

type MarkConversationQuery struct{}

type MarkConversationReq added in v1.0.143 

type MarkConversationReq struct {
	*MarkConversationQuery
	*MarkConversationBody
}

type MarkConversationRes added in v1.0.143 

type MarkConversationRes struct {

	// REQUIRED
	ResponseMetadata MarkConversationResResponseMetadata `json:"ResponseMetadata"`

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

type MarkConversationResResponseMetadata added in v1.0.143 

type MarkConversationResResponseMetadata 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   *MarkConversationResResponseMetadataError `json:"Error,omitempty"`
}

type MarkConversationResResponseMetadataError added in v1.0.143 

type MarkConversationResResponseMetadataError 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 ModifyConversation 

type ModifyConversation struct{}

type ModifyConversationBody 

type ModifyConversationBody struct {

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

	// REQUIRED; 会话信息
	ConversationCoreInfo ModifyConversationBodyConversationCoreInfo `json:"ConversationCoreInfo"`
}

type ModifyConversationBodyConversationCoreInfo 

type ModifyConversationBodyConversationCoreInfo struct {

	// REQUIRED; 需要修改的会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

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

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

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

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

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

	// 会话拥有人 UserId
	OwnerUserID *int64 `json:"OwnerUserId,omitempty"`
}

ModifyConversationBodyConversationCoreInfo - 会话信息

type ModifyConversationQuery 

type ModifyConversationQuery struct{}

type ModifyConversationReq 

type ModifyConversationReq struct {
	*ModifyConversationQuery
	*ModifyConversationBody
}

type ModifyConversationRes 

type ModifyConversationRes struct {

	// REQUIRED
	ResponseMetadata ModifyConversationResResponseMetadata `json:"ResponseMetadata"`

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

type ModifyConversationResResponseMetadata 

type ModifyConversationResResponseMetadata 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   *ModifyConversationResResponseMetadataError `json:"Error,omitempty"`
}

type ModifyConversationResResponseMetadataError 

type ModifyConversationResResponseMetadataError 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 ModifyConversationSetting 

type ModifyConversationSetting struct{}

type ModifyConversationSettingBody 

type ModifyConversationSettingBody struct {

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

	// REQUIRED; 用户会话设置
	ConversationSettingInfo ModifyConversationSettingBodyConversationSettingInfo `json:"ConversationSettingInfo"`
}

type ModifyConversationSettingBodyConversationSettingInfo 

type ModifyConversationSettingBodyConversationSettingInfo struct {

	// REQUIRED; 需要修改的会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 需要修改的会话成员 UserId
	ParticipantUserID int64 `json:"ParticipantUserId"`

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

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

	// 是否需要修改收藏时间
	IsSetFavorite *bool `json:"IsSetFavorite,omitempty"`

	// 是否需要修改置顶时间
	IsStickTop *bool `json:"IsStickTop,omitempty"`

	// 收藏时间戳，单位为毫秒
	SetFavoriteTime *int64 `json:"SetFavoriteTime,omitempty"`

	// 置顶时间戳，单位为毫秒
	StickTopTime *int64 `json:"StickTopTime,omitempty"`
}

ModifyConversationSettingBodyConversationSettingInfo - 用户会话设置

type ModifyConversationSettingQuery 

type ModifyConversationSettingQuery struct{}

type ModifyConversationSettingReq 

type ModifyConversationSettingReq struct {
	*ModifyConversationSettingQuery
	*ModifyConversationSettingBody
}

type ModifyConversationSettingRes 

type ModifyConversationSettingRes struct {

	// REQUIRED
	ResponseMetadata ModifyConversationSettingResResponseMetadata `json:"ResponseMetadata"`

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

type ModifyConversationSettingResResponseMetadata 

type ModifyConversationSettingResResponseMetadata 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   *ModifyConversationSettingResResponseMetadataError `json:"Error,omitempty"`
}

type ModifyConversationSettingResResponseMetadataError 

type ModifyConversationSettingResResponseMetadataError 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 ModifyMessage 

type ModifyMessage struct{}

type ModifyMessageBody 

type ModifyMessageBody struct {

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

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

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

	// 消息内容。修改时Content内容需符合客户端格式，详细信息请参看消息格式 [https://www.volcengine.com/docs/6348/372181#server]。
	Content *string `json:"Content,omitempty"`

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

type ModifyMessageQuery 

type ModifyMessageQuery struct{}

type ModifyMessageReq 

type ModifyMessageReq struct {
	*ModifyMessageQuery
	*ModifyMessageBody
}

type ModifyMessageRes 

type ModifyMessageRes struct {

	// REQUIRED
	ResponseMetadata ModifyMessageResResponseMetadata `json:"ResponseMetadata"`

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

type ModifyMessageResResponseMetadata 

type ModifyMessageResResponseMetadata 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   *ModifyMessageResResponseMetadataError `json:"Error,omitempty"`
}

type ModifyMessageResResponseMetadataError 

type ModifyMessageResResponseMetadataError 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 ModifyParticipantReadIndex 

type ModifyParticipantReadIndex struct{}

type ModifyParticipantReadIndexBody 

type ModifyParticipantReadIndexBody struct {

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

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

	// REQUIRED; 修改成员所属 UserId，UserId 必须大于 0。
	ParticipantUserID int64 `json:"ParticipantUserId"`

	// REQUIRED; 成员已读位置。传入的ReadIndex必须要大于该会话成员目前的ReadIndex。
	ReadIndex int64 `json:"ReadIndex"`
}

type ModifyParticipantReadIndexQuery 

type ModifyParticipantReadIndexQuery struct{}

type ModifyParticipantReadIndexReq 

type ModifyParticipantReadIndexReq struct {
	*ModifyParticipantReadIndexQuery
	*ModifyParticipantReadIndexBody
}

type ModifyParticipantReadIndexRes 

type ModifyParticipantReadIndexRes struct {

	// REQUIRED
	ResponseMetadata ModifyParticipantReadIndexResResponseMetadata `json:"ResponseMetadata"`

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

type ModifyParticipantReadIndexResResponseMetadata 

type ModifyParticipantReadIndexResResponseMetadata 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   *ModifyParticipantReadIndexResResponseMetadataError `json:"Error,omitempty"`
}

type ModifyParticipantReadIndexResResponseMetadataError 

type ModifyParticipantReadIndexResResponseMetadataError 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 QueryLiveParticipantStatus 

type QueryLiveParticipantStatus struct{}

type QueryLiveParticipantStatusBody 

type QueryLiveParticipantStatusBody struct {

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

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

	// REQUIRED; 查询群成员 UserId
	ParticipantUserIDs []int64 `json:"ParticipantUserIds"`
}

type QueryLiveParticipantStatusQuery 

type QueryLiveParticipantStatusQuery struct{}

type QueryLiveParticipantStatusReq 

type QueryLiveParticipantStatusReq struct {
	*QueryLiveParticipantStatusQuery
	*QueryLiveParticipantStatusBody
}

type QueryLiveParticipantStatusRes 

type QueryLiveParticipantStatusRes struct {

	// REQUIRED
	ResponseMetadata QueryLiveParticipantStatusResResponseMetadata `json:"ResponseMetadata"`

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

type QueryLiveParticipantStatusResResponseMetadata 

type QueryLiveParticipantStatusResResponseMetadata 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   *QueryLiveParticipantStatusResResponseMetadataError `json:"Error,omitempty"`
}

type QueryLiveParticipantStatusResResponseMetadataError 

type QueryLiveParticipantStatusResResponseMetadataError 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 QueryLiveParticipantStatusResResult 

type QueryLiveParticipantStatusResResult struct {

	// REQUIRED; 成员在直播群的状态
	Status []QueryLiveParticipantStatusResResultStatusItem `json:"Status"`
}

type QueryLiveParticipantStatusResResultStatusItem 

type QueryLiveParticipantStatusResResultStatusItem struct {

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

	// REQUIRED; 该成员所属会话 ID
	ConversationShortID int64 `json:"ConversationShortId"`

	// REQUIRED; 加群时间，单位为秒
	CreateTime int64 `json:"CreateTime"`

	// REQUIRED; 是否在群中
	IsInConversation bool `json:"IsInConversation"`

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

type QueryOnlineStatus 

type QueryOnlineStatus struct{}

type QueryOnlineStatusBody 

type QueryOnlineStatusBody struct {

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

	// REQUIRED; 查询用户的 UserId。一次最多查询 100 个成员。
	UserIDs []int64 `json:"UserIds"`
}

type QueryOnlineStatusQuery 

type QueryOnlineStatusQuery struct{}

type QueryOnlineStatusReq 

type QueryOnlineStatusReq struct {
	*QueryOnlineStatusQuery
	*QueryOnlineStatusBody
}

type QueryOnlineStatusRes 

type QueryOnlineStatusRes struct {

	// REQUIRED
	ResponseMetadata QueryOnlineStatusResResponseMetadata `json:"ResponseMetadata"`

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

type QueryOnlineStatusResResponseMetadata 

type QueryOnlineStatusResResponseMetadata 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   *QueryOnlineStatusResResponseMetadataError `json:"Error,omitempty"`
}

type QueryOnlineStatusResResponseMetadataError 

type QueryOnlineStatusResResponseMetadataError 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 QueryOnlineStatusResResult 

type QueryOnlineStatusResResult struct {

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

	// REQUIRED; 用户在线状态
	QueryOnlineStatusResults map[string][]QueryOnlineStatusResultItems `json:"QueryOnlineResults"`
}

type QueryOnlineStatusResultItems 

type QueryOnlineStatusResultItems struct {
	ConnID        string `json:"ConnId"`
	UserID        int64  `json:"UserId"`
	DeviceID      int64  `json:"DeviceId"`
	ClientVersion int64  `json:"ClientVersion"`
	Platform      string `json:"Platform"`
}

type RecallMessage 

type RecallMessage struct{}

type RecallMessageBody 

type RecallMessageBody struct {

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

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

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

	// REQUIRED; 撤回消息的会话成员 ID
	ParticipantUserID int64 `json:"ParticipantUserId"`

	// 撤回消息的会话成员角色。
	// * 0：普通会话成员。
	// * 1：群主。
	// * 2：管理员。
	RecallRole *int32 `json:"RecallRole,omitempty"`
}

type RecallMessageQuery 

type RecallMessageQuery struct{}

type RecallMessageReq 

type RecallMessageReq struct {
	*RecallMessageQuery
	*RecallMessageBody
}

type RecallMessageRes 

type RecallMessageRes struct {

	// REQUIRED
	ResponseMetadata RecallMessageResResponseMetadata `json:"ResponseMetadata"`

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

type RecallMessageResResponseMetadata 

type RecallMessageResResponseMetadata 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   *RecallMessageResResponseMetadataError `json:"Error,omitempty"`
}

type RecallMessageResResponseMetadataError 

type RecallMessageResResponseMetadataError 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 RegisterUsers added in v1.0.143 

type RegisterUsers struct{}

type RegisterUsersBody added in v1.0.143 

type RegisterUsersBody struct {

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

	// REQUIRED; 注册用户的信息。一次最多注册 20 个用户。
	Users []RegisterUsersBodyUsersItem `json:"Users"`
}

type RegisterUsersBodyUsersItem added in v1.0.143 

type RegisterUsersBodyUsersItem struct {

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

	// 1. 字段个数不能超过20个；
	// 2. key不能以"s:"开头（im的保留key），长度不能超过50字节
	// 3. value长度不能超过500字节
	Ext map[string]string `json:"Ext,omitempty"`

	// 长度不能超过100字节
	NickName *string `json:"NickName,omitempty"`

	// 长度不能超过500字节
	Portrait *string `json:"Portrait,omitempty"`

	// 用于全员广播
	Tags []string `json:"Tags,omitempty"`
}

type RegisterUsersQuery added in v1.0.143 

type RegisterUsersQuery struct{}

type RegisterUsersReq added in v1.0.143 

type RegisterUsersReq struct {
	*RegisterUsersQuery
	*RegisterUsersBody
}

type RegisterUsersRes added in v1.0.143 

type RegisterUsersRes struct {

	// REQUIRED
	ResponseMetadata RegisterUsersResResponseMetadata `json:"ResponseMetadata"`

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

type RegisterUsersResResponseMetadata added in v1.0.143 

type RegisterUsersResResponseMetadata 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   *RegisterUsersResResponseMetadataError `json:"Error,omitempty"`
}

type RegisterUsersResResponseMetadataError added in v1.0.143 

type RegisterUsersResResponseMetadataError 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 RegisterUsersResResult added in v1.0.143 

type RegisterUsersResResult struct {

	// REQUIRED; 注册失败的用户信息
	FailedInfos []RegisterUsersResResultFailedInfosItem `json:"FailedInfos"`
}

RegisterUsersResResult - 空。此接口无需关注。

type RegisterUsersResResultFailedInfosItem added in v1.0.143 

type RegisterUsersResResultFailedInfosItem struct {

	// REQUIRED; 错误码。参错误码 [412253]
	Code string `json:"Code"`

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

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

type RemoveBlackList 

type RemoveBlackList struct{}

type RemoveBlackListBody 

type RemoveBlackListBody struct {

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

	// REQUIRED; 需要移出黑名单的用户的 ID，一次最多移出 10 个用户
	BlackListUserIDs []int64 `json:"BlackListUserIds"`

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

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

type RemoveBlackListQuery 

type RemoveBlackListQuery struct{}

type RemoveBlackListReq 

type RemoveBlackListReq struct {
	*RemoveBlackListQuery
	*RemoveBlackListBody
}

type RemoveBlackListRes 

type RemoveBlackListRes struct {

	// REQUIRED
	ResponseMetadata RemoveBlackListResResponseMetadata `json:"ResponseMetadata"`

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

type RemoveBlackListResResponseMetadata 

type RemoveBlackListResResponseMetadata 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   *RemoveBlackListResResponseMetadataError `json:"Error,omitempty"`
}

type RemoveBlackListResResponseMetadataError 

type RemoveBlackListResResponseMetadataError 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 ScanConversationParticipantList 

type ScanConversationParticipantList struct{}

type ScanConversationParticipantListBody 

type ScanConversationParticipantListBody struct {

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

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

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

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

	// 标记类型。仅支持查询具有该标记的在线成员。
	MarkType *string `json:"MarkType,omitempty"`

	// 是否只查询群成员 UserId。
	// * true：是。
	// * false：否。
	// 默认值为 false。
	OnlyUserIDs *bool `json:"OnlyUserIds,omitempty"`

	// 按照进群的时间正序或逆序查询。
	// * false：正序。
	// * true：逆序。
	// 默认值为：fasle。
	Reverse *bool `json:"Reverse,omitempty"`

	// 直播群专用字段。是否需要获得直播群在线成员列表。
	// * true：是：拉取直播群在线成员列表（包含群主和管理员，只要在线就会返回，非直播群不会返回任何数据）。
	// * false：否：拉取成员列表（非直播群），拉取群主管理员（直播群）。
	// 默认值为 false。
	// 当此字段设置 true 时，Reverse 和 OnlyUserIds 字段均会失效，该接口按成员进入直播群时间逆序返回在线成员列表。
	ScanOnlineParticipant *bool `json:"ScanOnlineParticipant,omitempty"`
}

type ScanConversationParticipantListQuery 

type ScanConversationParticipantListQuery struct{}

type ScanConversationParticipantListReq 

type ScanConversationParticipantListReq struct {
	*ScanConversationParticipantListQuery
	*ScanConversationParticipantListBody
}

type ScanConversationParticipantListRes 

type ScanConversationParticipantListRes struct {

	// REQUIRED
	ResponseMetadata ScanConversationParticipantListResResponseMetadata `json:"ResponseMetadata"`

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

type ScanConversationParticipantListResResponseMetadata 

type ScanConversationParticipantListResResponseMetadata 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   *ScanConversationParticipantListResResponseMetadataError `json:"Error,omitempty"`
}

type ScanConversationParticipantListResResponseMetadataError 

type ScanConversationParticipantListResResponseMetadataError 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 ScanConversationParticipantListResResult 

type ScanConversationParticipantListResResult struct {

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

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

	// REQUIRED; 群成员详细信息
	Participants []ScanConversationParticipantListResResultParticipantsItem `json:"Participants"`
}

type ScanConversationParticipantListResResultParticipantsItem 

type ScanConversationParticipantListResResultParticipantsItem struct {

	// REQUIRED; 群成员头像
	AvatarURL string `json:"AvatarUrl"`

	// 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"`

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

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

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

type SendMessage 

type SendMessage struct{}

type SendMessageBody 

type SendMessageBody struct {

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

	// REQUIRED; 消息内容。当你给客户端发消息时，Content内容需符合客户端格式，详细信息请参看消息格式 [https://www.volcengine.com/docs/6348/372181#server]。
	Content string `json:"Content"`

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

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

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

	// 幂等id，如果创建时指定了此字段，并且数据库中存在此 id 对应的消息，不会重复发送。如果不指定，会随机生成一个。
	ClientMsgID *string `json:"ClientMsgId,omitempty"`

	// 消息对应时间戳，单位为毫秒。
	CreateTime *int64 `json:"CreateTime,omitempty"`

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

	// 消息不可见会话成员列表。VisibleUsers和InvisibleUsers均为空时，代表对所有人可见。
	InvisibleUsers []*int64 `json:"InvisibleUsers,omitempty"`

	// 会话中@的人
	MentionedUsers []*int64 `json:"MentionedUsers,omitempty"`

	// 消息优先级。
	// * 0：低优先级。
	// * 1：普通优先级。
	// * 2：高优先级。
	// 该字段仅对直播群有效。为避免直播群中消息频率太多导致服务端压力过大，你可以设置消息的优先级。当前直播群下，普通优先级和低优先级消息共用频控阈值为 30 条/秒，超过部分会被服务端直接丢弃。高优消息频控阈值为 10 条/秒，超过部分服务端无法保证不丢失。
	Priority *int32 `json:"Priority,omitempty"`

	// 引用消息。该接口中，该字段只需传入ReferencedMessageId和Hint参数
	RefMsgInfo *SendMessageBodyRefMsgInfo `json:"RefMsgInfo,omitempty"`

	// 消息可见会话成员列表
	VisibleUsers []*int64 `json:"VisibleUsers,omitempty"`
}

type SendMessageBodyRefMsgInfo 

type SendMessageBodyRefMsgInfo struct {

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

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

SendMessageBodyRefMsgInfo - 引用消息

type SendMessageQuery 

type SendMessageQuery struct{}

type SendMessageReq 

type SendMessageReq struct {
	*SendMessageQuery
	*SendMessageBody
}

type SendMessageRes 

type SendMessageRes struct {

	// REQUIRED
	ResponseMetadata SendMessageResResponseMetadata `json:"ResponseMetadata"`

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

type SendMessageResResponseMetadata 

type SendMessageResResponseMetadata 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   *SendMessageResResponseMetadataError `json:"Error,omitempty"`
}

type SendMessageResResponseMetadataError 

type SendMessageResResponseMetadataError 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 SendMessageResResult 

type SendMessageResResult struct {

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

type UnRegisterUsers added in v1.0.143 

type UnRegisterUsers struct{}

type UnRegisterUsersBody added in v1.0.143 

type UnRegisterUsersBody struct {

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

	// REQUIRED; 注销用户 UserId。一次最多注销 10 个用户。
	UserIDs []int64 `json:"UserIds"`
}

type UnRegisterUsersQuery added in v1.0.143 

type UnRegisterUsersQuery struct{}

type UnRegisterUsersReq added in v1.0.143 

type UnRegisterUsersReq struct {
	*UnRegisterUsersQuery
	*UnRegisterUsersBody
}

type UnRegisterUsersRes added in v1.0.143 

type UnRegisterUsersRes struct {

	// REQUIRED
	ResponseMetadata UnRegisterUsersResResponseMetadata `json:"ResponseMetadata"`

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

type UnRegisterUsersResResponseMetadata added in v1.0.143 

type UnRegisterUsersResResponseMetadata 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   *UnRegisterUsersResResponseMetadataError `json:"Error,omitempty"`
}

type UnRegisterUsersResResponseMetadataError added in v1.0.143 

type UnRegisterUsersResResponseMetadataError 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 UnRegisterUsersResResult added in v1.0.143 

type UnRegisterUsersResResult struct {

	// REQUIRED; 注销失败的用户信息
	FailedInfos []UnRegisterUsersResResultFailedInfosItem `json:"FailedInfos"`
}

UnRegisterUsersResResult - 空。此接口无需关注

type UnRegisterUsersResResultFailedInfosItem added in v1.0.143 

type UnRegisterUsersResResultFailedInfosItem 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; 失败的uid
	UserID int64 `json:"UserId"`
}

type UpdateBlackList 

type UpdateBlackList struct{}

type UpdateBlackListBody 

type UpdateBlackListBody struct {

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

	// REQUIRED; 黑名单用户 ID 及需要更新的扩展字段。一次最多更新 10 个黑名单用户的扩展字段。
	BlackListInfos []UpdateBlackListBodyBlackListInfosItem `json:"BlackListInfos"`

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

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

type UpdateBlackListBodyBlackListInfosItem 

type UpdateBlackListBodyBlackListInfosItem struct {

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

	// 黑名单用户的扩展字段，支持新增 key 和更新已有 key。更新已有 key 时，新 value 会覆盖旧 value。
	// 假设 ID 为 10002 的黑名单用户原 ext 为 {"key1":"value1"}，
	// * 若调用本接口通过 BlackListUserExt 传入 {"key1":"value2"}，此时 10002 用户的 ext 将更新为 {"key1":"value2"}；
	// * 若调用本接口通过 BlackListUserExt 传入 {"key2":"value2"}，此时 10002 用户的 ext 将更新为 {"key1":"value1", "key2":"value2"}。
	BlackListUserExt map[string]string `json:"BlackListUserExt,omitempty"`
}

type UpdateBlackListQuery 

type UpdateBlackListQuery struct{}

type UpdateBlackListReq 

type UpdateBlackListReq struct {
	*UpdateBlackListQuery
	*UpdateBlackListBody
}

type UpdateBlackListRes 

type UpdateBlackListRes struct {

	// REQUIRED
	ResponseMetadata UpdateBlackListResResponseMetadata `json:"ResponseMetadata"`

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

type UpdateBlackListResResponseMetadata 

type UpdateBlackListResResponseMetadata 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   *UpdateBlackListResResponseMetadataError `json:"Error,omitempty"`
}

type UpdateBlackListResResponseMetadataError 

type UpdateBlackListResResponseMetadataError 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 UpdateBlackListResResult 

type UpdateBlackListResResult struct {

	// REQUIRED; 更新失败的黑名单用户信息
	FailedInfos []UpdateBlackListResResultFailedInfosItem `json:"FailedInfos"`
}

type UpdateBlackListResResultFailedInfosItem 

type UpdateBlackListResResultFailedInfosItem 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 UpdateFriend added in v1.0.143 

type UpdateFriend struct{}

type UpdateFriendBody 

type UpdateFriendBody struct {

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

	// REQUIRED; 好友信息
	FriendInfos []UpdateFriendBodyFriendInfosItem `json:"FriendInfos"`

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

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

type UpdateFriendBodyFriendInfosItem 

type UpdateFriendBodyFriendInfosItem struct {

	// REQUIRED; 好友扩展字段。Ext与Alias为非必填字段，但是至少需要填一个，否则服务端会报错。
	Ext map[string]string `json:"Ext"`

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

	// 好友备注
	Alias *string `json:"Alias,omitempty"`
}

type UpdateFriendQuery added in v1.0.143 

type UpdateFriendQuery struct{}

type UpdateFriendReq added in v1.0.143 

type UpdateFriendReq struct {
	*UpdateFriendQuery
	*UpdateFriendBody
}

type UpdateFriendRes 

type UpdateFriendRes struct {

	// REQUIRED
	ResponseMetadata UpdateFriendResResponseMetadata `json:"ResponseMetadata"`
	Result           *UpdateFriendResResult          `json:"Result,omitempty"`
}

type UpdateFriendResResponseMetadata 

type UpdateFriendResResponseMetadata 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   *UpdateFriendResResponseMetadataError `json:"Error,omitempty"`
}

type UpdateFriendResResponseMetadataError 

type UpdateFriendResResponseMetadataError 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 UpdateFriendResResult 

type UpdateFriendResResult struct {

	// 更新失败的好友信息
	FailedInfos []UpdateFriendResResultFailedInfos `json:"FailedInfos,omitempty"`
}

type UpdateFriendResResultFailedInfos 

type UpdateFriendResResultFailedInfos 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"`
}

UpdateFriendResResultFailedInfos - 更新失败的好友信息

type UserBroadcast added in v1.0.143 

type UserBroadcast struct{}

type UserBroadcastBody added in v1.0.143 

type UserBroadcastBody struct {

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

	// REQUIRED; 消息内容。关于消息类型和消息内容，参看 消息相关 [https://www.volcengine.com/docs/6348/372181]
	Content string `json:"Content"`

	// REQUIRED; 消息过期时间，单位为秒，范围为[1,604800]
	MsgTTL int64 `json:"MsgTTL"`

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

	// REQUIRED; 发送方
	Sender int64 `json:"Sender"`

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

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

	// 筛选用户时，Tag 匹配关系。 0：或 1：且 默认值为 0。
	TagOp *int32 `json:"TagOp,omitempty"`

	// 筛选标签。不填表示全员广播。
	Tags []string `json:"Tags,omitempty"`
}

type UserBroadcastQuery added in v1.0.143 

type UserBroadcastQuery struct{}

type UserBroadcastReq added in v1.0.143 

type UserBroadcastReq struct {
	*UserBroadcastQuery
	*UserBroadcastBody
}

type UserBroadcastRes added in v1.0.143 

type UserBroadcastRes struct {

	// REQUIRED
	ResponseMetadata UserBroadcastResResponseMetadata `json:"ResponseMetadata"`

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

type UserBroadcastResResponseMetadata added in v1.0.143 

type UserBroadcastResResponseMetadata 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   *UserBroadcastResResponseMetadataError `json:"Error,omitempty"`
}

type UserBroadcastResResponseMetadataError added in v1.0.143 

type UserBroadcastResResponseMetadataError 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"`
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.