3055 lines
90 KiB
Python
3055 lines
90 KiB
Python
# -*- coding: utf-8 -*-
|
|
# This file is auto-generated, don't edit it. Thanks.
|
|
from Tea.model import TeaModel
|
|
from typing import Dict, List, Any
|
|
|
|
|
|
class AddGroupMembersHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
operation_source: str = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.operation_source = operation_source
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.operation_source is not None:
|
|
result['operationSource'] = self.operation_source
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('operationSource') is not None:
|
|
self.operation_source = m.get('operationSource')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class AddGroupMembersRequestMembers(TeaModel):
|
|
def __init__(
|
|
self,
|
|
nick: str = None,
|
|
uid: str = None,
|
|
):
|
|
self.nick = nick
|
|
# This parameter is required.
|
|
self.uid = uid
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.nick is not None:
|
|
result['nick'] = self.nick
|
|
if self.uid is not None:
|
|
result['uid'] = self.uid
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('nick') is not None:
|
|
self.nick = m.get('nick')
|
|
if m.get('uid') is not None:
|
|
self.uid = m.get('uid')
|
|
return self
|
|
|
|
|
|
class AddGroupMembersRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
conversation_id: str = None,
|
|
members: List[AddGroupMembersRequestMembers] = None,
|
|
operator_uid: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.conversation_id = conversation_id
|
|
# This parameter is required.
|
|
self.members = members
|
|
self.operator_uid = operator_uid
|
|
|
|
def validate(self):
|
|
if self.members:
|
|
for k in self.members:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.conversation_id is not None:
|
|
result['conversationId'] = self.conversation_id
|
|
result['members'] = []
|
|
if self.members is not None:
|
|
for k in self.members:
|
|
result['members'].append(k.to_map() if k else None)
|
|
if self.operator_uid is not None:
|
|
result['operatorUid'] = self.operator_uid
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('conversationId') is not None:
|
|
self.conversation_id = m.get('conversationId')
|
|
self.members = []
|
|
if m.get('members') is not None:
|
|
for k in m.get('members'):
|
|
temp_model = AddGroupMembersRequestMembers()
|
|
self.members.append(temp_model.from_map(k))
|
|
if m.get('operatorUid') is not None:
|
|
self.operator_uid = m.get('operatorUid')
|
|
return self
|
|
|
|
|
|
class AddGroupMembersResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
member_uids: List[str] = None,
|
|
):
|
|
# This parameter is required.
|
|
self.member_uids = member_uids
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.member_uids is not None:
|
|
result['memberUids'] = self.member_uids
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('memberUids') is not None:
|
|
self.member_uids = m.get('memberUids')
|
|
return self
|
|
|
|
|
|
class AddGroupMembersResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: AddGroupMembersResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = AddGroupMembersResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class AddProfileHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class AddProfileRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
app_uid: str = None,
|
|
avatar_media_id: str = None,
|
|
mobile_number: str = None,
|
|
nick: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.app_uid = app_uid
|
|
self.avatar_media_id = avatar_media_id
|
|
# This parameter is required.
|
|
self.mobile_number = mobile_number
|
|
# This parameter is required.
|
|
self.nick = nick
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.app_uid is not None:
|
|
result['appUid'] = self.app_uid
|
|
if self.avatar_media_id is not None:
|
|
result['avatarMediaId'] = self.avatar_media_id
|
|
if self.mobile_number is not None:
|
|
result['mobileNumber'] = self.mobile_number
|
|
if self.nick is not None:
|
|
result['nick'] = self.nick
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('appUid') is not None:
|
|
self.app_uid = m.get('appUid')
|
|
if m.get('avatarMediaId') is not None:
|
|
self.avatar_media_id = m.get('avatarMediaId')
|
|
if m.get('mobileNumber') is not None:
|
|
self.mobile_number = m.get('mobileNumber')
|
|
if m.get('nick') is not None:
|
|
self.nick = m.get('nick')
|
|
return self
|
|
|
|
|
|
class AddProfileResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
return self
|
|
|
|
|
|
class BatchSendHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class BatchSendRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
app_uids: List[str] = None,
|
|
content: str = None,
|
|
conversation_ids: List[str] = None,
|
|
user_id: str = None,
|
|
):
|
|
self.app_uids = app_uids
|
|
# This parameter is required.
|
|
self.content = content
|
|
self.conversation_ids = conversation_ids
|
|
# This parameter is required.
|
|
self.user_id = user_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.app_uids is not None:
|
|
result['appUids'] = self.app_uids
|
|
if self.content is not None:
|
|
result['content'] = self.content
|
|
if self.conversation_ids is not None:
|
|
result['conversationIds'] = self.conversation_ids
|
|
if self.user_id is not None:
|
|
result['userId'] = self.user_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('appUids') is not None:
|
|
self.app_uids = m.get('appUids')
|
|
if m.get('content') is not None:
|
|
self.content = m.get('content')
|
|
if m.get('conversationIds') is not None:
|
|
self.conversation_ids = m.get('conversationIds')
|
|
if m.get('userId') is not None:
|
|
self.user_id = m.get('userId')
|
|
return self
|
|
|
|
|
|
class BatchSendResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
task_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.task_id = task_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.task_id is not None:
|
|
result['taskId'] = self.task_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('taskId') is not None:
|
|
self.task_id = m.get('taskId')
|
|
return self
|
|
|
|
|
|
class BatchSendResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: BatchSendResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = BatchSendResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class CreateGroupHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
operation_source: str = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.operation_source = operation_source
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.operation_source is not None:
|
|
result['operationSource'] = self.operation_source
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('operationSource') is not None:
|
|
self.operation_source = m.get('operationSource')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class CreateGroupRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
channel: str = None,
|
|
creator_uid: str = None,
|
|
icon_media_id: str = None,
|
|
name: str = None,
|
|
properties: Dict[str, str] = None,
|
|
uuid: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.channel = channel
|
|
# This parameter is required.
|
|
self.creator_uid = creator_uid
|
|
self.icon_media_id = icon_media_id
|
|
# This parameter is required.
|
|
self.name = name
|
|
# This parameter is required.
|
|
self.properties = properties
|
|
# This parameter is required.
|
|
self.uuid = uuid
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.channel is not None:
|
|
result['channel'] = self.channel
|
|
if self.creator_uid is not None:
|
|
result['creatorUid'] = self.creator_uid
|
|
if self.icon_media_id is not None:
|
|
result['iconMediaId'] = self.icon_media_id
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.properties is not None:
|
|
result['properties'] = self.properties
|
|
if self.uuid is not None:
|
|
result['uuid'] = self.uuid
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('channel') is not None:
|
|
self.channel = m.get('channel')
|
|
if m.get('creatorUid') is not None:
|
|
self.creator_uid = m.get('creatorUid')
|
|
if m.get('iconMediaId') is not None:
|
|
self.icon_media_id = m.get('iconMediaId')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('properties') is not None:
|
|
self.properties = m.get('properties')
|
|
if m.get('uuid') is not None:
|
|
self.uuid = m.get('uuid')
|
|
return self
|
|
|
|
|
|
class CreateGroupResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
chat_id: str = None,
|
|
conversation_id: str = None,
|
|
create_time: int = None,
|
|
):
|
|
# This parameter is required.
|
|
self.chat_id = chat_id
|
|
# This parameter is required.
|
|
self.conversation_id = conversation_id
|
|
# This parameter is required.
|
|
self.create_time = create_time
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.chat_id is not None:
|
|
result['chatId'] = self.chat_id
|
|
if self.conversation_id is not None:
|
|
result['conversationId'] = self.conversation_id
|
|
if self.create_time is not None:
|
|
result['createTime'] = self.create_time
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('chatId') is not None:
|
|
self.chat_id = m.get('chatId')
|
|
if m.get('conversationId') is not None:
|
|
self.conversation_id = m.get('conversationId')
|
|
if m.get('createTime') is not None:
|
|
self.create_time = m.get('createTime')
|
|
return self
|
|
|
|
|
|
class CreateGroupResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: CreateGroupResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = CreateGroupResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class CreateTrustGroupHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
operation_source: str = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.operation_source = operation_source
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.operation_source is not None:
|
|
result['operationSource'] = self.operation_source
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('operationSource') is not None:
|
|
self.operation_source = m.get('operationSource')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class CreateTrustGroupRequestMembers(TeaModel):
|
|
def __init__(
|
|
self,
|
|
nick: str = None,
|
|
uid: str = None,
|
|
):
|
|
self.nick = nick
|
|
self.uid = uid
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.nick is not None:
|
|
result['nick'] = self.nick
|
|
if self.uid is not None:
|
|
result['uid'] = self.uid
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('nick') is not None:
|
|
self.nick = m.get('nick')
|
|
if m.get('uid') is not None:
|
|
self.uid = m.get('uid')
|
|
return self
|
|
|
|
|
|
class CreateTrustGroupRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
channel: str = None,
|
|
icon_media_id: str = None,
|
|
members: List[CreateTrustGroupRequestMembers] = None,
|
|
name: str = None,
|
|
properties: Dict[str, str] = None,
|
|
system_msg: str = None,
|
|
uuid: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.channel = channel
|
|
self.icon_media_id = icon_media_id
|
|
self.members = members
|
|
# This parameter is required.
|
|
self.name = name
|
|
self.properties = properties
|
|
self.system_msg = system_msg
|
|
# This parameter is required.
|
|
self.uuid = uuid
|
|
|
|
def validate(self):
|
|
if self.members:
|
|
for k in self.members:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.channel is not None:
|
|
result['channel'] = self.channel
|
|
if self.icon_media_id is not None:
|
|
result['iconMediaId'] = self.icon_media_id
|
|
result['members'] = []
|
|
if self.members is not None:
|
|
for k in self.members:
|
|
result['members'].append(k.to_map() if k else None)
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.properties is not None:
|
|
result['properties'] = self.properties
|
|
if self.system_msg is not None:
|
|
result['systemMsg'] = self.system_msg
|
|
if self.uuid is not None:
|
|
result['uuid'] = self.uuid
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('channel') is not None:
|
|
self.channel = m.get('channel')
|
|
if m.get('iconMediaId') is not None:
|
|
self.icon_media_id = m.get('iconMediaId')
|
|
self.members = []
|
|
if m.get('members') is not None:
|
|
for k in m.get('members'):
|
|
temp_model = CreateTrustGroupRequestMembers()
|
|
self.members.append(temp_model.from_map(k))
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('properties') is not None:
|
|
self.properties = m.get('properties')
|
|
if m.get('systemMsg') is not None:
|
|
self.system_msg = m.get('systemMsg')
|
|
if m.get('uuid') is not None:
|
|
self.uuid = m.get('uuid')
|
|
return self
|
|
|
|
|
|
class CreateTrustGroupResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
chat_id: str = None,
|
|
create_time: int = None,
|
|
open_conversation_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.chat_id = chat_id
|
|
# This parameter is required.
|
|
self.create_time = create_time
|
|
# This parameter is required.
|
|
self.open_conversation_id = open_conversation_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.chat_id is not None:
|
|
result['chatId'] = self.chat_id
|
|
if self.create_time is not None:
|
|
result['createTime'] = self.create_time
|
|
if self.open_conversation_id is not None:
|
|
result['openConversationId'] = self.open_conversation_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('chatId') is not None:
|
|
self.chat_id = m.get('chatId')
|
|
if m.get('createTime') is not None:
|
|
self.create_time = m.get('createTime')
|
|
if m.get('openConversationId') is not None:
|
|
self.open_conversation_id = m.get('openConversationId')
|
|
return self
|
|
|
|
|
|
class CreateTrustGroupResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: CreateTrustGroupResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = CreateTrustGroupResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class DismissGroupHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
operation_source: str = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.operation_source = operation_source
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.operation_source is not None:
|
|
result['operationSource'] = self.operation_source
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('operationSource') is not None:
|
|
self.operation_source = m.get('operationSource')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class DismissGroupRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
conversation_id: str = None,
|
|
operator_uid: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.conversation_id = conversation_id
|
|
self.operator_uid = operator_uid
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.conversation_id is not None:
|
|
result['conversationId'] = self.conversation_id
|
|
if self.operator_uid is not None:
|
|
result['operatorUid'] = self.operator_uid
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('conversationId') is not None:
|
|
self.conversation_id = m.get('conversationId')
|
|
if m.get('operatorUid') is not None:
|
|
self.operator_uid = m.get('operatorUid')
|
|
return self
|
|
|
|
|
|
class DismissGroupResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
return self
|
|
|
|
|
|
class GetConversationIdHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class GetConversationIdRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
app_uid: str = None,
|
|
user_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.app_uid = app_uid
|
|
# This parameter is required.
|
|
self.user_id = user_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.app_uid is not None:
|
|
result['appUid'] = self.app_uid
|
|
if self.user_id is not None:
|
|
result['userId'] = self.user_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('appUid') is not None:
|
|
self.app_uid = m.get('appUid')
|
|
if m.get('userId') is not None:
|
|
self.user_id = m.get('userId')
|
|
return self
|
|
|
|
|
|
class GetConversationIdResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
conversation_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.conversation_id = conversation_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.conversation_id is not None:
|
|
result['conversationId'] = self.conversation_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('conversationId') is not None:
|
|
self.conversation_id = m.get('conversationId')
|
|
return self
|
|
|
|
|
|
class GetConversationIdResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: GetConversationIdResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = GetConversationIdResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class GetMediaUrlHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class GetMediaUrlRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
media_id: str = None,
|
|
url_expire_time: int = None,
|
|
):
|
|
# This parameter is required.
|
|
self.media_id = media_id
|
|
self.url_expire_time = url_expire_time
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.media_id is not None:
|
|
result['mediaId'] = self.media_id
|
|
if self.url_expire_time is not None:
|
|
result['urlExpireTime'] = self.url_expire_time
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('mediaId') is not None:
|
|
self.media_id = m.get('mediaId')
|
|
if m.get('urlExpireTime') is not None:
|
|
self.url_expire_time = m.get('urlExpireTime')
|
|
return self
|
|
|
|
|
|
class GetMediaUrlResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
url: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.url = url
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.url is not None:
|
|
result['url'] = self.url
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('url') is not None:
|
|
self.url = m.get('url')
|
|
return self
|
|
|
|
|
|
class GetMediaUrlResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: GetMediaUrlResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = GetMediaUrlResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class GetMediaUrlsHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class GetMediaUrlsRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
media_ids: List[str] = None,
|
|
url_expire_time: int = None,
|
|
):
|
|
# This parameter is required.
|
|
self.media_ids = media_ids
|
|
self.url_expire_time = url_expire_time
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.media_ids is not None:
|
|
result['mediaIds'] = self.media_ids
|
|
if self.url_expire_time is not None:
|
|
result['urlExpireTime'] = self.url_expire_time
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('mediaIds') is not None:
|
|
self.media_ids = m.get('mediaIds')
|
|
if m.get('urlExpireTime') is not None:
|
|
self.url_expire_time = m.get('urlExpireTime')
|
|
return self
|
|
|
|
|
|
class GetMediaUrlsResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
urls: Dict[str, Any] = None,
|
|
):
|
|
self.urls = urls
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.urls is not None:
|
|
result['urls'] = self.urls
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('urls') is not None:
|
|
self.urls = m.get('urls')
|
|
return self
|
|
|
|
|
|
class GetMediaUrlsResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: GetMediaUrlsResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = GetMediaUrlsResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class GetSpaceFileUrlHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class GetSpaceFileUrlRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
file_id: str = None,
|
|
sender_uid: str = None,
|
|
space_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.file_id = file_id
|
|
# This parameter is required.
|
|
self.sender_uid = sender_uid
|
|
# This parameter is required.
|
|
self.space_id = space_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.file_id is not None:
|
|
result['fileId'] = self.file_id
|
|
if self.sender_uid is not None:
|
|
result['senderUid'] = self.sender_uid
|
|
if self.space_id is not None:
|
|
result['spaceId'] = self.space_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('fileId') is not None:
|
|
self.file_id = m.get('fileId')
|
|
if m.get('senderUid') is not None:
|
|
self.sender_uid = m.get('senderUid')
|
|
if m.get('spaceId') is not None:
|
|
self.space_id = m.get('spaceId')
|
|
return self
|
|
|
|
|
|
class GetSpaceFileUrlResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, Any] = None,
|
|
internal_resource_url: str = None,
|
|
resource_url: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.headers = headers
|
|
# This parameter is required.
|
|
self.internal_resource_url = internal_resource_url
|
|
# This parameter is required.
|
|
self.resource_url = resource_url
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.internal_resource_url is not None:
|
|
result['internalResourceUrl'] = self.internal_resource_url
|
|
if self.resource_url is not None:
|
|
result['resourceUrl'] = self.resource_url
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('internalResourceUrl') is not None:
|
|
self.internal_resource_url = m.get('internalResourceUrl')
|
|
if m.get('resourceUrl') is not None:
|
|
self.resource_url = m.get('resourceUrl')
|
|
return self
|
|
|
|
|
|
class GetSpaceFileUrlResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: GetSpaceFileUrlResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = GetSpaceFileUrlResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class ListGroupStaffMembersHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class ListGroupStaffMembersRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
conversation_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.conversation_id = conversation_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.conversation_id is not None:
|
|
result['conversationId'] = self.conversation_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('conversationId') is not None:
|
|
self.conversation_id = m.get('conversationId')
|
|
return self
|
|
|
|
|
|
class ListGroupStaffMembersResponseBodyMembers(TeaModel):
|
|
def __init__(
|
|
self,
|
|
nick: str = None,
|
|
uid: str = None,
|
|
):
|
|
self.nick = nick
|
|
# This parameter is required.
|
|
self.uid = uid
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.nick is not None:
|
|
result['nick'] = self.nick
|
|
if self.uid is not None:
|
|
result['uid'] = self.uid
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('nick') is not None:
|
|
self.nick = m.get('nick')
|
|
if m.get('uid') is not None:
|
|
self.uid = m.get('uid')
|
|
return self
|
|
|
|
|
|
class ListGroupStaffMembersResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
members: List[ListGroupStaffMembersResponseBodyMembers] = None,
|
|
):
|
|
# This parameter is required.
|
|
self.members = members
|
|
|
|
def validate(self):
|
|
if self.members:
|
|
for k in self.members:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['members'] = []
|
|
if self.members is not None:
|
|
for k in self.members:
|
|
result['members'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.members = []
|
|
if m.get('members') is not None:
|
|
for k in m.get('members'):
|
|
temp_model = ListGroupStaffMembersResponseBodyMembers()
|
|
self.members.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class ListGroupStaffMembersResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: ListGroupStaffMembersResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = ListGroupStaffMembersResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class QueryBatchSendResultHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class QueryBatchSendResultRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
sender_user_id: str = None,
|
|
task_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.sender_user_id = sender_user_id
|
|
# This parameter is required.
|
|
self.task_id = task_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.sender_user_id is not None:
|
|
result['senderUserId'] = self.sender_user_id
|
|
if self.task_id is not None:
|
|
result['taskId'] = self.task_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('senderUserId') is not None:
|
|
self.sender_user_id = m.get('senderUserId')
|
|
if m.get('taskId') is not None:
|
|
self.task_id = m.get('taskId')
|
|
return self
|
|
|
|
|
|
class QueryBatchSendResultResponseBodyResults(TeaModel):
|
|
def __init__(
|
|
self,
|
|
app_uid: str = None,
|
|
conversation_id: str = None,
|
|
error_code: str = None,
|
|
error_message: str = None,
|
|
msg_id: str = None,
|
|
):
|
|
self.app_uid = app_uid
|
|
self.conversation_id = conversation_id
|
|
self.error_code = error_code
|
|
self.error_message = error_message
|
|
self.msg_id = msg_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.app_uid is not None:
|
|
result['appUid'] = self.app_uid
|
|
if self.conversation_id is not None:
|
|
result['conversationId'] = self.conversation_id
|
|
if self.error_code is not None:
|
|
result['errorCode'] = self.error_code
|
|
if self.error_message is not None:
|
|
result['errorMessage'] = self.error_message
|
|
if self.msg_id is not None:
|
|
result['msgId'] = self.msg_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('appUid') is not None:
|
|
self.app_uid = m.get('appUid')
|
|
if m.get('conversationId') is not None:
|
|
self.conversation_id = m.get('conversationId')
|
|
if m.get('errorCode') is not None:
|
|
self.error_code = m.get('errorCode')
|
|
if m.get('errorMessage') is not None:
|
|
self.error_message = m.get('errorMessage')
|
|
if m.get('msgId') is not None:
|
|
self.msg_id = m.get('msgId')
|
|
return self
|
|
|
|
|
|
class QueryBatchSendResultResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
results: List[QueryBatchSendResultResponseBodyResults] = None,
|
|
status: int = None,
|
|
):
|
|
# This parameter is required.
|
|
self.results = results
|
|
# This parameter is required.
|
|
self.status = status
|
|
|
|
def validate(self):
|
|
if self.results:
|
|
for k in self.results:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['results'] = []
|
|
if self.results is not None:
|
|
for k in self.results:
|
|
result['results'].append(k.to_map() if k else None)
|
|
if self.status is not None:
|
|
result['status'] = self.status
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.results = []
|
|
if m.get('results') is not None:
|
|
for k in m.get('results'):
|
|
temp_model = QueryBatchSendResultResponseBodyResults()
|
|
self.results.append(temp_model.from_map(k))
|
|
if m.get('status') is not None:
|
|
self.status = m.get('status')
|
|
return self
|
|
|
|
|
|
class QueryBatchSendResultResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: QueryBatchSendResultResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = QueryBatchSendResultResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class ReadMessageHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
operation_source: str = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.operation_source = operation_source
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.operation_source is not None:
|
|
result['operationSource'] = self.operation_source
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('operationSource') is not None:
|
|
self.operation_source = m.get('operationSource')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class ReadMessageRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
message_id: str = None,
|
|
operator_uid: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.message_id = message_id
|
|
# This parameter is required.
|
|
self.operator_uid = operator_uid
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.message_id is not None:
|
|
result['messageId'] = self.message_id
|
|
if self.operator_uid is not None:
|
|
result['operatorUid'] = self.operator_uid
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('messageId') is not None:
|
|
self.message_id = m.get('messageId')
|
|
if m.get('operatorUid') is not None:
|
|
self.operator_uid = m.get('operatorUid')
|
|
return self
|
|
|
|
|
|
class ReadMessageResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
return self
|
|
|
|
|
|
class RecallMessageHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
operation_source: str = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.operation_source = operation_source
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.operation_source is not None:
|
|
result['operationSource'] = self.operation_source
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('operationSource') is not None:
|
|
self.operation_source = m.get('operationSource')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class RecallMessageRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
message_id: str = None,
|
|
operator_uid: str = None,
|
|
type: int = None,
|
|
):
|
|
# This parameter is required.
|
|
self.message_id = message_id
|
|
# This parameter is required.
|
|
self.operator_uid = operator_uid
|
|
self.type = type
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.message_id is not None:
|
|
result['messageId'] = self.message_id
|
|
if self.operator_uid is not None:
|
|
result['operatorUid'] = self.operator_uid
|
|
if self.type is not None:
|
|
result['type'] = self.type
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('messageId') is not None:
|
|
self.message_id = m.get('messageId')
|
|
if m.get('operatorUid') is not None:
|
|
self.operator_uid = m.get('operatorUid')
|
|
if m.get('type') is not None:
|
|
self.type = m.get('type')
|
|
return self
|
|
|
|
|
|
class RecallMessageResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
return self
|
|
|
|
|
|
class RemoveGroupMembersHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
operation_source: str = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.operation_source = operation_source
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.operation_source is not None:
|
|
result['operationSource'] = self.operation_source
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('operationSource') is not None:
|
|
self.operation_source = m.get('operationSource')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class RemoveGroupMembersRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
conversation_id: str = None,
|
|
member_uids: List[str] = None,
|
|
operator_uid: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.conversation_id = conversation_id
|
|
# This parameter is required.
|
|
self.member_uids = member_uids
|
|
self.operator_uid = operator_uid
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.conversation_id is not None:
|
|
result['conversationId'] = self.conversation_id
|
|
if self.member_uids is not None:
|
|
result['memberUids'] = self.member_uids
|
|
if self.operator_uid is not None:
|
|
result['operatorUid'] = self.operator_uid
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('conversationId') is not None:
|
|
self.conversation_id = m.get('conversationId')
|
|
if m.get('memberUids') is not None:
|
|
self.member_uids = m.get('memberUids')
|
|
if m.get('operatorUid') is not None:
|
|
self.operator_uid = m.get('operatorUid')
|
|
return self
|
|
|
|
|
|
class RemoveGroupMembersResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
return self
|
|
|
|
|
|
class SendMessageHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
operation_source: str = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.operation_source = operation_source
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.operation_source is not None:
|
|
result['operationSource'] = self.operation_source
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('operationSource') is not None:
|
|
self.operation_source = m.get('operationSource')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class SendMessageRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
content: str = None,
|
|
conversation_id: str = None,
|
|
create_time: int = None,
|
|
receiver_uid: str = None,
|
|
sender_uid: str = None,
|
|
uuid: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.content = content
|
|
self.conversation_id = conversation_id
|
|
self.create_time = create_time
|
|
self.receiver_uid = receiver_uid
|
|
# This parameter is required.
|
|
self.sender_uid = sender_uid
|
|
# This parameter is required.
|
|
self.uuid = uuid
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.content is not None:
|
|
result['content'] = self.content
|
|
if self.conversation_id is not None:
|
|
result['conversationId'] = self.conversation_id
|
|
if self.create_time is not None:
|
|
result['createTime'] = self.create_time
|
|
if self.receiver_uid is not None:
|
|
result['receiverUid'] = self.receiver_uid
|
|
if self.sender_uid is not None:
|
|
result['senderUid'] = self.sender_uid
|
|
if self.uuid is not None:
|
|
result['uuid'] = self.uuid
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('content') is not None:
|
|
self.content = m.get('content')
|
|
if m.get('conversationId') is not None:
|
|
self.conversation_id = m.get('conversationId')
|
|
if m.get('createTime') is not None:
|
|
self.create_time = m.get('createTime')
|
|
if m.get('receiverUid') is not None:
|
|
self.receiver_uid = m.get('receiverUid')
|
|
if m.get('senderUid') is not None:
|
|
self.sender_uid = m.get('senderUid')
|
|
if m.get('uuid') is not None:
|
|
self.uuid = m.get('uuid')
|
|
return self
|
|
|
|
|
|
class SendMessageResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
create_time: int = None,
|
|
message_id: str = None,
|
|
msg_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.create_time = create_time
|
|
# This parameter is required.
|
|
self.message_id = message_id
|
|
# This parameter is required.
|
|
self.msg_id = msg_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.create_time is not None:
|
|
result['createTime'] = self.create_time
|
|
if self.message_id is not None:
|
|
result['messageId'] = self.message_id
|
|
if self.msg_id is not None:
|
|
result['msgId'] = self.msg_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('createTime') is not None:
|
|
self.create_time = m.get('createTime')
|
|
if m.get('messageId') is not None:
|
|
self.message_id = m.get('messageId')
|
|
if m.get('msgId') is not None:
|
|
self.msg_id = m.get('msgId')
|
|
return self
|
|
|
|
|
|
class SendMessageResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: SendMessageResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = SendMessageResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class SendRobotMessageHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class SendRobotMessageRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
at_all: bool = None,
|
|
at_app_uids: List[str] = None,
|
|
at_mobiles: List[str] = None,
|
|
at_union_ids: List[str] = None,
|
|
at_users: List[str] = None,
|
|
channel: str = None,
|
|
msg_media_id_param_map: Dict[str, Any] = None,
|
|
msg_param_map: Dict[str, Any] = None,
|
|
msg_template_id: str = None,
|
|
receiver_app_uids: List[str] = None,
|
|
receiver_mobiles: List[str] = None,
|
|
receiver_union_ids: List[str] = None,
|
|
receiver_user_ids: List[str] = None,
|
|
robot_code: str = None,
|
|
target_open_conversation_id: str = None,
|
|
):
|
|
self.at_all = at_all
|
|
self.at_app_uids = at_app_uids
|
|
self.at_mobiles = at_mobiles
|
|
self.at_union_ids = at_union_ids
|
|
self.at_users = at_users
|
|
self.channel = channel
|
|
self.msg_media_id_param_map = msg_media_id_param_map
|
|
self.msg_param_map = msg_param_map
|
|
self.msg_template_id = msg_template_id
|
|
self.receiver_app_uids = receiver_app_uids
|
|
self.receiver_mobiles = receiver_mobiles
|
|
self.receiver_union_ids = receiver_union_ids
|
|
self.receiver_user_ids = receiver_user_ids
|
|
self.robot_code = robot_code
|
|
self.target_open_conversation_id = target_open_conversation_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.at_all is not None:
|
|
result['atAll'] = self.at_all
|
|
if self.at_app_uids is not None:
|
|
result['atAppUids'] = self.at_app_uids
|
|
if self.at_mobiles is not None:
|
|
result['atMobiles'] = self.at_mobiles
|
|
if self.at_union_ids is not None:
|
|
result['atUnionIds'] = self.at_union_ids
|
|
if self.at_users is not None:
|
|
result['atUsers'] = self.at_users
|
|
if self.channel is not None:
|
|
result['channel'] = self.channel
|
|
if self.msg_media_id_param_map is not None:
|
|
result['msgMediaIdParamMap'] = self.msg_media_id_param_map
|
|
if self.msg_param_map is not None:
|
|
result['msgParamMap'] = self.msg_param_map
|
|
if self.msg_template_id is not None:
|
|
result['msgTemplateId'] = self.msg_template_id
|
|
if self.receiver_app_uids is not None:
|
|
result['receiverAppUids'] = self.receiver_app_uids
|
|
if self.receiver_mobiles is not None:
|
|
result['receiverMobiles'] = self.receiver_mobiles
|
|
if self.receiver_union_ids is not None:
|
|
result['receiverUnionIds'] = self.receiver_union_ids
|
|
if self.receiver_user_ids is not None:
|
|
result['receiverUserIds'] = self.receiver_user_ids
|
|
if self.robot_code is not None:
|
|
result['robotCode'] = self.robot_code
|
|
if self.target_open_conversation_id is not None:
|
|
result['targetOpenConversationId'] = self.target_open_conversation_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('atAll') is not None:
|
|
self.at_all = m.get('atAll')
|
|
if m.get('atAppUids') is not None:
|
|
self.at_app_uids = m.get('atAppUids')
|
|
if m.get('atMobiles') is not None:
|
|
self.at_mobiles = m.get('atMobiles')
|
|
if m.get('atUnionIds') is not None:
|
|
self.at_union_ids = m.get('atUnionIds')
|
|
if m.get('atUsers') is not None:
|
|
self.at_users = m.get('atUsers')
|
|
if m.get('channel') is not None:
|
|
self.channel = m.get('channel')
|
|
if m.get('msgMediaIdParamMap') is not None:
|
|
self.msg_media_id_param_map = m.get('msgMediaIdParamMap')
|
|
if m.get('msgParamMap') is not None:
|
|
self.msg_param_map = m.get('msgParamMap')
|
|
if m.get('msgTemplateId') is not None:
|
|
self.msg_template_id = m.get('msgTemplateId')
|
|
if m.get('receiverAppUids') is not None:
|
|
self.receiver_app_uids = m.get('receiverAppUids')
|
|
if m.get('receiverMobiles') is not None:
|
|
self.receiver_mobiles = m.get('receiverMobiles')
|
|
if m.get('receiverUnionIds') is not None:
|
|
self.receiver_union_ids = m.get('receiverUnionIds')
|
|
if m.get('receiverUserIds') is not None:
|
|
self.receiver_user_ids = m.get('receiverUserIds')
|
|
if m.get('robotCode') is not None:
|
|
self.robot_code = m.get('robotCode')
|
|
if m.get('targetOpenConversationId') is not None:
|
|
self.target_open_conversation_id = m.get('targetOpenConversationId')
|
|
return self
|
|
|
|
|
|
class SendRobotMessageResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
open_msg_id: str = None,
|
|
):
|
|
self.open_msg_id = open_msg_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.open_msg_id is not None:
|
|
result['openMsgId'] = self.open_msg_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('openMsgId') is not None:
|
|
self.open_msg_id = m.get('openMsgId')
|
|
return self
|
|
|
|
|
|
class SendRobotMessageResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: SendRobotMessageResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = SendRobotMessageResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class UpdateGroupNameHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
operation_source: str = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.operation_source = operation_source
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.operation_source is not None:
|
|
result['operationSource'] = self.operation_source
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('operationSource') is not None:
|
|
self.operation_source = m.get('operationSource')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class UpdateGroupNameRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
conversation_id: str = None,
|
|
name: str = None,
|
|
operator_uid: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.conversation_id = conversation_id
|
|
# This parameter is required.
|
|
self.name = name
|
|
self.operator_uid = operator_uid
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.conversation_id is not None:
|
|
result['conversationId'] = self.conversation_id
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.operator_uid is not None:
|
|
result['operatorUid'] = self.operator_uid
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('conversationId') is not None:
|
|
self.conversation_id = m.get('conversationId')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('operatorUid') is not None:
|
|
self.operator_uid = m.get('operatorUid')
|
|
return self
|
|
|
|
|
|
class UpdateGroupNameResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
return self
|
|
|
|
|
|
class UpdateGroupOwnerHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class UpdateGroupOwnerRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
conversation_id: str = None,
|
|
operator_uid: str = None,
|
|
owner_uid: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.conversation_id = conversation_id
|
|
self.operator_uid = operator_uid
|
|
# This parameter is required.
|
|
self.owner_uid = owner_uid
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.conversation_id is not None:
|
|
result['conversationId'] = self.conversation_id
|
|
if self.operator_uid is not None:
|
|
result['operatorUid'] = self.operator_uid
|
|
if self.owner_uid is not None:
|
|
result['ownerUid'] = self.owner_uid
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('conversationId') is not None:
|
|
self.conversation_id = m.get('conversationId')
|
|
if m.get('operatorUid') is not None:
|
|
self.operator_uid = m.get('operatorUid')
|
|
if m.get('ownerUid') is not None:
|
|
self.owner_uid = m.get('ownerUid')
|
|
return self
|
|
|
|
|
|
class UpdateGroupOwnerResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
result: bool = None,
|
|
):
|
|
# This parameter is required.
|
|
self.result = result
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.result is not None:
|
|
result['result'] = self.result
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('result') is not None:
|
|
self.result = m.get('result')
|
|
return self
|
|
|
|
|
|
class UpdateGroupOwnerResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: UpdateGroupOwnerResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = UpdateGroupOwnerResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class UploadFileHeaders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
common_headers: Dict[str, str] = None,
|
|
x_acs_dingtalk_access_token: str = None,
|
|
):
|
|
self.common_headers = common_headers
|
|
self.x_acs_dingtalk_access_token = x_acs_dingtalk_access_token
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.common_headers is not None:
|
|
result['commonHeaders'] = self.common_headers
|
|
if self.x_acs_dingtalk_access_token is not None:
|
|
result['x-acs-dingtalk-access-token'] = self.x_acs_dingtalk_access_token
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('commonHeaders') is not None:
|
|
self.common_headers = m.get('commonHeaders')
|
|
if m.get('x-acs-dingtalk-access-token') is not None:
|
|
self.x_acs_dingtalk_access_token = m.get('x-acs-dingtalk-access-token')
|
|
return self
|
|
|
|
|
|
class UploadFileRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
file_name: str = None,
|
|
file_type: str = None,
|
|
file_url: str = None,
|
|
sender_uid: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.file_name = file_name
|
|
# This parameter is required.
|
|
self.file_type = file_type
|
|
# This parameter is required.
|
|
self.file_url = file_url
|
|
# This parameter is required.
|
|
self.sender_uid = sender_uid
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.file_name is not None:
|
|
result['fileName'] = self.file_name
|
|
if self.file_type is not None:
|
|
result['fileType'] = self.file_type
|
|
if self.file_url is not None:
|
|
result['fileUrl'] = self.file_url
|
|
if self.sender_uid is not None:
|
|
result['senderUid'] = self.sender_uid
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('fileName') is not None:
|
|
self.file_name = m.get('fileName')
|
|
if m.get('fileType') is not None:
|
|
self.file_type = m.get('fileType')
|
|
if m.get('fileUrl') is not None:
|
|
self.file_url = m.get('fileUrl')
|
|
if m.get('senderUid') is not None:
|
|
self.sender_uid = m.get('senderUid')
|
|
return self
|
|
|
|
|
|
class UploadFileResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
media_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.media_id = media_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.media_id is not None:
|
|
result['mediaId'] = self.media_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('mediaId') is not None:
|
|
self.media_id = m.get('mediaId')
|
|
return self
|
|
|
|
|
|
class UploadFileResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: UploadFileResponseBody = None,
|
|
):
|
|
self.headers = headers
|
|
self.status_code = status_code
|
|
self.body = body
|
|
|
|
def validate(self):
|
|
if self.body:
|
|
self.body.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.headers is not None:
|
|
result['headers'] = self.headers
|
|
if self.status_code is not None:
|
|
result['statusCode'] = self.status_code
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('headers') is not None:
|
|
self.headers = m.get('headers')
|
|
if m.get('statusCode') is not None:
|
|
self.status_code = m.get('statusCode')
|
|
if m.get('body') is not None:
|
|
temp_model = UploadFileResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|