# -*- 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 ResultValue(TeaModel):
    def __init__(
        self,
        status: str = None,
    ):
        self.status = status

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.status is not None:
            result['status'] = self.status
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('status') is not None:
            self.status = m.get('status')
        return self


class AddCustomRosterFieldHeaders(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 AddCustomRosterFieldRequest(TeaModel):
    def __init__(
        self,
        edit_from_employee_flag: bool = None,
        field_name: str = None,
        field_type: str = None,
        group_id: str = None,
        hidden_from_employee_flag: bool = None,
        hint: str = None,
        no_watermark: bool = None,
        number_decimal_place: int = None,
        number_format_type: str = None,
        number_value_type: str = None,
        option_text: str = None,
        required: bool = None,
        visible_by_emp: bool = None,
    ):
        # This parameter is required.
        self.edit_from_employee_flag = edit_from_employee_flag
        # This parameter is required.
        self.field_name = field_name
        # This parameter is required.
        self.field_type = field_type
        # This parameter is required.
        self.group_id = group_id
        # This parameter is required.
        self.hidden_from_employee_flag = hidden_from_employee_flag
        self.hint = hint
        self.no_watermark = no_watermark
        self.number_decimal_place = number_decimal_place
        self.number_format_type = number_format_type
        self.number_value_type = number_value_type
        self.option_text = option_text
        # This parameter is required.
        self.required = required
        # This parameter is required.
        self.visible_by_emp = visible_by_emp

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.edit_from_employee_flag is not None:
            result['editFromEmployeeFlag'] = self.edit_from_employee_flag
        if self.field_name is not None:
            result['fieldName'] = self.field_name
        if self.field_type is not None:
            result['fieldType'] = self.field_type
        if self.group_id is not None:
            result['groupId'] = self.group_id
        if self.hidden_from_employee_flag is not None:
            result['hiddenFromEmployeeFlag'] = self.hidden_from_employee_flag
        if self.hint is not None:
            result['hint'] = self.hint
        if self.no_watermark is not None:
            result['noWatermark'] = self.no_watermark
        if self.number_decimal_place is not None:
            result['numberDecimalPlace'] = self.number_decimal_place
        if self.number_format_type is not None:
            result['numberFormatType'] = self.number_format_type
        if self.number_value_type is not None:
            result['numberValueType'] = self.number_value_type
        if self.option_text is not None:
            result['optionText'] = self.option_text
        if self.required is not None:
            result['required'] = self.required
        if self.visible_by_emp is not None:
            result['visibleByEmp'] = self.visible_by_emp
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('editFromEmployeeFlag') is not None:
            self.edit_from_employee_flag = m.get('editFromEmployeeFlag')
        if m.get('fieldName') is not None:
            self.field_name = m.get('fieldName')
        if m.get('fieldType') is not None:
            self.field_type = m.get('fieldType')
        if m.get('groupId') is not None:
            self.group_id = m.get('groupId')
        if m.get('hiddenFromEmployeeFlag') is not None:
            self.hidden_from_employee_flag = m.get('hiddenFromEmployeeFlag')
        if m.get('hint') is not None:
            self.hint = m.get('hint')
        if m.get('noWatermark') is not None:
            self.no_watermark = m.get('noWatermark')
        if m.get('numberDecimalPlace') is not None:
            self.number_decimal_place = m.get('numberDecimalPlace')
        if m.get('numberFormatType') is not None:
            self.number_format_type = m.get('numberFormatType')
        if m.get('numberValueType') is not None:
            self.number_value_type = m.get('numberValueType')
        if m.get('optionText') is not None:
            self.option_text = m.get('optionText')
        if m.get('required') is not None:
            self.required = m.get('required')
        if m.get('visibleByEmp') is not None:
            self.visible_by_emp = m.get('visibleByEmp')
        return self


class AddCustomRosterFieldResponseBodyResult(TeaModel):
    def __init__(
        self,
        contact_client_flag: bool = None,
        contact_flag: bool = None,
        contact_source: int = None,
        contact_system_flag: bool = None,
        deleted: bool = None,
        derived: bool = None,
        disabled: int = None,
        edit_from_employee_flag: bool = None,
        editable_by_hr: bool = None,
        field_code: str = None,
        field_name: str = None,
        field_tip: str = None,
        field_type: str = None,
        group_id: str = None,
        hidden_from_employee_flag: bool = None,
        hint: str = None,
        history_field: bool = None,
        index: int = None,
        modify_options: bool = None,
        no_watermark: bool = None,
        number_decimal_place: str = None,
        number_format_type: str = None,
        number_value_type: str = None,
        option_text: str = None,
        required: bool = None,
        source_field_code: str = None,
        system_flag: bool = None,
        text_to_select_field: bool = None,
        value: str = None,
        visible_by_emp: bool = None,
    ):
        self.contact_client_flag = contact_client_flag
        self.contact_flag = contact_flag
        self.contact_source = contact_source
        self.contact_system_flag = contact_system_flag
        self.deleted = deleted
        self.derived = derived
        self.disabled = disabled
        self.edit_from_employee_flag = edit_from_employee_flag
        self.editable_by_hr = editable_by_hr
        self.field_code = field_code
        self.field_name = field_name
        self.field_tip = field_tip
        self.field_type = field_type
        self.group_id = group_id
        self.hidden_from_employee_flag = hidden_from_employee_flag
        self.hint = hint
        self.history_field = history_field
        self.index = index
        self.modify_options = modify_options
        self.no_watermark = no_watermark
        self.number_decimal_place = number_decimal_place
        self.number_format_type = number_format_type
        self.number_value_type = number_value_type
        self.option_text = option_text
        self.required = required
        self.source_field_code = source_field_code
        self.system_flag = system_flag
        self.text_to_select_field = text_to_select_field
        self.value = value
        self.visible_by_emp = visible_by_emp

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.contact_client_flag is not None:
            result['contactClientFlag'] = self.contact_client_flag
        if self.contact_flag is not None:
            result['contactFlag'] = self.contact_flag
        if self.contact_source is not None:
            result['contactSource'] = self.contact_source
        if self.contact_system_flag is not None:
            result['contactSystemFlag'] = self.contact_system_flag
        if self.deleted is not None:
            result['deleted'] = self.deleted
        if self.derived is not None:
            result['derived'] = self.derived
        if self.disabled is not None:
            result['disabled'] = self.disabled
        if self.edit_from_employee_flag is not None:
            result['editFromEmployeeFlag'] = self.edit_from_employee_flag
        if self.editable_by_hr is not None:
            result['editableByHr'] = self.editable_by_hr
        if self.field_code is not None:
            result['fieldCode'] = self.field_code
        if self.field_name is not None:
            result['fieldName'] = self.field_name
        if self.field_tip is not None:
            result['fieldTip'] = self.field_tip
        if self.field_type is not None:
            result['fieldType'] = self.field_type
        if self.group_id is not None:
            result['groupId'] = self.group_id
        if self.hidden_from_employee_flag is not None:
            result['hiddenFromEmployeeFlag'] = self.hidden_from_employee_flag
        if self.hint is not None:
            result['hint'] = self.hint
        if self.history_field is not None:
            result['historyField'] = self.history_field
        if self.index is not None:
            result['index'] = self.index
        if self.modify_options is not None:
            result['modifyOptions'] = self.modify_options
        if self.no_watermark is not None:
            result['noWatermark'] = self.no_watermark
        if self.number_decimal_place is not None:
            result['numberDecimalPlace'] = self.number_decimal_place
        if self.number_format_type is not None:
            result['numberFormatType'] = self.number_format_type
        if self.number_value_type is not None:
            result['numberValueType'] = self.number_value_type
        if self.option_text is not None:
            result['optionText'] = self.option_text
        if self.required is not None:
            result['required'] = self.required
        if self.source_field_code is not None:
            result['sourceFieldCode'] = self.source_field_code
        if self.system_flag is not None:
            result['systemFlag'] = self.system_flag
        if self.text_to_select_field is not None:
            result['textToSelectField'] = self.text_to_select_field
        if self.value is not None:
            result['value'] = self.value
        if self.visible_by_emp is not None:
            result['visibleByEmp'] = self.visible_by_emp
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('contactClientFlag') is not None:
            self.contact_client_flag = m.get('contactClientFlag')
        if m.get('contactFlag') is not None:
            self.contact_flag = m.get('contactFlag')
        if m.get('contactSource') is not None:
            self.contact_source = m.get('contactSource')
        if m.get('contactSystemFlag') is not None:
            self.contact_system_flag = m.get('contactSystemFlag')
        if m.get('deleted') is not None:
            self.deleted = m.get('deleted')
        if m.get('derived') is not None:
            self.derived = m.get('derived')
        if m.get('disabled') is not None:
            self.disabled = m.get('disabled')
        if m.get('editFromEmployeeFlag') is not None:
            self.edit_from_employee_flag = m.get('editFromEmployeeFlag')
        if m.get('editableByHr') is not None:
            self.editable_by_hr = m.get('editableByHr')
        if m.get('fieldCode') is not None:
            self.field_code = m.get('fieldCode')
        if m.get('fieldName') is not None:
            self.field_name = m.get('fieldName')
        if m.get('fieldTip') is not None:
            self.field_tip = m.get('fieldTip')
        if m.get('fieldType') is not None:
            self.field_type = m.get('fieldType')
        if m.get('groupId') is not None:
            self.group_id = m.get('groupId')
        if m.get('hiddenFromEmployeeFlag') is not None:
            self.hidden_from_employee_flag = m.get('hiddenFromEmployeeFlag')
        if m.get('hint') is not None:
            self.hint = m.get('hint')
        if m.get('historyField') is not None:
            self.history_field = m.get('historyField')
        if m.get('index') is not None:
            self.index = m.get('index')
        if m.get('modifyOptions') is not None:
            self.modify_options = m.get('modifyOptions')
        if m.get('noWatermark') is not None:
            self.no_watermark = m.get('noWatermark')
        if m.get('numberDecimalPlace') is not None:
            self.number_decimal_place = m.get('numberDecimalPlace')
        if m.get('numberFormatType') is not None:
            self.number_format_type = m.get('numberFormatType')
        if m.get('numberValueType') is not None:
            self.number_value_type = m.get('numberValueType')
        if m.get('optionText') is not None:
            self.option_text = m.get('optionText')
        if m.get('required') is not None:
            self.required = m.get('required')
        if m.get('sourceFieldCode') is not None:
            self.source_field_code = m.get('sourceFieldCode')
        if m.get('systemFlag') is not None:
            self.system_flag = m.get('systemFlag')
        if m.get('textToSelectField') is not None:
            self.text_to_select_field = m.get('textToSelectField')
        if m.get('value') is not None:
            self.value = m.get('value')
        if m.get('visibleByEmp') is not None:
            self.visible_by_emp = m.get('visibleByEmp')
        return self


class AddCustomRosterFieldResponseBody(TeaModel):
    def __init__(
        self,
        ding_open_errcode: int = None,
        error_msg: str = None,
        result: AddCustomRosterFieldResponseBodyResult = None,
        success: bool = None,
    ):
        self.ding_open_errcode = ding_open_errcode
        self.error_msg = error_msg
        self.result = result
        self.success = success

    def validate(self):
        if self.result:
            self.result.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.ding_open_errcode is not None:
            result['dingOpenErrcode'] = self.ding_open_errcode
        if self.error_msg is not None:
            result['errorMsg'] = self.error_msg
        if self.result is not None:
            result['result'] = self.result.to_map()
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('dingOpenErrcode') is not None:
            self.ding_open_errcode = m.get('dingOpenErrcode')
        if m.get('errorMsg') is not None:
            self.error_msg = m.get('errorMsg')
        if m.get('result') is not None:
            temp_model = AddCustomRosterFieldResponseBodyResult()
            self.result = temp_model.from_map(m['result'])
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class AddCustomRosterFieldResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: AddCustomRosterFieldResponseBody = 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 = AddCustomRosterFieldResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class AddHrmLegalEntityHeaders(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 AddHrmLegalEntityRequestExtManageAddress(TeaModel):
    def __init__(
        self,
        area_code: str = None,
        area_name: str = None,
        city_code: str = None,
        city_name: str = None,
        country_code: str = None,
        country_name: str = None,
        detail_address: str = None,
        global_area_type: str = None,
        province_code: str = None,
        province_name: str = None,
    ):
        self.area_code = area_code
        self.area_name = area_name
        self.city_code = city_code
        self.city_name = city_name
        self.country_code = country_code
        self.country_name = country_name
        self.detail_address = detail_address
        self.global_area_type = global_area_type
        self.province_code = province_code
        self.province_name = province_name

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.area_code is not None:
            result['areaCode'] = self.area_code
        if self.area_name is not None:
            result['areaName'] = self.area_name
        if self.city_code is not None:
            result['cityCode'] = self.city_code
        if self.city_name is not None:
            result['cityName'] = self.city_name
        if self.country_code is not None:
            result['countryCode'] = self.country_code
        if self.country_name is not None:
            result['countryName'] = self.country_name
        if self.detail_address is not None:
            result['detailAddress'] = self.detail_address
        if self.global_area_type is not None:
            result['globalAreaType'] = self.global_area_type
        if self.province_code is not None:
            result['provinceCode'] = self.province_code
        if self.province_name is not None:
            result['provinceName'] = self.province_name
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('areaCode') is not None:
            self.area_code = m.get('areaCode')
        if m.get('areaName') is not None:
            self.area_name = m.get('areaName')
        if m.get('cityCode') is not None:
            self.city_code = m.get('cityCode')
        if m.get('cityName') is not None:
            self.city_name = m.get('cityName')
        if m.get('countryCode') is not None:
            self.country_code = m.get('countryCode')
        if m.get('countryName') is not None:
            self.country_name = m.get('countryName')
        if m.get('detailAddress') is not None:
            self.detail_address = m.get('detailAddress')
        if m.get('globalAreaType') is not None:
            self.global_area_type = m.get('globalAreaType')
        if m.get('provinceCode') is not None:
            self.province_code = m.get('provinceCode')
        if m.get('provinceName') is not None:
            self.province_name = m.get('provinceName')
        return self


class AddHrmLegalEntityRequestExtRegistrationAddress(TeaModel):
    def __init__(
        self,
        area_code: str = None,
        area_name: str = None,
        city_code: str = None,
        city_name: str = None,
        country_code: str = None,
        country_name: str = None,
        detail_address: str = None,
        global_area_type: str = None,
        province_code: str = None,
        province_name: str = None,
    ):
        self.area_code = area_code
        self.area_name = area_name
        self.city_code = city_code
        self.city_name = city_name
        self.country_code = country_code
        self.country_name = country_name
        self.detail_address = detail_address
        self.global_area_type = global_area_type
        self.province_code = province_code
        self.province_name = province_name

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.area_code is not None:
            result['areaCode'] = self.area_code
        if self.area_name is not None:
            result['areaName'] = self.area_name
        if self.city_code is not None:
            result['cityCode'] = self.city_code
        if self.city_name is not None:
            result['cityName'] = self.city_name
        if self.country_code is not None:
            result['countryCode'] = self.country_code
        if self.country_name is not None:
            result['countryName'] = self.country_name
        if self.detail_address is not None:
            result['detailAddress'] = self.detail_address
        if self.global_area_type is not None:
            result['globalAreaType'] = self.global_area_type
        if self.province_code is not None:
            result['provinceCode'] = self.province_code
        if self.province_name is not None:
            result['provinceName'] = self.province_name
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('areaCode') is not None:
            self.area_code = m.get('areaCode')
        if m.get('areaName') is not None:
            self.area_name = m.get('areaName')
        if m.get('cityCode') is not None:
            self.city_code = m.get('cityCode')
        if m.get('cityName') is not None:
            self.city_name = m.get('cityName')
        if m.get('countryCode') is not None:
            self.country_code = m.get('countryCode')
        if m.get('countryName') is not None:
            self.country_name = m.get('countryName')
        if m.get('detailAddress') is not None:
            self.detail_address = m.get('detailAddress')
        if m.get('globalAreaType') is not None:
            self.global_area_type = m.get('globalAreaType')
        if m.get('provinceCode') is not None:
            self.province_code = m.get('provinceCode')
        if m.get('provinceName') is not None:
            self.province_name = m.get('provinceName')
        return self


class AddHrmLegalEntityRequestExt(TeaModel):
    def __init__(
        self,
        legal_entity_en_name: str = None,
        legal_entity_en_short_name: str = None,
        legal_entity_type: str = None,
        manage_address: AddHrmLegalEntityRequestExtManageAddress = None,
        registration_address: AddHrmLegalEntityRequestExtRegistrationAddress = None,
        registration_date: int = None,
        unified_social_credit_code: str = None,
        zip_code: str = None,
    ):
        self.legal_entity_en_name = legal_entity_en_name
        self.legal_entity_en_short_name = legal_entity_en_short_name
        self.legal_entity_type = legal_entity_type
        self.manage_address = manage_address
        self.registration_address = registration_address
        self.registration_date = registration_date
        self.unified_social_credit_code = unified_social_credit_code
        self.zip_code = zip_code

    def validate(self):
        if self.manage_address:
            self.manage_address.validate()
        if self.registration_address:
            self.registration_address.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.legal_entity_en_name is not None:
            result['legalEntityEnName'] = self.legal_entity_en_name
        if self.legal_entity_en_short_name is not None:
            result['legalEntityEnShortName'] = self.legal_entity_en_short_name
        if self.legal_entity_type is not None:
            result['legalEntityType'] = self.legal_entity_type
        if self.manage_address is not None:
            result['manageAddress'] = self.manage_address.to_map()
        if self.registration_address is not None:
            result['registrationAddress'] = self.registration_address.to_map()
        if self.registration_date is not None:
            result['registrationDate'] = self.registration_date
        if self.unified_social_credit_code is not None:
            result['unifiedSocialCreditCode'] = self.unified_social_credit_code
        if self.zip_code is not None:
            result['zipCode'] = self.zip_code
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('legalEntityEnName') is not None:
            self.legal_entity_en_name = m.get('legalEntityEnName')
        if m.get('legalEntityEnShortName') is not None:
            self.legal_entity_en_short_name = m.get('legalEntityEnShortName')
        if m.get('legalEntityType') is not None:
            self.legal_entity_type = m.get('legalEntityType')
        if m.get('manageAddress') is not None:
            temp_model = AddHrmLegalEntityRequestExtManageAddress()
            self.manage_address = temp_model.from_map(m['manageAddress'])
        if m.get('registrationAddress') is not None:
            temp_model = AddHrmLegalEntityRequestExtRegistrationAddress()
            self.registration_address = temp_model.from_map(m['registrationAddress'])
        if m.get('registrationDate') is not None:
            self.registration_date = m.get('registrationDate')
        if m.get('unifiedSocialCreditCode') is not None:
            self.unified_social_credit_code = m.get('unifiedSocialCreditCode')
        if m.get('zipCode') is not None:
            self.zip_code = m.get('zipCode')
        return self


class AddHrmLegalEntityRequest(TeaModel):
    def __init__(
        self,
        corp_id: str = None,
        create_user_id: str = None,
        ext: AddHrmLegalEntityRequestExt = None,
        legal_entity_name: str = None,
        legal_entity_short_name: str = None,
        legal_entity_status: int = None,
        legal_person_name: str = None,
        ding_tenant_id: int = None,
    ):
        # This parameter is required.
        self.corp_id = corp_id
        self.create_user_id = create_user_id
        self.ext = ext
        # This parameter is required.
        self.legal_entity_name = legal_entity_name
        self.legal_entity_short_name = legal_entity_short_name
        # This parameter is required.
        self.legal_entity_status = legal_entity_status
        self.legal_person_name = legal_person_name
        self.ding_tenant_id = ding_tenant_id

    def validate(self):
        if self.ext:
            self.ext.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.corp_id is not None:
            result['corpId'] = self.corp_id
        if self.create_user_id is not None:
            result['createUserId'] = self.create_user_id
        if self.ext is not None:
            result['ext'] = self.ext.to_map()
        if self.legal_entity_name is not None:
            result['legalEntityName'] = self.legal_entity_name
        if self.legal_entity_short_name is not None:
            result['legalEntityShortName'] = self.legal_entity_short_name
        if self.legal_entity_status is not None:
            result['legalEntityStatus'] = self.legal_entity_status
        if self.legal_person_name is not None:
            result['legalPersonName'] = self.legal_person_name
        if self.ding_tenant_id is not None:
            result['dingTenantId'] = self.ding_tenant_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('corpId') is not None:
            self.corp_id = m.get('corpId')
        if m.get('createUserId') is not None:
            self.create_user_id = m.get('createUserId')
        if m.get('ext') is not None:
            temp_model = AddHrmLegalEntityRequestExt()
            self.ext = temp_model.from_map(m['ext'])
        if m.get('legalEntityName') is not None:
            self.legal_entity_name = m.get('legalEntityName')
        if m.get('legalEntityShortName') is not None:
            self.legal_entity_short_name = m.get('legalEntityShortName')
        if m.get('legalEntityStatus') is not None:
            self.legal_entity_status = m.get('legalEntityStatus')
        if m.get('legalPersonName') is not None:
            self.legal_person_name = m.get('legalPersonName')
        if m.get('dingTenantId') is not None:
            self.ding_tenant_id = m.get('dingTenantId')
        return self


class AddHrmLegalEntityResponseBodyResult(TeaModel):
    def __init__(
        self,
        corp_id: str = None,
        gmt_create: int = None,
        gmt_modified: int = None,
        legal_entity_id: str = None,
        legal_entity_name: str = None,
        legal_entity_short_name: str = None,
        legal_entity_status: int = None,
        legal_person_name: str = None,
    ):
        self.corp_id = corp_id
        self.gmt_create = gmt_create
        self.gmt_modified = gmt_modified
        self.legal_entity_id = legal_entity_id
        self.legal_entity_name = legal_entity_name
        self.legal_entity_short_name = legal_entity_short_name
        self.legal_entity_status = legal_entity_status
        self.legal_person_name = legal_person_name

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.corp_id is not None:
            result['corpId'] = self.corp_id
        if self.gmt_create is not None:
            result['gmtCreate'] = self.gmt_create
        if self.gmt_modified is not None:
            result['gmtModified'] = self.gmt_modified
        if self.legal_entity_id is not None:
            result['legalEntityId'] = self.legal_entity_id
        if self.legal_entity_name is not None:
            result['legalEntityName'] = self.legal_entity_name
        if self.legal_entity_short_name is not None:
            result['legalEntityShortName'] = self.legal_entity_short_name
        if self.legal_entity_status is not None:
            result['legalEntityStatus'] = self.legal_entity_status
        if self.legal_person_name is not None:
            result['legalPersonName'] = self.legal_person_name
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('corpId') is not None:
            self.corp_id = m.get('corpId')
        if m.get('gmtCreate') is not None:
            self.gmt_create = m.get('gmtCreate')
        if m.get('gmtModified') is not None:
            self.gmt_modified = m.get('gmtModified')
        if m.get('legalEntityId') is not None:
            self.legal_entity_id = m.get('legalEntityId')
        if m.get('legalEntityName') is not None:
            self.legal_entity_name = m.get('legalEntityName')
        if m.get('legalEntityShortName') is not None:
            self.legal_entity_short_name = m.get('legalEntityShortName')
        if m.get('legalEntityStatus') is not None:
            self.legal_entity_status = m.get('legalEntityStatus')
        if m.get('legalPersonName') is not None:
            self.legal_person_name = m.get('legalPersonName')
        return self


class AddHrmLegalEntityResponseBody(TeaModel):
    def __init__(
        self,
        result: AddHrmLegalEntityResponseBodyResult = None,
        success: bool = None,
    ):
        self.result = result
        self.success = success

    def validate(self):
        if self.result:
            self.result.validate()

    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.to_map()
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('result') is not None:
            temp_model = AddHrmLegalEntityResponseBodyResult()
            self.result = temp_model.from_map(m['result'])
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class AddHrmLegalEntityResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: AddHrmLegalEntityResponseBody = 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 = AddHrmLegalEntityResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class AddHrmPreentryHeaders(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 AddHrmPreentryRequestGroupsSectionsEmpFieldVOList(TeaModel):
    def __init__(
        self,
        field_code: str = None,
        value: str = None,
    ):
        self.field_code = field_code
        self.value = value

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.field_code is not None:
            result['fieldCode'] = self.field_code
        if self.value is not None:
            result['value'] = self.value
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('fieldCode') is not None:
            self.field_code = m.get('fieldCode')
        if m.get('value') is not None:
            self.value = m.get('value')
        return self


class AddHrmPreentryRequestGroupsSections(TeaModel):
    def __init__(
        self,
        emp_field_volist: List[AddHrmPreentryRequestGroupsSectionsEmpFieldVOList] = None,
        old_index: int = None,
    ):
        self.emp_field_volist = emp_field_volist
        self.old_index = old_index

    def validate(self):
        if self.emp_field_volist:
            for k in self.emp_field_volist:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['empFieldVOList'] = []
        if self.emp_field_volist is not None:
            for k in self.emp_field_volist:
                result['empFieldVOList'].append(k.to_map() if k else None)
        if self.old_index is not None:
            result['oldIndex'] = self.old_index
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.emp_field_volist = []
        if m.get('empFieldVOList') is not None:
            for k in m.get('empFieldVOList'):
                temp_model = AddHrmPreentryRequestGroupsSectionsEmpFieldVOList()
                self.emp_field_volist.append(temp_model.from_map(k))
        if m.get('oldIndex') is not None:
            self.old_index = m.get('oldIndex')
        return self


class AddHrmPreentryRequestGroups(TeaModel):
    def __init__(
        self,
        group_id: str = None,
        sections: List[AddHrmPreentryRequestGroupsSections] = None,
    ):
        self.group_id = group_id
        self.sections = sections

    def validate(self):
        if self.sections:
            for k in self.sections:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.group_id is not None:
            result['groupId'] = self.group_id
        result['sections'] = []
        if self.sections is not None:
            for k in self.sections:
                result['sections'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('groupId') is not None:
            self.group_id = m.get('groupId')
        self.sections = []
        if m.get('sections') is not None:
            for k in m.get('sections'):
                temp_model = AddHrmPreentryRequestGroupsSections()
                self.sections.append(temp_model.from_map(k))
        return self


class AddHrmPreentryRequest(TeaModel):
    def __init__(
        self,
        agent_id: int = None,
        groups: List[AddHrmPreentryRequestGroups] = None,
        mobile: str = None,
        name: str = None,
        need_send_pre_entry_msg: bool = None,
        pre_entry_time: int = None,
    ):
        self.agent_id = agent_id
        self.groups = groups
        # This parameter is required.
        self.mobile = mobile
        # This parameter is required.
        self.name = name
        self.need_send_pre_entry_msg = need_send_pre_entry_msg
        self.pre_entry_time = pre_entry_time

    def validate(self):
        if self.groups:
            for k in self.groups:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.agent_id is not None:
            result['agentId'] = self.agent_id
        result['groups'] = []
        if self.groups is not None:
            for k in self.groups:
                result['groups'].append(k.to_map() if k else None)
        if self.mobile is not None:
            result['mobile'] = self.mobile
        if self.name is not None:
            result['name'] = self.name
        if self.need_send_pre_entry_msg is not None:
            result['needSendPreEntryMsg'] = self.need_send_pre_entry_msg
        if self.pre_entry_time is not None:
            result['preEntryTime'] = self.pre_entry_time
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('agentId') is not None:
            self.agent_id = m.get('agentId')
        self.groups = []
        if m.get('groups') is not None:
            for k in m.get('groups'):
                temp_model = AddHrmPreentryRequestGroups()
                self.groups.append(temp_model.from_map(k))
        if m.get('mobile') is not None:
            self.mobile = m.get('mobile')
        if m.get('name') is not None:
            self.name = m.get('name')
        if m.get('needSendPreEntryMsg') is not None:
            self.need_send_pre_entry_msg = m.get('needSendPreEntryMsg')
        if m.get('preEntryTime') is not None:
            self.pre_entry_time = m.get('preEntryTime')
        return self


class AddHrmPreentryResponseBody(TeaModel):
    def __init__(
        self,
        tmp_user_id: str = None,
    ):
        self.tmp_user_id = tmp_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.tmp_user_id is not None:
            result['tmpUserId'] = self.tmp_user_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('tmpUserId') is not None:
            self.tmp_user_id = m.get('tmpUserId')
        return self


class AddHrmPreentryResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: AddHrmPreentryResponseBody = 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 = AddHrmPreentryResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class AddRosterFieldFormHeaders(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 AddRosterFieldFormRequest(TeaModel):
    def __init__(
        self,
        detail: bool = None,
        name: str = None,
    ):
        # This parameter is required.
        self.detail = detail
        # This parameter is required.
        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.detail is not None:
            result['detail'] = self.detail
        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('detail') is not None:
            self.detail = m.get('detail')
        if m.get('name') is not None:
            self.name = m.get('name')
        return self


class AddRosterFieldFormResponseBodyResult(TeaModel):
    def __init__(
        self,
        biz_group_id: int = None,
        content: str = None,
        corp_id: str = None,
        delete_flag: str = None,
        detail: bool = None,
        form_id: str = None,
        gmt_create: Any = None,
        gmt_modified: Any = None,
        icon: str = None,
        id: int = None,
        memo: str = None,
        name: str = None,
        sort_order: int = None,
        version_id: int = None,
    ):
        self.biz_group_id = biz_group_id
        self.content = content
        self.corp_id = corp_id
        self.delete_flag = delete_flag
        self.detail = detail
        self.form_id = form_id
        self.gmt_create = gmt_create
        self.gmt_modified = gmt_modified
        self.icon = icon
        self.id = id
        self.memo = memo
        self.name = name
        self.sort_order = sort_order
        self.version_id = version_id

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_group_id is not None:
            result['bizGroupId'] = self.biz_group_id
        if self.content is not None:
            result['content'] = self.content
        if self.corp_id is not None:
            result['corpId'] = self.corp_id
        if self.delete_flag is not None:
            result['deleteFlag'] = self.delete_flag
        if self.detail is not None:
            result['detail'] = self.detail
        if self.form_id is not None:
            result['formId'] = self.form_id
        if self.gmt_create is not None:
            result['gmtCreate'] = self.gmt_create
        if self.gmt_modified is not None:
            result['gmtModified'] = self.gmt_modified
        if self.icon is not None:
            result['icon'] = self.icon
        if self.id is not None:
            result['id'] = self.id
        if self.memo is not None:
            result['memo'] = self.memo
        if self.name is not None:
            result['name'] = self.name
        if self.sort_order is not None:
            result['sortOrder'] = self.sort_order
        if self.version_id is not None:
            result['versionId'] = self.version_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('bizGroupId') is not None:
            self.biz_group_id = m.get('bizGroupId')
        if m.get('content') is not None:
            self.content = m.get('content')
        if m.get('corpId') is not None:
            self.corp_id = m.get('corpId')
        if m.get('deleteFlag') is not None:
            self.delete_flag = m.get('deleteFlag')
        if m.get('detail') is not None:
            self.detail = m.get('detail')
        if m.get('formId') is not None:
            self.form_id = m.get('formId')
        if m.get('gmtCreate') is not None:
            self.gmt_create = m.get('gmtCreate')
        if m.get('gmtModified') is not None:
            self.gmt_modified = m.get('gmtModified')
        if m.get('icon') is not None:
            self.icon = m.get('icon')
        if m.get('id') is not None:
            self.id = m.get('id')
        if m.get('memo') is not None:
            self.memo = m.get('memo')
        if m.get('name') is not None:
            self.name = m.get('name')
        if m.get('sortOrder') is not None:
            self.sort_order = m.get('sortOrder')
        if m.get('versionId') is not None:
            self.version_id = m.get('versionId')
        return self


class AddRosterFieldFormResponseBody(TeaModel):
    def __init__(
        self,
        ding_open_errcode: int = None,
        error_msg: str = None,
        result: AddRosterFieldFormResponseBodyResult = None,
        success: bool = None,
    ):
        self.ding_open_errcode = ding_open_errcode
        self.error_msg = error_msg
        self.result = result
        self.success = success

    def validate(self):
        if self.result:
            self.result.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.ding_open_errcode is not None:
            result['dingOpenErrcode'] = self.ding_open_errcode
        if self.error_msg is not None:
            result['errorMsg'] = self.error_msg
        if self.result is not None:
            result['result'] = self.result.to_map()
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('dingOpenErrcode') is not None:
            self.ding_open_errcode = m.get('dingOpenErrcode')
        if m.get('errorMsg') is not None:
            self.error_msg = m.get('errorMsg')
        if m.get('result') is not None:
            temp_model = AddRosterFieldFormResponseBodyResult()
            self.result = temp_model.from_map(m['result'])
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class AddRosterFieldFormResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: AddRosterFieldFormResponseBody = 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 = AddRosterFieldFormResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ConvertUnionIdHeaders(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 ConvertUnionIdRequest(TeaModel):
    def __init__(
        self,
        union_id_list: List[str] = None,
        user_id_list: List[str] = None,
    ):
        self.union_id_list = union_id_list
        self.user_id_list = user_id_list

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.union_id_list is not None:
            result['unionIdList'] = self.union_id_list
        if self.user_id_list is not None:
            result['userIdList'] = self.user_id_list
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('unionIdList') is not None:
            self.union_id_list = m.get('unionIdList')
        if m.get('userIdList') is not None:
            self.user_id_list = m.get('userIdList')
        return self


class ConvertUnionIdResponseBodyResultIsvUserUnionIdVOList(TeaModel):
    def __init__(
        self,
        union_id: str = None,
        user_id: str = None,
    ):
        self.union_id = union_id
        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.union_id is not None:
            result['unionId'] = self.union_id
        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('unionId') is not None:
            self.union_id = m.get('unionId')
        if m.get('userId') is not None:
            self.user_id = m.get('userId')
        return self


class ConvertUnionIdResponseBodyResult(TeaModel):
    def __init__(
        self,
        corp_id: str = None,
        isv_user_union_id_volist: List[ConvertUnionIdResponseBodyResultIsvUserUnionIdVOList] = None,
    ):
        self.corp_id = corp_id
        self.isv_user_union_id_volist = isv_user_union_id_volist

    def validate(self):
        if self.isv_user_union_id_volist:
            for k in self.isv_user_union_id_volist:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.corp_id is not None:
            result['corpId'] = self.corp_id
        result['isvUserUnionIdVOList'] = []
        if self.isv_user_union_id_volist is not None:
            for k in self.isv_user_union_id_volist:
                result['isvUserUnionIdVOList'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('corpId') is not None:
            self.corp_id = m.get('corpId')
        self.isv_user_union_id_volist = []
        if m.get('isvUserUnionIdVOList') is not None:
            for k in m.get('isvUserUnionIdVOList'):
                temp_model = ConvertUnionIdResponseBodyResultIsvUserUnionIdVOList()
                self.isv_user_union_id_volist.append(temp_model.from_map(k))
        return self


class ConvertUnionIdResponseBody(TeaModel):
    def __init__(
        self,
        result: ConvertUnionIdResponseBodyResult = None,
        success: bool = None,
    ):
        self.result = result
        self.success = success

    def validate(self):
        if self.result:
            self.result.validate()

    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.to_map()
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('result') is not None:
            temp_model = ConvertUnionIdResponseBodyResult()
            self.result = temp_model.from_map(m['result'])
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class ConvertUnionIdResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: ConvertUnionIdResponseBody = 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 = ConvertUnionIdResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class CreateRecordHeaders(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 CreateRecordRequestAttachmentList(TeaModel):
    def __init__(
        self,
        field_code: str = None,
        field_name: str = None,
        field_type: str = None,
        field_value: str = None,
        group_id: str = None,
    ):
        self.field_code = field_code
        self.field_name = field_name
        self.field_type = field_type
        self.field_value = field_value
        self.group_id = group_id

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.field_code is not None:
            result['fieldCode'] = self.field_code
        if self.field_name is not None:
            result['fieldName'] = self.field_name
        if self.field_type is not None:
            result['fieldType'] = self.field_type
        if self.field_value is not None:
            result['fieldValue'] = self.field_value
        if self.group_id is not None:
            result['groupId'] = self.group_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('fieldCode') is not None:
            self.field_code = m.get('fieldCode')
        if m.get('fieldName') is not None:
            self.field_name = m.get('fieldName')
        if m.get('fieldType') is not None:
            self.field_type = m.get('fieldType')
        if m.get('fieldValue') is not None:
            self.field_value = m.get('fieldValue')
        if m.get('groupId') is not None:
            self.group_id = m.get('groupId')
        return self


class CreateRecordRequestFieldList(TeaModel):
    def __init__(
        self,
        field_code: str = None,
        field_name: str = None,
        field_type: str = None,
        field_value: str = None,
        group_id: str = None,
        option_id: str = None,
        options: str = None,
        sign_required: bool = None,
        user_custom_field: bool = None,
    ):
        self.field_code = field_code
        self.field_name = field_name
        self.field_type = field_type
        self.field_value = field_value
        self.group_id = group_id
        self.option_id = option_id
        self.options = options
        self.sign_required = sign_required
        self.user_custom_field = user_custom_field

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.field_code is not None:
            result['fieldCode'] = self.field_code
        if self.field_name is not None:
            result['fieldName'] = self.field_name
        if self.field_type is not None:
            result['fieldType'] = self.field_type
        if self.field_value is not None:
            result['fieldValue'] = self.field_value
        if self.group_id is not None:
            result['groupId'] = self.group_id
        if self.option_id is not None:
            result['optionId'] = self.option_id
        if self.options is not None:
            result['options'] = self.options
        if self.sign_required is not None:
            result['signRequired'] = self.sign_required
        if self.user_custom_field is not None:
            result['userCustomField'] = self.user_custom_field
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('fieldCode') is not None:
            self.field_code = m.get('fieldCode')
        if m.get('fieldName') is not None:
            self.field_name = m.get('fieldName')
        if m.get('fieldType') is not None:
            self.field_type = m.get('fieldType')
        if m.get('fieldValue') is not None:
            self.field_value = m.get('fieldValue')
        if m.get('groupId') is not None:
            self.group_id = m.get('groupId')
        if m.get('optionId') is not None:
            self.option_id = m.get('optionId')
        if m.get('options') is not None:
            self.options = m.get('options')
        if m.get('signRequired') is not None:
            self.sign_required = m.get('signRequired')
        if m.get('userCustomField') is not None:
            self.user_custom_field = m.get('userCustomField')
        return self


class CreateRecordRequestGroupListFieldList(TeaModel):
    def __init__(
        self,
        field_code: str = None,
        field_name: str = None,
        field_type: str = None,
        field_value: str = None,
        options: str = None,
        option_id: str = None,
        group_id: str = None,
    ):
        self.field_code = field_code
        self.field_name = field_name
        self.field_type = field_type
        self.field_value = field_value
        self.options = options
        self.option_id = option_id
        self.group_id = group_id

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.field_code is not None:
            result['fieldCode'] = self.field_code
        if self.field_name is not None:
            result['fieldName'] = self.field_name
        if self.field_type is not None:
            result['fieldType'] = self.field_type
        if self.field_value is not None:
            result['fieldValue'] = self.field_value
        if self.options is not None:
            result['options'] = self.options
        if self.option_id is not None:
            result['optionId'] = self.option_id
        if self.group_id is not None:
            result['groupId'] = self.group_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('fieldCode') is not None:
            self.field_code = m.get('fieldCode')
        if m.get('fieldName') is not None:
            self.field_name = m.get('fieldName')
        if m.get('fieldType') is not None:
            self.field_type = m.get('fieldType')
        if m.get('fieldValue') is not None:
            self.field_value = m.get('fieldValue')
        if m.get('options') is not None:
            self.options = m.get('options')
        if m.get('optionId') is not None:
            self.option_id = m.get('optionId')
        if m.get('groupId') is not None:
            self.group_id = m.get('groupId')
        return self


class CreateRecordRequestGroupList(TeaModel):
    def __init__(
        self,
        detail_flag: bool = None,
        field_list: List[List[CreateRecordRequestGroupListFieldList]] = None,
        group_id: str = None,
        group_name: str = None,
    ):
        self.detail_flag = detail_flag
        self.field_list = field_list
        self.group_id = group_id
        self.group_name = group_name

    def validate(self):
        if self.field_list:
            for k in self.field_list:
                for k1 in k:
                    if k1:
                        k1.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.detail_flag is not None:
            result['detailFlag'] = self.detail_flag
        result['fieldList'] = []
        if self.field_list is not None:
            for k in self.field_list:
                l1 = []
                for k1 in k:
                    l1.append(k1.to_map() if k1 else None)
                result['fieldList'].append(l1)
        if self.group_id is not None:
            result['groupId'] = self.group_id
        if self.group_name is not None:
            result['groupName'] = self.group_name
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('detailFlag') is not None:
            self.detail_flag = m.get('detailFlag')
        self.field_list = []
        if m.get('fieldList') is not None:
            for k in m.get('fieldList'):
                l1 = []
                for k1 in k:
                    temp_model = CreateRecordRequestGroupListFieldList()
                    l1.append(temp_model.from_map(k1))
                self.field_list.append(l1)
        if m.get('groupId') is not None:
            self.group_id = m.get('groupId')
        if m.get('groupName') is not None:
            self.group_name = m.get('groupName')
        return self


class CreateRecordRequest(TeaModel):
    def __init__(
        self,
        attachment_list: List[CreateRecordRequestAttachmentList] = None,
        dept_id: int = None,
        field_list: List[CreateRecordRequestFieldList] = None,
        group_list: List[CreateRecordRequestGroupList] = None,
        outer_id: str = None,
        remark: str = None,
        sign_last_legal_entity_name: str = None,
        sign_legal_entity_name: str = None,
        sign_source: str = None,
        sign_start_user_id: str = None,
        sign_user_id: str = None,
        template_id: str = None,
    ):
        self.attachment_list = attachment_list
        self.dept_id = dept_id
        self.field_list = field_list
        self.group_list = group_list
        self.outer_id = outer_id
        self.remark = remark
        self.sign_last_legal_entity_name = sign_last_legal_entity_name
        self.sign_legal_entity_name = sign_legal_entity_name
        # This parameter is required.
        self.sign_source = sign_source
        # This parameter is required.
        self.sign_start_user_id = sign_start_user_id
        # This parameter is required.
        self.sign_user_id = sign_user_id
        # This parameter is required.
        self.template_id = template_id

    def validate(self):
        if self.attachment_list:
            for k in self.attachment_list:
                if k:
                    k.validate()
        if self.field_list:
            for k in self.field_list:
                if k:
                    k.validate()
        if self.group_list:
            for k in self.group_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['attachmentList'] = []
        if self.attachment_list is not None:
            for k in self.attachment_list:
                result['attachmentList'].append(k.to_map() if k else None)
        if self.dept_id is not None:
            result['deptId'] = self.dept_id
        result['fieldList'] = []
        if self.field_list is not None:
            for k in self.field_list:
                result['fieldList'].append(k.to_map() if k else None)
        result['groupList'] = []
        if self.group_list is not None:
            for k in self.group_list:
                result['groupList'].append(k.to_map() if k else None)
        if self.outer_id is not None:
            result['outerId'] = self.outer_id
        if self.remark is not None:
            result['remark'] = self.remark
        if self.sign_last_legal_entity_name is not None:
            result['signLastLegalEntityName'] = self.sign_last_legal_entity_name
        if self.sign_legal_entity_name is not None:
            result['signLegalEntityName'] = self.sign_legal_entity_name
        if self.sign_source is not None:
            result['signSource'] = self.sign_source
        if self.sign_start_user_id is not None:
            result['signStartUserId'] = self.sign_start_user_id
        if self.sign_user_id is not None:
            result['signUserId'] = self.sign_user_id
        if self.template_id is not None:
            result['templateId'] = self.template_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.attachment_list = []
        if m.get('attachmentList') is not None:
            for k in m.get('attachmentList'):
                temp_model = CreateRecordRequestAttachmentList()
                self.attachment_list.append(temp_model.from_map(k))
        if m.get('deptId') is not None:
            self.dept_id = m.get('deptId')
        self.field_list = []
        if m.get('fieldList') is not None:
            for k in m.get('fieldList'):
                temp_model = CreateRecordRequestFieldList()
                self.field_list.append(temp_model.from_map(k))
        self.group_list = []
        if m.get('groupList') is not None:
            for k in m.get('groupList'):
                temp_model = CreateRecordRequestGroupList()
                self.group_list.append(temp_model.from_map(k))
        if m.get('outerId') is not None:
            self.outer_id = m.get('outerId')
        if m.get('remark') is not None:
            self.remark = m.get('remark')
        if m.get('signLastLegalEntityName') is not None:
            self.sign_last_legal_entity_name = m.get('signLastLegalEntityName')
        if m.get('signLegalEntityName') is not None:
            self.sign_legal_entity_name = m.get('signLegalEntityName')
        if m.get('signSource') is not None:
            self.sign_source = m.get('signSource')
        if m.get('signStartUserId') is not None:
            self.sign_start_user_id = m.get('signStartUserId')
        if m.get('signUserId') is not None:
            self.sign_user_id = m.get('signUserId')
        if m.get('templateId') is not None:
            self.template_id = m.get('templateId')
        return self


class CreateRecordResponseBodyResult(TeaModel):
    def __init__(
        self,
        details: str = None,
        item_id: str = None,
        type: str = None,
    ):
        self.details = details
        self.item_id = item_id
        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.details is not None:
            result['details'] = self.details
        if self.item_id is not None:
            result['itemId'] = self.item_id
        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('details') is not None:
            self.details = m.get('details')
        if m.get('itemId') is not None:
            self.item_id = m.get('itemId')
        if m.get('type') is not None:
            self.type = m.get('type')
        return self


class CreateRecordResponseBody(TeaModel):
    def __init__(
        self,
        result: CreateRecordResponseBodyResult = None,
        success: bool = None,
    ):
        self.result = result
        self.success = success

    def validate(self):
        if self.result:
            self.result.validate()

    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.to_map()
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('result') is not None:
            temp_model = CreateRecordResponseBodyResult()
            self.result = temp_model.from_map(m['result'])
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class CreateRecordResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: CreateRecordResponseBody = 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 = CreateRecordResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteCustomRosterFieldHeaders(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 DeleteCustomRosterFieldRequest(TeaModel):
    def __init__(
        self,
        field_code: str = None,
        group_id: str = None,
    ):
        # This parameter is required.
        self.field_code = field_code
        # This parameter is required.
        self.group_id = group_id

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.field_code is not None:
            result['fieldCode'] = self.field_code
        if self.group_id is not None:
            result['groupId'] = self.group_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('fieldCode') is not None:
            self.field_code = m.get('fieldCode')
        if m.get('groupId') is not None:
            self.group_id = m.get('groupId')
        return self


class DeleteCustomRosterFieldResponseBody(TeaModel):
    def __init__(
        self,
        ding_open_errcode: int = None,
        error_msg: str = None,
        result: bool = None,
        success: bool = None,
    ):
        self.ding_open_errcode = ding_open_errcode
        self.error_msg = error_msg
        self.result = result
        self.success = success

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.ding_open_errcode is not None:
            result['dingOpenErrcode'] = self.ding_open_errcode
        if self.error_msg is not None:
            result['errorMsg'] = self.error_msg
        if self.result is not None:
            result['result'] = self.result
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('dingOpenErrcode') is not None:
            self.ding_open_errcode = m.get('dingOpenErrcode')
        if m.get('errorMsg') is not None:
            self.error_msg = m.get('errorMsg')
        if m.get('result') is not None:
            self.result = m.get('result')
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class DeleteCustomRosterFieldResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: DeleteCustomRosterFieldResponseBody = 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 = DeleteCustomRosterFieldResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeleteRosterFieldFormHeaders(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 DeleteRosterFieldFormRequest(TeaModel):
    def __init__(
        self,
        form_id: str = None,
        user_id: str = None,
    ):
        # This parameter is required.
        self.form_id = form_id
        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.form_id is not None:
            result['formId'] = self.form_id
        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('formId') is not None:
            self.form_id = m.get('formId')
        if m.get('userId') is not None:
            self.user_id = m.get('userId')
        return self


class DeleteRosterFieldFormResponseBody(TeaModel):
    def __init__(
        self,
        ding_open_errcode: int = None,
        error_msg: str = None,
        result: bool = None,
        success: bool = None,
    ):
        self.ding_open_errcode = ding_open_errcode
        self.error_msg = error_msg
        self.result = result
        self.success = success

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.ding_open_errcode is not None:
            result['dingOpenErrcode'] = self.ding_open_errcode
        if self.error_msg is not None:
            result['errorMsg'] = self.error_msg
        if self.result is not None:
            result['result'] = self.result
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('dingOpenErrcode') is not None:
            self.ding_open_errcode = m.get('dingOpenErrcode')
        if m.get('errorMsg') is not None:
            self.error_msg = m.get('errorMsg')
        if m.get('result') is not None:
            self.result = m.get('result')
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class DeleteRosterFieldFormResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: DeleteRosterFieldFormResponseBody = 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 = DeleteRosterFieldFormResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeviceMarketManagerResponseBody(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 DeviceMarketManagerResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: DeviceMarketManagerResponseBody = 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 = DeviceMarketManagerResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class DeviceMarketOrderManagerResponseBody(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 DeviceMarketOrderManagerResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: DeviceMarketOrderManagerResponseBody = 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 = DeviceMarketOrderManagerResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class ECertQueryHeaders(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 ECertQueryRequest(TeaModel):
    def __init__(
        self,
        user_id: str = None,
    ):
        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.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('userId') is not None:
            self.user_id = m.get('userId')
        return self


class ECertQueryResponseBody(TeaModel):
    def __init__(
        self,
        cert_no: str = None,
        employ_job_id: str = None,
        employ_job_id_label: str = None,
        employ_position_id: str = None,
        employ_position_id_label: str = None,
        employ_position_rank_id: str = None,
        employ_position_rank_id_label: str = None,
        hired_date: str = None,
        last_work_day: str = None,
        main_dept_id: int = None,
        main_dept_name: str = None,
        name: str = None,
        real_name: str = None,
        termination_reason_passive: List[str] = None,
        termination_reason_voluntary: List[str] = None,
    ):
        self.cert_no = cert_no
        self.employ_job_id = employ_job_id
        self.employ_job_id_label = employ_job_id_label
        self.employ_position_id = employ_position_id
        self.employ_position_id_label = employ_position_id_label
        self.employ_position_rank_id = employ_position_rank_id
        self.employ_position_rank_id_label = employ_position_rank_id_label
        self.hired_date = hired_date
        self.last_work_day = last_work_day
        self.main_dept_id = main_dept_id
        self.main_dept_name = main_dept_name
        # This parameter is required.
        self.name = name
        self.real_name = real_name
        self.termination_reason_passive = termination_reason_passive
        self.termination_reason_voluntary = termination_reason_voluntary

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.cert_no is not None:
            result['certNO'] = self.cert_no
        if self.employ_job_id is not None:
            result['employJobId'] = self.employ_job_id
        if self.employ_job_id_label is not None:
            result['employJobIdLabel'] = self.employ_job_id_label
        if self.employ_position_id is not None:
            result['employPositionId'] = self.employ_position_id
        if self.employ_position_id_label is not None:
            result['employPositionIdLabel'] = self.employ_position_id_label
        if self.employ_position_rank_id is not None:
            result['employPositionRankId'] = self.employ_position_rank_id
        if self.employ_position_rank_id_label is not None:
            result['employPositionRankIdLabel'] = self.employ_position_rank_id_label
        if self.hired_date is not None:
            result['hiredDate'] = self.hired_date
        if self.last_work_day is not None:
            result['lastWorkDay'] = self.last_work_day
        if self.main_dept_id is not None:
            result['mainDeptId'] = self.main_dept_id
        if self.main_dept_name is not None:
            result['mainDeptName'] = self.main_dept_name
        if self.name is not None:
            result['name'] = self.name
        if self.real_name is not None:
            result['realName'] = self.real_name
        if self.termination_reason_passive is not None:
            result['terminationReasonPassive'] = self.termination_reason_passive
        if self.termination_reason_voluntary is not None:
            result['terminationReasonVoluntary'] = self.termination_reason_voluntary
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('certNO') is not None:
            self.cert_no = m.get('certNO')
        if m.get('employJobId') is not None:
            self.employ_job_id = m.get('employJobId')
        if m.get('employJobIdLabel') is not None:
            self.employ_job_id_label = m.get('employJobIdLabel')
        if m.get('employPositionId') is not None:
            self.employ_position_id = m.get('employPositionId')
        if m.get('employPositionIdLabel') is not None:
            self.employ_position_id_label = m.get('employPositionIdLabel')
        if m.get('employPositionRankId') is not None:
            self.employ_position_rank_id = m.get('employPositionRankId')
        if m.get('employPositionRankIdLabel') is not None:
            self.employ_position_rank_id_label = m.get('employPositionRankIdLabel')
        if m.get('hiredDate') is not None:
            self.hired_date = m.get('hiredDate')
        if m.get('lastWorkDay') is not None:
            self.last_work_day = m.get('lastWorkDay')
        if m.get('mainDeptId') is not None:
            self.main_dept_id = m.get('mainDeptId')
        if m.get('mainDeptName') is not None:
            self.main_dept_name = m.get('mainDeptName')
        if m.get('name') is not None:
            self.name = m.get('name')
        if m.get('realName') is not None:
            self.real_name = m.get('realName')
        if m.get('terminationReasonPassive') is not None:
            self.termination_reason_passive = m.get('terminationReasonPassive')
        if m.get('terminationReasonVoluntary') is not None:
            self.termination_reason_voluntary = m.get('terminationReasonVoluntary')
        return self


class ECertQueryResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: ECertQueryResponseBody = 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 = ECertQueryResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class EmpStartDismissionHeaders(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 EmpStartDismissionRequest(TeaModel):
    def __init__(
        self,
        last_work_date: int = None,
        partner: bool = None,
        remark: str = None,
        termination_reason_passive: List[str] = None,
        termination_reason_voluntary: List[str] = None,
        to_hire_black_list: bool = None,
        to_hire_dismission_talent: bool = None,
        to_hrm_black_list: bool = None,
        user_id: str = None,
    ):
        # This parameter is required.
        self.last_work_date = last_work_date
        self.partner = partner
        self.remark = remark
        self.termination_reason_passive = termination_reason_passive
        self.termination_reason_voluntary = termination_reason_voluntary
        self.to_hire_black_list = to_hire_black_list
        self.to_hire_dismission_talent = to_hire_dismission_talent
        self.to_hrm_black_list = to_hrm_black_list
        # 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.last_work_date is not None:
            result['lastWorkDate'] = self.last_work_date
        if self.partner is not None:
            result['partner'] = self.partner
        if self.remark is not None:
            result['remark'] = self.remark
        if self.termination_reason_passive is not None:
            result['terminationReasonPassive'] = self.termination_reason_passive
        if self.termination_reason_voluntary is not None:
            result['terminationReasonVoluntary'] = self.termination_reason_voluntary
        if self.to_hire_black_list is not None:
            result['toHireBlackList'] = self.to_hire_black_list
        if self.to_hire_dismission_talent is not None:
            result['toHireDismissionTalent'] = self.to_hire_dismission_talent
        if self.to_hrm_black_list is not None:
            result['toHrmBlackList'] = self.to_hrm_black_list
        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('lastWorkDate') is not None:
            self.last_work_date = m.get('lastWorkDate')
        if m.get('partner') is not None:
            self.partner = m.get('partner')
        if m.get('remark') is not None:
            self.remark = m.get('remark')
        if m.get('terminationReasonPassive') is not None:
            self.termination_reason_passive = m.get('terminationReasonPassive')
        if m.get('terminationReasonVoluntary') is not None:
            self.termination_reason_voluntary = m.get('terminationReasonVoluntary')
        if m.get('toHireBlackList') is not None:
            self.to_hire_black_list = m.get('toHireBlackList')
        if m.get('toHireDismissionTalent') is not None:
            self.to_hire_dismission_talent = m.get('toHireDismissionTalent')
        if m.get('toHrmBlackList') is not None:
            self.to_hrm_black_list = m.get('toHrmBlackList')
        if m.get('userId') is not None:
            self.user_id = m.get('userId')
        return self


class EmpStartDismissionResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
        result: bool = None,
        success: bool = None,
    ):
        self.request_id = request_id
        self.result = result
        self.success = success

    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
        if self.result is not None:
            result['result'] = self.result
        if self.success is not None:
            result['success'] = self.success
        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')
        if m.get('result') is not None:
            self.result = m.get('result')
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class EmpStartDismissionResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: EmpStartDismissionResponseBody = 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 = EmpStartDismissionResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class EmployeeAttachmentUpdateHeaders(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 EmployeeAttachmentUpdateRequest(TeaModel):
    def __init__(
        self,
        app_agent_id: int = None,
        field_code: str = None,
        file_suffix: str = None,
        media_id: str = None,
        user_id: str = None,
    ):
        # This parameter is required.
        self.app_agent_id = app_agent_id
        # This parameter is required.
        self.field_code = field_code
        self.file_suffix = file_suffix
        # This parameter is required.
        self.media_id = media_id
        # 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_agent_id is not None:
            result['appAgentId'] = self.app_agent_id
        if self.field_code is not None:
            result['fieldCode'] = self.field_code
        if self.file_suffix is not None:
            result['fileSuffix'] = self.file_suffix
        if self.media_id is not None:
            result['mediaId'] = self.media_id
        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('appAgentId') is not None:
            self.app_agent_id = m.get('appAgentId')
        if m.get('fieldCode') is not None:
            self.field_code = m.get('fieldCode')
        if m.get('fileSuffix') is not None:
            self.file_suffix = m.get('fileSuffix')
        if m.get('mediaId') is not None:
            self.media_id = m.get('mediaId')
        if m.get('userId') is not None:
            self.user_id = m.get('userId')
        return self


class EmployeeAttachmentUpdateResponseBody(TeaModel):
    def __init__(
        self,
        result: bool = None,
        success: bool = None,
    ):
        self.result = result
        self.success = success

    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
        if self.success is not None:
            result['success'] = self.success
        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')
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class EmployeeAttachmentUpdateResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: EmployeeAttachmentUpdateResponseBody = 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 = EmployeeAttachmentUpdateResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class EsignRollbackHeaders(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 EsignRollbackRequest(TeaModel):
    def __init__(
        self,
        opt_user_id: str = None,
    ):
        # This parameter is required.
        self.opt_user_id = opt_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.opt_user_id is not None:
            result['optUserId'] = self.opt_user_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('optUserId') is not None:
            self.opt_user_id = m.get('optUserId')
        return self


class EsignRollbackResponseBody(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 EsignRollbackResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: EsignRollbackResponseBody = 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 = EsignRollbackResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetAllDismissionReasonsHeaders(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 GetAllDismissionReasonsResponseBodyResultPassiveList(TeaModel):
    def __init__(
        self,
        id: str = None,
        name: str = None,
    ):
        self.id = id
        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.id is not None:
            result['id'] = self.id
        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('id') is not None:
            self.id = m.get('id')
        if m.get('name') is not None:
            self.name = m.get('name')
        return self


class GetAllDismissionReasonsResponseBodyResultVoluntaryList(TeaModel):
    def __init__(
        self,
        id: str = None,
        name: str = None,
    ):
        self.id = id
        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.id is not None:
            result['id'] = self.id
        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('id') is not None:
            self.id = m.get('id')
        if m.get('name') is not None:
            self.name = m.get('name')
        return self


class GetAllDismissionReasonsResponseBodyResult(TeaModel):
    def __init__(
        self,
        passive_list: List[GetAllDismissionReasonsResponseBodyResultPassiveList] = None,
        voluntary_list: List[GetAllDismissionReasonsResponseBodyResultVoluntaryList] = None,
    ):
        self.passive_list = passive_list
        self.voluntary_list = voluntary_list

    def validate(self):
        if self.passive_list:
            for k in self.passive_list:
                if k:
                    k.validate()
        if self.voluntary_list:
            for k in self.voluntary_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['passiveList'] = []
        if self.passive_list is not None:
            for k in self.passive_list:
                result['passiveList'].append(k.to_map() if k else None)
        result['voluntaryList'] = []
        if self.voluntary_list is not None:
            for k in self.voluntary_list:
                result['voluntaryList'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.passive_list = []
        if m.get('passiveList') is not None:
            for k in m.get('passiveList'):
                temp_model = GetAllDismissionReasonsResponseBodyResultPassiveList()
                self.passive_list.append(temp_model.from_map(k))
        self.voluntary_list = []
        if m.get('voluntaryList') is not None:
            for k in m.get('voluntaryList'):
                temp_model = GetAllDismissionReasonsResponseBodyResultVoluntaryList()
                self.voluntary_list.append(temp_model.from_map(k))
        return self


class GetAllDismissionReasonsResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
        result: GetAllDismissionReasonsResponseBodyResult = None,
        success: bool = None,
    ):
        self.request_id = request_id
        self.result = result
        self.success = success

    def validate(self):
        if self.result:
            self.result.validate()

    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
        if self.result is not None:
            result['result'] = self.result.to_map()
        if self.success is not None:
            result['success'] = self.success
        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')
        if m.get('result') is not None:
            temp_model = GetAllDismissionReasonsResponseBodyResult()
            self.result = temp_model.from_map(m['result'])
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class GetAllDismissionReasonsResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: GetAllDismissionReasonsResponseBody = 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 = GetAllDismissionReasonsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetDismissionRecordHeaders(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 GetDismissionRecordRequest(TeaModel):
    def __init__(
        self,
        next_token: int = None,
        size: int = None,
    ):
        self.next_token = next_token
        self.size = size

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.next_token is not None:
            result['nextToken'] = self.next_token
        if self.size is not None:
            result['size'] = self.size
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('nextToken') is not None:
            self.next_token = m.get('nextToken')
        if m.get('size') is not None:
            self.size = m.get('size')
        return self


class GetDismissionRecordResponseBodyResultList(TeaModel):
    def __init__(
        self,
        last_work_day: int = None,
        staff_id: str = None,
    ):
        self.last_work_day = last_work_day
        self.staff_id = staff_id

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.last_work_day is not None:
            result['lastWorkDay'] = self.last_work_day
        if self.staff_id is not None:
            result['staffId'] = self.staff_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('lastWorkDay') is not None:
            self.last_work_day = m.get('lastWorkDay')
        if m.get('staffId') is not None:
            self.staff_id = m.get('staffId')
        return self


class GetDismissionRecordResponseBodyResult(TeaModel):
    def __init__(
        self,
        has_more: bool = None,
        list: List[GetDismissionRecordResponseBodyResultList] = None,
        next_cursor: int = None,
    ):
        self.has_more = has_more
        self.list = list
        self.next_cursor = next_cursor

    def validate(self):
        if self.list:
            for k in self.list:
                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['list'] = []
        if self.list is not None:
            for k in self.list:
                result['list'].append(k.to_map() if k else None)
        if self.next_cursor is not None:
            result['nextCursor'] = self.next_cursor
        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.list = []
        if m.get('list') is not None:
            for k in m.get('list'):
                temp_model = GetDismissionRecordResponseBodyResultList()
                self.list.append(temp_model.from_map(k))
        if m.get('nextCursor') is not None:
            self.next_cursor = m.get('nextCursor')
        return self


class GetDismissionRecordResponseBody(TeaModel):
    def __init__(
        self,
        result: GetDismissionRecordResponseBodyResult = None,
        success: bool = None,
    ):
        self.result = result
        self.success = success

    def validate(self):
        if self.result:
            self.result.validate()

    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.to_map()
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('result') is not None:
            temp_model = GetDismissionRecordResponseBodyResult()
            self.result = temp_model.from_map(m['result'])
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class GetDismissionRecordResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: GetDismissionRecordResponseBody = 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 = GetDismissionRecordResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetEmployeeRosterByFieldHeaders(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 GetEmployeeRosterByFieldRequest(TeaModel):
    def __init__(
        self,
        app_agent_id: int = None,
        field_filter_list: List[str] = None,
        text_2select_convert: bool = None,
        user_id_list: List[str] = None,
    ):
        # This parameter is required.
        self.app_agent_id = app_agent_id
        self.field_filter_list = field_filter_list
        self.text_2select_convert = text_2select_convert
        # This parameter is required.
        self.user_id_list = user_id_list

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.app_agent_id is not None:
            result['appAgentId'] = self.app_agent_id
        if self.field_filter_list is not None:
            result['fieldFilterList'] = self.field_filter_list
        if self.text_2select_convert is not None:
            result['text2SelectConvert'] = self.text_2select_convert
        if self.user_id_list is not None:
            result['userIdList'] = self.user_id_list
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('appAgentId') is not None:
            self.app_agent_id = m.get('appAgentId')
        if m.get('fieldFilterList') is not None:
            self.field_filter_list = m.get('fieldFilterList')
        if m.get('text2SelectConvert') is not None:
            self.text_2select_convert = m.get('text2SelectConvert')
        if m.get('userIdList') is not None:
            self.user_id_list = m.get('userIdList')
        return self


class GetEmployeeRosterByFieldResponseBodyResultFieldDataListFieldValueList(TeaModel):
    def __init__(
        self,
        item_index: int = None,
        label: str = None,
        value: str = None,
    ):
        self.item_index = item_index
        self.label = label
        self.value = value

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.item_index is not None:
            result['itemIndex'] = self.item_index
        if self.label is not None:
            result['label'] = self.label
        if self.value is not None:
            result['value'] = self.value
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('itemIndex') is not None:
            self.item_index = m.get('itemIndex')
        if m.get('label') is not None:
            self.label = m.get('label')
        if m.get('value') is not None:
            self.value = m.get('value')
        return self


class GetEmployeeRosterByFieldResponseBodyResultFieldDataList(TeaModel):
    def __init__(
        self,
        field_code: str = None,
        field_name: str = None,
        field_value_list: List[GetEmployeeRosterByFieldResponseBodyResultFieldDataListFieldValueList] = None,
        group_id: str = None,
    ):
        self.field_code = field_code
        self.field_name = field_name
        self.field_value_list = field_value_list
        self.group_id = group_id

    def validate(self):
        if self.field_value_list:
            for k in self.field_value_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.field_code is not None:
            result['fieldCode'] = self.field_code
        if self.field_name is not None:
            result['fieldName'] = self.field_name
        result['fieldValueList'] = []
        if self.field_value_list is not None:
            for k in self.field_value_list:
                result['fieldValueList'].append(k.to_map() if k else None)
        if self.group_id is not None:
            result['groupId'] = self.group_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('fieldCode') is not None:
            self.field_code = m.get('fieldCode')
        if m.get('fieldName') is not None:
            self.field_name = m.get('fieldName')
        self.field_value_list = []
        if m.get('fieldValueList') is not None:
            for k in m.get('fieldValueList'):
                temp_model = GetEmployeeRosterByFieldResponseBodyResultFieldDataListFieldValueList()
                self.field_value_list.append(temp_model.from_map(k))
        if m.get('groupId') is not None:
            self.group_id = m.get('groupId')
        return self


class GetEmployeeRosterByFieldResponseBodyResult(TeaModel):
    def __init__(
        self,
        corp_id: str = None,
        field_data_list: List[GetEmployeeRosterByFieldResponseBodyResultFieldDataList] = None,
        union_id: str = None,
        user_id: str = None,
    ):
        self.corp_id = corp_id
        self.field_data_list = field_data_list
        self.union_id = union_id
        self.user_id = user_id

    def validate(self):
        if self.field_data_list:
            for k in self.field_data_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.corp_id is not None:
            result['corpId'] = self.corp_id
        result['fieldDataList'] = []
        if self.field_data_list is not None:
            for k in self.field_data_list:
                result['fieldDataList'].append(k.to_map() if k else None)
        if self.union_id is not None:
            result['unionId'] = self.union_id
        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('corpId') is not None:
            self.corp_id = m.get('corpId')
        self.field_data_list = []
        if m.get('fieldDataList') is not None:
            for k in m.get('fieldDataList'):
                temp_model = GetEmployeeRosterByFieldResponseBodyResultFieldDataList()
                self.field_data_list.append(temp_model.from_map(k))
        if m.get('unionId') is not None:
            self.union_id = m.get('unionId')
        if m.get('userId') is not None:
            self.user_id = m.get('userId')
        return self


class GetEmployeeRosterByFieldResponseBody(TeaModel):
    def __init__(
        self,
        result: List[GetEmployeeRosterByFieldResponseBodyResult] = None,
    ):
        self.result = result

    def validate(self):
        if self.result:
            for k in self.result:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['result'] = []
        if self.result is not None:
            for k in self.result:
                result['result'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.result = []
        if m.get('result') is not None:
            for k in m.get('result'):
                temp_model = GetEmployeeRosterByFieldResponseBodyResult()
                self.result.append(temp_model.from_map(k))
        return self


class GetEmployeeRosterByFieldResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: GetEmployeeRosterByFieldResponseBody = 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 = GetEmployeeRosterByFieldResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetFileTemplateListHeaders(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 GetFileTemplateListRequest(TeaModel):
    def __init__(
        self,
        max_results: int = None,
        next_token: int = None,
        sign_source: str = None,
        template_status: int = None,
        template_type_list: List[str] = None,
    ):
        self.max_results = max_results
        self.next_token = next_token
        # This parameter is required.
        self.sign_source = sign_source
        self.template_status = template_status
        self.template_type_list = template_type_list

    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.sign_source is not None:
            result['signSource'] = self.sign_source
        if self.template_status is not None:
            result['templateStatus'] = self.template_status
        if self.template_type_list is not None:
            result['templateTypeList'] = self.template_type_list
        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('signSource') is not None:
            self.sign_source = m.get('signSource')
        if m.get('templateStatus') is not None:
            self.template_status = m.get('templateStatus')
        if m.get('templateTypeList') is not None:
            self.template_type_list = m.get('templateTypeList')
        return self


class GetFileTemplateListResponseBodyResultDataAttachmentList(TeaModel):
    def __init__(
        self,
        desc: str = None,
        field_code: str = None,
        field_name: str = None,
        field_type: str = None,
        group_id: str = None,
        sign_required: bool = None,
        user_custom_field: bool = None,
    ):
        self.desc = desc
        self.field_code = field_code
        self.field_name = field_name
        self.field_type = field_type
        self.group_id = group_id
        self.sign_required = sign_required
        self.user_custom_field = user_custom_field

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.desc is not None:
            result['desc'] = self.desc
        if self.field_code is not None:
            result['fieldCode'] = self.field_code
        if self.field_name is not None:
            result['fieldName'] = self.field_name
        if self.field_type is not None:
            result['fieldType'] = self.field_type
        if self.group_id is not None:
            result['groupId'] = self.group_id
        if self.sign_required is not None:
            result['signRequired'] = self.sign_required
        if self.user_custom_field is not None:
            result['userCustomField'] = self.user_custom_field
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('desc') is not None:
            self.desc = m.get('desc')
        if m.get('fieldCode') is not None:
            self.field_code = m.get('fieldCode')
        if m.get('fieldName') is not None:
            self.field_name = m.get('fieldName')
        if m.get('fieldType') is not None:
            self.field_type = m.get('fieldType')
        if m.get('groupId') is not None:
            self.group_id = m.get('groupId')
        if m.get('signRequired') is not None:
            self.sign_required = m.get('signRequired')
        if m.get('userCustomField') is not None:
            self.user_custom_field = m.get('userCustomField')
        return self


class GetFileTemplateListResponseBodyResultDataFieldList(TeaModel):
    def __init__(
        self,
        desc: str = None,
        field_code: str = None,
        field_name: str = None,
        field_type: str = None,
        group_id: str = None,
        sign_required: bool = None,
        user_custom_field: bool = None,
    ):
        self.desc = desc
        self.field_code = field_code
        self.field_name = field_name
        self.field_type = field_type
        self.group_id = group_id
        self.sign_required = sign_required
        self.user_custom_field = user_custom_field

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.desc is not None:
            result['desc'] = self.desc
        if self.field_code is not None:
            result['fieldCode'] = self.field_code
        if self.field_name is not None:
            result['fieldName'] = self.field_name
        if self.field_type is not None:
            result['fieldType'] = self.field_type
        if self.group_id is not None:
            result['groupId'] = self.group_id
        if self.sign_required is not None:
            result['signRequired'] = self.sign_required
        if self.user_custom_field is not None:
            result['userCustomField'] = self.user_custom_field
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('desc') is not None:
            self.desc = m.get('desc')
        if m.get('fieldCode') is not None:
            self.field_code = m.get('fieldCode')
        if m.get('fieldName') is not None:
            self.field_name = m.get('fieldName')
        if m.get('fieldType') is not None:
            self.field_type = m.get('fieldType')
        if m.get('groupId') is not None:
            self.group_id = m.get('groupId')
        if m.get('signRequired') is not None:
            self.sign_required = m.get('signRequired')
        if m.get('userCustomField') is not None:
            self.user_custom_field = m.get('userCustomField')
        return self


class GetFileTemplateListResponseBodyResultDataGroupListFieldList(TeaModel):
    def __init__(
        self,
        desc: str = None,
        field_code: str = None,
        field_name: str = None,
        field_type: str = None,
        group_id: str = None,
        sign_required: bool = None,
        user_custom_field: bool = None,
    ):
        self.desc = desc
        self.field_code = field_code
        self.field_name = field_name
        self.field_type = field_type
        self.group_id = group_id
        self.sign_required = sign_required
        self.user_custom_field = user_custom_field

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.desc is not None:
            result['desc'] = self.desc
        if self.field_code is not None:
            result['fieldCode'] = self.field_code
        if self.field_name is not None:
            result['fieldName'] = self.field_name
        if self.field_type is not None:
            result['fieldType'] = self.field_type
        if self.group_id is not None:
            result['groupId'] = self.group_id
        if self.sign_required is not None:
            result['signRequired'] = self.sign_required
        if self.user_custom_field is not None:
            result['userCustomField'] = self.user_custom_field
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('desc') is not None:
            self.desc = m.get('desc')
        if m.get('fieldCode') is not None:
            self.field_code = m.get('fieldCode')
        if m.get('fieldName') is not None:
            self.field_name = m.get('fieldName')
        if m.get('fieldType') is not None:
            self.field_type = m.get('fieldType')
        if m.get('groupId') is not None:
            self.group_id = m.get('groupId')
        if m.get('signRequired') is not None:
            self.sign_required = m.get('signRequired')
        if m.get('userCustomField') is not None:
            self.user_custom_field = m.get('userCustomField')
        return self


class GetFileTemplateListResponseBodyResultDataGroupList(TeaModel):
    def __init__(
        self,
        detail_flag: bool = None,
        field_list: List[GetFileTemplateListResponseBodyResultDataGroupListFieldList] = None,
        group_id: str = None,
        group_name: str = None,
    ):
        self.detail_flag = detail_flag
        self.field_list = field_list
        self.group_id = group_id
        self.group_name = group_name

    def validate(self):
        if self.field_list:
            for k in self.field_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.detail_flag is not None:
            result['detailFlag'] = self.detail_flag
        result['fieldList'] = []
        if self.field_list is not None:
            for k in self.field_list:
                result['fieldList'].append(k.to_map() if k else None)
        if self.group_id is not None:
            result['groupId'] = self.group_id
        if self.group_name is not None:
            result['groupName'] = self.group_name
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('detailFlag') is not None:
            self.detail_flag = m.get('detailFlag')
        self.field_list = []
        if m.get('fieldList') is not None:
            for k in m.get('fieldList'):
                temp_model = GetFileTemplateListResponseBodyResultDataGroupListFieldList()
                self.field_list.append(temp_model.from_map(k))
        if m.get('groupId') is not None:
            self.group_id = m.get('groupId')
        if m.get('groupName') is not None:
            self.group_name = m.get('groupName')
        return self


class GetFileTemplateListResponseBodyResultData(TeaModel):
    def __init__(
        self,
        attachment_list: List[GetFileTemplateListResponseBodyResultDataAttachmentList] = None,
        corp_id: str = None,
        field_list: List[GetFileTemplateListResponseBodyResultDataFieldList] = None,
        group_list: List[GetFileTemplateListResponseBodyResultDataGroupList] = None,
        template_id: str = None,
        template_inst_name: str = None,
        template_name: str = None,
        template_sign_status: int = None,
        template_status: int = None,
        template_type: str = None,
        template_type_name: str = None,
        tenant_id: int = None,
    ):
        self.attachment_list = attachment_list
        self.corp_id = corp_id
        self.field_list = field_list
        self.group_list = group_list
        self.template_id = template_id
        self.template_inst_name = template_inst_name
        self.template_name = template_name
        self.template_sign_status = template_sign_status
        self.template_status = template_status
        self.template_type = template_type
        self.template_type_name = template_type_name
        self.tenant_id = tenant_id

    def validate(self):
        if self.attachment_list:
            for k in self.attachment_list:
                if k:
                    k.validate()
        if self.field_list:
            for k in self.field_list:
                if k:
                    k.validate()
        if self.group_list:
            for k in self.group_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['attachmentList'] = []
        if self.attachment_list is not None:
            for k in self.attachment_list:
                result['attachmentList'].append(k.to_map() if k else None)
        if self.corp_id is not None:
            result['corpId'] = self.corp_id
        result['fieldList'] = []
        if self.field_list is not None:
            for k in self.field_list:
                result['fieldList'].append(k.to_map() if k else None)
        result['groupList'] = []
        if self.group_list is not None:
            for k in self.group_list:
                result['groupList'].append(k.to_map() if k else None)
        if self.template_id is not None:
            result['templateId'] = self.template_id
        if self.template_inst_name is not None:
            result['templateInstName'] = self.template_inst_name
        if self.template_name is not None:
            result['templateName'] = self.template_name
        if self.template_sign_status is not None:
            result['templateSignStatus'] = self.template_sign_status
        if self.template_status is not None:
            result['templateStatus'] = self.template_status
        if self.template_type is not None:
            result['templateType'] = self.template_type
        if self.template_type_name is not None:
            result['templateTypeName'] = self.template_type_name
        if self.tenant_id is not None:
            result['tenantId'] = self.tenant_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.attachment_list = []
        if m.get('attachmentList') is not None:
            for k in m.get('attachmentList'):
                temp_model = GetFileTemplateListResponseBodyResultDataAttachmentList()
                self.attachment_list.append(temp_model.from_map(k))
        if m.get('corpId') is not None:
            self.corp_id = m.get('corpId')
        self.field_list = []
        if m.get('fieldList') is not None:
            for k in m.get('fieldList'):
                temp_model = GetFileTemplateListResponseBodyResultDataFieldList()
                self.field_list.append(temp_model.from_map(k))
        self.group_list = []
        if m.get('groupList') is not None:
            for k in m.get('groupList'):
                temp_model = GetFileTemplateListResponseBodyResultDataGroupList()
                self.group_list.append(temp_model.from_map(k))
        if m.get('templateId') is not None:
            self.template_id = m.get('templateId')
        if m.get('templateInstName') is not None:
            self.template_inst_name = m.get('templateInstName')
        if m.get('templateName') is not None:
            self.template_name = m.get('templateName')
        if m.get('templateSignStatus') is not None:
            self.template_sign_status = m.get('templateSignStatus')
        if m.get('templateStatus') is not None:
            self.template_status = m.get('templateStatus')
        if m.get('templateType') is not None:
            self.template_type = m.get('templateType')
        if m.get('templateTypeName') is not None:
            self.template_type_name = m.get('templateTypeName')
        if m.get('tenantId') is not None:
            self.tenant_id = m.get('tenantId')
        return self


class GetFileTemplateListResponseBodyResult(TeaModel):
    def __init__(
        self,
        data: List[GetFileTemplateListResponseBodyResultData] = None,
        has_more: bool = None,
        next_token: int = None,
    ):
        self.data = data
        # This parameter is required.
        self.has_more = has_more
        self.next_token = next_token

    def validate(self):
        if self.data:
            for k in self.data:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['data'] = []
        if self.data is not None:
            for k in self.data:
                result['data'].append(k.to_map() if k else None)
        if self.has_more is not None:
            result['hasMore'] = self.has_more
        if self.next_token is not None:
            result['nextToken'] = self.next_token
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.data = []
        if m.get('data') is not None:
            for k in m.get('data'):
                temp_model = GetFileTemplateListResponseBodyResultData()
                self.data.append(temp_model.from_map(k))
        if m.get('hasMore') is not None:
            self.has_more = m.get('hasMore')
        if m.get('nextToken') is not None:
            self.next_token = m.get('nextToken')
        return self


class GetFileTemplateListResponseBody(TeaModel):
    def __init__(
        self,
        result: GetFileTemplateListResponseBodyResult = None,
        success: bool = None,
    ):
        self.result = result
        self.success = success

    def validate(self):
        if self.result:
            self.result.validate()

    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.to_map()
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('result') is not None:
            temp_model = GetFileTemplateListResponseBodyResult()
            self.result = temp_model.from_map(m['result'])
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class GetFileTemplateListResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: GetFileTemplateListResponseBody = 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 = GetFileTemplateListResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetSignRecordByIdHeaders(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 GetSignRecordByIdRequest(TeaModel):
    def __init__(
        self,
        body: List[str] = None,
    ):
        # This parameter is required.
        self.body = body

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.body is not None:
            result['body'] = self.body
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('body') is not None:
            self.body = m.get('body')
        return self


class GetSignRecordByIdResponseBodyResult(TeaModel):
    def __init__(
        self,
        corp_id: str = None,
        remark: str = None,
        sign_expire_time: int = None,
        sign_file_name: str = None,
        sign_finish_time: int = None,
        sign_legal_entity_name: str = None,
        sign_record_id: str = None,
        sign_start_time: int = None,
        sign_status: str = None,
        sign_status_remarks: str = None,
        sign_template_type: str = None,
        sign_user_id: str = None,
        sign_user_name: str = None,
        sign_way: str = None,
    ):
        self.corp_id = corp_id
        self.remark = remark
        self.sign_expire_time = sign_expire_time
        self.sign_file_name = sign_file_name
        self.sign_finish_time = sign_finish_time
        self.sign_legal_entity_name = sign_legal_entity_name
        self.sign_record_id = sign_record_id
        self.sign_start_time = sign_start_time
        self.sign_status = sign_status
        self.sign_status_remarks = sign_status_remarks
        self.sign_template_type = sign_template_type
        self.sign_user_id = sign_user_id
        self.sign_user_name = sign_user_name
        self.sign_way = sign_way

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.corp_id is not None:
            result['corpId'] = self.corp_id
        if self.remark is not None:
            result['remark'] = self.remark
        if self.sign_expire_time is not None:
            result['signExpireTime'] = self.sign_expire_time
        if self.sign_file_name is not None:
            result['signFileName'] = self.sign_file_name
        if self.sign_finish_time is not None:
            result['signFinishTime'] = self.sign_finish_time
        if self.sign_legal_entity_name is not None:
            result['signLegalEntityName'] = self.sign_legal_entity_name
        if self.sign_record_id is not None:
            result['signRecordId'] = self.sign_record_id
        if self.sign_start_time is not None:
            result['signStartTime'] = self.sign_start_time
        if self.sign_status is not None:
            result['signStatus'] = self.sign_status
        if self.sign_status_remarks is not None:
            result['signStatusRemarks'] = self.sign_status_remarks
        if self.sign_template_type is not None:
            result['signTemplateType'] = self.sign_template_type
        if self.sign_user_id is not None:
            result['signUserId'] = self.sign_user_id
        if self.sign_user_name is not None:
            result['signUserName'] = self.sign_user_name
        if self.sign_way is not None:
            result['signWay'] = self.sign_way
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('corpId') is not None:
            self.corp_id = m.get('corpId')
        if m.get('remark') is not None:
            self.remark = m.get('remark')
        if m.get('signExpireTime') is not None:
            self.sign_expire_time = m.get('signExpireTime')
        if m.get('signFileName') is not None:
            self.sign_file_name = m.get('signFileName')
        if m.get('signFinishTime') is not None:
            self.sign_finish_time = m.get('signFinishTime')
        if m.get('signLegalEntityName') is not None:
            self.sign_legal_entity_name = m.get('signLegalEntityName')
        if m.get('signRecordId') is not None:
            self.sign_record_id = m.get('signRecordId')
        if m.get('signStartTime') is not None:
            self.sign_start_time = m.get('signStartTime')
        if m.get('signStatus') is not None:
            self.sign_status = m.get('signStatus')
        if m.get('signStatusRemarks') is not None:
            self.sign_status_remarks = m.get('signStatusRemarks')
        if m.get('signTemplateType') is not None:
            self.sign_template_type = m.get('signTemplateType')
        if m.get('signUserId') is not None:
            self.sign_user_id = m.get('signUserId')
        if m.get('signUserName') is not None:
            self.sign_user_name = m.get('signUserName')
        if m.get('signWay') is not None:
            self.sign_way = m.get('signWay')
        return self


class GetSignRecordByIdResponseBody(TeaModel):
    def __init__(
        self,
        result: List[GetSignRecordByIdResponseBodyResult] = None,
        success: bool = None,
    ):
        self.result = result
        # This parameter is required.
        self.success = success

    def validate(self):
        if self.result:
            for k in self.result:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['result'] = []
        if self.result is not None:
            for k in self.result:
                result['result'].append(k.to_map() if k else None)
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.result = []
        if m.get('result') is not None:
            for k in m.get('result'):
                temp_model = GetSignRecordByIdResponseBodyResult()
                self.result.append(temp_model.from_map(k))
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class GetSignRecordByIdResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: GetSignRecordByIdResponseBody = 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 = GetSignRecordByIdResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetSignRecordByUserIdHeaders(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 GetSignRecordByUserIdRequest(TeaModel):
    def __init__(
        self,
        max_results: int = None,
        next_token: int = None,
        sign_status: List[str] = None,
        sign_user_id: str = None,
    ):
        self.max_results = max_results
        self.next_token = next_token
        self.sign_status = sign_status
        # This parameter is required.
        self.sign_user_id = sign_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.max_results is not None:
            result['maxResults'] = self.max_results
        if self.next_token is not None:
            result['nextToken'] = self.next_token
        if self.sign_status is not None:
            result['signStatus'] = self.sign_status
        if self.sign_user_id is not None:
            result['signUserId'] = self.sign_user_id
        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('signStatus') is not None:
            self.sign_status = m.get('signStatus')
        if m.get('signUserId') is not None:
            self.sign_user_id = m.get('signUserId')
        return self


class GetSignRecordByUserIdResponseBodyResultData(TeaModel):
    def __init__(
        self,
        corp_id: str = None,
        outer_id: str = None,
        remark: str = None,
        sign_expire_time: int = None,
        sign_file_name: str = None,
        sign_file_url: str = None,
        sign_finish_time: int = None,
        sign_legal_entity_name: str = None,
        sign_record_id: str = None,
        sign_start_time: int = None,
        sign_status: str = None,
        sign_status_remarks: str = None,
        sign_template_type: str = None,
        sign_user_id: str = None,
        sign_user_name: str = None,
        sign_way: str = None,
    ):
        self.corp_id = corp_id
        self.outer_id = outer_id
        self.remark = remark
        self.sign_expire_time = sign_expire_time
        self.sign_file_name = sign_file_name
        self.sign_file_url = sign_file_url
        self.sign_finish_time = sign_finish_time
        self.sign_legal_entity_name = sign_legal_entity_name
        self.sign_record_id = sign_record_id
        self.sign_start_time = sign_start_time
        self.sign_status = sign_status
        self.sign_status_remarks = sign_status_remarks
        self.sign_template_type = sign_template_type
        self.sign_user_id = sign_user_id
        self.sign_user_name = sign_user_name
        self.sign_way = sign_way

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.corp_id is not None:
            result['corpId'] = self.corp_id
        if self.outer_id is not None:
            result['outerId'] = self.outer_id
        if self.remark is not None:
            result['remark'] = self.remark
        if self.sign_expire_time is not None:
            result['signExpireTime'] = self.sign_expire_time
        if self.sign_file_name is not None:
            result['signFileName'] = self.sign_file_name
        if self.sign_file_url is not None:
            result['signFileUrl'] = self.sign_file_url
        if self.sign_finish_time is not None:
            result['signFinishTime'] = self.sign_finish_time
        if self.sign_legal_entity_name is not None:
            result['signLegalEntityName'] = self.sign_legal_entity_name
        if self.sign_record_id is not None:
            result['signRecordId'] = self.sign_record_id
        if self.sign_start_time is not None:
            result['signStartTime'] = self.sign_start_time
        if self.sign_status is not None:
            result['signStatus'] = self.sign_status
        if self.sign_status_remarks is not None:
            result['signStatusRemarks'] = self.sign_status_remarks
        if self.sign_template_type is not None:
            result['signTemplateType'] = self.sign_template_type
        if self.sign_user_id is not None:
            result['signUserId'] = self.sign_user_id
        if self.sign_user_name is not None:
            result['signUserName'] = self.sign_user_name
        if self.sign_way is not None:
            result['signWay'] = self.sign_way
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('corpId') is not None:
            self.corp_id = m.get('corpId')
        if m.get('outerId') is not None:
            self.outer_id = m.get('outerId')
        if m.get('remark') is not None:
            self.remark = m.get('remark')
        if m.get('signExpireTime') is not None:
            self.sign_expire_time = m.get('signExpireTime')
        if m.get('signFileName') is not None:
            self.sign_file_name = m.get('signFileName')
        if m.get('signFileUrl') is not None:
            self.sign_file_url = m.get('signFileUrl')
        if m.get('signFinishTime') is not None:
            self.sign_finish_time = m.get('signFinishTime')
        if m.get('signLegalEntityName') is not None:
            self.sign_legal_entity_name = m.get('signLegalEntityName')
        if m.get('signRecordId') is not None:
            self.sign_record_id = m.get('signRecordId')
        if m.get('signStartTime') is not None:
            self.sign_start_time = m.get('signStartTime')
        if m.get('signStatus') is not None:
            self.sign_status = m.get('signStatus')
        if m.get('signStatusRemarks') is not None:
            self.sign_status_remarks = m.get('signStatusRemarks')
        if m.get('signTemplateType') is not None:
            self.sign_template_type = m.get('signTemplateType')
        if m.get('signUserId') is not None:
            self.sign_user_id = m.get('signUserId')
        if m.get('signUserName') is not None:
            self.sign_user_name = m.get('signUserName')
        if m.get('signWay') is not None:
            self.sign_way = m.get('signWay')
        return self


class GetSignRecordByUserIdResponseBodyResult(TeaModel):
    def __init__(
        self,
        data: List[GetSignRecordByUserIdResponseBodyResultData] = None,
        has_more: bool = None,
        next_token: int = None,
    ):
        self.data = data
        self.has_more = has_more
        self.next_token = next_token

    def validate(self):
        if self.data:
            for k in self.data:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['data'] = []
        if self.data is not None:
            for k in self.data:
                result['data'].append(k.to_map() if k else None)
        if self.has_more is not None:
            result['hasMore'] = self.has_more
        if self.next_token is not None:
            result['nextToken'] = self.next_token
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.data = []
        if m.get('data') is not None:
            for k in m.get('data'):
                temp_model = GetSignRecordByUserIdResponseBodyResultData()
                self.data.append(temp_model.from_map(k))
        if m.get('hasMore') is not None:
            self.has_more = m.get('hasMore')
        if m.get('nextToken') is not None:
            self.next_token = m.get('nextToken')
        return self


class GetSignRecordByUserIdResponseBody(TeaModel):
    def __init__(
        self,
        result: GetSignRecordByUserIdResponseBodyResult = None,
        success: bool = None,
    ):
        self.result = result
        self.success = success

    def validate(self):
        if self.result:
            self.result.validate()

    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.to_map()
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('result') is not None:
            temp_model = GetSignRecordByUserIdResponseBodyResult()
            self.result = temp_model.from_map(m['result'])
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class GetSignRecordByUserIdResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: GetSignRecordByUserIdResponseBody = 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 = GetSignRecordByUserIdResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class GetUserSignedRecordsByOuterIdHeaders(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 GetUserSignedRecordsByOuterIdRequest(TeaModel):
    def __init__(
        self,
        body: List[str] = None,
    ):
        self.body = body

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.body is not None:
            result['body'] = self.body
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('body') is not None:
            self.body = m.get('body')
        return self


class GetUserSignedRecordsByOuterIdResponseBodyResult(TeaModel):
    def __init__(
        self,
        corp_id: str = None,
        outer_id: str = None,
        remark: str = None,
        sign_expire_time: str = None,
        sign_file_name: str = None,
        sign_file_url: str = None,
        sign_finish_time: str = None,
        sign_legal_entity_name: str = None,
        sign_record_id: str = None,
        sign_start_time: str = None,
        sign_status: str = None,
        sign_status_remarks: str = None,
        sign_template_type: str = None,
        sign_user_id: str = None,
        sign_user_name: str = None,
        sign_way: str = None,
    ):
        self.corp_id = corp_id
        self.outer_id = outer_id
        self.remark = remark
        self.sign_expire_time = sign_expire_time
        self.sign_file_name = sign_file_name
        self.sign_file_url = sign_file_url
        self.sign_finish_time = sign_finish_time
        self.sign_legal_entity_name = sign_legal_entity_name
        self.sign_record_id = sign_record_id
        self.sign_start_time = sign_start_time
        self.sign_status = sign_status
        self.sign_status_remarks = sign_status_remarks
        self.sign_template_type = sign_template_type
        self.sign_user_id = sign_user_id
        self.sign_user_name = sign_user_name
        self.sign_way = sign_way

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.corp_id is not None:
            result['corpId'] = self.corp_id
        if self.outer_id is not None:
            result['outerId'] = self.outer_id
        if self.remark is not None:
            result['remark'] = self.remark
        if self.sign_expire_time is not None:
            result['signExpireTime'] = self.sign_expire_time
        if self.sign_file_name is not None:
            result['signFileName'] = self.sign_file_name
        if self.sign_file_url is not None:
            result['signFileUrl'] = self.sign_file_url
        if self.sign_finish_time is not None:
            result['signFinishTime'] = self.sign_finish_time
        if self.sign_legal_entity_name is not None:
            result['signLegalEntityName'] = self.sign_legal_entity_name
        if self.sign_record_id is not None:
            result['signRecordId'] = self.sign_record_id
        if self.sign_start_time is not None:
            result['signStartTime'] = self.sign_start_time
        if self.sign_status is not None:
            result['signStatus'] = self.sign_status
        if self.sign_status_remarks is not None:
            result['signStatusRemarks'] = self.sign_status_remarks
        if self.sign_template_type is not None:
            result['signTemplateType'] = self.sign_template_type
        if self.sign_user_id is not None:
            result['signUserId'] = self.sign_user_id
        if self.sign_user_name is not None:
            result['signUserName'] = self.sign_user_name
        if self.sign_way is not None:
            result['signWay'] = self.sign_way
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('corpId') is not None:
            self.corp_id = m.get('corpId')
        if m.get('outerId') is not None:
            self.outer_id = m.get('outerId')
        if m.get('remark') is not None:
            self.remark = m.get('remark')
        if m.get('signExpireTime') is not None:
            self.sign_expire_time = m.get('signExpireTime')
        if m.get('signFileName') is not None:
            self.sign_file_name = m.get('signFileName')
        if m.get('signFileUrl') is not None:
            self.sign_file_url = m.get('signFileUrl')
        if m.get('signFinishTime') is not None:
            self.sign_finish_time = m.get('signFinishTime')
        if m.get('signLegalEntityName') is not None:
            self.sign_legal_entity_name = m.get('signLegalEntityName')
        if m.get('signRecordId') is not None:
            self.sign_record_id = m.get('signRecordId')
        if m.get('signStartTime') is not None:
            self.sign_start_time = m.get('signStartTime')
        if m.get('signStatus') is not None:
            self.sign_status = m.get('signStatus')
        if m.get('signStatusRemarks') is not None:
            self.sign_status_remarks = m.get('signStatusRemarks')
        if m.get('signTemplateType') is not None:
            self.sign_template_type = m.get('signTemplateType')
        if m.get('signUserId') is not None:
            self.sign_user_id = m.get('signUserId')
        if m.get('signUserName') is not None:
            self.sign_user_name = m.get('signUserName')
        if m.get('signWay') is not None:
            self.sign_way = m.get('signWay')
        return self


class GetUserSignedRecordsByOuterIdResponseBody(TeaModel):
    def __init__(
        self,
        result: List[GetUserSignedRecordsByOuterIdResponseBodyResult] = None,
        success: bool = None,
    ):
        self.result = result
        self.success = success

    def validate(self):
        if self.result:
            for k in self.result:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['result'] = []
        if self.result is not None:
            for k in self.result:
                result['result'].append(k.to_map() if k else None)
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.result = []
        if m.get('result') is not None:
            for k in m.get('result'):
                temp_model = GetUserSignedRecordsByOuterIdResponseBodyResult()
                self.result.append(temp_model.from_map(k))
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class GetUserSignedRecordsByOuterIdResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: GetUserSignedRecordsByOuterIdResponseBody = 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 = GetUserSignedRecordsByOuterIdResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class HrmAuthResourcesQueryHeaders(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 HrmAuthResourcesQueryRequest(TeaModel):
    def __init__(
        self,
        auth_resource_ids: List[str] = None,
        user_id: str = None,
    ):
        # This parameter is required.
        self.auth_resource_ids = auth_resource_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.auth_resource_ids is not None:
            result['authResourceIds'] = self.auth_resource_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('authResourceIds') is not None:
            self.auth_resource_ids = m.get('authResourceIds')
        if m.get('userId') is not None:
            self.user_id = m.get('userId')
        return self


class HrmAuthResourcesQueryResponseBodyResult(TeaModel):
    def __init__(
        self,
        authorized: bool = None,
        resource_id: str = None,
    ):
        self.authorized = authorized
        self.resource_id = resource_id

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.authorized is not None:
            result['authorized'] = self.authorized
        if self.resource_id is not None:
            result['resourceId'] = self.resource_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('authorized') is not None:
            self.authorized = m.get('authorized')
        if m.get('resourceId') is not None:
            self.resource_id = m.get('resourceId')
        return self


class HrmAuthResourcesQueryResponseBody(TeaModel):
    def __init__(
        self,
        result: List[HrmAuthResourcesQueryResponseBodyResult] = None,
    ):
        self.result = result

    def validate(self):
        if self.result:
            for k in self.result:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['result'] = []
        if self.result is not None:
            for k in self.result:
                result['result'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.result = []
        if m.get('result') is not None:
            for k in m.get('result'):
                temp_model = HrmAuthResourcesQueryResponseBodyResult()
                self.result.append(temp_model.from_map(k))
        return self


class HrmAuthResourcesQueryResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: HrmAuthResourcesQueryResponseBody = 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 = HrmAuthResourcesQueryResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class HrmBenefitQueryHeaders(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 HrmBenefitQueryRequest(TeaModel):
    def __init__(
        self,
        benefit_codes: List[str] = None,
    ):
        # This parameter is required.
        self.benefit_codes = benefit_codes

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.benefit_codes is not None:
            result['benefitCodes'] = self.benefit_codes
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('benefitCodes') is not None:
            self.benefit_codes = m.get('benefitCodes')
        return self


class HrmBenefitQueryResponseBody(TeaModel):
    def __init__(
        self,
        result: Any = None,
    ):
        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 HrmBenefitQueryResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: HrmBenefitQueryResponseBody = 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 = HrmBenefitQueryResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class HrmCorpConfigQueryHeaders(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 HrmCorpConfigQueryRequest(TeaModel):
    def __init__(
        self,
        sub_type: str = None,
        type: str = None,
    ):
        # This parameter is required.
        self.sub_type = sub_type
        # This parameter is required.
        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.sub_type is not None:
            result['subType'] = self.sub_type
        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('subType') is not None:
            self.sub_type = m.get('subType')
        if m.get('type') is not None:
            self.type = m.get('type')
        return self


class HrmCorpConfigQueryResponseBody(TeaModel):
    def __init__(
        self,
        result: str = None,
    ):
        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 HrmCorpConfigQueryResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: HrmCorpConfigQueryResponseBody = 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 = HrmCorpConfigQueryResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class HrmMailSendHeaders(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 HrmMailSendRequestMailAttachments(TeaModel):
    def __init__(
        self,
        name: str = None,
        path: str = None,
        type: str = None,
    ):
        # This parameter is required.
        self.name = name
        # This parameter is required.
        self.path = path
        # This parameter is required.
        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.name is not None:
            result['name'] = self.name
        if self.path is not None:
            result['path'] = self.path
        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('name') is not None:
            self.name = m.get('name')
        if m.get('path') is not None:
            self.path = m.get('path')
        if m.get('type') is not None:
            self.type = m.get('type')
        return self


class HrmMailSendRequestMailMeetingAlarm(TeaModel):
    def __init__(
        self,
        alarm_desc: str = None,
        alarm_minutes: int = None,
        alarm_summary: str = None,
    ):
        # This parameter is required.
        self.alarm_desc = alarm_desc
        # This parameter is required.
        self.alarm_minutes = alarm_minutes
        # This parameter is required.
        self.alarm_summary = alarm_summary

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.alarm_desc is not None:
            result['alarmDesc'] = self.alarm_desc
        if self.alarm_minutes is not None:
            result['alarmMinutes'] = self.alarm_minutes
        if self.alarm_summary is not None:
            result['alarmSummary'] = self.alarm_summary
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('alarmDesc') is not None:
            self.alarm_desc = m.get('alarmDesc')
        if m.get('alarmMinutes') is not None:
            self.alarm_minutes = m.get('alarmMinutes')
        if m.get('alarmSummary') is not None:
            self.alarm_summary = m.get('alarmSummary')
        return self


class HrmMailSendRequestMailMeetingAttendees(TeaModel):
    def __init__(
        self,
        address: str = None,
        name: str = None,
    ):
        # This parameter is required.
        self.address = address
        # This parameter is required.
        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.address is not None:
            result['address'] = self.address
        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('address') is not None:
            self.address = m.get('address')
        if m.get('name') is not None:
            self.name = m.get('name')
        return self


class HrmMailSendRequestMailMeetingOrganizer(TeaModel):
    def __init__(
        self,
        address: str = None,
        name: str = None,
    ):
        # This parameter is required.
        self.address = address
        # This parameter is required.
        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.address is not None:
            result['address'] = self.address
        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('address') is not None:
            self.address = m.get('address')
        if m.get('name') is not None:
            self.name = m.get('name')
        return self


class HrmMailSendRequestMailMeeting(TeaModel):
    def __init__(
        self,
        alarm: HrmMailSendRequestMailMeetingAlarm = None,
        attendees: List[HrmMailSendRequestMailMeetingAttendees] = None,
        description: str = None,
        end_time: int = None,
        location: str = None,
        method: str = None,
        organizer: HrmMailSendRequestMailMeetingOrganizer = None,
        sequence: int = None,
        start_time: int = None,
        summary: str = None,
        uuid: str = None,
    ):
        self.alarm = alarm
        self.attendees = attendees
        self.description = description
        # This parameter is required.
        self.end_time = end_time
        self.location = location
        # This parameter is required.
        self.method = method
        self.organizer = organizer
        self.sequence = sequence
        # This parameter is required.
        self.start_time = start_time
        # This parameter is required.
        self.summary = summary
        # This parameter is required.
        self.uuid = uuid

    def validate(self):
        if self.alarm:
            self.alarm.validate()
        if self.attendees:
            for k in self.attendees:
                if k:
                    k.validate()
        if self.organizer:
            self.organizer.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.alarm is not None:
            result['alarm'] = self.alarm.to_map()
        result['attendees'] = []
        if self.attendees is not None:
            for k in self.attendees:
                result['attendees'].append(k.to_map() if k else None)
        if self.description is not None:
            result['description'] = self.description
        if self.end_time is not None:
            result['endTime'] = self.end_time
        if self.location is not None:
            result['location'] = self.location
        if self.method is not None:
            result['method'] = self.method
        if self.organizer is not None:
            result['organizer'] = self.organizer.to_map()
        if self.sequence is not None:
            result['sequence'] = self.sequence
        if self.start_time is not None:
            result['startTime'] = self.start_time
        if self.summary is not None:
            result['summary'] = self.summary
        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('alarm') is not None:
            temp_model = HrmMailSendRequestMailMeetingAlarm()
            self.alarm = temp_model.from_map(m['alarm'])
        self.attendees = []
        if m.get('attendees') is not None:
            for k in m.get('attendees'):
                temp_model = HrmMailSendRequestMailMeetingAttendees()
                self.attendees.append(temp_model.from_map(k))
        if m.get('description') is not None:
            self.description = m.get('description')
        if m.get('endTime') is not None:
            self.end_time = m.get('endTime')
        if m.get('location') is not None:
            self.location = m.get('location')
        if m.get('method') is not None:
            self.method = m.get('method')
        if m.get('organizer') is not None:
            temp_model = HrmMailSendRequestMailMeetingOrganizer()
            self.organizer = temp_model.from_map(m['organizer'])
        if m.get('sequence') is not None:
            self.sequence = m.get('sequence')
        if m.get('startTime') is not None:
            self.start_time = m.get('startTime')
        if m.get('summary') is not None:
            self.summary = m.get('summary')
        if m.get('uuid') is not None:
            self.uuid = m.get('uuid')
        return self


class HrmMailSendRequestMail(TeaModel):
    def __init__(
        self,
        attachments: List[HrmMailSendRequestMailAttachments] = None,
        bcc_address: str = None,
        cc_address: str = None,
        content: str = None,
        meeting: HrmMailSendRequestMailMeeting = None,
        receiver_address: str = None,
        sender_alias: str = None,
        subject: str = None,
    ):
        self.attachments = attachments
        self.bcc_address = bcc_address
        self.cc_address = cc_address
        # This parameter is required.
        self.content = content
        self.meeting = meeting
        # This parameter is required.
        self.receiver_address = receiver_address
        # This parameter is required.
        self.sender_alias = sender_alias
        # This parameter is required.
        self.subject = subject

    def validate(self):
        if self.attachments:
            for k in self.attachments:
                if k:
                    k.validate()
        if self.meeting:
            self.meeting.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['attachments'] = []
        if self.attachments is not None:
            for k in self.attachments:
                result['attachments'].append(k.to_map() if k else None)
        if self.bcc_address is not None:
            result['bccAddress'] = self.bcc_address
        if self.cc_address is not None:
            result['ccAddress'] = self.cc_address
        if self.content is not None:
            result['content'] = self.content
        if self.meeting is not None:
            result['meeting'] = self.meeting.to_map()
        if self.receiver_address is not None:
            result['receiverAddress'] = self.receiver_address
        if self.sender_alias is not None:
            result['senderAlias'] = self.sender_alias
        if self.subject is not None:
            result['subject'] = self.subject
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.attachments = []
        if m.get('attachments') is not None:
            for k in m.get('attachments'):
                temp_model = HrmMailSendRequestMailAttachments()
                self.attachments.append(temp_model.from_map(k))
        if m.get('bccAddress') is not None:
            self.bcc_address = m.get('bccAddress')
        if m.get('ccAddress') is not None:
            self.cc_address = m.get('ccAddress')
        if m.get('content') is not None:
            self.content = m.get('content')
        if m.get('meeting') is not None:
            temp_model = HrmMailSendRequestMailMeeting()
            self.meeting = temp_model.from_map(m['meeting'])
        if m.get('receiverAddress') is not None:
            self.receiver_address = m.get('receiverAddress')
        if m.get('senderAlias') is not None:
            self.sender_alias = m.get('senderAlias')
        if m.get('subject') is not None:
            self.subject = m.get('subject')
        return self


class HrmMailSendRequestOperator(TeaModel):
    def __init__(
        self,
        biz_id: str = None,
        mail_account_type: str = None,
        token: str = None,
    ):
        # This parameter is required.
        self.biz_id = biz_id
        # This parameter is required.
        self.mail_account_type = mail_account_type
        # This parameter is required.
        self.token = token

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_id is not None:
            result['bizId'] = self.biz_id
        if self.mail_account_type is not None:
            result['mailAccountType'] = self.mail_account_type
        if self.token is not None:
            result['token'] = self.token
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('bizId') is not None:
            self.biz_id = m.get('bizId')
        if m.get('mailAccountType') is not None:
            self.mail_account_type = m.get('mailAccountType')
        if m.get('token') is not None:
            self.token = m.get('token')
        return self


class HrmMailSendRequest(TeaModel):
    def __init__(
        self,
        mail: HrmMailSendRequestMail = None,
        operator: HrmMailSendRequestOperator = None,
    ):
        # This parameter is required.
        self.mail = mail
        # This parameter is required.
        self.operator = operator

    def validate(self):
        if self.mail:
            self.mail.validate()
        if self.operator:
            self.operator.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.mail is not None:
            result['mail'] = self.mail.to_map()
        if self.operator is not None:
            result['operator'] = self.operator.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('mail') is not None:
            temp_model = HrmMailSendRequestMail()
            self.mail = temp_model.from_map(m['mail'])
        if m.get('operator') is not None:
            temp_model = HrmMailSendRequestOperator()
            self.operator = temp_model.from_map(m['operator'])
        return self


class HrmMailSendResponseBody(TeaModel):
    def __init__(
        self,
        result: str = None,
    ):
        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 HrmMailSendResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: HrmMailSendResponseBody = 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 = HrmMailSendResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class HrmMokaEventHeaders(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 HrmMokaEventRequest(TeaModel):
    def __init__(
        self,
        biz_id: str = None,
        content: str = None,
    ):
        # This parameter is required.
        self.biz_id = biz_id
        # This parameter is required.
        self.content = content

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_id is not None:
            result['bizId'] = self.biz_id
        if self.content is not None:
            result['content'] = self.content
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('bizId') is not None:
            self.biz_id = m.get('bizId')
        if m.get('content') is not None:
            self.content = m.get('content')
        return self


class HrmMokaEventResponseBody(TeaModel):
    def __init__(
        self,
        result: bool = None,
    ):
        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 HrmMokaEventResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: HrmMokaEventResponseBody = 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 = HrmMokaEventResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class HrmMokaOapiHeaders(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 HrmMokaOapiRequest(TeaModel):
    def __init__(
        self,
        api_code: str = None,
        params: Any = None,
    ):
        # This parameter is required.
        self.api_code = api_code
        self.params = params

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.api_code is not None:
            result['apiCode'] = self.api_code
        if self.params is not None:
            result['params'] = self.params
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('apiCode') is not None:
            self.api_code = m.get('apiCode')
        if m.get('params') is not None:
            self.params = m.get('params')
        return self


class HrmMokaOapiResponseBody(TeaModel):
    def __init__(
        self,
        biz_success: bool = None,
        error_code: str = None,
        error_msg: str = None,
        result: Dict[str, Any] = None,
    ):
        self.biz_success = biz_success
        self.error_code = error_code
        self.error_msg = error_msg
        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.biz_success is not None:
            result['bizSuccess'] = self.biz_success
        if self.error_code is not None:
            result['errorCode'] = self.error_code
        if self.error_msg is not None:
            result['errorMsg'] = self.error_msg
        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('bizSuccess') is not None:
            self.biz_success = m.get('bizSuccess')
        if m.get('errorCode') is not None:
            self.error_code = m.get('errorCode')
        if m.get('errorMsg') is not None:
            self.error_msg = m.get('errorMsg')
        if m.get('result') is not None:
            self.result = m.get('result')
        return self


class HrmMokaOapiResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: HrmMokaOapiResponseBody = 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 = HrmMokaOapiResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class HrmProcessRegularHeaders(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 HrmProcessRegularRequest(TeaModel):
    def __init__(
        self,
        operation_id: str = None,
        regular_date: int = None,
        remark: str = None,
        user_id: str = None,
    ):
        # This parameter is required.
        self.operation_id = operation_id
        # This parameter is required.
        self.regular_date = regular_date
        self.remark = remark
        # 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.operation_id is not None:
            result['operationId'] = self.operation_id
        if self.regular_date is not None:
            result['regularDate'] = self.regular_date
        if self.remark is not None:
            result['remark'] = self.remark
        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('operationId') is not None:
            self.operation_id = m.get('operationId')
        if m.get('regularDate') is not None:
            self.regular_date = m.get('regularDate')
        if m.get('remark') is not None:
            self.remark = m.get('remark')
        if m.get('userId') is not None:
            self.user_id = m.get('userId')
        return self


class HrmProcessRegularResponseBody(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 HrmProcessRegularResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: HrmProcessRegularResponseBody = 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 = HrmProcessRegularResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class HrmProcessTerminationAndHandoverHeaders(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 HrmProcessTerminationAndHandoverRequest(TeaModel):
    def __init__(
        self,
        aflow_hand_over_user_id: str = None,
        ding_pan_handover_user_id: str = None,
        direct_subordinates_handover_user_id: str = None,
        dismission_memo: str = None,
        dismission_reason: int = None,
        doc_note_handover_user_id: str = None,
        last_work_date: int = None,
        opt_user_id: str = None,
        permission_handover_user_id: str = None,
        termination_reason_passive: List[str] = None,
        termination_reason_voluntary: List[str] = None,
        user_id: str = None,
    ):
        self.aflow_hand_over_user_id = aflow_hand_over_user_id
        self.ding_pan_handover_user_id = ding_pan_handover_user_id
        self.direct_subordinates_handover_user_id = direct_subordinates_handover_user_id
        # This parameter is required.
        self.dismission_memo = dismission_memo
        self.dismission_reason = dismission_reason
        self.doc_note_handover_user_id = doc_note_handover_user_id
        # This parameter is required.
        self.last_work_date = last_work_date
        # This parameter is required.
        self.opt_user_id = opt_user_id
        self.permission_handover_user_id = permission_handover_user_id
        self.termination_reason_passive = termination_reason_passive
        self.termination_reason_voluntary = termination_reason_voluntary
        # 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.aflow_hand_over_user_id is not None:
            result['aflowHandOverUserId'] = self.aflow_hand_over_user_id
        if self.ding_pan_handover_user_id is not None:
            result['dingPanHandoverUserId'] = self.ding_pan_handover_user_id
        if self.direct_subordinates_handover_user_id is not None:
            result['directSubordinatesHandoverUserId'] = self.direct_subordinates_handover_user_id
        if self.dismission_memo is not None:
            result['dismissionMemo'] = self.dismission_memo
        if self.dismission_reason is not None:
            result['dismissionReason'] = self.dismission_reason
        if self.doc_note_handover_user_id is not None:
            result['docNoteHandoverUserId'] = self.doc_note_handover_user_id
        if self.last_work_date is not None:
            result['lastWorkDate'] = self.last_work_date
        if self.opt_user_id is not None:
            result['optUserId'] = self.opt_user_id
        if self.permission_handover_user_id is not None:
            result['permissionHandoverUserId'] = self.permission_handover_user_id
        if self.termination_reason_passive is not None:
            result['terminationReasonPassive'] = self.termination_reason_passive
        if self.termination_reason_voluntary is not None:
            result['terminationReasonVoluntary'] = self.termination_reason_voluntary
        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('aflowHandOverUserId') is not None:
            self.aflow_hand_over_user_id = m.get('aflowHandOverUserId')
        if m.get('dingPanHandoverUserId') is not None:
            self.ding_pan_handover_user_id = m.get('dingPanHandoverUserId')
        if m.get('directSubordinatesHandoverUserId') is not None:
            self.direct_subordinates_handover_user_id = m.get('directSubordinatesHandoverUserId')
        if m.get('dismissionMemo') is not None:
            self.dismission_memo = m.get('dismissionMemo')
        if m.get('dismissionReason') is not None:
            self.dismission_reason = m.get('dismissionReason')
        if m.get('docNoteHandoverUserId') is not None:
            self.doc_note_handover_user_id = m.get('docNoteHandoverUserId')
        if m.get('lastWorkDate') is not None:
            self.last_work_date = m.get('lastWorkDate')
        if m.get('optUserId') is not None:
            self.opt_user_id = m.get('optUserId')
        if m.get('permissionHandoverUserId') is not None:
            self.permission_handover_user_id = m.get('permissionHandoverUserId')
        if m.get('terminationReasonPassive') is not None:
            self.termination_reason_passive = m.get('terminationReasonPassive')
        if m.get('terminationReasonVoluntary') is not None:
            self.termination_reason_voluntary = m.get('terminationReasonVoluntary')
        if m.get('userId') is not None:
            self.user_id = m.get('userId')
        return self


class HrmProcessTerminationAndHandoverResponseBody(TeaModel):
    def __init__(
        self,
        result: bool = None,
    ):
        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 HrmProcessTerminationAndHandoverResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: HrmProcessTerminationAndHandoverResponseBody = 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 = HrmProcessTerminationAndHandoverResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class HrmProcessTransferHeaders(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 HrmProcessTransferRequest(TeaModel):
    def __init__(
        self,
        dept_ids_after_transfer: List[int] = None,
        job_id_after_transfer: str = None,
        main_dept_id_after_transfer: int = None,
        operate_user_id: str = None,
        position_id_after_transfer: str = None,
        position_level_after_transfer: str = None,
        position_name_after_transfer: str = None,
        rank_id_after_transfer: str = None,
        user_id: str = None,
    ):
        self.dept_ids_after_transfer = dept_ids_after_transfer
        self.job_id_after_transfer = job_id_after_transfer
        self.main_dept_id_after_transfer = main_dept_id_after_transfer
        self.operate_user_id = operate_user_id
        self.position_id_after_transfer = position_id_after_transfer
        self.position_level_after_transfer = position_level_after_transfer
        self.position_name_after_transfer = position_name_after_transfer
        self.rank_id_after_transfer = rank_id_after_transfer
        # 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.dept_ids_after_transfer is not None:
            result['deptIdsAfterTransfer'] = self.dept_ids_after_transfer
        if self.job_id_after_transfer is not None:
            result['jobIdAfterTransfer'] = self.job_id_after_transfer
        if self.main_dept_id_after_transfer is not None:
            result['mainDeptIdAfterTransfer'] = self.main_dept_id_after_transfer
        if self.operate_user_id is not None:
            result['operateUserId'] = self.operate_user_id
        if self.position_id_after_transfer is not None:
            result['positionIdAfterTransfer'] = self.position_id_after_transfer
        if self.position_level_after_transfer is not None:
            result['positionLevelAfterTransfer'] = self.position_level_after_transfer
        if self.position_name_after_transfer is not None:
            result['positionNameAfterTransfer'] = self.position_name_after_transfer
        if self.rank_id_after_transfer is not None:
            result['rankIdAfterTransfer'] = self.rank_id_after_transfer
        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('deptIdsAfterTransfer') is not None:
            self.dept_ids_after_transfer = m.get('deptIdsAfterTransfer')
        if m.get('jobIdAfterTransfer') is not None:
            self.job_id_after_transfer = m.get('jobIdAfterTransfer')
        if m.get('mainDeptIdAfterTransfer') is not None:
            self.main_dept_id_after_transfer = m.get('mainDeptIdAfterTransfer')
        if m.get('operateUserId') is not None:
            self.operate_user_id = m.get('operateUserId')
        if m.get('positionIdAfterTransfer') is not None:
            self.position_id_after_transfer = m.get('positionIdAfterTransfer')
        if m.get('positionLevelAfterTransfer') is not None:
            self.position_level_after_transfer = m.get('positionLevelAfterTransfer')
        if m.get('positionNameAfterTransfer') is not None:
            self.position_name_after_transfer = m.get('positionNameAfterTransfer')
        if m.get('rankIdAfterTransfer') is not None:
            self.rank_id_after_transfer = m.get('rankIdAfterTransfer')
        if m.get('userId') is not None:
            self.user_id = m.get('userId')
        return self


class HrmProcessTransferResponseBody(TeaModel):
    def __init__(
        self,
        result: bool = None,
    ):
        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 HrmProcessTransferResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: HrmProcessTransferResponseBody = 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 = HrmProcessTransferResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class HrmProcessUpdateTerminationInfoHeaders(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 HrmProcessUpdateTerminationInfoRequest(TeaModel):
    def __init__(
        self,
        dismission_memo: str = None,
        last_work_date: int = None,
        user_id: str = None,
    ):
        # This parameter is required.
        self.dismission_memo = dismission_memo
        # This parameter is required.
        self.last_work_date = last_work_date
        # 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.dismission_memo is not None:
            result['dismissionMemo'] = self.dismission_memo
        if self.last_work_date is not None:
            result['lastWorkDate'] = self.last_work_date
        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('dismissionMemo') is not None:
            self.dismission_memo = m.get('dismissionMemo')
        if m.get('lastWorkDate') is not None:
            self.last_work_date = m.get('lastWorkDate')
        if m.get('userId') is not None:
            self.user_id = m.get('userId')
        return self


class HrmProcessUpdateTerminationInfoResponseBody(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 HrmProcessUpdateTerminationInfoResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: HrmProcessUpdateTerminationInfoResponseBody = 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 = HrmProcessUpdateTerminationInfoResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class HrmPtsServiceHeaders(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 HrmPtsServiceRequest(TeaModel):
    def __init__(
        self,
        env: str = None,
        method: str = None,
        outer_id: str = None,
        params: Any = None,
        path: str = None,
    ):
        # This parameter is required.
        self.env = env
        self.method = method
        # This parameter is required.
        self.outer_id = outer_id
        self.params = params
        # This parameter is required.
        self.path = path

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.env is not None:
            result['env'] = self.env
        if self.method is not None:
            result['method'] = self.method
        if self.outer_id is not None:
            result['outerId'] = self.outer_id
        if self.params is not None:
            result['params'] = self.params
        if self.path is not None:
            result['path'] = self.path
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('env') is not None:
            self.env = m.get('env')
        if m.get('method') is not None:
            self.method = m.get('method')
        if m.get('outerId') is not None:
            self.outer_id = m.get('outerId')
        if m.get('params') is not None:
            self.params = m.get('params')
        if m.get('path') is not None:
            self.path = m.get('path')
        return self


class HrmPtsServiceResponseBody(TeaModel):
    def __init__(
        self,
        biz_success: bool = None,
        error_code: str = None,
        error_msg: str = None,
        result: Dict[str, Any] = None,
    ):
        self.biz_success = biz_success
        self.error_code = error_code
        self.error_msg = error_msg
        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.biz_success is not None:
            result['bizSuccess'] = self.biz_success
        if self.error_code is not None:
            result['errorCode'] = self.error_code
        if self.error_msg is not None:
            result['errorMsg'] = self.error_msg
        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('bizSuccess') is not None:
            self.biz_success = m.get('bizSuccess')
        if m.get('errorCode') is not None:
            self.error_code = m.get('errorCode')
        if m.get('errorMsg') is not None:
            self.error_msg = m.get('errorMsg')
        if m.get('result') is not None:
            self.result = m.get('result')
        return self


class HrmPtsServiceResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: HrmPtsServiceResponseBody = 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 = HrmPtsServiceResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class InvalidSignRecordsHeaders(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 InvalidSignRecordsRequest(TeaModel):
    def __init__(
        self,
        invalid_user_id: str = None,
        sign_record_ids: List[str] = None,
        status_remark: str = None,
    ):
        # This parameter is required.
        self.invalid_user_id = invalid_user_id
        # This parameter is required.
        self.sign_record_ids = sign_record_ids
        # This parameter is required.
        self.status_remark = status_remark

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.invalid_user_id is not None:
            result['invalidUserId'] = self.invalid_user_id
        if self.sign_record_ids is not None:
            result['signRecordIds'] = self.sign_record_ids
        if self.status_remark is not None:
            result['statusRemark'] = self.status_remark
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('invalidUserId') is not None:
            self.invalid_user_id = m.get('invalidUserId')
        if m.get('signRecordIds') is not None:
            self.sign_record_ids = m.get('signRecordIds')
        if m.get('statusRemark') is not None:
            self.status_remark = m.get('statusRemark')
        return self


class InvalidSignRecordsResponseBodyResultFailItems(TeaModel):
    def __init__(
        self,
        item_id: str = None,
        type: str = None,
    ):
        self.item_id = item_id
        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.item_id is not None:
            result['itemId'] = self.item_id
        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('itemId') is not None:
            self.item_id = m.get('itemId')
        if m.get('type') is not None:
            self.type = m.get('type')
        return self


class InvalidSignRecordsResponseBodyResultSuccessItems(TeaModel):
    def __init__(
        self,
        item_id: str = None,
    ):
        self.item_id = item_id

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.item_id is not None:
            result['itemId'] = self.item_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('itemId') is not None:
            self.item_id = m.get('itemId')
        return self


class InvalidSignRecordsResponseBodyResult(TeaModel):
    def __init__(
        self,
        fail_items: List[InvalidSignRecordsResponseBodyResultFailItems] = None,
        success_items: List[InvalidSignRecordsResponseBodyResultSuccessItems] = None,
    ):
        self.fail_items = fail_items
        self.success_items = success_items

    def validate(self):
        if self.fail_items:
            for k in self.fail_items:
                if k:
                    k.validate()
        if self.success_items:
            for k in self.success_items:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['failItems'] = []
        if self.fail_items is not None:
            for k in self.fail_items:
                result['failItems'].append(k.to_map() if k else None)
        result['successItems'] = []
        if self.success_items is not None:
            for k in self.success_items:
                result['successItems'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.fail_items = []
        if m.get('failItems') is not None:
            for k in m.get('failItems'):
                temp_model = InvalidSignRecordsResponseBodyResultFailItems()
                self.fail_items.append(temp_model.from_map(k))
        self.success_items = []
        if m.get('successItems') is not None:
            for k in m.get('successItems'):
                temp_model = InvalidSignRecordsResponseBodyResultSuccessItems()
                self.success_items.append(temp_model.from_map(k))
        return self


class InvalidSignRecordsResponseBody(TeaModel):
    def __init__(
        self,
        result: InvalidSignRecordsResponseBodyResult = None,
        success: bool = None,
    ):
        self.result = result
        # This parameter is required.
        self.success = success

    def validate(self):
        if self.result:
            self.result.validate()

    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.to_map()
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('result') is not None:
            temp_model = InvalidSignRecordsResponseBodyResult()
            self.result = temp_model.from_map(m['result'])
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class InvalidSignRecordsResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: InvalidSignRecordsResponseBody = 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 = InvalidSignRecordsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class MasterDataDeleteHeaders(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 MasterDataDeleteRequestBodyFieldList(TeaModel):
    def __init__(
        self,
        name: str = None,
        value_str: str = None,
    ):
        self.name = name
        self.value_str = value_str

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.name is not None:
            result['name'] = self.name
        if self.value_str is not None:
            result['valueStr'] = self.value_str
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('name') is not None:
            self.name = m.get('name')
        if m.get('valueStr') is not None:
            self.value_str = m.get('valueStr')
        return self


class MasterDataDeleteRequestBodyScope(TeaModel):
    def __init__(
        self,
        scope_code: str = None,
        version: int = None,
    ):
        # This parameter is required.
        self.scope_code = scope_code
        self.version = version

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.scope_code is not None:
            result['scopeCode'] = self.scope_code
        if self.version is not None:
            result['version'] = self.version
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('scopeCode') is not None:
            self.scope_code = m.get('scopeCode')
        if m.get('version') is not None:
            self.version = m.get('version')
        return self


class MasterDataDeleteRequestBody(TeaModel):
    def __init__(
        self,
        biz_time: int = None,
        biz_uk: str = None,
        entity_code: str = None,
        field_list: List[MasterDataDeleteRequestBodyFieldList] = None,
        scope: MasterDataDeleteRequestBodyScope = None,
    ):
        # This parameter is required.
        self.biz_time = biz_time
        # This parameter is required.
        self.biz_uk = biz_uk
        self.entity_code = entity_code
        self.field_list = field_list
        # This parameter is required.
        self.scope = scope

    def validate(self):
        if self.field_list:
            for k in self.field_list:
                if k:
                    k.validate()
        if self.scope:
            self.scope.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_time is not None:
            result['bizTime'] = self.biz_time
        if self.biz_uk is not None:
            result['bizUk'] = self.biz_uk
        if self.entity_code is not None:
            result['entityCode'] = self.entity_code
        result['fieldList'] = []
        if self.field_list is not None:
            for k in self.field_list:
                result['fieldList'].append(k.to_map() if k else None)
        if self.scope is not None:
            result['scope'] = self.scope.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('bizTime') is not None:
            self.biz_time = m.get('bizTime')
        if m.get('bizUk') is not None:
            self.biz_uk = m.get('bizUk')
        if m.get('entityCode') is not None:
            self.entity_code = m.get('entityCode')
        self.field_list = []
        if m.get('fieldList') is not None:
            for k in m.get('fieldList'):
                temp_model = MasterDataDeleteRequestBodyFieldList()
                self.field_list.append(temp_model.from_map(k))
        if m.get('scope') is not None:
            temp_model = MasterDataDeleteRequestBodyScope()
            self.scope = temp_model.from_map(m['scope'])
        return self


class MasterDataDeleteRequest(TeaModel):
    def __init__(
        self,
        body: List[MasterDataDeleteRequestBody] = None,
        tenant_id: int = None,
    ):
        # This parameter is required.
        self.body = body
        # This parameter is required.
        self.tenant_id = tenant_id

    def validate(self):
        if self.body:
            for k in self.body:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['body'] = []
        if self.body is not None:
            for k in self.body:
                result['body'].append(k.to_map() if k else None)
        if self.tenant_id is not None:
            result['tenantId'] = self.tenant_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.body = []
        if m.get('body') is not None:
            for k in m.get('body'):
                temp_model = MasterDataDeleteRequestBody()
                self.body.append(temp_model.from_map(k))
        if m.get('tenantId') is not None:
            self.tenant_id = m.get('tenantId')
        return self


class MasterDataDeleteResponseBodyFailResult(TeaModel):
    def __init__(
        self,
        biz_uk: str = None,
        error_code: str = None,
        error_msg: str = None,
        success: bool = None,
    ):
        self.biz_uk = biz_uk
        self.error_code = error_code
        self.error_msg = error_msg
        self.success = success

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_uk is not None:
            result['bizUK'] = self.biz_uk
        if self.error_code is not None:
            result['errorCode'] = self.error_code
        if self.error_msg is not None:
            result['errorMsg'] = self.error_msg
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('bizUK') is not None:
            self.biz_uk = m.get('bizUK')
        if m.get('errorCode') is not None:
            self.error_code = m.get('errorCode')
        if m.get('errorMsg') is not None:
            self.error_msg = m.get('errorMsg')
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class MasterDataDeleteResponseBody(TeaModel):
    def __init__(
        self,
        all_success: bool = None,
        fail_result: List[MasterDataDeleteResponseBodyFailResult] = None,
    ):
        # This parameter is required.
        self.all_success = all_success
        self.fail_result = fail_result

    def validate(self):
        if self.fail_result:
            for k in self.fail_result:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.all_success is not None:
            result['allSuccess'] = self.all_success
        result['failResult'] = []
        if self.fail_result is not None:
            for k in self.fail_result:
                result['failResult'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('allSuccess') is not None:
            self.all_success = m.get('allSuccess')
        self.fail_result = []
        if m.get('failResult') is not None:
            for k in m.get('failResult'):
                temp_model = MasterDataDeleteResponseBodyFailResult()
                self.fail_result.append(temp_model.from_map(k))
        return self


class MasterDataDeleteResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: MasterDataDeleteResponseBody = 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 = MasterDataDeleteResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class MasterDataQueryHeaders(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 MasterDataQueryRequestQueryParamsConditionList(TeaModel):
    def __init__(
        self,
        operate: str = None,
        value: str = None,
    ):
        self.operate = operate
        self.value = value

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.operate is not None:
            result['operate'] = self.operate
        if self.value is not None:
            result['value'] = self.value
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('operate') is not None:
            self.operate = m.get('operate')
        if m.get('value') is not None:
            self.value = m.get('value')
        return self


class MasterDataQueryRequestQueryParams(TeaModel):
    def __init__(
        self,
        condition_list: List[MasterDataQueryRequestQueryParamsConditionList] = None,
        field_code: str = None,
        join_type: str = None,
    ):
        self.condition_list = condition_list
        self.field_code = field_code
        self.join_type = join_type

    def validate(self):
        if self.condition_list:
            for k in self.condition_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['conditionList'] = []
        if self.condition_list is not None:
            for k in self.condition_list:
                result['conditionList'].append(k.to_map() if k else None)
        if self.field_code is not None:
            result['fieldCode'] = self.field_code
        if self.join_type is not None:
            result['joinType'] = self.join_type
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.condition_list = []
        if m.get('conditionList') is not None:
            for k in m.get('conditionList'):
                temp_model = MasterDataQueryRequestQueryParamsConditionList()
                self.condition_list.append(temp_model.from_map(k))
        if m.get('fieldCode') is not None:
            self.field_code = m.get('fieldCode')
        if m.get('joinType') is not None:
            self.join_type = m.get('joinType')
        return self


class MasterDataQueryRequest(TeaModel):
    def __init__(
        self,
        biz_uk: str = None,
        max_results: int = None,
        next_token: int = None,
        opt_user_id: str = None,
        query_params: List[MasterDataQueryRequestQueryParams] = None,
        relation_ids: List[str] = None,
        scope_code: str = None,
        tenant_id: int = None,
        view_entity_code: str = None,
    ):
        self.biz_uk = biz_uk
        # This parameter is required.
        self.max_results = max_results
        # This parameter is required.
        self.next_token = next_token
        self.opt_user_id = opt_user_id
        self.query_params = query_params
        # This parameter is required.
        self.relation_ids = relation_ids
        # This parameter is required.
        self.scope_code = scope_code
        # This parameter is required.
        self.tenant_id = tenant_id
        # This parameter is required.
        self.view_entity_code = view_entity_code

    def validate(self):
        if self.query_params:
            for k in self.query_params:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_uk is not None:
            result['bizUK'] = self.biz_uk
        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.opt_user_id is not None:
            result['optUserId'] = self.opt_user_id
        result['queryParams'] = []
        if self.query_params is not None:
            for k in self.query_params:
                result['queryParams'].append(k.to_map() if k else None)
        if self.relation_ids is not None:
            result['relationIds'] = self.relation_ids
        if self.scope_code is not None:
            result['scopeCode'] = self.scope_code
        if self.tenant_id is not None:
            result['tenantId'] = self.tenant_id
        if self.view_entity_code is not None:
            result['viewEntityCode'] = self.view_entity_code
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('bizUK') is not None:
            self.biz_uk = m.get('bizUK')
        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('optUserId') is not None:
            self.opt_user_id = m.get('optUserId')
        self.query_params = []
        if m.get('queryParams') is not None:
            for k in m.get('queryParams'):
                temp_model = MasterDataQueryRequestQueryParams()
                self.query_params.append(temp_model.from_map(k))
        if m.get('relationIds') is not None:
            self.relation_ids = m.get('relationIds')
        if m.get('scopeCode') is not None:
            self.scope_code = m.get('scopeCode')
        if m.get('tenantId') is not None:
            self.tenant_id = m.get('tenantId')
        if m.get('viewEntityCode') is not None:
            self.view_entity_code = m.get('viewEntityCode')
        return self


class MasterDataQueryResponseBodyResultViewEntityFieldVOListFieldDataVO(TeaModel):
    def __init__(
        self,
        key: str = None,
        value: str = None,
    ):
        self.key = key
        self.value = value

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.key is not None:
            result['key'] = self.key
        if self.value is not None:
            result['value'] = self.value
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('key') is not None:
            self.key = m.get('key')
        if m.get('value') is not None:
            self.value = m.get('value')
        return self


class MasterDataQueryResponseBodyResultViewEntityFieldVOList(TeaModel):
    def __init__(
        self,
        field_code: str = None,
        field_data_vo: MasterDataQueryResponseBodyResultViewEntityFieldVOListFieldDataVO = None,
        field_name: str = None,
        field_type: str = None,
    ):
        self.field_code = field_code
        self.field_data_vo = field_data_vo
        self.field_name = field_name
        self.field_type = field_type

    def validate(self):
        if self.field_data_vo:
            self.field_data_vo.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.field_code is not None:
            result['fieldCode'] = self.field_code
        if self.field_data_vo is not None:
            result['fieldDataVO'] = self.field_data_vo.to_map()
        if self.field_name is not None:
            result['fieldName'] = self.field_name
        if self.field_type is not None:
            result['fieldType'] = self.field_type
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('fieldCode') is not None:
            self.field_code = m.get('fieldCode')
        if m.get('fieldDataVO') is not None:
            temp_model = MasterDataQueryResponseBodyResultViewEntityFieldVOListFieldDataVO()
            self.field_data_vo = temp_model.from_map(m['fieldDataVO'])
        if m.get('fieldName') is not None:
            self.field_name = m.get('fieldName')
        if m.get('fieldType') is not None:
            self.field_type = m.get('fieldType')
        return self


class MasterDataQueryResponseBodyResult(TeaModel):
    def __init__(
        self,
        outer_id: str = None,
        relation_id: str = None,
        scope_code: str = None,
        view_entity_code: str = None,
        view_entity_field_volist: List[MasterDataQueryResponseBodyResultViewEntityFieldVOList] = None,
    ):
        self.outer_id = outer_id
        # This parameter is required.
        self.relation_id = relation_id
        # This parameter is required.
        self.scope_code = scope_code
        # This parameter is required.
        self.view_entity_code = view_entity_code
        self.view_entity_field_volist = view_entity_field_volist

    def validate(self):
        if self.view_entity_field_volist:
            for k in self.view_entity_field_volist:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.outer_id is not None:
            result['outerId'] = self.outer_id
        if self.relation_id is not None:
            result['relationId'] = self.relation_id
        if self.scope_code is not None:
            result['scopeCode'] = self.scope_code
        if self.view_entity_code is not None:
            result['viewEntityCode'] = self.view_entity_code
        result['viewEntityFieldVOList'] = []
        if self.view_entity_field_volist is not None:
            for k in self.view_entity_field_volist:
                result['viewEntityFieldVOList'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('outerId') is not None:
            self.outer_id = m.get('outerId')
        if m.get('relationId') is not None:
            self.relation_id = m.get('relationId')
        if m.get('scopeCode') is not None:
            self.scope_code = m.get('scopeCode')
        if m.get('viewEntityCode') is not None:
            self.view_entity_code = m.get('viewEntityCode')
        self.view_entity_field_volist = []
        if m.get('viewEntityFieldVOList') is not None:
            for k in m.get('viewEntityFieldVOList'):
                temp_model = MasterDataQueryResponseBodyResultViewEntityFieldVOList()
                self.view_entity_field_volist.append(temp_model.from_map(k))
        return self


class MasterDataQueryResponseBody(TeaModel):
    def __init__(
        self,
        has_more: bool = None,
        next_token: int = None,
        result: List[MasterDataQueryResponseBodyResult] = None,
        success: bool = None,
        total: int = None,
    ):
        self.has_more = has_more
        self.next_token = next_token
        # This parameter is required.
        self.result = result
        # This parameter is required.
        self.success = success
        self.total = total

    def validate(self):
        if self.result:
            for k in self.result:
                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
        if self.next_token is not None:
            result['nextToken'] = self.next_token
        result['result'] = []
        if self.result is not None:
            for k in self.result:
                result['result'].append(k.to_map() if k else None)
        if self.success is not None:
            result['success'] = self.success
        if self.total is not None:
            result['total'] = self.total
        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')
        if m.get('nextToken') is not None:
            self.next_token = m.get('nextToken')
        self.result = []
        if m.get('result') is not None:
            for k in m.get('result'):
                temp_model = MasterDataQueryResponseBodyResult()
                self.result.append(temp_model.from_map(k))
        if m.get('success') is not None:
            self.success = m.get('success')
        if m.get('total') is not None:
            self.total = m.get('total')
        return self


class MasterDataQueryResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: MasterDataQueryResponseBody = 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 = MasterDataQueryResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class MasterDataSaveHeaders(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 MasterDataSaveRequestBodyFieldList(TeaModel):
    def __init__(
        self,
        name: str = None,
        value_str: str = None,
    ):
        # This parameter is required.
        self.name = name
        # This parameter is required.
        self.value_str = value_str

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.name is not None:
            result['name'] = self.name
        if self.value_str is not None:
            result['valueStr'] = self.value_str
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('name') is not None:
            self.name = m.get('name')
        if m.get('valueStr') is not None:
            self.value_str = m.get('valueStr')
        return self


class MasterDataSaveRequestBodyScope(TeaModel):
    def __init__(
        self,
        scope_code: str = None,
        version: int = None,
    ):
        # This parameter is required.
        self.scope_code = scope_code
        self.version = version

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.scope_code is not None:
            result['scopeCode'] = self.scope_code
        if self.version is not None:
            result['version'] = self.version
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('scopeCode') is not None:
            self.scope_code = m.get('scopeCode')
        if m.get('version') is not None:
            self.version = m.get('version')
        return self


class MasterDataSaveRequestBody(TeaModel):
    def __init__(
        self,
        biz_time: int = None,
        biz_uk: str = None,
        entity_code: str = None,
        field_list: List[MasterDataSaveRequestBodyFieldList] = None,
        scope: MasterDataSaveRequestBodyScope = None,
        user_id: str = None,
    ):
        # This parameter is required.
        self.biz_time = biz_time
        # This parameter is required.
        self.biz_uk = biz_uk
        self.entity_code = entity_code
        # This parameter is required.
        self.field_list = field_list
        # This parameter is required.
        self.scope = scope
        # This parameter is required.
        self.user_id = user_id

    def validate(self):
        if self.field_list:
            for k in self.field_list:
                if k:
                    k.validate()
        if self.scope:
            self.scope.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_time is not None:
            result['bizTime'] = self.biz_time
        if self.biz_uk is not None:
            result['bizUk'] = self.biz_uk
        if self.entity_code is not None:
            result['entityCode'] = self.entity_code
        result['fieldList'] = []
        if self.field_list is not None:
            for k in self.field_list:
                result['fieldList'].append(k.to_map() if k else None)
        if self.scope is not None:
            result['scope'] = self.scope.to_map()
        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('bizTime') is not None:
            self.biz_time = m.get('bizTime')
        if m.get('bizUk') is not None:
            self.biz_uk = m.get('bizUk')
        if m.get('entityCode') is not None:
            self.entity_code = m.get('entityCode')
        self.field_list = []
        if m.get('fieldList') is not None:
            for k in m.get('fieldList'):
                temp_model = MasterDataSaveRequestBodyFieldList()
                self.field_list.append(temp_model.from_map(k))
        if m.get('scope') is not None:
            temp_model = MasterDataSaveRequestBodyScope()
            self.scope = temp_model.from_map(m['scope'])
        if m.get('userId') is not None:
            self.user_id = m.get('userId')
        return self


class MasterDataSaveRequest(TeaModel):
    def __init__(
        self,
        body: List[MasterDataSaveRequestBody] = None,
        tenant_id: int = None,
    ):
        # This parameter is required.
        self.body = body
        # This parameter is required.
        self.tenant_id = tenant_id

    def validate(self):
        if self.body:
            for k in self.body:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['body'] = []
        if self.body is not None:
            for k in self.body:
                result['body'].append(k.to_map() if k else None)
        if self.tenant_id is not None:
            result['tenantId'] = self.tenant_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.body = []
        if m.get('body') is not None:
            for k in m.get('body'):
                temp_model = MasterDataSaveRequestBody()
                self.body.append(temp_model.from_map(k))
        if m.get('tenantId') is not None:
            self.tenant_id = m.get('tenantId')
        return self


class MasterDataSaveResponseBodyFailResult(TeaModel):
    def __init__(
        self,
        biz_uk: str = None,
        error_code: str = None,
        error_msg: str = None,
        success: bool = None,
    ):
        self.biz_uk = biz_uk
        self.error_code = error_code
        self.error_msg = error_msg
        self.success = success

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_uk is not None:
            result['bizUk'] = self.biz_uk
        if self.error_code is not None:
            result['errorCode'] = self.error_code
        if self.error_msg is not None:
            result['errorMsg'] = self.error_msg
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('bizUk') is not None:
            self.biz_uk = m.get('bizUk')
        if m.get('errorCode') is not None:
            self.error_code = m.get('errorCode')
        if m.get('errorMsg') is not None:
            self.error_msg = m.get('errorMsg')
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class MasterDataSaveResponseBody(TeaModel):
    def __init__(
        self,
        all_success: bool = None,
        fail_result: List[MasterDataSaveResponseBodyFailResult] = None,
    ):
        # This parameter is required.
        self.all_success = all_success
        self.fail_result = fail_result

    def validate(self):
        if self.fail_result:
            for k in self.fail_result:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.all_success is not None:
            result['allSuccess'] = self.all_success
        result['failResult'] = []
        if self.fail_result is not None:
            for k in self.fail_result:
                result['failResult'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('allSuccess') is not None:
            self.all_success = m.get('allSuccess')
        self.fail_result = []
        if m.get('failResult') is not None:
            for k in m.get('failResult'):
                temp_model = MasterDataSaveResponseBodyFailResult()
                self.fail_result.append(temp_model.from_map(k))
        return self


class MasterDataSaveResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: MasterDataSaveResponseBody = 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 = MasterDataSaveResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class MasterDataTenantQueyHeaders(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 MasterDataTenantQueyRequest(TeaModel):
    def __init__(
        self,
        entity_code: str = None,
        scope_code: str = None,
    ):
        # This parameter is required.
        self.entity_code = entity_code
        # This parameter is required.
        self.scope_code = scope_code

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.entity_code is not None:
            result['entityCode'] = self.entity_code
        if self.scope_code is not None:
            result['scopeCode'] = self.scope_code
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('entityCode') is not None:
            self.entity_code = m.get('entityCode')
        if m.get('scopeCode') is not None:
            self.scope_code = m.get('scopeCode')
        return self


class MasterDataTenantQueyResponseBodyResult(TeaModel):
    def __init__(
        self,
        has_data: bool = None,
        integrate_data_auth: bool = None,
        name: str = None,
        read_auth: bool = None,
        tenant_id: int = None,
        type: int = None,
    ):
        self.has_data = has_data
        self.integrate_data_auth = integrate_data_auth
        # This parameter is required.
        self.name = name
        self.read_auth = read_auth
        # This parameter is required.
        self.tenant_id = tenant_id
        # This parameter is required.
        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.has_data is not None:
            result['hasData'] = self.has_data
        if self.integrate_data_auth is not None:
            result['integrateDataAuth'] = self.integrate_data_auth
        if self.name is not None:
            result['name'] = self.name
        if self.read_auth is not None:
            result['readAuth'] = self.read_auth
        if self.tenant_id is not None:
            result['tenantId'] = self.tenant_id
        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('hasData') is not None:
            self.has_data = m.get('hasData')
        if m.get('integrateDataAuth') is not None:
            self.integrate_data_auth = m.get('integrateDataAuth')
        if m.get('name') is not None:
            self.name = m.get('name')
        if m.get('readAuth') is not None:
            self.read_auth = m.get('readAuth')
        if m.get('tenantId') is not None:
            self.tenant_id = m.get('tenantId')
        if m.get('type') is not None:
            self.type = m.get('type')
        return self


class MasterDataTenantQueyResponseBody(TeaModel):
    def __init__(
        self,
        result: List[MasterDataTenantQueyResponseBodyResult] = None,
    ):
        # This parameter is required.
        self.result = result

    def validate(self):
        if self.result:
            for k in self.result:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['result'] = []
        if self.result is not None:
            for k in self.result:
                result['result'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.result = []
        if m.get('result') is not None:
            for k in m.get('result'):
                temp_model = MasterDataTenantQueyResponseBodyResult()
                self.result.append(temp_model.from_map(k))
        return self


class MasterDataTenantQueyResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: MasterDataTenantQueyResponseBody = 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 = MasterDataTenantQueyResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class MasterDatasGetHeaders(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 MasterDatasGetRequest(TeaModel):
    def __init__(
        self,
        obj_id: str = None,
        scope_code: str = None,
        tenant_id: int = None,
        view_entity_code: str = None,
    ):
        # This parameter is required.
        self.obj_id = obj_id
        # This parameter is required.
        self.scope_code = scope_code
        # This parameter is required.
        self.tenant_id = tenant_id
        # This parameter is required.
        self.view_entity_code = view_entity_code

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.obj_id is not None:
            result['objId'] = self.obj_id
        if self.scope_code is not None:
            result['scopeCode'] = self.scope_code
        if self.tenant_id is not None:
            result['tenantId'] = self.tenant_id
        if self.view_entity_code is not None:
            result['viewEntityCode'] = self.view_entity_code
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('objId') is not None:
            self.obj_id = m.get('objId')
        if m.get('scopeCode') is not None:
            self.scope_code = m.get('scopeCode')
        if m.get('tenantId') is not None:
            self.tenant_id = m.get('tenantId')
        if m.get('viewEntityCode') is not None:
            self.view_entity_code = m.get('viewEntityCode')
        return self


class MasterDatasGetResponseBodyResultViewEntityFieldVOListFieldDataVO(TeaModel):
    def __init__(
        self,
        key: str = None,
        value: str = None,
    ):
        self.key = key
        self.value = value

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.key is not None:
            result['key'] = self.key
        if self.value is not None:
            result['value'] = self.value
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('key') is not None:
            self.key = m.get('key')
        if m.get('value') is not None:
            self.value = m.get('value')
        return self


class MasterDatasGetResponseBodyResultViewEntityFieldVOList(TeaModel):
    def __init__(
        self,
        field_code: str = None,
        field_data_vo: MasterDatasGetResponseBodyResultViewEntityFieldVOListFieldDataVO = None,
        field_name: str = None,
        field_type: str = None,
    ):
        self.field_code = field_code
        self.field_data_vo = field_data_vo
        self.field_name = field_name
        self.field_type = field_type

    def validate(self):
        if self.field_data_vo:
            self.field_data_vo.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.field_code is not None:
            result['fieldCode'] = self.field_code
        if self.field_data_vo is not None:
            result['fieldDataVO'] = self.field_data_vo.to_map()
        if self.field_name is not None:
            result['fieldName'] = self.field_name
        if self.field_type is not None:
            result['fieldType'] = self.field_type
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('fieldCode') is not None:
            self.field_code = m.get('fieldCode')
        if m.get('fieldDataVO') is not None:
            temp_model = MasterDatasGetResponseBodyResultViewEntityFieldVOListFieldDataVO()
            self.field_data_vo = temp_model.from_map(m['fieldDataVO'])
        if m.get('fieldName') is not None:
            self.field_name = m.get('fieldName')
        if m.get('fieldType') is not None:
            self.field_type = m.get('fieldType')
        return self


class MasterDatasGetResponseBodyResult(TeaModel):
    def __init__(
        self,
        obj_id: str = None,
        relation_id: str = None,
        scope_code: str = None,
        view_entity_code: str = None,
        view_entity_field_volist: List[MasterDatasGetResponseBodyResultViewEntityFieldVOList] = None,
    ):
        self.obj_id = obj_id
        # This parameter is required.
        self.relation_id = relation_id
        self.scope_code = scope_code
        self.view_entity_code = view_entity_code
        self.view_entity_field_volist = view_entity_field_volist

    def validate(self):
        if self.view_entity_field_volist:
            for k in self.view_entity_field_volist:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.obj_id is not None:
            result['objId'] = self.obj_id
        if self.relation_id is not None:
            result['relationId'] = self.relation_id
        if self.scope_code is not None:
            result['scopeCode'] = self.scope_code
        if self.view_entity_code is not None:
            result['viewEntityCode'] = self.view_entity_code
        result['viewEntityFieldVOList'] = []
        if self.view_entity_field_volist is not None:
            for k in self.view_entity_field_volist:
                result['viewEntityFieldVOList'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('objId') is not None:
            self.obj_id = m.get('objId')
        if m.get('relationId') is not None:
            self.relation_id = m.get('relationId')
        if m.get('scopeCode') is not None:
            self.scope_code = m.get('scopeCode')
        if m.get('viewEntityCode') is not None:
            self.view_entity_code = m.get('viewEntityCode')
        self.view_entity_field_volist = []
        if m.get('viewEntityFieldVOList') is not None:
            for k in m.get('viewEntityFieldVOList'):
                temp_model = MasterDatasGetResponseBodyResultViewEntityFieldVOList()
                self.view_entity_field_volist.append(temp_model.from_map(k))
        return self


class MasterDatasGetResponseBody(TeaModel):
    def __init__(
        self,
        result: MasterDatasGetResponseBodyResult = None,
    ):
        self.result = result

    def validate(self):
        if self.result:
            self.result.validate()

    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.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('result') is not None:
            temp_model = MasterDatasGetResponseBodyResult()
            self.result = temp_model.from_map(m['result'])
        return self


class MasterDatasGetResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: MasterDatasGetResponseBody = 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 = MasterDatasGetResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class MasterDatasQueryHeaders(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 MasterDatasQueryRequestQueryParamsConditionList(TeaModel):
    def __init__(
        self,
        operate: str = None,
        value: str = None,
    ):
        self.operate = operate
        self.value = value

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.operate is not None:
            result['operate'] = self.operate
        if self.value is not None:
            result['value'] = self.value
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('operate') is not None:
            self.operate = m.get('operate')
        if m.get('value') is not None:
            self.value = m.get('value')
        return self


class MasterDatasQueryRequestQueryParams(TeaModel):
    def __init__(
        self,
        condition_list: List[MasterDatasQueryRequestQueryParamsConditionList] = None,
        field_code: str = None,
        join_type: str = None,
    ):
        self.condition_list = condition_list
        self.field_code = field_code
        self.join_type = join_type

    def validate(self):
        if self.condition_list:
            for k in self.condition_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['conditionList'] = []
        if self.condition_list is not None:
            for k in self.condition_list:
                result['conditionList'].append(k.to_map() if k else None)
        if self.field_code is not None:
            result['fieldCode'] = self.field_code
        if self.join_type is not None:
            result['joinType'] = self.join_type
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.condition_list = []
        if m.get('conditionList') is not None:
            for k in m.get('conditionList'):
                temp_model = MasterDatasQueryRequestQueryParamsConditionList()
                self.condition_list.append(temp_model.from_map(k))
        if m.get('fieldCode') is not None:
            self.field_code = m.get('fieldCode')
        if m.get('joinType') is not None:
            self.join_type = m.get('joinType')
        return self


class MasterDatasQueryRequest(TeaModel):
    def __init__(
        self,
        biz_uk: str = None,
        max_results: int = None,
        next_token: int = None,
        query_params: List[MasterDatasQueryRequestQueryParams] = None,
        relation_ids: List[str] = None,
        scope_code: str = None,
        tenant_id: int = None,
        view_entity_code: str = None,
    ):
        self.biz_uk = biz_uk
        # This parameter is required.
        self.max_results = max_results
        # This parameter is required.
        self.next_token = next_token
        self.query_params = query_params
        # This parameter is required.
        self.relation_ids = relation_ids
        # This parameter is required.
        self.scope_code = scope_code
        # This parameter is required.
        self.tenant_id = tenant_id
        # This parameter is required.
        self.view_entity_code = view_entity_code

    def validate(self):
        if self.query_params:
            for k in self.query_params:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_uk is not None:
            result['bizUK'] = self.biz_uk
        if self.max_results is not None:
            result['maxResults'] = self.max_results
        if self.next_token is not None:
            result['nextToken'] = self.next_token
        result['queryParams'] = []
        if self.query_params is not None:
            for k in self.query_params:
                result['queryParams'].append(k.to_map() if k else None)
        if self.relation_ids is not None:
            result['relationIds'] = self.relation_ids
        if self.scope_code is not None:
            result['scopeCode'] = self.scope_code
        if self.tenant_id is not None:
            result['tenantId'] = self.tenant_id
        if self.view_entity_code is not None:
            result['viewEntityCode'] = self.view_entity_code
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('bizUK') is not None:
            self.biz_uk = m.get('bizUK')
        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')
        self.query_params = []
        if m.get('queryParams') is not None:
            for k in m.get('queryParams'):
                temp_model = MasterDatasQueryRequestQueryParams()
                self.query_params.append(temp_model.from_map(k))
        if m.get('relationIds') is not None:
            self.relation_ids = m.get('relationIds')
        if m.get('scopeCode') is not None:
            self.scope_code = m.get('scopeCode')
        if m.get('tenantId') is not None:
            self.tenant_id = m.get('tenantId')
        if m.get('viewEntityCode') is not None:
            self.view_entity_code = m.get('viewEntityCode')
        return self


class MasterDatasQueryResponseBodyResultViewEntityFieldVOListFieldDataVO(TeaModel):
    def __init__(
        self,
        key: str = None,
        value: str = None,
    ):
        self.key = key
        self.value = value

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.key is not None:
            result['key'] = self.key
        if self.value is not None:
            result['value'] = self.value
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('key') is not None:
            self.key = m.get('key')
        if m.get('value') is not None:
            self.value = m.get('value')
        return self


class MasterDatasQueryResponseBodyResultViewEntityFieldVOList(TeaModel):
    def __init__(
        self,
        field_code: str = None,
        field_data_vo: MasterDatasQueryResponseBodyResultViewEntityFieldVOListFieldDataVO = None,
        field_name: str = None,
        field_type: str = None,
    ):
        self.field_code = field_code
        self.field_data_vo = field_data_vo
        self.field_name = field_name
        self.field_type = field_type

    def validate(self):
        if self.field_data_vo:
            self.field_data_vo.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.field_code is not None:
            result['fieldCode'] = self.field_code
        if self.field_data_vo is not None:
            result['fieldDataVO'] = self.field_data_vo.to_map()
        if self.field_name is not None:
            result['fieldName'] = self.field_name
        if self.field_type is not None:
            result['fieldType'] = self.field_type
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('fieldCode') is not None:
            self.field_code = m.get('fieldCode')
        if m.get('fieldDataVO') is not None:
            temp_model = MasterDatasQueryResponseBodyResultViewEntityFieldVOListFieldDataVO()
            self.field_data_vo = temp_model.from_map(m['fieldDataVO'])
        if m.get('fieldName') is not None:
            self.field_name = m.get('fieldName')
        if m.get('fieldType') is not None:
            self.field_type = m.get('fieldType')
        return self


class MasterDatasQueryResponseBodyResult(TeaModel):
    def __init__(
        self,
        obj_id: str = None,
        relation_id: str = None,
        scope_code: str = None,
        view_entity_code: str = None,
        view_entity_field_volist: List[MasterDatasQueryResponseBodyResultViewEntityFieldVOList] = None,
    ):
        self.obj_id = obj_id
        # This parameter is required.
        self.relation_id = relation_id
        self.scope_code = scope_code
        self.view_entity_code = view_entity_code
        self.view_entity_field_volist = view_entity_field_volist

    def validate(self):
        if self.view_entity_field_volist:
            for k in self.view_entity_field_volist:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.obj_id is not None:
            result['objId'] = self.obj_id
        if self.relation_id is not None:
            result['relationId'] = self.relation_id
        if self.scope_code is not None:
            result['scopeCode'] = self.scope_code
        if self.view_entity_code is not None:
            result['viewEntityCode'] = self.view_entity_code
        result['viewEntityFieldVOList'] = []
        if self.view_entity_field_volist is not None:
            for k in self.view_entity_field_volist:
                result['viewEntityFieldVOList'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('objId') is not None:
            self.obj_id = m.get('objId')
        if m.get('relationId') is not None:
            self.relation_id = m.get('relationId')
        if m.get('scopeCode') is not None:
            self.scope_code = m.get('scopeCode')
        if m.get('viewEntityCode') is not None:
            self.view_entity_code = m.get('viewEntityCode')
        self.view_entity_field_volist = []
        if m.get('viewEntityFieldVOList') is not None:
            for k in m.get('viewEntityFieldVOList'):
                temp_model = MasterDatasQueryResponseBodyResultViewEntityFieldVOList()
                self.view_entity_field_volist.append(temp_model.from_map(k))
        return self


class MasterDatasQueryResponseBody(TeaModel):
    def __init__(
        self,
        has_more: bool = None,
        next_token: int = None,
        result: List[MasterDatasQueryResponseBodyResult] = None,
        success: bool = None,
        total: int = None,
    ):
        self.has_more = has_more
        self.next_token = next_token
        self.result = result
        # This parameter is required.
        self.success = success
        self.total = total

    def validate(self):
        if self.result:
            for k in self.result:
                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
        if self.next_token is not None:
            result['nextToken'] = self.next_token
        result['result'] = []
        if self.result is not None:
            for k in self.result:
                result['result'].append(k.to_map() if k else None)
        if self.success is not None:
            result['success'] = self.success
        if self.total is not None:
            result['total'] = self.total
        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')
        if m.get('nextToken') is not None:
            self.next_token = m.get('nextToken')
        self.result = []
        if m.get('result') is not None:
            for k in m.get('result'):
                temp_model = MasterDatasQueryResponseBodyResult()
                self.result.append(temp_model.from_map(k))
        if m.get('success') is not None:
            self.success = m.get('success')
        if m.get('total') is not None:
            self.total = m.get('total')
        return self


class MasterDatasQueryResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: MasterDatasQueryResponseBody = 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 = MasterDatasQueryResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class OpenOemMicroAppHeaders(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 OpenOemMicroAppRequest(TeaModel):
    def __init__(
        self,
        tenant_id: int = None,
    ):
        self.tenant_id = tenant_id

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.tenant_id is not None:
            result['tenantId'] = self.tenant_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('tenantId') is not None:
            self.tenant_id = m.get('tenantId')
        return self


class OpenOemMicroAppResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
        success: bool = None,
    ):
        self.request_id = request_id
        self.success = success

    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
        if self.success is not None:
            result['success'] = self.success
        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')
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class OpenOemMicroAppResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: OpenOemMicroAppResponseBody = 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 = OpenOemMicroAppResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class QueryCustomEntryProcessesHeaders(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 QueryCustomEntryProcessesRequest(TeaModel):
    def __init__(
        self,
        max_results: int = None,
        next_token: int = None,
        operate_user_id: str = None,
    ):
        self.max_results = max_results
        self.next_token = next_token
        self.operate_user_id = operate_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.max_results is not None:
            result['maxResults'] = self.max_results
        if self.next_token is not None:
            result['nextToken'] = self.next_token
        if self.operate_user_id is not None:
            result['operateUserId'] = self.operate_user_id
        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('operateUserId') is not None:
            self.operate_user_id = m.get('operateUserId')
        return self


class QueryCustomEntryProcessesResponseBodyList(TeaModel):
    def __init__(
        self,
        form_desc: str = None,
        form_id: str = None,
        form_name: str = None,
        short_url: str = None,
    ):
        self.form_desc = form_desc
        self.form_id = form_id
        self.form_name = form_name
        self.short_url = short_url

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.form_desc is not None:
            result['formDesc'] = self.form_desc
        if self.form_id is not None:
            result['formId'] = self.form_id
        if self.form_name is not None:
            result['formName'] = self.form_name
        if self.short_url is not None:
            result['shortUrl'] = self.short_url
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('formDesc') is not None:
            self.form_desc = m.get('formDesc')
        if m.get('formId') is not None:
            self.form_id = m.get('formId')
        if m.get('formName') is not None:
            self.form_name = m.get('formName')
        if m.get('shortUrl') is not None:
            self.short_url = m.get('shortUrl')
        return self


class QueryCustomEntryProcessesResponseBody(TeaModel):
    def __init__(
        self,
        has_more: bool = None,
        list: List[QueryCustomEntryProcessesResponseBodyList] = None,
        next_token: int = None,
    ):
        self.has_more = has_more
        self.list = list
        self.next_token = next_token

    def validate(self):
        if self.list:
            for k in self.list:
                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['list'] = []
        if self.list is not None:
            for k in self.list:
                result['list'].append(k.to_map() if k else None)
        if self.next_token is not None:
            result['nextToken'] = self.next_token
        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.list = []
        if m.get('list') is not None:
            for k in m.get('list'):
                temp_model = QueryCustomEntryProcessesResponseBodyList()
                self.list.append(temp_model.from_map(k))
        if m.get('nextToken') is not None:
            self.next_token = m.get('nextToken')
        return self


class QueryCustomEntryProcessesResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: QueryCustomEntryProcessesResponseBody = 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 = QueryCustomEntryProcessesResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class QueryDismissionStaffIdListHeaders(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 QueryDismissionStaffIdListRequest(TeaModel):
    def __init__(
        self,
        max_results: int = None,
        next_token: int = None,
    ):
        self.max_results = max_results
        self.next_token = next_token

    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
        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')
        return self


class QueryDismissionStaffIdListResponseBody(TeaModel):
    def __init__(
        self,
        has_more: bool = None,
        next_token: int = None,
        user_id_list: List[str] = None,
    ):
        self.has_more = has_more
        self.next_token = next_token
        self.user_id_list = user_id_list

    def validate(self):
        pass

    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
        if self.next_token is not None:
            result['nextToken'] = self.next_token
        if self.user_id_list is not None:
            result['userIdList'] = self.user_id_list
        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')
        if m.get('nextToken') is not None:
            self.next_token = m.get('nextToken')
        if m.get('userIdList') is not None:
            self.user_id_list = m.get('userIdList')
        return self


class QueryDismissionStaffIdListResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: QueryDismissionStaffIdListResponseBody = 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 = QueryDismissionStaffIdListResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class QueryHrmEmployeeDismissionInfoHeaders(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 QueryHrmEmployeeDismissionInfoRequest(TeaModel):
    def __init__(
        self,
        user_id_list: List[str] = None,
    ):
        # This parameter is required.
        self.user_id_list = user_id_list

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.user_id_list is not None:
            result['userIdList'] = self.user_id_list
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('userIdList') is not None:
            self.user_id_list = m.get('userIdList')
        return self


class QueryHrmEmployeeDismissionInfoShrinkRequest(TeaModel):
    def __init__(
        self,
        user_id_list_shrink: str = None,
    ):
        # This parameter is required.
        self.user_id_list_shrink = user_id_list_shrink

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.user_id_list_shrink is not None:
            result['userIdList'] = self.user_id_list_shrink
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('userIdList') is not None:
            self.user_id_list_shrink = m.get('userIdList')
        return self


class QueryHrmEmployeeDismissionInfoResponseBodyResultDeptList(TeaModel):
    def __init__(
        self,
        dept_id: int = None,
        dept_path: str = None,
    ):
        self.dept_id = dept_id
        self.dept_path = dept_path

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dept_id is not None:
            result['dept_id'] = self.dept_id
        if self.dept_path is not None:
            result['dept_path'] = self.dept_path
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('dept_id') is not None:
            self.dept_id = m.get('dept_id')
        if m.get('dept_path') is not None:
            self.dept_path = m.get('dept_path')
        return self


class QueryHrmEmployeeDismissionInfoResponseBodyResult(TeaModel):
    def __init__(
        self,
        dept_list: List[QueryHrmEmployeeDismissionInfoResponseBodyResultDeptList] = None,
        handover_user_id: str = None,
        last_work_day: int = None,
        main_dept_id: int = None,
        main_dept_name: str = None,
        name: str = None,
        passive_reason: List[str] = None,
        pre_status: int = None,
        reason_memo: str = None,
        status: int = None,
        user_id: str = None,
        voluntary_reason: List[str] = None,
    ):
        self.dept_list = dept_list
        self.handover_user_id = handover_user_id
        self.last_work_day = last_work_day
        self.main_dept_id = main_dept_id
        self.main_dept_name = main_dept_name
        self.name = name
        self.passive_reason = passive_reason
        self.pre_status = pre_status
        self.reason_memo = reason_memo
        self.status = status
        self.user_id = user_id
        self.voluntary_reason = voluntary_reason

    def validate(self):
        if self.dept_list:
            for k in self.dept_list:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['deptList'] = []
        if self.dept_list is not None:
            for k in self.dept_list:
                result['deptList'].append(k.to_map() if k else None)
        if self.handover_user_id is not None:
            result['handoverUserId'] = self.handover_user_id
        if self.last_work_day is not None:
            result['lastWorkDay'] = self.last_work_day
        if self.main_dept_id is not None:
            result['mainDeptId'] = self.main_dept_id
        if self.main_dept_name is not None:
            result['mainDeptName'] = self.main_dept_name
        if self.name is not None:
            result['name'] = self.name
        if self.passive_reason is not None:
            result['passiveReason'] = self.passive_reason
        if self.pre_status is not None:
            result['preStatus'] = self.pre_status
        if self.reason_memo is not None:
            result['reasonMemo'] = self.reason_memo
        if self.status is not None:
            result['status'] = self.status
        if self.user_id is not None:
            result['userId'] = self.user_id
        if self.voluntary_reason is not None:
            result['voluntaryReason'] = self.voluntary_reason
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.dept_list = []
        if m.get('deptList') is not None:
            for k in m.get('deptList'):
                temp_model = QueryHrmEmployeeDismissionInfoResponseBodyResultDeptList()
                self.dept_list.append(temp_model.from_map(k))
        if m.get('handoverUserId') is not None:
            self.handover_user_id = m.get('handoverUserId')
        if m.get('lastWorkDay') is not None:
            self.last_work_day = m.get('lastWorkDay')
        if m.get('mainDeptId') is not None:
            self.main_dept_id = m.get('mainDeptId')
        if m.get('mainDeptName') is not None:
            self.main_dept_name = m.get('mainDeptName')
        if m.get('name') is not None:
            self.name = m.get('name')
        if m.get('passiveReason') is not None:
            self.passive_reason = m.get('passiveReason')
        if m.get('preStatus') is not None:
            self.pre_status = m.get('preStatus')
        if m.get('reasonMemo') is not None:
            self.reason_memo = m.get('reasonMemo')
        if m.get('status') is not None:
            self.status = m.get('status')
        if m.get('userId') is not None:
            self.user_id = m.get('userId')
        if m.get('voluntaryReason') is not None:
            self.voluntary_reason = m.get('voluntaryReason')
        return self


class QueryHrmEmployeeDismissionInfoResponseBody(TeaModel):
    def __init__(
        self,
        result: List[QueryHrmEmployeeDismissionInfoResponseBodyResult] = None,
    ):
        self.result = result

    def validate(self):
        if self.result:
            for k in self.result:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['result'] = []
        if self.result is not None:
            for k in self.result:
                result['result'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.result = []
        if m.get('result') is not None:
            for k in m.get('result'):
                temp_model = QueryHrmEmployeeDismissionInfoResponseBodyResult()
                self.result.append(temp_model.from_map(k))
        return self


class QueryHrmEmployeeDismissionInfoResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: QueryHrmEmployeeDismissionInfoResponseBody = 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 = QueryHrmEmployeeDismissionInfoResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class QueryJobRanksHeaders(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 QueryJobRanksRequest(TeaModel):
    def __init__(
        self,
        max_results: int = None,
        next_token: int = None,
        rank_category_id: str = None,
        rank_code: str = None,
        rank_name: str = None,
    ):
        # This parameter is required.
        self.max_results = max_results
        # This parameter is required.
        self.next_token = next_token
        self.rank_category_id = rank_category_id
        self.rank_code = rank_code
        self.rank_name = rank_name

    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.rank_category_id is not None:
            result['rankCategoryId'] = self.rank_category_id
        if self.rank_code is not None:
            result['rankCode'] = self.rank_code
        if self.rank_name is not None:
            result['rankName'] = self.rank_name
        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('rankCategoryId') is not None:
            self.rank_category_id = m.get('rankCategoryId')
        if m.get('rankCode') is not None:
            self.rank_code = m.get('rankCode')
        if m.get('rankName') is not None:
            self.rank_name = m.get('rankName')
        return self


class QueryJobRanksResponseBodyList(TeaModel):
    def __init__(
        self,
        max_job_grade: int = None,
        min_job_grade: int = None,
        rank_category_id: str = None,
        rank_code: str = None,
        rank_description: str = None,
        rank_id: str = None,
        rank_name: str = None,
    ):
        self.max_job_grade = max_job_grade
        self.min_job_grade = min_job_grade
        self.rank_category_id = rank_category_id
        self.rank_code = rank_code
        self.rank_description = rank_description
        self.rank_id = rank_id
        self.rank_name = rank_name

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.max_job_grade is not None:
            result['maxJobGrade'] = self.max_job_grade
        if self.min_job_grade is not None:
            result['minJobGrade'] = self.min_job_grade
        if self.rank_category_id is not None:
            result['rankCategoryId'] = self.rank_category_id
        if self.rank_code is not None:
            result['rankCode'] = self.rank_code
        if self.rank_description is not None:
            result['rankDescription'] = self.rank_description
        if self.rank_id is not None:
            result['rankId'] = self.rank_id
        if self.rank_name is not None:
            result['rankName'] = self.rank_name
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('maxJobGrade') is not None:
            self.max_job_grade = m.get('maxJobGrade')
        if m.get('minJobGrade') is not None:
            self.min_job_grade = m.get('minJobGrade')
        if m.get('rankCategoryId') is not None:
            self.rank_category_id = m.get('rankCategoryId')
        if m.get('rankCode') is not None:
            self.rank_code = m.get('rankCode')
        if m.get('rankDescription') is not None:
            self.rank_description = m.get('rankDescription')
        if m.get('rankId') is not None:
            self.rank_id = m.get('rankId')
        if m.get('rankName') is not None:
            self.rank_name = m.get('rankName')
        return self


class QueryJobRanksResponseBody(TeaModel):
    def __init__(
        self,
        has_more: bool = None,
        list: List[QueryJobRanksResponseBodyList] = None,
        next_token: int = None,
    ):
        self.has_more = has_more
        self.list = list
        self.next_token = next_token

    def validate(self):
        if self.list:
            for k in self.list:
                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['list'] = []
        if self.list is not None:
            for k in self.list:
                result['list'].append(k.to_map() if k else None)
        if self.next_token is not None:
            result['nextToken'] = self.next_token
        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.list = []
        if m.get('list') is not None:
            for k in m.get('list'):
                temp_model = QueryJobRanksResponseBodyList()
                self.list.append(temp_model.from_map(k))
        if m.get('nextToken') is not None:
            self.next_token = m.get('nextToken')
        return self


class QueryJobRanksResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: QueryJobRanksResponseBody = 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 = QueryJobRanksResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class QueryJobsHeaders(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 QueryJobsRequest(TeaModel):
    def __init__(
        self,
        job_name: str = None,
        max_results: int = None,
        next_token: int = None,
    ):
        self.job_name = job_name
        # This parameter is required.
        self.max_results = max_results
        # This parameter is required.
        self.next_token = next_token

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.job_name is not None:
            result['jobName'] = self.job_name
        if self.max_results is not None:
            result['maxResults'] = self.max_results
        if self.next_token is not None:
            result['nextToken'] = self.next_token
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('jobName') is not None:
            self.job_name = m.get('jobName')
        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')
        return self


class QueryJobsResponseBodyList(TeaModel):
    def __init__(
        self,
        job_description: str = None,
        job_id: str = None,
        job_name: str = None,
    ):
        self.job_description = job_description
        self.job_id = job_id
        self.job_name = job_name

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.job_description is not None:
            result['jobDescription'] = self.job_description
        if self.job_id is not None:
            result['jobId'] = self.job_id
        if self.job_name is not None:
            result['jobName'] = self.job_name
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('jobDescription') is not None:
            self.job_description = m.get('jobDescription')
        if m.get('jobId') is not None:
            self.job_id = m.get('jobId')
        if m.get('jobName') is not None:
            self.job_name = m.get('jobName')
        return self


class QueryJobsResponseBody(TeaModel):
    def __init__(
        self,
        has_more: bool = None,
        list: List[QueryJobsResponseBodyList] = None,
        next_token: int = None,
    ):
        self.has_more = has_more
        self.list = list
        self.next_token = next_token

    def validate(self):
        if self.list:
            for k in self.list:
                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['list'] = []
        if self.list is not None:
            for k in self.list:
                result['list'].append(k.to_map() if k else None)
        if self.next_token is not None:
            result['nextToken'] = self.next_token
        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.list = []
        if m.get('list') is not None:
            for k in m.get('list'):
                temp_model = QueryJobsResponseBodyList()
                self.list.append(temp_model.from_map(k))
        if m.get('nextToken') is not None:
            self.next_token = m.get('nextToken')
        return self


class QueryJobsResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: QueryJobsResponseBody = 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 = QueryJobsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class QueryMicroAppStatusHeaders(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 QueryMicroAppStatusRequest(TeaModel):
    def __init__(
        self,
        tenant_id_list: List[int] = None,
    ):
        self.tenant_id_list = tenant_id_list

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.tenant_id_list is not None:
            result['tenantIdList'] = self.tenant_id_list
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('tenantIdList') is not None:
            self.tenant_id_list = m.get('tenantIdList')
        return self


class QueryMicroAppStatusResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
        result: Dict[str, ResultValue] = None,
        success: bool = None,
    ):
        self.request_id = request_id
        self.result = result
        self.success = success

    def validate(self):
        if self.result:
            for v in self.result.values():
                if v:
                    v.validate()

    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
        result['result'] = {}
        if self.result is not None:
            for k, v in self.result.items():
                result['result'][k] = v.to_map()
        if self.success is not None:
            result['success'] = self.success
        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')
        self.result = {}
        if m.get('result') is not None:
            for k, v in m.get('result').items():
                temp_model = ResultValue()
                self.result[k] = temp_model.from_map(v)
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class QueryMicroAppStatusResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: QueryMicroAppStatusResponseBody = 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 = QueryMicroAppStatusResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class QueryMicroAppViewHeaders(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 QueryMicroAppViewRequest(TeaModel):
    def __init__(
        self,
        tenant_id_list: List[int] = None,
        view_user_id: str = None,
    ):
        self.tenant_id_list = tenant_id_list
        self.view_user_id = view_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.tenant_id_list is not None:
            result['tenantIdList'] = self.tenant_id_list
        if self.view_user_id is not None:
            result['viewUserId'] = self.view_user_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('tenantIdList') is not None:
            self.tenant_id_list = m.get('tenantIdList')
        if m.get('viewUserId') is not None:
            self.view_user_id = m.get('viewUserId')
        return self


class QueryMicroAppViewResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
        result: Dict[str, bool] = None,
        success: bool = None,
    ):
        self.request_id = request_id
        self.result = result
        self.success = success

    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
        if self.result is not None:
            result['result'] = self.result
        if self.success is not None:
            result['success'] = self.success
        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')
        if m.get('result') is not None:
            self.result = m.get('result')
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class QueryMicroAppViewResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: QueryMicroAppViewResponseBody = 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 = QueryMicroAppViewResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class QueryPositionVersionHeaders(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 QueryPositionVersionResponseBody(TeaModel):
    def __init__(
        self,
        result: str = None,
    ):
        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 QueryPositionVersionResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: QueryPositionVersionResponseBody = 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 = QueryPositionVersionResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class QueryPositionsHeaders(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 QueryPositionsRequest(TeaModel):
    def __init__(
        self,
        dept_id: int = None,
        in_category_ids: List[str] = None,
        in_position_ids: List[str] = None,
        position_name: str = None,
        max_results: int = None,
        next_token: int = None,
    ):
        self.dept_id = dept_id
        self.in_category_ids = in_category_ids
        self.in_position_ids = in_position_ids
        self.position_name = position_name
        # This parameter is required.
        self.max_results = max_results
        # This parameter is required.
        self.next_token = next_token

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dept_id is not None:
            result['deptId'] = self.dept_id
        if self.in_category_ids is not None:
            result['inCategoryIds'] = self.in_category_ids
        if self.in_position_ids is not None:
            result['inPositionIds'] = self.in_position_ids
        if self.position_name is not None:
            result['positionName'] = self.position_name
        if self.max_results is not None:
            result['maxResults'] = self.max_results
        if self.next_token is not None:
            result['nextToken'] = self.next_token
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('deptId') is not None:
            self.dept_id = m.get('deptId')
        if m.get('inCategoryIds') is not None:
            self.in_category_ids = m.get('inCategoryIds')
        if m.get('inPositionIds') is not None:
            self.in_position_ids = m.get('inPositionIds')
        if m.get('positionName') is not None:
            self.position_name = m.get('positionName')
        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')
        return self


class QueryPositionsResponseBodyList(TeaModel):
    def __init__(
        self,
        job_id: str = None,
        position_category_id: str = None,
        position_des: str = None,
        position_id: str = None,
        position_name: str = None,
        rank_id_list: List[str] = None,
        status: int = None,
    ):
        self.job_id = job_id
        self.position_category_id = position_category_id
        self.position_des = position_des
        self.position_id = position_id
        self.position_name = position_name
        self.rank_id_list = rank_id_list
        self.status = status

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.job_id is not None:
            result['jobId'] = self.job_id
        if self.position_category_id is not None:
            result['positionCategoryId'] = self.position_category_id
        if self.position_des is not None:
            result['positionDes'] = self.position_des
        if self.position_id is not None:
            result['positionId'] = self.position_id
        if self.position_name is not None:
            result['positionName'] = self.position_name
        if self.rank_id_list is not None:
            result['rankIdList'] = self.rank_id_list
        if self.status is not None:
            result['status'] = self.status
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('jobId') is not None:
            self.job_id = m.get('jobId')
        if m.get('positionCategoryId') is not None:
            self.position_category_id = m.get('positionCategoryId')
        if m.get('positionDes') is not None:
            self.position_des = m.get('positionDes')
        if m.get('positionId') is not None:
            self.position_id = m.get('positionId')
        if m.get('positionName') is not None:
            self.position_name = m.get('positionName')
        if m.get('rankIdList') is not None:
            self.rank_id_list = m.get('rankIdList')
        if m.get('status') is not None:
            self.status = m.get('status')
        return self


class QueryPositionsResponseBody(TeaModel):
    def __init__(
        self,
        has_more: bool = None,
        list: List[QueryPositionsResponseBodyList] = None,
        next_token: int = None,
    ):
        self.has_more = has_more
        self.list = list
        self.next_token = next_token

    def validate(self):
        if self.list:
            for k in self.list:
                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['list'] = []
        if self.list is not None:
            for k in self.list:
                result['list'].append(k.to_map() if k else None)
        if self.next_token is not None:
            result['nextToken'] = self.next_token
        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.list = []
        if m.get('list') is not None:
            for k in m.get('list'):
                temp_model = QueryPositionsResponseBodyList()
                self.list.append(temp_model.from_map(k))
        if m.get('nextToken') is not None:
            self.next_token = m.get('nextToken')
        return self


class QueryPositionsResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: QueryPositionsResponseBody = 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 = QueryPositionsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class RevokeSignRecordsHeaders(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 RevokeSignRecordsRequest(TeaModel):
    def __init__(
        self,
        revoke_user_id: str = None,
        sign_record_ids: List[str] = None,
        status_remark: str = None,
    ):
        # This parameter is required.
        self.revoke_user_id = revoke_user_id
        # This parameter is required.
        self.sign_record_ids = sign_record_ids
        # This parameter is required.
        self.status_remark = status_remark

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.revoke_user_id is not None:
            result['revokeUserId'] = self.revoke_user_id
        if self.sign_record_ids is not None:
            result['signRecordIds'] = self.sign_record_ids
        if self.status_remark is not None:
            result['statusRemark'] = self.status_remark
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('revokeUserId') is not None:
            self.revoke_user_id = m.get('revokeUserId')
        if m.get('signRecordIds') is not None:
            self.sign_record_ids = m.get('signRecordIds')
        if m.get('statusRemark') is not None:
            self.status_remark = m.get('statusRemark')
        return self


class RevokeSignRecordsResponseBodyResultFailItems(TeaModel):
    def __init__(
        self,
        item_id: str = None,
        type: str = None,
    ):
        self.item_id = item_id
        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.item_id is not None:
            result['itemId'] = self.item_id
        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('itemId') is not None:
            self.item_id = m.get('itemId')
        if m.get('type') is not None:
            self.type = m.get('type')
        return self


class RevokeSignRecordsResponseBodyResultSuccessItems(TeaModel):
    def __init__(
        self,
        item_id: str = None,
    ):
        self.item_id = item_id

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.item_id is not None:
            result['itemId'] = self.item_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('itemId') is not None:
            self.item_id = m.get('itemId')
        return self


class RevokeSignRecordsResponseBodyResult(TeaModel):
    def __init__(
        self,
        fail_items: List[RevokeSignRecordsResponseBodyResultFailItems] = None,
        success_items: List[RevokeSignRecordsResponseBodyResultSuccessItems] = None,
    ):
        self.fail_items = fail_items
        self.success_items = success_items

    def validate(self):
        if self.fail_items:
            for k in self.fail_items:
                if k:
                    k.validate()
        if self.success_items:
            for k in self.success_items:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['failItems'] = []
        if self.fail_items is not None:
            for k in self.fail_items:
                result['failItems'].append(k.to_map() if k else None)
        result['successItems'] = []
        if self.success_items is not None:
            for k in self.success_items:
                result['successItems'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.fail_items = []
        if m.get('failItems') is not None:
            for k in m.get('failItems'):
                temp_model = RevokeSignRecordsResponseBodyResultFailItems()
                self.fail_items.append(temp_model.from_map(k))
        self.success_items = []
        if m.get('successItems') is not None:
            for k in m.get('successItems'):
                temp_model = RevokeSignRecordsResponseBodyResultSuccessItems()
                self.success_items.append(temp_model.from_map(k))
        return self


class RevokeSignRecordsResponseBody(TeaModel):
    def __init__(
        self,
        result: RevokeSignRecordsResponseBodyResult = None,
        success: bool = None,
    ):
        self.result = result
        # This parameter is required.
        self.success = success

    def validate(self):
        if self.result:
            self.result.validate()

    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.to_map()
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('result') is not None:
            temp_model = RevokeSignRecordsResponseBodyResult()
            self.result = temp_model.from_map(m['result'])
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class RevokeSignRecordsResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: RevokeSignRecordsResponseBody = 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 = RevokeSignRecordsResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class RevokeTerminationHeaders(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 RevokeTerminationRequest(TeaModel):
    def __init__(
        self,
        user_id: str = None,
    ):
        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.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('userId') is not None:
            self.user_id = m.get('userId')
        return self


class RevokeTerminationResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
        result: bool = None,
        success: bool = None,
    ):
        self.request_id = request_id
        self.result = result
        self.success = success

    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
        if self.result is not None:
            result['result'] = self.result
        if self.success is not None:
            result['success'] = self.success
        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')
        if m.get('result') is not None:
            self.result = m.get('result')
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class RevokeTerminationResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: RevokeTerminationResponseBody = 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 = RevokeTerminationResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class RosterMetaAvailableFieldListHeaders(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 RosterMetaAvailableFieldListRequest(TeaModel):
    def __init__(
        self,
        app_agent_id: int = None,
    ):
        # This parameter is required.
        self.app_agent_id = app_agent_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_agent_id is not None:
            result['appAgentId'] = self.app_agent_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('appAgentId') is not None:
            self.app_agent_id = m.get('appAgentId')
        return self


class RosterMetaAvailableFieldListResponseBodyResult(TeaModel):
    def __init__(
        self,
        field_code: str = None,
        field_name: str = None,
        field_type: str = None,
        option_text: str = None,
    ):
        self.field_code = field_code
        self.field_name = field_name
        self.field_type = field_type
        self.option_text = option_text

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.field_code is not None:
            result['fieldCode'] = self.field_code
        if self.field_name is not None:
            result['fieldName'] = self.field_name
        if self.field_type is not None:
            result['fieldType'] = self.field_type
        if self.option_text is not None:
            result['optionText'] = self.option_text
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('fieldCode') is not None:
            self.field_code = m.get('fieldCode')
        if m.get('fieldName') is not None:
            self.field_name = m.get('fieldName')
        if m.get('fieldType') is not None:
            self.field_type = m.get('fieldType')
        if m.get('optionText') is not None:
            self.option_text = m.get('optionText')
        return self


class RosterMetaAvailableFieldListResponseBody(TeaModel):
    def __init__(
        self,
        result: List[RosterMetaAvailableFieldListResponseBodyResult] = None,
    ):
        self.result = result

    def validate(self):
        if self.result:
            for k in self.result:
                if k:
                    k.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        result['result'] = []
        if self.result is not None:
            for k in self.result:
                result['result'].append(k.to_map() if k else None)
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        self.result = []
        if m.get('result') is not None:
            for k in m.get('result'):
                temp_model = RosterMetaAvailableFieldListResponseBodyResult()
                self.result.append(temp_model.from_map(k))
        return self


class RosterMetaAvailableFieldListResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: RosterMetaAvailableFieldListResponseBody = 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 = RosterMetaAvailableFieldListResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class RosterMetaFieldOptionsUpdateHeaders(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 RosterMetaFieldOptionsUpdateRequest(TeaModel):
    def __init__(
        self,
        app_agent_id: int = None,
        field_code: str = None,
        group_id: str = None,
        labels: List[str] = None,
        modify_type: str = None,
    ):
        self.app_agent_id = app_agent_id
        # This parameter is required.
        self.field_code = field_code
        # This parameter is required.
        self.group_id = group_id
        # This parameter is required.
        self.labels = labels
        # This parameter is required.
        self.modify_type = modify_type

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.app_agent_id is not None:
            result['appAgentId'] = self.app_agent_id
        if self.field_code is not None:
            result['fieldCode'] = self.field_code
        if self.group_id is not None:
            result['groupId'] = self.group_id
        if self.labels is not None:
            result['labels'] = self.labels
        if self.modify_type is not None:
            result['modifyType'] = self.modify_type
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('appAgentId') is not None:
            self.app_agent_id = m.get('appAgentId')
        if m.get('fieldCode') is not None:
            self.field_code = m.get('fieldCode')
        if m.get('groupId') is not None:
            self.group_id = m.get('groupId')
        if m.get('labels') is not None:
            self.labels = m.get('labels')
        if m.get('modifyType') is not None:
            self.modify_type = m.get('modifyType')
        return self


class RosterMetaFieldOptionsUpdateResponseBody(TeaModel):
    def __init__(
        self,
        result: bool = None,
    ):
        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 RosterMetaFieldOptionsUpdateResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: RosterMetaFieldOptionsUpdateResponseBody = 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 = RosterMetaFieldOptionsUpdateResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class SendIsvCardMessageHeaders(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 SendIsvCardMessageRequest(TeaModel):
    def __init__(
        self,
        agent_id: int = None,
        biz_id: str = None,
        message_type: str = None,
        receiver_user_ids: List[str] = None,
        scene_type: str = None,
        scope: str = None,
        sender_user_id: str = None,
        value_map: Dict[str, str] = None,
    ):
        # This parameter is required.
        self.agent_id = agent_id
        # This parameter is required.
        self.biz_id = biz_id
        # This parameter is required.
        self.message_type = message_type
        # This parameter is required.
        self.receiver_user_ids = receiver_user_ids
        # This parameter is required.
        self.scene_type = scene_type
        # This parameter is required.
        self.scope = scope
        # This parameter is required.
        self.sender_user_id = sender_user_id
        self.value_map = value_map

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.agent_id is not None:
            result['agentId'] = self.agent_id
        if self.biz_id is not None:
            result['bizId'] = self.biz_id
        if self.message_type is not None:
            result['messageType'] = self.message_type
        if self.receiver_user_ids is not None:
            result['receiverUserIds'] = self.receiver_user_ids
        if self.scene_type is not None:
            result['sceneType'] = self.scene_type
        if self.scope is not None:
            result['scope'] = self.scope
        if self.sender_user_id is not None:
            result['senderUserId'] = self.sender_user_id
        if self.value_map is not None:
            result['valueMap'] = self.value_map
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('agentId') is not None:
            self.agent_id = m.get('agentId')
        if m.get('bizId') is not None:
            self.biz_id = m.get('bizId')
        if m.get('messageType') is not None:
            self.message_type = m.get('messageType')
        if m.get('receiverUserIds') is not None:
            self.receiver_user_ids = m.get('receiverUserIds')
        if m.get('sceneType') is not None:
            self.scene_type = m.get('sceneType')
        if m.get('scope') is not None:
            self.scope = m.get('scope')
        if m.get('senderUserId') is not None:
            self.sender_user_id = m.get('senderUserId')
        if m.get('valueMap') is not None:
            self.value_map = m.get('valueMap')
        return self


class SendIsvCardMessageResponseBodyHrmInteractiveCardSendResult(TeaModel):
    def __init__(
        self,
        biz_id: str = None,
        error_code: str = None,
        error_msg: str = None,
    ):
        self.biz_id = biz_id
        self.error_code = error_code
        self.error_msg = error_msg

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_id is not None:
            result['bizId'] = self.biz_id
        if self.error_code is not None:
            result['errorCode'] = self.error_code
        if self.error_msg is not None:
            result['errorMsg'] = self.error_msg
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('bizId') is not None:
            self.biz_id = m.get('bizId')
        if m.get('errorCode') is not None:
            self.error_code = m.get('errorCode')
        if m.get('errorMsg') is not None:
            self.error_msg = m.get('errorMsg')
        return self


class SendIsvCardMessageResponseBody(TeaModel):
    def __init__(
        self,
        error_code: str = None,
        error_msg: str = None,
        hrm_interactive_card_send_result: SendIsvCardMessageResponseBodyHrmInteractiveCardSendResult = None,
        request_id: str = None,
        success: bool = None,
    ):
        self.error_code = error_code
        self.error_msg = error_msg
        self.hrm_interactive_card_send_result = hrm_interactive_card_send_result
        self.request_id = request_id
        self.success = success

    def validate(self):
        if self.hrm_interactive_card_send_result:
            self.hrm_interactive_card_send_result.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['errorCode'] = self.error_code
        if self.error_msg is not None:
            result['errorMsg'] = self.error_msg
        if self.hrm_interactive_card_send_result is not None:
            result['hrmInteractiveCardSendResult'] = self.hrm_interactive_card_send_result.to_map()
        if self.request_id is not None:
            result['requestId'] = self.request_id
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('errorCode') is not None:
            self.error_code = m.get('errorCode')
        if m.get('errorMsg') is not None:
            self.error_msg = m.get('errorMsg')
        if m.get('hrmInteractiveCardSendResult') is not None:
            temp_model = SendIsvCardMessageResponseBodyHrmInteractiveCardSendResult()
            self.hrm_interactive_card_send_result = temp_model.from_map(m['hrmInteractiveCardSendResult'])
        if m.get('requestId') is not None:
            self.request_id = m.get('requestId')
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class SendIsvCardMessageResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: SendIsvCardMessageResponseBody = 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 = SendIsvCardMessageResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class SendRealAuthInviteMessageHeaders(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 SendRealAuthInviteMessageRequestOnWorkingEmpSearchVO(TeaModel):
    def __init__(
        self,
        user_ids: List[str] = None,
    ):
        # This parameter is required.
        self.user_ids = user_ids

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.user_ids is not None:
            result['userIds'] = self.user_ids
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('userIds') is not None:
            self.user_ids = m.get('userIds')
        return self


class SendRealAuthInviteMessageRequest(TeaModel):
    def __init__(
        self,
        inviter_id: str = None,
        on_working_emp_search_vo: SendRealAuthInviteMessageRequestOnWorkingEmpSearchVO = None,
    ):
        # This parameter is required.
        self.inviter_id = inviter_id
        # This parameter is required.
        self.on_working_emp_search_vo = on_working_emp_search_vo

    def validate(self):
        if self.on_working_emp_search_vo:
            self.on_working_emp_search_vo.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.inviter_id is not None:
            result['inviterId'] = self.inviter_id
        if self.on_working_emp_search_vo is not None:
            result['onWorkingEmpSearchVO'] = self.on_working_emp_search_vo.to_map()
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('inviterId') is not None:
            self.inviter_id = m.get('inviterId')
        if m.get('onWorkingEmpSearchVO') is not None:
            temp_model = SendRealAuthInviteMessageRequestOnWorkingEmpSearchVO()
            self.on_working_emp_search_vo = temp_model.from_map(m['onWorkingEmpSearchVO'])
        return self


class SendRealAuthInviteMessageResponseBodyResult(TeaModel):
    def __init__(
        self,
        had_invited_num: int = None,
        had_real_auth_num: int = None,
        success_num: int = None,
    ):
        self.had_invited_num = had_invited_num
        self.had_real_auth_num = had_real_auth_num
        self.success_num = success_num

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.had_invited_num is not None:
            result['hadInvitedNum'] = self.had_invited_num
        if self.had_real_auth_num is not None:
            result['hadRealAuthNum'] = self.had_real_auth_num
        if self.success_num is not None:
            result['successNum'] = self.success_num
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('hadInvitedNum') is not None:
            self.had_invited_num = m.get('hadInvitedNum')
        if m.get('hadRealAuthNum') is not None:
            self.had_real_auth_num = m.get('hadRealAuthNum')
        if m.get('successNum') is not None:
            self.success_num = m.get('successNum')
        return self


class SendRealAuthInviteMessageResponseBody(TeaModel):
    def __init__(
        self,
        ding_open_errcode: int = None,
        error_msg: str = None,
        result: SendRealAuthInviteMessageResponseBodyResult = None,
        success: bool = None,
    ):
        self.ding_open_errcode = ding_open_errcode
        self.error_msg = error_msg
        self.result = result
        self.success = success

    def validate(self):
        if self.result:
            self.result.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.ding_open_errcode is not None:
            result['dingOpenErrcode'] = self.ding_open_errcode
        if self.error_msg is not None:
            result['errorMsg'] = self.error_msg
        if self.result is not None:
            result['result'] = self.result.to_map()
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('dingOpenErrcode') is not None:
            self.ding_open_errcode = m.get('dingOpenErrcode')
        if m.get('errorMsg') is not None:
            self.error_msg = m.get('errorMsg')
        if m.get('result') is not None:
            temp_model = SendRealAuthInviteMessageResponseBodyResult()
            self.result = temp_model.from_map(m['result'])
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class SendRealAuthInviteMessageResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: SendRealAuthInviteMessageResponseBody = 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 = SendRealAuthInviteMessageResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class SolutionTaskInitHeaders(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 SolutionTaskInitRequest(TeaModel):
    def __init__(
        self,
        category: str = None,
        claim_time: int = None,
        description: str = None,
        finish_time: int = None,
        outer_id: str = None,
        status: str = None,
        title: str = None,
        user_id: str = None,
        solution_type: str = None,
    ):
        # This parameter is required.
        self.category = category
        self.claim_time = claim_time
        self.description = description
        self.finish_time = finish_time
        # This parameter is required.
        self.outer_id = outer_id
        # This parameter is required.
        self.status = status
        # This parameter is required.
        self.title = title
        # This parameter is required.
        self.user_id = user_id
        # This parameter is required.
        self.solution_type = solution_type

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.category is not None:
            result['category'] = self.category
        if self.claim_time is not None:
            result['claimTime'] = self.claim_time
        if self.description is not None:
            result['description'] = self.description
        if self.finish_time is not None:
            result['finishTime'] = self.finish_time
        if self.outer_id is not None:
            result['outerId'] = self.outer_id
        if self.status is not None:
            result['status'] = self.status
        if self.title is not None:
            result['title'] = self.title
        if self.user_id is not None:
            result['userId'] = self.user_id
        if self.solution_type is not None:
            result['solutionType'] = self.solution_type
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('category') is not None:
            self.category = m.get('category')
        if m.get('claimTime') is not None:
            self.claim_time = m.get('claimTime')
        if m.get('description') is not None:
            self.description = m.get('description')
        if m.get('finishTime') is not None:
            self.finish_time = m.get('finishTime')
        if m.get('outerId') is not None:
            self.outer_id = m.get('outerId')
        if m.get('status') is not None:
            self.status = m.get('status')
        if m.get('title') is not None:
            self.title = m.get('title')
        if m.get('userId') is not None:
            self.user_id = m.get('userId')
        if m.get('solutionType') is not None:
            self.solution_type = m.get('solutionType')
        return self


class SolutionTaskInitResponseBody(TeaModel):
    def __init__(
        self,
        result: bool = None,
    ):
        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 SolutionTaskInitResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: SolutionTaskInitResponseBody = 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 = SolutionTaskInitResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class SolutionTaskSaveHeaders(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 SolutionTaskSaveRequest(TeaModel):
    def __init__(
        self,
        claim_time: int = None,
        description: str = None,
        finish_time: int = None,
        outer_id: str = None,
        solution_instance_id: str = None,
        start_time: int = None,
        status: str = None,
        task_type: str = None,
        template_outer_id: str = None,
        title: str = None,
        user_id: str = None,
        solution_type: str = None,
    ):
        self.claim_time = claim_time
        self.description = description
        self.finish_time = finish_time
        # This parameter is required.
        self.outer_id = outer_id
        # This parameter is required.
        self.solution_instance_id = solution_instance_id
        self.start_time = start_time
        # This parameter is required.
        self.status = status
        # This parameter is required.
        self.task_type = task_type
        self.template_outer_id = template_outer_id
        # This parameter is required.
        self.title = title
        # This parameter is required.
        self.user_id = user_id
        # This parameter is required.
        self.solution_type = solution_type

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.claim_time is not None:
            result['claimTime'] = self.claim_time
        if self.description is not None:
            result['description'] = self.description
        if self.finish_time is not None:
            result['finishTime'] = self.finish_time
        if self.outer_id is not None:
            result['outerId'] = self.outer_id
        if self.solution_instance_id is not None:
            result['solutionInstanceId'] = self.solution_instance_id
        if self.start_time is not None:
            result['startTime'] = self.start_time
        if self.status is not None:
            result['status'] = self.status
        if self.task_type is not None:
            result['taskType'] = self.task_type
        if self.template_outer_id is not None:
            result['templateOuterId'] = self.template_outer_id
        if self.title is not None:
            result['title'] = self.title
        if self.user_id is not None:
            result['userId'] = self.user_id
        if self.solution_type is not None:
            result['solutionType'] = self.solution_type
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('claimTime') is not None:
            self.claim_time = m.get('claimTime')
        if m.get('description') is not None:
            self.description = m.get('description')
        if m.get('finishTime') is not None:
            self.finish_time = m.get('finishTime')
        if m.get('outerId') is not None:
            self.outer_id = m.get('outerId')
        if m.get('solutionInstanceId') is not None:
            self.solution_instance_id = m.get('solutionInstanceId')
        if m.get('startTime') is not None:
            self.start_time = m.get('startTime')
        if m.get('status') is not None:
            self.status = m.get('status')
        if m.get('taskType') is not None:
            self.task_type = m.get('taskType')
        if m.get('templateOuterId') is not None:
            self.template_outer_id = m.get('templateOuterId')
        if m.get('title') is not None:
            self.title = m.get('title')
        if m.get('userId') is not None:
            self.user_id = m.get('userId')
        if m.get('solutionType') is not None:
            self.solution_type = m.get('solutionType')
        return self


class SolutionTaskSaveResponseBody(TeaModel):
    def __init__(
        self,
        result: bool = None,
    ):
        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 SolutionTaskSaveResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: SolutionTaskSaveResponseBody = 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 = SolutionTaskSaveResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class SyncSolutionStatusHeaders(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 SyncSolutionStatusRequest(TeaModel):
    def __init__(
        self,
        biz_id: str = None,
        solution_status: str = None,
        solution_type: str = None,
        tenant_id: int = None,
        user_ids: List[str] = None,
    ):
        # This parameter is required.
        self.biz_id = biz_id
        # This parameter is required.
        self.solution_status = solution_status
        # This parameter is required.
        self.solution_type = solution_type
        # This parameter is required.
        self.tenant_id = tenant_id
        # This parameter is required.
        self.user_ids = user_ids

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.biz_id is not None:
            result['bizId'] = self.biz_id
        if self.solution_status is not None:
            result['solutionStatus'] = self.solution_status
        if self.solution_type is not None:
            result['solutionType'] = self.solution_type
        if self.tenant_id is not None:
            result['tenantId'] = self.tenant_id
        if self.user_ids is not None:
            result['userIds'] = self.user_ids
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('bizId') is not None:
            self.biz_id = m.get('bizId')
        if m.get('solutionStatus') is not None:
            self.solution_status = m.get('solutionStatus')
        if m.get('solutionType') is not None:
            self.solution_type = m.get('solutionType')
        if m.get('tenantId') is not None:
            self.tenant_id = m.get('tenantId')
        if m.get('userIds') is not None:
            self.user_ids = m.get('userIds')
        return self


class SyncSolutionStatusResponseBody(TeaModel):
    def __init__(
        self,
        result: bool = None,
    ):
        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 SyncSolutionStatusResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: SyncSolutionStatusResponseBody = 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 = SyncSolutionStatusResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class SyncTaskTemplateHeaders(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 SyncTaskTemplateRequestTaskScopeVO(TeaModel):
    def __init__(
        self,
        dept_ids: List[int] = None,
        position_ids: List[str] = None,
        role_ids: List[str] = None,
        user_ids: List[str] = None,
    ):
        self.dept_ids = dept_ids
        self.position_ids = position_ids
        self.role_ids = role_ids
        self.user_ids = user_ids

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.dept_ids is not None:
            result['deptIds'] = self.dept_ids
        if self.position_ids is not None:
            result['positionIds'] = self.position_ids
        if self.role_ids is not None:
            result['roleIds'] = self.role_ids
        if self.user_ids is not None:
            result['userIds'] = self.user_ids
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('deptIds') is not None:
            self.dept_ids = m.get('deptIds')
        if m.get('positionIds') is not None:
            self.position_ids = m.get('positionIds')
        if m.get('roleIds') is not None:
            self.role_ids = m.get('roleIds')
        if m.get('userIds') is not None:
            self.user_ids = m.get('userIds')
        return self


class SyncTaskTemplateRequest(TeaModel):
    def __init__(
        self,
        delete: bool = None,
        des: str = None,
        ext: str = None,
        name: str = None,
        opt_user_id: str = None,
        outer_id: str = None,
        task_scope_vo: SyncTaskTemplateRequestTaskScopeVO = None,
        task_type: str = None,
        solution_type: str = None,
    ):
        self.delete = delete
        self.des = des
        self.ext = ext
        # This parameter is required.
        self.name = name
        # This parameter is required.
        self.opt_user_id = opt_user_id
        # This parameter is required.
        self.outer_id = outer_id
        self.task_scope_vo = task_scope_vo
        # This parameter is required.
        self.task_type = task_type
        # This parameter is required.
        self.solution_type = solution_type

    def validate(self):
        if self.task_scope_vo:
            self.task_scope_vo.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.delete is not None:
            result['delete'] = self.delete
        if self.des is not None:
            result['des'] = self.des
        if self.ext is not None:
            result['ext'] = self.ext
        if self.name is not None:
            result['name'] = self.name
        if self.opt_user_id is not None:
            result['optUserId'] = self.opt_user_id
        if self.outer_id is not None:
            result['outerId'] = self.outer_id
        if self.task_scope_vo is not None:
            result['taskScopeVO'] = self.task_scope_vo.to_map()
        if self.task_type is not None:
            result['taskType'] = self.task_type
        if self.solution_type is not None:
            result['solutionType'] = self.solution_type
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('delete') is not None:
            self.delete = m.get('delete')
        if m.get('des') is not None:
            self.des = m.get('des')
        if m.get('ext') is not None:
            self.ext = m.get('ext')
        if m.get('name') is not None:
            self.name = m.get('name')
        if m.get('optUserId') is not None:
            self.opt_user_id = m.get('optUserId')
        if m.get('outerId') is not None:
            self.outer_id = m.get('outerId')
        if m.get('taskScopeVO') is not None:
            temp_model = SyncTaskTemplateRequestTaskScopeVO()
            self.task_scope_vo = temp_model.from_map(m['taskScopeVO'])
        if m.get('taskType') is not None:
            self.task_type = m.get('taskType')
        if m.get('solutionType') is not None:
            self.solution_type = m.get('solutionType')
        return self


class SyncTaskTemplateResponseBody(TeaModel):
    def __init__(
        self,
        result: bool = None,
    ):
        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 SyncTaskTemplateResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: SyncTaskTemplateResponseBody = 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 = SyncTaskTemplateResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateCustomRosterFieldHeaders(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 UpdateCustomRosterFieldRequest(TeaModel):
    def __init__(
        self,
        contact_client_flag: bool = None,
        contact_flag: bool = None,
        contact_source: int = None,
        contact_system_flag: bool = None,
        deleted: bool = None,
        derived: bool = None,
        disabled: int = None,
        edit_from_employee_flag: bool = None,
        editable_by_hr: bool = None,
        field_code: str = None,
        field_name: str = None,
        field_tip: str = None,
        field_type: str = None,
        group_id: str = None,
        hidden_from_employee_flag: bool = None,
        hint: str = None,
        history_field: bool = None,
        index: int = None,
        modify_options: bool = None,
        no_watermark: bool = None,
        number_decimal_place: int = None,
        number_format_type: str = None,
        number_value_type: str = None,
        option_text: str = None,
        required: bool = None,
        source_field_code: str = None,
        system_flag: bool = None,
        text_to_select_field: bool = None,
        update_user_id: str = None,
        value: str = None,
        visible_by_emp: bool = None,
    ):
        self.contact_client_flag = contact_client_flag
        self.contact_flag = contact_flag
        self.contact_source = contact_source
        self.contact_system_flag = contact_system_flag
        self.deleted = deleted
        self.derived = derived
        self.disabled = disabled
        # This parameter is required.
        self.edit_from_employee_flag = edit_from_employee_flag
        self.editable_by_hr = editable_by_hr
        # This parameter is required.
        self.field_code = field_code
        # This parameter is required.
        self.field_name = field_name
        self.field_tip = field_tip
        # This parameter is required.
        self.field_type = field_type
        # This parameter is required.
        self.group_id = group_id
        # This parameter is required.
        self.hidden_from_employee_flag = hidden_from_employee_flag
        self.hint = hint
        self.history_field = history_field
        self.index = index
        self.modify_options = modify_options
        self.no_watermark = no_watermark
        self.number_decimal_place = number_decimal_place
        self.number_format_type = number_format_type
        self.number_value_type = number_value_type
        self.option_text = option_text
        # This parameter is required.
        self.required = required
        self.source_field_code = source_field_code
        self.system_flag = system_flag
        self.text_to_select_field = text_to_select_field
        # This parameter is required.
        self.update_user_id = update_user_id
        self.value = value
        # This parameter is required.
        self.visible_by_emp = visible_by_emp

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.contact_client_flag is not None:
            result['contactClientFlag'] = self.contact_client_flag
        if self.contact_flag is not None:
            result['contactFlag'] = self.contact_flag
        if self.contact_source is not None:
            result['contactSource'] = self.contact_source
        if self.contact_system_flag is not None:
            result['contactSystemFlag'] = self.contact_system_flag
        if self.deleted is not None:
            result['deleted'] = self.deleted
        if self.derived is not None:
            result['derived'] = self.derived
        if self.disabled is not None:
            result['disabled'] = self.disabled
        if self.edit_from_employee_flag is not None:
            result['editFromEmployeeFlag'] = self.edit_from_employee_flag
        if self.editable_by_hr is not None:
            result['editableByHr'] = self.editable_by_hr
        if self.field_code is not None:
            result['fieldCode'] = self.field_code
        if self.field_name is not None:
            result['fieldName'] = self.field_name
        if self.field_tip is not None:
            result['fieldTip'] = self.field_tip
        if self.field_type is not None:
            result['fieldType'] = self.field_type
        if self.group_id is not None:
            result['groupId'] = self.group_id
        if self.hidden_from_employee_flag is not None:
            result['hiddenFromEmployeeFlag'] = self.hidden_from_employee_flag
        if self.hint is not None:
            result['hint'] = self.hint
        if self.history_field is not None:
            result['historyField'] = self.history_field
        if self.index is not None:
            result['index'] = self.index
        if self.modify_options is not None:
            result['modifyOptions'] = self.modify_options
        if self.no_watermark is not None:
            result['noWatermark'] = self.no_watermark
        if self.number_decimal_place is not None:
            result['numberDecimalPlace'] = self.number_decimal_place
        if self.number_format_type is not None:
            result['numberFormatType'] = self.number_format_type
        if self.number_value_type is not None:
            result['numberValueType'] = self.number_value_type
        if self.option_text is not None:
            result['optionText'] = self.option_text
        if self.required is not None:
            result['required'] = self.required
        if self.source_field_code is not None:
            result['sourceFieldCode'] = self.source_field_code
        if self.system_flag is not None:
            result['systemFlag'] = self.system_flag
        if self.text_to_select_field is not None:
            result['textToSelectField'] = self.text_to_select_field
        if self.update_user_id is not None:
            result['updateUserId'] = self.update_user_id
        if self.value is not None:
            result['value'] = self.value
        if self.visible_by_emp is not None:
            result['visibleByEmp'] = self.visible_by_emp
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('contactClientFlag') is not None:
            self.contact_client_flag = m.get('contactClientFlag')
        if m.get('contactFlag') is not None:
            self.contact_flag = m.get('contactFlag')
        if m.get('contactSource') is not None:
            self.contact_source = m.get('contactSource')
        if m.get('contactSystemFlag') is not None:
            self.contact_system_flag = m.get('contactSystemFlag')
        if m.get('deleted') is not None:
            self.deleted = m.get('deleted')
        if m.get('derived') is not None:
            self.derived = m.get('derived')
        if m.get('disabled') is not None:
            self.disabled = m.get('disabled')
        if m.get('editFromEmployeeFlag') is not None:
            self.edit_from_employee_flag = m.get('editFromEmployeeFlag')
        if m.get('editableByHr') is not None:
            self.editable_by_hr = m.get('editableByHr')
        if m.get('fieldCode') is not None:
            self.field_code = m.get('fieldCode')
        if m.get('fieldName') is not None:
            self.field_name = m.get('fieldName')
        if m.get('fieldTip') is not None:
            self.field_tip = m.get('fieldTip')
        if m.get('fieldType') is not None:
            self.field_type = m.get('fieldType')
        if m.get('groupId') is not None:
            self.group_id = m.get('groupId')
        if m.get('hiddenFromEmployeeFlag') is not None:
            self.hidden_from_employee_flag = m.get('hiddenFromEmployeeFlag')
        if m.get('hint') is not None:
            self.hint = m.get('hint')
        if m.get('historyField') is not None:
            self.history_field = m.get('historyField')
        if m.get('index') is not None:
            self.index = m.get('index')
        if m.get('modifyOptions') is not None:
            self.modify_options = m.get('modifyOptions')
        if m.get('noWatermark') is not None:
            self.no_watermark = m.get('noWatermark')
        if m.get('numberDecimalPlace') is not None:
            self.number_decimal_place = m.get('numberDecimalPlace')
        if m.get('numberFormatType') is not None:
            self.number_format_type = m.get('numberFormatType')
        if m.get('numberValueType') is not None:
            self.number_value_type = m.get('numberValueType')
        if m.get('optionText') is not None:
            self.option_text = m.get('optionText')
        if m.get('required') is not None:
            self.required = m.get('required')
        if m.get('sourceFieldCode') is not None:
            self.source_field_code = m.get('sourceFieldCode')
        if m.get('systemFlag') is not None:
            self.system_flag = m.get('systemFlag')
        if m.get('textToSelectField') is not None:
            self.text_to_select_field = m.get('textToSelectField')
        if m.get('updateUserId') is not None:
            self.update_user_id = m.get('updateUserId')
        if m.get('value') is not None:
            self.value = m.get('value')
        if m.get('visibleByEmp') is not None:
            self.visible_by_emp = m.get('visibleByEmp')
        return self


class UpdateCustomRosterFieldResponseBodyResult(TeaModel):
    def __init__(
        self,
        contact_client_flag: bool = None,
        contact_flag: bool = None,
        contact_source: int = None,
        contact_system_flag: bool = None,
        deleted: bool = None,
        derived: bool = None,
        disabled: int = None,
        edit_from_employee_flag: bool = None,
        editable_by_hr: bool = None,
        field_code: str = None,
        field_name: str = None,
        field_tip: str = None,
        field_type: str = None,
        group_id: str = None,
        hidden_from_employee_flag: bool = None,
        hint: str = None,
        history_field: bool = None,
        index: int = None,
        modify_options: bool = None,
        no_watermark: bool = None,
        number_decimal_place: str = None,
        number_format_type: str = None,
        number_value_type: str = None,
        option_text: str = None,
        required: bool = None,
        source_field_code: str = None,
        system_flag: bool = None,
        text_to_select_field: bool = None,
        value: str = None,
        visible_by_emp: bool = None,
    ):
        self.contact_client_flag = contact_client_flag
        self.contact_flag = contact_flag
        self.contact_source = contact_source
        self.contact_system_flag = contact_system_flag
        self.deleted = deleted
        self.derived = derived
        self.disabled = disabled
        self.edit_from_employee_flag = edit_from_employee_flag
        self.editable_by_hr = editable_by_hr
        self.field_code = field_code
        self.field_name = field_name
        self.field_tip = field_tip
        self.field_type = field_type
        self.group_id = group_id
        self.hidden_from_employee_flag = hidden_from_employee_flag
        self.hint = hint
        self.history_field = history_field
        self.index = index
        self.modify_options = modify_options
        self.no_watermark = no_watermark
        self.number_decimal_place = number_decimal_place
        self.number_format_type = number_format_type
        self.number_value_type = number_value_type
        self.option_text = option_text
        self.required = required
        self.source_field_code = source_field_code
        self.system_flag = system_flag
        self.text_to_select_field = text_to_select_field
        self.value = value
        self.visible_by_emp = visible_by_emp

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.contact_client_flag is not None:
            result['contactClientFlag'] = self.contact_client_flag
        if self.contact_flag is not None:
            result['contactFlag'] = self.contact_flag
        if self.contact_source is not None:
            result['contactSource'] = self.contact_source
        if self.contact_system_flag is not None:
            result['contactSystemFlag'] = self.contact_system_flag
        if self.deleted is not None:
            result['deleted'] = self.deleted
        if self.derived is not None:
            result['derived'] = self.derived
        if self.disabled is not None:
            result['disabled'] = self.disabled
        if self.edit_from_employee_flag is not None:
            result['editFromEmployeeFlag'] = self.edit_from_employee_flag
        if self.editable_by_hr is not None:
            result['editableByHr'] = self.editable_by_hr
        if self.field_code is not None:
            result['fieldCode'] = self.field_code
        if self.field_name is not None:
            result['fieldName'] = self.field_name
        if self.field_tip is not None:
            result['fieldTip'] = self.field_tip
        if self.field_type is not None:
            result['fieldType'] = self.field_type
        if self.group_id is not None:
            result['groupId'] = self.group_id
        if self.hidden_from_employee_flag is not None:
            result['hiddenFromEmployeeFlag'] = self.hidden_from_employee_flag
        if self.hint is not None:
            result['hint'] = self.hint
        if self.history_field is not None:
            result['historyField'] = self.history_field
        if self.index is not None:
            result['index'] = self.index
        if self.modify_options is not None:
            result['modifyOptions'] = self.modify_options
        if self.no_watermark is not None:
            result['noWatermark'] = self.no_watermark
        if self.number_decimal_place is not None:
            result['numberDecimalPlace'] = self.number_decimal_place
        if self.number_format_type is not None:
            result['numberFormatType'] = self.number_format_type
        if self.number_value_type is not None:
            result['numberValueType'] = self.number_value_type
        if self.option_text is not None:
            result['optionText'] = self.option_text
        if self.required is not None:
            result['required'] = self.required
        if self.source_field_code is not None:
            result['sourceFieldCode'] = self.source_field_code
        if self.system_flag is not None:
            result['systemFlag'] = self.system_flag
        if self.text_to_select_field is not None:
            result['textToSelectField'] = self.text_to_select_field
        if self.value is not None:
            result['value'] = self.value
        if self.visible_by_emp is not None:
            result['visibleByEmp'] = self.visible_by_emp
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('contactClientFlag') is not None:
            self.contact_client_flag = m.get('contactClientFlag')
        if m.get('contactFlag') is not None:
            self.contact_flag = m.get('contactFlag')
        if m.get('contactSource') is not None:
            self.contact_source = m.get('contactSource')
        if m.get('contactSystemFlag') is not None:
            self.contact_system_flag = m.get('contactSystemFlag')
        if m.get('deleted') is not None:
            self.deleted = m.get('deleted')
        if m.get('derived') is not None:
            self.derived = m.get('derived')
        if m.get('disabled') is not None:
            self.disabled = m.get('disabled')
        if m.get('editFromEmployeeFlag') is not None:
            self.edit_from_employee_flag = m.get('editFromEmployeeFlag')
        if m.get('editableByHr') is not None:
            self.editable_by_hr = m.get('editableByHr')
        if m.get('fieldCode') is not None:
            self.field_code = m.get('fieldCode')
        if m.get('fieldName') is not None:
            self.field_name = m.get('fieldName')
        if m.get('fieldTip') is not None:
            self.field_tip = m.get('fieldTip')
        if m.get('fieldType') is not None:
            self.field_type = m.get('fieldType')
        if m.get('groupId') is not None:
            self.group_id = m.get('groupId')
        if m.get('hiddenFromEmployeeFlag') is not None:
            self.hidden_from_employee_flag = m.get('hiddenFromEmployeeFlag')
        if m.get('hint') is not None:
            self.hint = m.get('hint')
        if m.get('historyField') is not None:
            self.history_field = m.get('historyField')
        if m.get('index') is not None:
            self.index = m.get('index')
        if m.get('modifyOptions') is not None:
            self.modify_options = m.get('modifyOptions')
        if m.get('noWatermark') is not None:
            self.no_watermark = m.get('noWatermark')
        if m.get('numberDecimalPlace') is not None:
            self.number_decimal_place = m.get('numberDecimalPlace')
        if m.get('numberFormatType') is not None:
            self.number_format_type = m.get('numberFormatType')
        if m.get('numberValueType') is not None:
            self.number_value_type = m.get('numberValueType')
        if m.get('optionText') is not None:
            self.option_text = m.get('optionText')
        if m.get('required') is not None:
            self.required = m.get('required')
        if m.get('sourceFieldCode') is not None:
            self.source_field_code = m.get('sourceFieldCode')
        if m.get('systemFlag') is not None:
            self.system_flag = m.get('systemFlag')
        if m.get('textToSelectField') is not None:
            self.text_to_select_field = m.get('textToSelectField')
        if m.get('value') is not None:
            self.value = m.get('value')
        if m.get('visibleByEmp') is not None:
            self.visible_by_emp = m.get('visibleByEmp')
        return self


class UpdateCustomRosterFieldResponseBody(TeaModel):
    def __init__(
        self,
        ding_open_errcode: int = None,
        error_msg: str = None,
        result: UpdateCustomRosterFieldResponseBodyResult = None,
        success: bool = None,
    ):
        self.ding_open_errcode = ding_open_errcode
        self.error_msg = error_msg
        self.result = result
        self.success = success

    def validate(self):
        if self.result:
            self.result.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.ding_open_errcode is not None:
            result['dingOpenErrcode'] = self.ding_open_errcode
        if self.error_msg is not None:
            result['errorMsg'] = self.error_msg
        if self.result is not None:
            result['result'] = self.result.to_map()
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('dingOpenErrcode') is not None:
            self.ding_open_errcode = m.get('dingOpenErrcode')
        if m.get('errorMsg') is not None:
            self.error_msg = m.get('errorMsg')
        if m.get('result') is not None:
            temp_model = UpdateCustomRosterFieldResponseBodyResult()
            self.result = temp_model.from_map(m['result'])
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class UpdateCustomRosterFieldResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: UpdateCustomRosterFieldResponseBody = 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 = UpdateCustomRosterFieldResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateEmpDismissionInfoHeaders(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 UpdateEmpDismissionInfoRequest(TeaModel):
    def __init__(
        self,
        dismission_memo: str = None,
        last_work_date: int = None,
        partner: bool = None,
        termination_reason_passive: List[str] = None,
        termination_reason_voluntary: List[str] = None,
        user_id: str = None,
    ):
        self.dismission_memo = dismission_memo
        # This parameter is required.
        self.last_work_date = last_work_date
        self.partner = partner
        self.termination_reason_passive = termination_reason_passive
        self.termination_reason_voluntary = termination_reason_voluntary
        # 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.dismission_memo is not None:
            result['dismissionMemo'] = self.dismission_memo
        if self.last_work_date is not None:
            result['lastWorkDate'] = self.last_work_date
        if self.partner is not None:
            result['partner'] = self.partner
        if self.termination_reason_passive is not None:
            result['terminationReasonPassive'] = self.termination_reason_passive
        if self.termination_reason_voluntary is not None:
            result['terminationReasonVoluntary'] = self.termination_reason_voluntary
        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('dismissionMemo') is not None:
            self.dismission_memo = m.get('dismissionMemo')
        if m.get('lastWorkDate') is not None:
            self.last_work_date = m.get('lastWorkDate')
        if m.get('partner') is not None:
            self.partner = m.get('partner')
        if m.get('terminationReasonPassive') is not None:
            self.termination_reason_passive = m.get('terminationReasonPassive')
        if m.get('terminationReasonVoluntary') is not None:
            self.termination_reason_voluntary = m.get('terminationReasonVoluntary')
        if m.get('userId') is not None:
            self.user_id = m.get('userId')
        return self


class UpdateEmpDismissionInfoResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
        result: bool = None,
        success: bool = None,
    ):
        self.request_id = request_id
        self.result = result
        self.success = success

    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
        if self.result is not None:
            result['result'] = self.result
        if self.success is not None:
            result['success'] = self.success
        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')
        if m.get('result') is not None:
            self.result = m.get('result')
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class UpdateEmpDismissionInfoResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: UpdateEmpDismissionInfoResponseBody = 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 = UpdateEmpDismissionInfoResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateHrmLegalEntityNameHeaders(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 UpdateHrmLegalEntityNameRequest(TeaModel):
    def __init__(
        self,
        ding_tenant_id: int = None,
        legal_entity_name: str = None,
        origin_legal_entity_name: str = None,
    ):
        self.ding_tenant_id = ding_tenant_id
        # This parameter is required.
        self.legal_entity_name = legal_entity_name
        # This parameter is required.
        self.origin_legal_entity_name = origin_legal_entity_name

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.ding_tenant_id is not None:
            result['dingTenantId'] = self.ding_tenant_id
        if self.legal_entity_name is not None:
            result['legalEntityName'] = self.legal_entity_name
        if self.origin_legal_entity_name is not None:
            result['originLegalEntityName'] = self.origin_legal_entity_name
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('dingTenantId') is not None:
            self.ding_tenant_id = m.get('dingTenantId')
        if m.get('legalEntityName') is not None:
            self.legal_entity_name = m.get('legalEntityName')
        if m.get('originLegalEntityName') is not None:
            self.origin_legal_entity_name = m.get('originLegalEntityName')
        return self


class UpdateHrmLegalEntityNameResponseBodyResult(TeaModel):
    def __init__(
        self,
        corp_id: str = None,
        gmt_create: int = None,
        gmt_modified: int = None,
        legal_entity_id: str = None,
        legal_entity_name: str = None,
        legal_entity_short_name: str = None,
        legal_entity_status: int = None,
        legal_person_name: str = None,
    ):
        self.corp_id = corp_id
        self.gmt_create = gmt_create
        self.gmt_modified = gmt_modified
        self.legal_entity_id = legal_entity_id
        self.legal_entity_name = legal_entity_name
        self.legal_entity_short_name = legal_entity_short_name
        self.legal_entity_status = legal_entity_status
        self.legal_person_name = legal_person_name

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.corp_id is not None:
            result['corpId'] = self.corp_id
        if self.gmt_create is not None:
            result['gmtCreate'] = self.gmt_create
        if self.gmt_modified is not None:
            result['gmtModified'] = self.gmt_modified
        if self.legal_entity_id is not None:
            result['legalEntityId'] = self.legal_entity_id
        if self.legal_entity_name is not None:
            result['legalEntityName'] = self.legal_entity_name
        if self.legal_entity_short_name is not None:
            result['legalEntityShortName'] = self.legal_entity_short_name
        if self.legal_entity_status is not None:
            result['legalEntityStatus'] = self.legal_entity_status
        if self.legal_person_name is not None:
            result['legalPersonName'] = self.legal_person_name
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('corpId') is not None:
            self.corp_id = m.get('corpId')
        if m.get('gmtCreate') is not None:
            self.gmt_create = m.get('gmtCreate')
        if m.get('gmtModified') is not None:
            self.gmt_modified = m.get('gmtModified')
        if m.get('legalEntityId') is not None:
            self.legal_entity_id = m.get('legalEntityId')
        if m.get('legalEntityName') is not None:
            self.legal_entity_name = m.get('legalEntityName')
        if m.get('legalEntityShortName') is not None:
            self.legal_entity_short_name = m.get('legalEntityShortName')
        if m.get('legalEntityStatus') is not None:
            self.legal_entity_status = m.get('legalEntityStatus')
        if m.get('legalPersonName') is not None:
            self.legal_person_name = m.get('legalPersonName')
        return self


class UpdateHrmLegalEntityNameResponseBody(TeaModel):
    def __init__(
        self,
        result: UpdateHrmLegalEntityNameResponseBodyResult = None,
        success: bool = None,
    ):
        self.result = result
        self.success = success

    def validate(self):
        if self.result:
            self.result.validate()

    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.to_map()
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('result') is not None:
            temp_model = UpdateHrmLegalEntityNameResponseBodyResult()
            self.result = temp_model.from_map(m['result'])
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class UpdateHrmLegalEntityNameResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: UpdateHrmLegalEntityNameResponseBody = 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 = UpdateHrmLegalEntityNameResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateHrmLegalEntityWithoutNameHeaders(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 UpdateHrmLegalEntityWithoutNameRequestExtManageAddress(TeaModel):
    def __init__(
        self,
        area_code: str = None,
        area_name: str = None,
        city_code: str = None,
        city_name: str = None,
        country_code: str = None,
        country_name: str = None,
        detail_address: str = None,
        global_area_type: str = None,
        province_code: str = None,
        province_name: str = None,
    ):
        self.area_code = area_code
        self.area_name = area_name
        self.city_code = city_code
        self.city_name = city_name
        self.country_code = country_code
        self.country_name = country_name
        self.detail_address = detail_address
        self.global_area_type = global_area_type
        self.province_code = province_code
        self.province_name = province_name

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.area_code is not None:
            result['areaCode'] = self.area_code
        if self.area_name is not None:
            result['areaName'] = self.area_name
        if self.city_code is not None:
            result['cityCode'] = self.city_code
        if self.city_name is not None:
            result['cityName'] = self.city_name
        if self.country_code is not None:
            result['countryCode'] = self.country_code
        if self.country_name is not None:
            result['countryName'] = self.country_name
        if self.detail_address is not None:
            result['detailAddress'] = self.detail_address
        if self.global_area_type is not None:
            result['globalAreaType'] = self.global_area_type
        if self.province_code is not None:
            result['provinceCode'] = self.province_code
        if self.province_name is not None:
            result['provinceName'] = self.province_name
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('areaCode') is not None:
            self.area_code = m.get('areaCode')
        if m.get('areaName') is not None:
            self.area_name = m.get('areaName')
        if m.get('cityCode') is not None:
            self.city_code = m.get('cityCode')
        if m.get('cityName') is not None:
            self.city_name = m.get('cityName')
        if m.get('countryCode') is not None:
            self.country_code = m.get('countryCode')
        if m.get('countryName') is not None:
            self.country_name = m.get('countryName')
        if m.get('detailAddress') is not None:
            self.detail_address = m.get('detailAddress')
        if m.get('globalAreaType') is not None:
            self.global_area_type = m.get('globalAreaType')
        if m.get('provinceCode') is not None:
            self.province_code = m.get('provinceCode')
        if m.get('provinceName') is not None:
            self.province_name = m.get('provinceName')
        return self


class UpdateHrmLegalEntityWithoutNameRequestExtRegistrationAddress(TeaModel):
    def __init__(
        self,
        area_code: str = None,
        area_name: str = None,
        city_code: str = None,
        city_name: str = None,
        country_code: str = None,
        country_name: str = None,
        detail_address: str = None,
        global_area_type: str = None,
        province_code: str = None,
        province_name: str = None,
    ):
        self.area_code = area_code
        self.area_name = area_name
        self.city_code = city_code
        self.city_name = city_name
        self.country_code = country_code
        self.country_name = country_name
        self.detail_address = detail_address
        self.global_area_type = global_area_type
        self.province_code = province_code
        self.province_name = province_name

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.area_code is not None:
            result['areaCode'] = self.area_code
        if self.area_name is not None:
            result['areaName'] = self.area_name
        if self.city_code is not None:
            result['cityCode'] = self.city_code
        if self.city_name is not None:
            result['cityName'] = self.city_name
        if self.country_code is not None:
            result['countryCode'] = self.country_code
        if self.country_name is not None:
            result['countryName'] = self.country_name
        if self.detail_address is not None:
            result['detailAddress'] = self.detail_address
        if self.global_area_type is not None:
            result['globalAreaType'] = self.global_area_type
        if self.province_code is not None:
            result['provinceCode'] = self.province_code
        if self.province_name is not None:
            result['provinceName'] = self.province_name
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('areaCode') is not None:
            self.area_code = m.get('areaCode')
        if m.get('areaName') is not None:
            self.area_name = m.get('areaName')
        if m.get('cityCode') is not None:
            self.city_code = m.get('cityCode')
        if m.get('cityName') is not None:
            self.city_name = m.get('cityName')
        if m.get('countryCode') is not None:
            self.country_code = m.get('countryCode')
        if m.get('countryName') is not None:
            self.country_name = m.get('countryName')
        if m.get('detailAddress') is not None:
            self.detail_address = m.get('detailAddress')
        if m.get('globalAreaType') is not None:
            self.global_area_type = m.get('globalAreaType')
        if m.get('provinceCode') is not None:
            self.province_code = m.get('provinceCode')
        if m.get('provinceName') is not None:
            self.province_name = m.get('provinceName')
        return self


class UpdateHrmLegalEntityWithoutNameRequestExt(TeaModel):
    def __init__(
        self,
        legal_entity_en_name: str = None,
        legal_entity_en_short_name: str = None,
        legal_entity_type: str = None,
        manage_address: UpdateHrmLegalEntityWithoutNameRequestExtManageAddress = None,
        registration_address: UpdateHrmLegalEntityWithoutNameRequestExtRegistrationAddress = None,
        registration_date: int = None,
        unified_social_credit_code: str = None,
        zip_code: str = None,
    ):
        self.legal_entity_en_name = legal_entity_en_name
        self.legal_entity_en_short_name = legal_entity_en_short_name
        self.legal_entity_type = legal_entity_type
        self.manage_address = manage_address
        self.registration_address = registration_address
        self.registration_date = registration_date
        self.unified_social_credit_code = unified_social_credit_code
        self.zip_code = zip_code

    def validate(self):
        if self.manage_address:
            self.manage_address.validate()
        if self.registration_address:
            self.registration_address.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.legal_entity_en_name is not None:
            result['legalEntityEnName'] = self.legal_entity_en_name
        if self.legal_entity_en_short_name is not None:
            result['legalEntityEnShortName'] = self.legal_entity_en_short_name
        if self.legal_entity_type is not None:
            result['legalEntityType'] = self.legal_entity_type
        if self.manage_address is not None:
            result['manageAddress'] = self.manage_address.to_map()
        if self.registration_address is not None:
            result['registrationAddress'] = self.registration_address.to_map()
        if self.registration_date is not None:
            result['registrationDate'] = self.registration_date
        if self.unified_social_credit_code is not None:
            result['unifiedSocialCreditCode'] = self.unified_social_credit_code
        if self.zip_code is not None:
            result['zipCode'] = self.zip_code
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('legalEntityEnName') is not None:
            self.legal_entity_en_name = m.get('legalEntityEnName')
        if m.get('legalEntityEnShortName') is not None:
            self.legal_entity_en_short_name = m.get('legalEntityEnShortName')
        if m.get('legalEntityType') is not None:
            self.legal_entity_type = m.get('legalEntityType')
        if m.get('manageAddress') is not None:
            temp_model = UpdateHrmLegalEntityWithoutNameRequestExtManageAddress()
            self.manage_address = temp_model.from_map(m['manageAddress'])
        if m.get('registrationAddress') is not None:
            temp_model = UpdateHrmLegalEntityWithoutNameRequestExtRegistrationAddress()
            self.registration_address = temp_model.from_map(m['registrationAddress'])
        if m.get('registrationDate') is not None:
            self.registration_date = m.get('registrationDate')
        if m.get('unifiedSocialCreditCode') is not None:
            self.unified_social_credit_code = m.get('unifiedSocialCreditCode')
        if m.get('zipCode') is not None:
            self.zip_code = m.get('zipCode')
        return self


class UpdateHrmLegalEntityWithoutNameRequest(TeaModel):
    def __init__(
        self,
        corp_id: str = None,
        create_user_id: str = None,
        ext: UpdateHrmLegalEntityWithoutNameRequestExt = None,
        legal_entity_name: str = None,
        legal_entity_short_name: str = None,
        legal_entity_status: int = None,
        legal_person_name: str = None,
        ding_tenant_id: int = None,
    ):
        # This parameter is required.
        self.corp_id = corp_id
        self.create_user_id = create_user_id
        self.ext = ext
        # This parameter is required.
        self.legal_entity_name = legal_entity_name
        self.legal_entity_short_name = legal_entity_short_name
        # This parameter is required.
        self.legal_entity_status = legal_entity_status
        self.legal_person_name = legal_person_name
        self.ding_tenant_id = ding_tenant_id

    def validate(self):
        if self.ext:
            self.ext.validate()

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.corp_id is not None:
            result['corpId'] = self.corp_id
        if self.create_user_id is not None:
            result['createUserId'] = self.create_user_id
        if self.ext is not None:
            result['ext'] = self.ext.to_map()
        if self.legal_entity_name is not None:
            result['legalEntityName'] = self.legal_entity_name
        if self.legal_entity_short_name is not None:
            result['legalEntityShortName'] = self.legal_entity_short_name
        if self.legal_entity_status is not None:
            result['legalEntityStatus'] = self.legal_entity_status
        if self.legal_person_name is not None:
            result['legalPersonName'] = self.legal_person_name
        if self.ding_tenant_id is not None:
            result['dingTenantId'] = self.ding_tenant_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('corpId') is not None:
            self.corp_id = m.get('corpId')
        if m.get('createUserId') is not None:
            self.create_user_id = m.get('createUserId')
        if m.get('ext') is not None:
            temp_model = UpdateHrmLegalEntityWithoutNameRequestExt()
            self.ext = temp_model.from_map(m['ext'])
        if m.get('legalEntityName') is not None:
            self.legal_entity_name = m.get('legalEntityName')
        if m.get('legalEntityShortName') is not None:
            self.legal_entity_short_name = m.get('legalEntityShortName')
        if m.get('legalEntityStatus') is not None:
            self.legal_entity_status = m.get('legalEntityStatus')
        if m.get('legalPersonName') is not None:
            self.legal_person_name = m.get('legalPersonName')
        if m.get('dingTenantId') is not None:
            self.ding_tenant_id = m.get('dingTenantId')
        return self


class UpdateHrmLegalEntityWithoutNameResponseBodyResult(TeaModel):
    def __init__(
        self,
        corp_id: str = None,
        gmt_create: int = None,
        gmt_modified: int = None,
        legal_entity_id: str = None,
        legal_entity_name: str = None,
        legal_entity_short_name: str = None,
        legal_entity_status: int = None,
        legal_person_name: str = None,
    ):
        self.corp_id = corp_id
        self.gmt_create = gmt_create
        self.gmt_modified = gmt_modified
        self.legal_entity_id = legal_entity_id
        self.legal_entity_name = legal_entity_name
        self.legal_entity_short_name = legal_entity_short_name
        self.legal_entity_status = legal_entity_status
        self.legal_person_name = legal_person_name

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.corp_id is not None:
            result['corpId'] = self.corp_id
        if self.gmt_create is not None:
            result['gmtCreate'] = self.gmt_create
        if self.gmt_modified is not None:
            result['gmtModified'] = self.gmt_modified
        if self.legal_entity_id is not None:
            result['legalEntityId'] = self.legal_entity_id
        if self.legal_entity_name is not None:
            result['legalEntityName'] = self.legal_entity_name
        if self.legal_entity_short_name is not None:
            result['legalEntityShortName'] = self.legal_entity_short_name
        if self.legal_entity_status is not None:
            result['legalEntityStatus'] = self.legal_entity_status
        if self.legal_person_name is not None:
            result['legalPersonName'] = self.legal_person_name
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('corpId') is not None:
            self.corp_id = m.get('corpId')
        if m.get('gmtCreate') is not None:
            self.gmt_create = m.get('gmtCreate')
        if m.get('gmtModified') is not None:
            self.gmt_modified = m.get('gmtModified')
        if m.get('legalEntityId') is not None:
            self.legal_entity_id = m.get('legalEntityId')
        if m.get('legalEntityName') is not None:
            self.legal_entity_name = m.get('legalEntityName')
        if m.get('legalEntityShortName') is not None:
            self.legal_entity_short_name = m.get('legalEntityShortName')
        if m.get('legalEntityStatus') is not None:
            self.legal_entity_status = m.get('legalEntityStatus')
        if m.get('legalPersonName') is not None:
            self.legal_person_name = m.get('legalPersonName')
        return self


class UpdateHrmLegalEntityWithoutNameResponseBody(TeaModel):
    def __init__(
        self,
        result: UpdateHrmLegalEntityWithoutNameResponseBodyResult = None,
        success: bool = None,
    ):
        self.result = result
        self.success = success

    def validate(self):
        if self.result:
            self.result.validate()

    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.to_map()
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('result') is not None:
            temp_model = UpdateHrmLegalEntityWithoutNameResponseBodyResult()
            self.result = temp_model.from_map(m['result'])
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class UpdateHrmLegalEntityWithoutNameResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: UpdateHrmLegalEntityWithoutNameResponseBody = 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 = UpdateHrmLegalEntityWithoutNameResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateHrmVersionRollBackStatusHeaders(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 UpdateHrmVersionRollBackStatusRequest(TeaModel):
    def __init__(
        self,
        config_value: str = None,
        opt_user_id: str = None,
    ):
        self.config_value = config_value
        self.opt_user_id = opt_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.config_value is not None:
            result['configValue'] = self.config_value
        if self.opt_user_id is not None:
            result['optUserId'] = self.opt_user_id
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('configValue') is not None:
            self.config_value = m.get('configValue')
        if m.get('optUserId') is not None:
            self.opt_user_id = m.get('optUserId')
        return self


class UpdateHrmVersionRollBackStatusResponseBody(TeaModel):
    def __init__(
        self,
        request_id: str = None,
        result: bool = None,
        success: bool = None,
    ):
        self.request_id = request_id
        self.result = result
        self.success = success

    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
        if self.result is not None:
            result['result'] = self.result
        if self.success is not None:
            result['success'] = self.success
        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')
        if m.get('result') is not None:
            self.result = m.get('result')
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class UpdateHrmVersionRollBackStatusResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: UpdateHrmVersionRollBackStatusResponseBody = 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 = UpdateHrmVersionRollBackStatusResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateIsvCardMessageHeaders(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 UpdateIsvCardMessageRequest(TeaModel):
    def __init__(
        self,
        agent_id: int = None,
        biz_id: str = None,
        message_type: str = None,
        scene_type: str = None,
        scope: str = None,
        value_map: Dict[str, str] = None,
    ):
        self.agent_id = agent_id
        # This parameter is required.
        self.biz_id = biz_id
        # This parameter is required.
        self.message_type = message_type
        # This parameter is required.
        self.scene_type = scene_type
        # This parameter is required.
        self.scope = scope
        # This parameter is required.
        self.value_map = value_map

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.agent_id is not None:
            result['agentId'] = self.agent_id
        if self.biz_id is not None:
            result['bizId'] = self.biz_id
        if self.message_type is not None:
            result['messageType'] = self.message_type
        if self.scene_type is not None:
            result['sceneType'] = self.scene_type
        if self.scope is not None:
            result['scope'] = self.scope
        if self.value_map is not None:
            result['valueMap'] = self.value_map
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('agentId') is not None:
            self.agent_id = m.get('agentId')
        if m.get('bizId') is not None:
            self.biz_id = m.get('bizId')
        if m.get('messageType') is not None:
            self.message_type = m.get('messageType')
        if m.get('sceneType') is not None:
            self.scene_type = m.get('sceneType')
        if m.get('scope') is not None:
            self.scope = m.get('scope')
        if m.get('valueMap') is not None:
            self.value_map = m.get('valueMap')
        return self


class UpdateIsvCardMessageResponseBody(TeaModel):
    def __init__(
        self,
        error_code: str = None,
        error_msg: str = None,
        request_id: str = None,
        success: bool = None,
    ):
        self.error_code = error_code
        self.error_msg = error_msg
        self.request_id = request_id
        self.success = success

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.error_code is not None:
            result['errorCode'] = self.error_code
        if self.error_msg is not None:
            result['errorMsg'] = self.error_msg
        if self.request_id is not None:
            result['requestId'] = self.request_id
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('errorCode') is not None:
            self.error_code = m.get('errorCode')
        if m.get('errorMsg') is not None:
            self.error_msg = m.get('errorMsg')
        if m.get('requestId') is not None:
            self.request_id = m.get('requestId')
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class UpdateIsvCardMessageResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: UpdateIsvCardMessageResponseBody = 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 = UpdateIsvCardMessageResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UpdateRosterFieldFormHeaders(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 UpdateRosterFieldFormRequest(TeaModel):
    def __init__(
        self,
        detail: bool = None,
        form_id: str = None,
        name: str = None,
        user_id: str = None,
    ):
        # This parameter is required.
        self.detail = detail
        # This parameter is required.
        self.form_id = form_id
        # This parameter is required.
        self.name = name
        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.detail is not None:
            result['detail'] = self.detail
        if self.form_id is not None:
            result['formId'] = self.form_id
        if self.name is not None:
            result['name'] = self.name
        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('detail') is not None:
            self.detail = m.get('detail')
        if m.get('formId') is not None:
            self.form_id = m.get('formId')
        if m.get('name') is not None:
            self.name = m.get('name')
        if m.get('userId') is not None:
            self.user_id = m.get('userId')
        return self


class UpdateRosterFieldFormResponseBody(TeaModel):
    def __init__(
        self,
        ding_open_errcode: int = None,
        error_msg: str = None,
        result: bool = None,
        success: bool = None,
    ):
        self.ding_open_errcode = ding_open_errcode
        self.error_msg = error_msg
        self.result = result
        self.success = success

    def validate(self):
        pass

    def to_map(self):
        _map = super().to_map()
        if _map is not None:
            return _map

        result = dict()
        if self.ding_open_errcode is not None:
            result['dingOpenErrcode'] = self.ding_open_errcode
        if self.error_msg is not None:
            result['errorMsg'] = self.error_msg
        if self.result is not None:
            result['result'] = self.result
        if self.success is not None:
            result['success'] = self.success
        return result

    def from_map(self, m: dict = None):
        m = m or dict()
        if m.get('dingOpenErrcode') is not None:
            self.ding_open_errcode = m.get('dingOpenErrcode')
        if m.get('errorMsg') is not None:
            self.error_msg = m.get('errorMsg')
        if m.get('result') is not None:
            self.result = m.get('result')
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class UpdateRosterFieldFormResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: UpdateRosterFieldFormResponseBody = 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 = UpdateRosterFieldFormResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self


class UploadAttachmentHeaders(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 UploadAttachmentRequest(TeaModel):
    def __init__(
        self,
        media_id: str = None,
        user_id: str = None,
    ):
        self.media_id = media_id
        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.media_id is not None:
            result['mediaId'] = self.media_id
        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('mediaId') is not None:
            self.media_id = m.get('mediaId')
        if m.get('userId') is not None:
            self.user_id = m.get('userId')
        return self


class UploadAttachmentResponseBody(TeaModel):
    def __init__(
        self,
        result: str = None,
        success: bool = None,
    ):
        self.result = result
        self.success = success

    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
        if self.success is not None:
            result['success'] = self.success
        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')
        if m.get('success') is not None:
            self.success = m.get('success')
        return self


class UploadAttachmentResponse(TeaModel):
    def __init__(
        self,
        headers: Dict[str, str] = None,
        status_code: int = None,
        body: UploadAttachmentResponseBody = 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 = UploadAttachmentResponseBody()
            self.body = temp_model.from_map(m['body'])
        return self