2195 lines
66 KiB
Python
2195 lines
66 KiB
Python
# -*- coding: utf-8 -*-
|
|
# This file is auto-generated, don't edit it. Thanks.
|
|
from Tea.model import TeaModel
|
|
from typing import BinaryIO, List, Dict, Any
|
|
|
|
|
|
class DraftMessageBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
body_html: BinaryIO = None,
|
|
body_text: BinaryIO = None,
|
|
):
|
|
# This parameter is required.
|
|
self.body_html = body_html
|
|
# This parameter is required.
|
|
self.body_text = body_text
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.body_html is not None:
|
|
result['bodyHtml'] = self.body_html
|
|
if self.body_text is not None:
|
|
result['bodyText'] = self.body_text
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('bodyHtml') is not None:
|
|
self.body_html = m.get('bodyHtml')
|
|
if m.get('bodyText') is not None:
|
|
self.body_text = m.get('bodyText')
|
|
return self
|
|
|
|
|
|
class Recipient(TeaModel):
|
|
def __init__(
|
|
self,
|
|
email: BinaryIO = None,
|
|
name: BinaryIO = None,
|
|
):
|
|
self.email = email
|
|
self.name = name
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.email is not None:
|
|
result['email'] = self.email
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('email') is not None:
|
|
self.email = m.get('email')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
return self
|
|
|
|
|
|
class DraftMessage(TeaModel):
|
|
def __init__(
|
|
self,
|
|
bcc_recipients: List[Recipient] = None,
|
|
body: DraftMessageBody = None,
|
|
cc_recipients: List[Recipient] = None,
|
|
from_: Recipient = None,
|
|
internet_message_headers: Dict[str, Any] = None,
|
|
internet_message_id: BinaryIO = None,
|
|
is_read_receipt_requested: bool = None,
|
|
priority: BinaryIO = None,
|
|
reply_to: Recipient = None,
|
|
subject: BinaryIO = None,
|
|
summary: BinaryIO = None,
|
|
tags: List[BinaryIO] = None,
|
|
to_recipients: List[Recipient] = None,
|
|
):
|
|
# This parameter is required.
|
|
self.bcc_recipients = bcc_recipients
|
|
# This parameter is required.
|
|
self.body = body
|
|
# This parameter is required.
|
|
self.cc_recipients = cc_recipients
|
|
# This parameter is required.
|
|
self.from_ = from_
|
|
# This parameter is required.
|
|
self.internet_message_headers = internet_message_headers
|
|
# This parameter is required.
|
|
self.internet_message_id = internet_message_id
|
|
# This parameter is required.
|
|
self.is_read_receipt_requested = is_read_receipt_requested
|
|
# This parameter is required.
|
|
self.priority = priority
|
|
# This parameter is required.
|
|
self.reply_to = reply_to
|
|
# This parameter is required.
|
|
self.subject = subject
|
|
# This parameter is required.
|
|
self.summary = summary
|
|
# This parameter is required.
|
|
self.tags = tags
|
|
# This parameter is required.
|
|
self.to_recipients = to_recipients
|
|
|
|
def validate(self):
|
|
if self.bcc_recipients:
|
|
for k in self.bcc_recipients:
|
|
if k:
|
|
k.validate()
|
|
if self.body:
|
|
self.body.validate()
|
|
if self.cc_recipients:
|
|
for k in self.cc_recipients:
|
|
if k:
|
|
k.validate()
|
|
if self.from_:
|
|
self.from_.validate()
|
|
if self.reply_to:
|
|
self.reply_to.validate()
|
|
if self.to_recipients:
|
|
for k in self.to_recipients:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['bccRecipients'] = []
|
|
if self.bcc_recipients is not None:
|
|
for k in self.bcc_recipients:
|
|
result['bccRecipients'].append(k.to_map() if k else None)
|
|
if self.body is not None:
|
|
result['body'] = self.body.to_map()
|
|
result['ccRecipients'] = []
|
|
if self.cc_recipients is not None:
|
|
for k in self.cc_recipients:
|
|
result['ccRecipients'].append(k.to_map() if k else None)
|
|
if self.from_ is not None:
|
|
result['from'] = self.from_.to_map()
|
|
if self.internet_message_headers is not None:
|
|
result['internetMessageHeaders'] = self.internet_message_headers
|
|
if self.internet_message_id is not None:
|
|
result['internetMessageId'] = self.internet_message_id
|
|
if self.is_read_receipt_requested is not None:
|
|
result['isReadReceiptRequested'] = self.is_read_receipt_requested
|
|
if self.priority is not None:
|
|
result['priority'] = self.priority
|
|
if self.reply_to is not None:
|
|
result['replyTo'] = self.reply_to.to_map()
|
|
if self.subject is not None:
|
|
result['subject'] = self.subject
|
|
if self.summary is not None:
|
|
result['summary'] = self.summary
|
|
if self.tags is not None:
|
|
result['tags'] = self.tags
|
|
result['toRecipients'] = []
|
|
if self.to_recipients is not None:
|
|
for k in self.to_recipients:
|
|
result['toRecipients'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.bcc_recipients = []
|
|
if m.get('bccRecipients') is not None:
|
|
for k in m.get('bccRecipients'):
|
|
temp_model = Recipient()
|
|
self.bcc_recipients.append(temp_model.from_map(k))
|
|
if m.get('body') is not None:
|
|
temp_model = DraftMessageBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
self.cc_recipients = []
|
|
if m.get('ccRecipients') is not None:
|
|
for k in m.get('ccRecipients'):
|
|
temp_model = Recipient()
|
|
self.cc_recipients.append(temp_model.from_map(k))
|
|
if m.get('from') is not None:
|
|
temp_model = Recipient()
|
|
self.from_ = temp_model.from_map(m['from'])
|
|
if m.get('internetMessageHeaders') is not None:
|
|
self.internet_message_headers = m.get('internetMessageHeaders')
|
|
if m.get('internetMessageId') is not None:
|
|
self.internet_message_id = m.get('internetMessageId')
|
|
if m.get('isReadReceiptRequested') is not None:
|
|
self.is_read_receipt_requested = m.get('isReadReceiptRequested')
|
|
if m.get('priority') is not None:
|
|
self.priority = m.get('priority')
|
|
if m.get('replyTo') is not None:
|
|
temp_model = Recipient()
|
|
self.reply_to = temp_model.from_map(m['replyTo'])
|
|
if m.get('subject') is not None:
|
|
self.subject = m.get('subject')
|
|
if m.get('summary') is not None:
|
|
self.summary = m.get('summary')
|
|
if m.get('tags') is not None:
|
|
self.tags = m.get('tags')
|
|
self.to_recipients = []
|
|
if m.get('toRecipients') is not None:
|
|
for k in m.get('toRecipients'):
|
|
temp_model = Recipient()
|
|
self.to_recipients.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class Message(TeaModel):
|
|
def __init__(
|
|
self,
|
|
bcc_recipients: List[Recipient] = None,
|
|
cc_recipients: List[Recipient] = None,
|
|
conversation_id: BinaryIO = None,
|
|
folder_id: BinaryIO = None,
|
|
from_: Recipient = None,
|
|
has_attachments: bool = None,
|
|
id: BinaryIO = None,
|
|
internet_message_headers: Dict[str, Any] = None,
|
|
internet_message_id: BinaryIO = None,
|
|
is_forwarded: bool = None,
|
|
is_read: bool = None,
|
|
is_read_receipt_requested: bool = None,
|
|
is_replied: bool = None,
|
|
last_modified_date_time: BinaryIO = None,
|
|
priority: BinaryIO = None,
|
|
received_date_time: BinaryIO = None,
|
|
reply_to: Recipient = None,
|
|
sent_date_time: BinaryIO = None,
|
|
subject: BinaryIO = None,
|
|
summary: BinaryIO = None,
|
|
tags: List[str] = None,
|
|
to_recipients: List[Recipient] = None,
|
|
):
|
|
# This parameter is required.
|
|
self.bcc_recipients = bcc_recipients
|
|
# This parameter is required.
|
|
self.cc_recipients = cc_recipients
|
|
# This parameter is required.
|
|
self.conversation_id = conversation_id
|
|
# This parameter is required.
|
|
self.folder_id = folder_id
|
|
# This parameter is required.
|
|
self.from_ = from_
|
|
# This parameter is required.
|
|
self.has_attachments = has_attachments
|
|
# This parameter is required.
|
|
self.id = id
|
|
# This parameter is required.
|
|
self.internet_message_headers = internet_message_headers
|
|
# This parameter is required.
|
|
self.internet_message_id = internet_message_id
|
|
# This parameter is required.
|
|
self.is_forwarded = is_forwarded
|
|
# This parameter is required.
|
|
self.is_read = is_read
|
|
# This parameter is required.
|
|
self.is_read_receipt_requested = is_read_receipt_requested
|
|
# This parameter is required.
|
|
self.is_replied = is_replied
|
|
# This parameter is required.
|
|
self.last_modified_date_time = last_modified_date_time
|
|
# This parameter is required.
|
|
self.priority = priority
|
|
# This parameter is required.
|
|
self.received_date_time = received_date_time
|
|
# This parameter is required.
|
|
self.reply_to = reply_to
|
|
# This parameter is required.
|
|
self.sent_date_time = sent_date_time
|
|
# This parameter is required.
|
|
self.subject = subject
|
|
# This parameter is required.
|
|
self.summary = summary
|
|
# This parameter is required.
|
|
self.tags = tags
|
|
# This parameter is required.
|
|
self.to_recipients = to_recipients
|
|
|
|
def validate(self):
|
|
if self.bcc_recipients:
|
|
for k in self.bcc_recipients:
|
|
if k:
|
|
k.validate()
|
|
if self.cc_recipients:
|
|
for k in self.cc_recipients:
|
|
if k:
|
|
k.validate()
|
|
if self.from_:
|
|
self.from_.validate()
|
|
if self.reply_to:
|
|
self.reply_to.validate()
|
|
if self.to_recipients:
|
|
for k in self.to_recipients:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['bccRecipients'] = []
|
|
if self.bcc_recipients is not None:
|
|
for k in self.bcc_recipients:
|
|
result['bccRecipients'].append(k.to_map() if k else None)
|
|
result['ccRecipients'] = []
|
|
if self.cc_recipients is not None:
|
|
for k in self.cc_recipients:
|
|
result['ccRecipients'].append(k.to_map() if k else None)
|
|
if self.conversation_id is not None:
|
|
result['conversationId'] = self.conversation_id
|
|
if self.folder_id is not None:
|
|
result['folderId'] = self.folder_id
|
|
if self.from_ is not None:
|
|
result['from'] = self.from_.to_map()
|
|
if self.has_attachments is not None:
|
|
result['hasAttachments'] = self.has_attachments
|
|
if self.id is not None:
|
|
result['id'] = self.id
|
|
if self.internet_message_headers is not None:
|
|
result['internetMessageHeaders'] = self.internet_message_headers
|
|
if self.internet_message_id is not None:
|
|
result['internetMessageId'] = self.internet_message_id
|
|
if self.is_forwarded is not None:
|
|
result['isForwarded'] = self.is_forwarded
|
|
if self.is_read is not None:
|
|
result['isRead'] = self.is_read
|
|
if self.is_read_receipt_requested is not None:
|
|
result['isReadReceiptRequested'] = self.is_read_receipt_requested
|
|
if self.is_replied is not None:
|
|
result['isReplied'] = self.is_replied
|
|
if self.last_modified_date_time is not None:
|
|
result['lastModifiedDateTime'] = self.last_modified_date_time
|
|
if self.priority is not None:
|
|
result['priority'] = self.priority
|
|
if self.received_date_time is not None:
|
|
result['receivedDateTime'] = self.received_date_time
|
|
if self.reply_to is not None:
|
|
result['replyTo'] = self.reply_to.to_map()
|
|
if self.sent_date_time is not None:
|
|
result['sentDateTime'] = self.sent_date_time
|
|
if self.subject is not None:
|
|
result['subject'] = self.subject
|
|
if self.summary is not None:
|
|
result['summary'] = self.summary
|
|
if self.tags is not None:
|
|
result['tags'] = self.tags
|
|
result['toRecipients'] = []
|
|
if self.to_recipients is not None:
|
|
for k in self.to_recipients:
|
|
result['toRecipients'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.bcc_recipients = []
|
|
if m.get('bccRecipients') is not None:
|
|
for k in m.get('bccRecipients'):
|
|
temp_model = Recipient()
|
|
self.bcc_recipients.append(temp_model.from_map(k))
|
|
self.cc_recipients = []
|
|
if m.get('ccRecipients') is not None:
|
|
for k in m.get('ccRecipients'):
|
|
temp_model = Recipient()
|
|
self.cc_recipients.append(temp_model.from_map(k))
|
|
if m.get('conversationId') is not None:
|
|
self.conversation_id = m.get('conversationId')
|
|
if m.get('folderId') is not None:
|
|
self.folder_id = m.get('folderId')
|
|
if m.get('from') is not None:
|
|
temp_model = Recipient()
|
|
self.from_ = temp_model.from_map(m['from'])
|
|
if m.get('hasAttachments') is not None:
|
|
self.has_attachments = m.get('hasAttachments')
|
|
if m.get('id') is not None:
|
|
self.id = m.get('id')
|
|
if m.get('internetMessageHeaders') is not None:
|
|
self.internet_message_headers = m.get('internetMessageHeaders')
|
|
if m.get('internetMessageId') is not None:
|
|
self.internet_message_id = m.get('internetMessageId')
|
|
if m.get('isForwarded') is not None:
|
|
self.is_forwarded = m.get('isForwarded')
|
|
if m.get('isRead') is not None:
|
|
self.is_read = m.get('isRead')
|
|
if m.get('isReadReceiptRequested') is not None:
|
|
self.is_read_receipt_requested = m.get('isReadReceiptRequested')
|
|
if m.get('isReplied') is not None:
|
|
self.is_replied = m.get('isReplied')
|
|
if m.get('lastModifiedDateTime') is not None:
|
|
self.last_modified_date_time = m.get('lastModifiedDateTime')
|
|
if m.get('priority') is not None:
|
|
self.priority = m.get('priority')
|
|
if m.get('receivedDateTime') is not None:
|
|
self.received_date_time = m.get('receivedDateTime')
|
|
if m.get('replyTo') is not None:
|
|
temp_model = Recipient()
|
|
self.reply_to = temp_model.from_map(m['replyTo'])
|
|
if m.get('sentDateTime') is not None:
|
|
self.sent_date_time = m.get('sentDateTime')
|
|
if m.get('subject') is not None:
|
|
self.subject = m.get('subject')
|
|
if m.get('summary') is not None:
|
|
self.summary = m.get('summary')
|
|
if m.get('tags') is not None:
|
|
self.tags = m.get('tags')
|
|
self.to_recipients = []
|
|
if m.get('toRecipients') is not None:
|
|
for k in m.get('toRecipients'):
|
|
temp_model = Recipient()
|
|
self.to_recipients.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class CreateMailFolderHeaders(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 CreateMailFolderRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
display_name: str = None,
|
|
extensions: Dict[str, Any] = None,
|
|
foler_id: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.display_name = display_name
|
|
self.extensions = extensions
|
|
self.foler_id = foler_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.display_name is not None:
|
|
result['displayName'] = self.display_name
|
|
if self.extensions is not None:
|
|
result['extensions'] = self.extensions
|
|
if self.foler_id is not None:
|
|
result['folerId'] = self.foler_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('displayName') is not None:
|
|
self.display_name = m.get('displayName')
|
|
if m.get('extensions') is not None:
|
|
self.extensions = m.get('extensions')
|
|
if m.get('folerId') is not None:
|
|
self.foler_id = m.get('folerId')
|
|
return self
|
|
|
|
|
|
class CreateMailFolderResponseBodyFolder(TeaModel):
|
|
def __init__(
|
|
self,
|
|
child_folder_count: int = None,
|
|
display_name: str = None,
|
|
extensions: Dict[str, Any] = None,
|
|
id: str = None,
|
|
parent_folder_id: str = None,
|
|
total_item_count: int = None,
|
|
unread_item_count: int = None,
|
|
):
|
|
self.child_folder_count = child_folder_count
|
|
self.display_name = display_name
|
|
self.extensions = extensions
|
|
self.id = id
|
|
self.parent_folder_id = parent_folder_id
|
|
self.total_item_count = total_item_count
|
|
self.unread_item_count = unread_item_count
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.child_folder_count is not None:
|
|
result['childFolderCount'] = self.child_folder_count
|
|
if self.display_name is not None:
|
|
result['displayName'] = self.display_name
|
|
if self.extensions is not None:
|
|
result['extensions'] = self.extensions
|
|
if self.id is not None:
|
|
result['id'] = self.id
|
|
if self.parent_folder_id is not None:
|
|
result['parentFolderId'] = self.parent_folder_id
|
|
if self.total_item_count is not None:
|
|
result['totalItemCount'] = self.total_item_count
|
|
if self.unread_item_count is not None:
|
|
result['unreadItemCount'] = self.unread_item_count
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('childFolderCount') is not None:
|
|
self.child_folder_count = m.get('childFolderCount')
|
|
if m.get('displayName') is not None:
|
|
self.display_name = m.get('displayName')
|
|
if m.get('extensions') is not None:
|
|
self.extensions = m.get('extensions')
|
|
if m.get('id') is not None:
|
|
self.id = m.get('id')
|
|
if m.get('parentFolderId') is not None:
|
|
self.parent_folder_id = m.get('parentFolderId')
|
|
if m.get('totalItemCount') is not None:
|
|
self.total_item_count = m.get('totalItemCount')
|
|
if m.get('unreadItemCount') is not None:
|
|
self.unread_item_count = m.get('unreadItemCount')
|
|
return self
|
|
|
|
|
|
class CreateMailFolderResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
folder: CreateMailFolderResponseBodyFolder = None,
|
|
request_id: str = None,
|
|
):
|
|
self.folder = folder
|
|
self.request_id = request_id
|
|
|
|
def validate(self):
|
|
if self.folder:
|
|
self.folder.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.folder is not None:
|
|
result['folder'] = self.folder.to_map()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('folder') is not None:
|
|
temp_model = CreateMailFolderResponseBodyFolder()
|
|
self.folder = temp_model.from_map(m['folder'])
|
|
if m.get('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
return self
|
|
|
|
|
|
class CreateMailFolderResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: CreateMailFolderResponseBody = 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 = CreateMailFolderResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class CreateMessageHeaders(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 CreateMessageRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
message: DraftMessage = None,
|
|
):
|
|
self.message = message
|
|
|
|
def validate(self):
|
|
if self.message:
|
|
self.message.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.message is not None:
|
|
result['message'] = self.message.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('message') is not None:
|
|
temp_model = DraftMessage()
|
|
self.message = temp_model.from_map(m['message'])
|
|
return self
|
|
|
|
|
|
class CreateMessageResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
message: Message = None,
|
|
request_id: str = None,
|
|
):
|
|
self.message = message
|
|
self.request_id = request_id
|
|
|
|
def validate(self):
|
|
if self.message:
|
|
self.message.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.message is not None:
|
|
result['message'] = self.message.to_map()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('message') is not None:
|
|
temp_model = Message()
|
|
self.message = temp_model.from_map(m['message'])
|
|
if m.get('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
return self
|
|
|
|
|
|
class CreateMessageResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: CreateMessageResponseBody = 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 = CreateMessageResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class CreateUserHeaders(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 CreateUserRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
email: str = None,
|
|
employee_type: str = None,
|
|
name: str = None,
|
|
password: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.email = email
|
|
# This parameter is required.
|
|
self.employee_type = employee_type
|
|
# This parameter is required.
|
|
self.name = name
|
|
# This parameter is required.
|
|
self.password = password
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.email is not None:
|
|
result['email'] = self.email
|
|
if self.employee_type is not None:
|
|
result['employeeType'] = self.employee_type
|
|
if self.name is not None:
|
|
result['name'] = self.name
|
|
if self.password is not None:
|
|
result['password'] = self.password
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('email') is not None:
|
|
self.email = m.get('email')
|
|
if m.get('employeeType') is not None:
|
|
self.employee_type = m.get('employeeType')
|
|
if m.get('name') is not None:
|
|
self.name = m.get('name')
|
|
if m.get('password') is not None:
|
|
self.password = m.get('password')
|
|
return self
|
|
|
|
|
|
class CreateUserResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
email: str = None,
|
|
):
|
|
self.email = email
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.email is not None:
|
|
result['email'] = self.email
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('email') is not None:
|
|
self.email = m.get('email')
|
|
return self
|
|
|
|
|
|
class CreateUserResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: CreateUserResponseBody = 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 = CreateUserResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class DeleteMailFolderHeaders(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 DeleteMailFolderResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
):
|
|
self.request_id = request_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
return self
|
|
|
|
|
|
class DeleteMailFolderResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: DeleteMailFolderResponseBody = 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 = DeleteMailFolderResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class DeleteMessagesHeaders(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 DeleteMessagesRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
delete_type: str = None,
|
|
ids: List[str] = None,
|
|
):
|
|
self.delete_type = delete_type
|
|
# This parameter is required.
|
|
self.ids = ids
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.delete_type is not None:
|
|
result['deleteType'] = self.delete_type
|
|
if self.ids is not None:
|
|
result['ids'] = self.ids
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('deleteType') is not None:
|
|
self.delete_type = m.get('deleteType')
|
|
if m.get('ids') is not None:
|
|
self.ids = m.get('ids')
|
|
return self
|
|
|
|
|
|
class DeleteMessagesResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
):
|
|
self.request_id = request_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
return self
|
|
|
|
|
|
class DeleteMessagesResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: DeleteMessagesResponseBody = 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 = DeleteMessagesResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class GetMessageHeaders(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 GetMessageRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
select_fields: str = None,
|
|
):
|
|
self.select_fields = select_fields
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.select_fields is not None:
|
|
result['selectFields'] = self.select_fields
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('selectFields') is not None:
|
|
self.select_fields = m.get('selectFields')
|
|
return self
|
|
|
|
|
|
class GetMessageResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
message: Message = None,
|
|
request_id: str = None,
|
|
):
|
|
self.message = message
|
|
self.request_id = request_id
|
|
|
|
def validate(self):
|
|
if self.message:
|
|
self.message.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.message is not None:
|
|
result['message'] = self.message.to_map()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('message') is not None:
|
|
temp_model = Message()
|
|
self.message = temp_model.from_map(m['message'])
|
|
if m.get('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
return self
|
|
|
|
|
|
class GetMessageResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: GetMessageResponseBody = 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 = GetMessageResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class ListMailFoldersHeaders(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 ListMailFoldersRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
folder_id: str = None,
|
|
):
|
|
self.folder_id = folder_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.folder_id is not None:
|
|
result['folderId'] = self.folder_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('folderId') is not None:
|
|
self.folder_id = m.get('folderId')
|
|
return self
|
|
|
|
|
|
class ListMailFoldersResponseBodyFolders(TeaModel):
|
|
def __init__(
|
|
self,
|
|
child_folder_count: int = None,
|
|
display_name: str = None,
|
|
extensions: Dict[str, str] = None,
|
|
id: str = None,
|
|
parent_folder_id: str = None,
|
|
total_item_count: int = None,
|
|
unread_item_count: int = None,
|
|
):
|
|
# This parameter is required.
|
|
self.child_folder_count = child_folder_count
|
|
# This parameter is required.
|
|
self.display_name = display_name
|
|
self.extensions = extensions
|
|
# This parameter is required.
|
|
self.id = id
|
|
# This parameter is required.
|
|
self.parent_folder_id = parent_folder_id
|
|
# This parameter is required.
|
|
self.total_item_count = total_item_count
|
|
# This parameter is required.
|
|
self.unread_item_count = unread_item_count
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.child_folder_count is not None:
|
|
result['childFolderCount'] = self.child_folder_count
|
|
if self.display_name is not None:
|
|
result['displayName'] = self.display_name
|
|
if self.extensions is not None:
|
|
result['extensions'] = self.extensions
|
|
if self.id is not None:
|
|
result['id'] = self.id
|
|
if self.parent_folder_id is not None:
|
|
result['parentFolderId'] = self.parent_folder_id
|
|
if self.total_item_count is not None:
|
|
result['totalItemCount'] = self.total_item_count
|
|
if self.unread_item_count is not None:
|
|
result['unreadItemCount'] = self.unread_item_count
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('childFolderCount') is not None:
|
|
self.child_folder_count = m.get('childFolderCount')
|
|
if m.get('displayName') is not None:
|
|
self.display_name = m.get('displayName')
|
|
if m.get('extensions') is not None:
|
|
self.extensions = m.get('extensions')
|
|
if m.get('id') is not None:
|
|
self.id = m.get('id')
|
|
if m.get('parentFolderId') is not None:
|
|
self.parent_folder_id = m.get('parentFolderId')
|
|
if m.get('totalItemCount') is not None:
|
|
self.total_item_count = m.get('totalItemCount')
|
|
if m.get('unreadItemCount') is not None:
|
|
self.unread_item_count = m.get('unreadItemCount')
|
|
return self
|
|
|
|
|
|
class ListMailFoldersResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
folders: List[ListMailFoldersResponseBodyFolders] = None,
|
|
):
|
|
self.folders = folders
|
|
|
|
def validate(self):
|
|
if self.folders:
|
|
for k in self.folders:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
result['folders'] = []
|
|
if self.folders is not None:
|
|
for k in self.folders:
|
|
result['folders'].append(k.to_map() if k else None)
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
self.folders = []
|
|
if m.get('folders') is not None:
|
|
for k in m.get('folders'):
|
|
temp_model = ListMailFoldersResponseBodyFolders()
|
|
self.folders.append(temp_model.from_map(k))
|
|
return self
|
|
|
|
|
|
class ListMailFoldersResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: ListMailFoldersResponseBody = 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 = ListMailFoldersResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class ListMessagesHeaders(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 ListMessagesRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
max_results: int = None,
|
|
next_token: str = None,
|
|
select_fields: str = None,
|
|
):
|
|
# This parameter is required.
|
|
self.max_results = max_results
|
|
self.next_token = next_token
|
|
self.select_fields = select_fields
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.max_results is not None:
|
|
result['maxResults'] = self.max_results
|
|
if self.next_token is not None:
|
|
result['nextToken'] = self.next_token
|
|
if self.select_fields is not None:
|
|
result['selectFields'] = self.select_fields
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('maxResults') is not None:
|
|
self.max_results = m.get('maxResults')
|
|
if m.get('nextToken') is not None:
|
|
self.next_token = m.get('nextToken')
|
|
if m.get('selectFields') is not None:
|
|
self.select_fields = m.get('selectFields')
|
|
return self
|
|
|
|
|
|
class ListMessagesResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
has_more: bool = None,
|
|
messages: List[Message] = None,
|
|
next_token: str = None,
|
|
request_id: str = None,
|
|
):
|
|
self.has_more = has_more
|
|
self.messages = messages
|
|
self.next_token = next_token
|
|
self.request_id = request_id
|
|
|
|
def validate(self):
|
|
if self.messages:
|
|
for k in self.messages:
|
|
if k:
|
|
k.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.has_more is not None:
|
|
result['hasMore'] = self.has_more
|
|
result['messages'] = []
|
|
if self.messages is not None:
|
|
for k in self.messages:
|
|
result['messages'].append(k.to_map() if k else None)
|
|
if self.next_token is not None:
|
|
result['nextToken'] = self.next_token
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('hasMore') is not None:
|
|
self.has_more = m.get('hasMore')
|
|
self.messages = []
|
|
if m.get('messages') is not None:
|
|
for k in m.get('messages'):
|
|
temp_model = Message()
|
|
self.messages.append(temp_model.from_map(k))
|
|
if m.get('nextToken') is not None:
|
|
self.next_token = m.get('nextToken')
|
|
if m.get('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
return self
|
|
|
|
|
|
class ListMessagesResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: ListMessagesResponseBody = 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 = ListMessagesResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class MoveMailFolderHeaders(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 MoveMailFolderRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
destination_folder_id: str = None,
|
|
):
|
|
self.destination_folder_id = destination_folder_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.destination_folder_id is not None:
|
|
result['destinationFolderId'] = self.destination_folder_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('destinationFolderId') is not None:
|
|
self.destination_folder_id = m.get('destinationFolderId')
|
|
return self
|
|
|
|
|
|
class MoveMailFolderResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
):
|
|
self.request_id = request_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
return self
|
|
|
|
|
|
class MoveMailFolderResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: MoveMailFolderResponseBody = 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 = MoveMailFolderResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class SendMessageHeaders(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 SendMessageRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
save_to_sent_items: bool = None,
|
|
):
|
|
self.save_to_sent_items = save_to_sent_items
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.save_to_sent_items is not None:
|
|
result['saveToSentItems'] = self.save_to_sent_items
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('saveToSentItems') is not None:
|
|
self.save_to_sent_items = m.get('saveToSentItems')
|
|
return self
|
|
|
|
|
|
class SendMessageResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
):
|
|
self.request_id = request_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
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 UpdateMailFolderHeaders(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 UpdateMailFolderRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
display_name: str = None,
|
|
):
|
|
self.display_name = display_name
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.display_name is not None:
|
|
result['displayName'] = self.display_name
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('displayName') is not None:
|
|
self.display_name = m.get('displayName')
|
|
return self
|
|
|
|
|
|
class UpdateMailFolderResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
request_id: str = None,
|
|
):
|
|
self.request_id = request_id
|
|
|
|
def validate(self):
|
|
pass
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
return self
|
|
|
|
|
|
class UpdateMailFolderResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: UpdateMailFolderResponseBody = 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 = UpdateMailFolderResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|
|
class UpdateMessageHeaders(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 UpdateMessageRequest(TeaModel):
|
|
def __init__(
|
|
self,
|
|
message: DraftMessage = None,
|
|
):
|
|
self.message = message
|
|
|
|
def validate(self):
|
|
if self.message:
|
|
self.message.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.message is not None:
|
|
result['message'] = self.message.to_map()
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('message') is not None:
|
|
temp_model = DraftMessage()
|
|
self.message = temp_model.from_map(m['message'])
|
|
return self
|
|
|
|
|
|
class UpdateMessageResponseBody(TeaModel):
|
|
def __init__(
|
|
self,
|
|
message: Message = None,
|
|
request_id: str = None,
|
|
):
|
|
self.message = message
|
|
self.request_id = request_id
|
|
|
|
def validate(self):
|
|
if self.message:
|
|
self.message.validate()
|
|
|
|
def to_map(self):
|
|
_map = super().to_map()
|
|
if _map is not None:
|
|
return _map
|
|
|
|
result = dict()
|
|
if self.message is not None:
|
|
result['message'] = self.message.to_map()
|
|
if self.request_id is not None:
|
|
result['requestId'] = self.request_id
|
|
return result
|
|
|
|
def from_map(self, m: dict = None):
|
|
m = m or dict()
|
|
if m.get('message') is not None:
|
|
temp_model = Message()
|
|
self.message = temp_model.from_map(m['message'])
|
|
if m.get('requestId') is not None:
|
|
self.request_id = m.get('requestId')
|
|
return self
|
|
|
|
|
|
class UpdateMessageResponse(TeaModel):
|
|
def __init__(
|
|
self,
|
|
headers: Dict[str, str] = None,
|
|
status_code: int = None,
|
|
body: UpdateMessageResponseBody = 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 = UpdateMessageResponseBody()
|
|
self.body = temp_model.from_map(m['body'])
|
|
return self
|
|
|
|
|