# -*- coding: utf-8 -*-
# This file is auto-generated, don't edit it. Thanks.
from typing import Dict
from Tea.core import TeaCore

from alibabacloud_tea_openapi.client import Client as OpenApiClient
from alibabacloud_tea_openapi import models as open_api_models
from alibabacloud_tea_util.client import Client as UtilClient
from alibabacloud_endpoint_util.client import Client as EndpointUtilClient
from alibabacloud_cms20240330 import models as cms_20240330_models
from alibabacloud_tea_util import models as util_models
from alibabacloud_openapi_util.client import Client as OpenApiUtilClient


class Client(OpenApiClient):
    """
    *\
    """
    def __init__(
        self, 
        config: open_api_models.Config,
    ):
        super().__init__(config)
        self._endpoint_rule = ''
        self.check_config(config)
        self._endpoint = self.get_endpoint('cms', self._region_id, self._endpoint_rule, self._network, self._suffix, self._endpoint_map, self._endpoint)

    def get_endpoint(
        self,
        product_id: str,
        region_id: str,
        endpoint_rule: str,
        network: str,
        suffix: str,
        endpoint_map: Dict[str, str],
        endpoint: str,
    ) -> str:
        if not UtilClient.empty(endpoint):
            return endpoint
        if not UtilClient.is_unset(endpoint_map) and not UtilClient.empty(endpoint_map.get(region_id)):
            return endpoint_map.get(region_id)
        return EndpointUtilClient.get_endpoint_rules(product_id, region_id, endpoint_rule, network, suffix)

    def active_contact_channel_with_options(
        self,
        request: cms_20240330_models.ActiveContactChannelRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ActiveContactChannelResponse:
        """
        @summary 激活验证码
        
        @param request: ActiveContactChannelRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ActiveContactChannelResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.code):
            query['code'] = request.code
        if not UtilClient.is_unset(request.site):
            query['site'] = request.site
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ActiveContactChannel',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/contacts/action/activate',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ActiveContactChannelResponse(),
            self.call_api(params, req, runtime)
        )

    async def active_contact_channel_with_options_async(
        self,
        request: cms_20240330_models.ActiveContactChannelRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ActiveContactChannelResponse:
        """
        @summary 激活验证码
        
        @param request: ActiveContactChannelRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ActiveContactChannelResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.code):
            query['code'] = request.code
        if not UtilClient.is_unset(request.site):
            query['site'] = request.site
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ActiveContactChannel',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/contacts/action/activate',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ActiveContactChannelResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def active_contact_channel(
        self,
        request: cms_20240330_models.ActiveContactChannelRequest,
    ) -> cms_20240330_models.ActiveContactChannelResponse:
        """
        @summary 激活验证码
        
        @param request: ActiveContactChannelRequest
        @return: ActiveContactChannelResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.active_contact_channel_with_options(request, headers, runtime)

    async def active_contact_channel_async(
        self,
        request: cms_20240330_models.ActiveContactChannelRequest,
    ) -> cms_20240330_models.ActiveContactChannelResponse:
        """
        @summary 激活验证码
        
        @param request: ActiveContactChannelRequest
        @return: ActiveContactChannelResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.active_contact_channel_with_options_async(request, headers, runtime)

    def add_memories_with_options(
        self,
        workspace: str,
        memory_store_name: str,
        request: cms_20240330_models.AddMemoriesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.AddMemoriesResponse:
        """
        @summary 添加记忆
        
        @param request: AddMemoriesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: AddMemoriesResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.agent_id):
            body['agentId'] = request.agent_id
        if not UtilClient.is_unset(request.app_id):
            body['appId'] = request.app_id
        if not UtilClient.is_unset(request.async_mode):
            body['asyncMode'] = request.async_mode
        if not UtilClient.is_unset(request.custom_instructions):
            body['customInstructions'] = request.custom_instructions
        if not UtilClient.is_unset(request.infer):
            body['infer'] = request.infer
        if not UtilClient.is_unset(request.messages):
            body['messages'] = request.messages
        if not UtilClient.is_unset(request.metadata):
            body['metadata'] = request.metadata
        if not UtilClient.is_unset(request.run_id):
            body['runId'] = request.run_id
        if not UtilClient.is_unset(request.user_id):
            body['userId'] = request.user_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='AddMemories',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}/memory',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.AddMemoriesResponse(),
            self.call_api(params, req, runtime)
        )

    async def add_memories_with_options_async(
        self,
        workspace: str,
        memory_store_name: str,
        request: cms_20240330_models.AddMemoriesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.AddMemoriesResponse:
        """
        @summary 添加记忆
        
        @param request: AddMemoriesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: AddMemoriesResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.agent_id):
            body['agentId'] = request.agent_id
        if not UtilClient.is_unset(request.app_id):
            body['appId'] = request.app_id
        if not UtilClient.is_unset(request.async_mode):
            body['asyncMode'] = request.async_mode
        if not UtilClient.is_unset(request.custom_instructions):
            body['customInstructions'] = request.custom_instructions
        if not UtilClient.is_unset(request.infer):
            body['infer'] = request.infer
        if not UtilClient.is_unset(request.messages):
            body['messages'] = request.messages
        if not UtilClient.is_unset(request.metadata):
            body['metadata'] = request.metadata
        if not UtilClient.is_unset(request.run_id):
            body['runId'] = request.run_id
        if not UtilClient.is_unset(request.user_id):
            body['userId'] = request.user_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='AddMemories',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}/memory',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.AddMemoriesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def add_memories(
        self,
        workspace: str,
        memory_store_name: str,
        request: cms_20240330_models.AddMemoriesRequest,
    ) -> cms_20240330_models.AddMemoriesResponse:
        """
        @summary 添加记忆
        
        @param request: AddMemoriesRequest
        @return: AddMemoriesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.add_memories_with_options(workspace, memory_store_name, request, headers, runtime)

    async def add_memories_async(
        self,
        workspace: str,
        memory_store_name: str,
        request: cms_20240330_models.AddMemoriesRequest,
    ) -> cms_20240330_models.AddMemoriesResponse:
        """
        @summary 添加记忆
        
        @param request: AddMemoriesRequest
        @return: AddMemoriesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.add_memories_with_options_async(workspace, memory_store_name, request, headers, runtime)

    def change_resource_group_with_options(
        self,
        request: cms_20240330_models.ChangeResourceGroupRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ChangeResourceGroupResponse:
        """
        @summary 修改资源所属资源组
        
        @param request: ChangeResourceGroupRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ChangeResourceGroupResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.resource_group_id):
            body['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.resource_id):
            body['resourceId'] = request.resource_id
        if not UtilClient.is_unset(request.resource_type):
            body['resourceType'] = request.resource_type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='ChangeResourceGroup',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/resourcegroup',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ChangeResourceGroupResponse(),
            self.call_api(params, req, runtime)
        )

    async def change_resource_group_with_options_async(
        self,
        request: cms_20240330_models.ChangeResourceGroupRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ChangeResourceGroupResponse:
        """
        @summary 修改资源所属资源组
        
        @param request: ChangeResourceGroupRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ChangeResourceGroupResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.resource_group_id):
            body['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.resource_id):
            body['resourceId'] = request.resource_id
        if not UtilClient.is_unset(request.resource_type):
            body['resourceType'] = request.resource_type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='ChangeResourceGroup',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/resourcegroup',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ChangeResourceGroupResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def change_resource_group(
        self,
        request: cms_20240330_models.ChangeResourceGroupRequest,
    ) -> cms_20240330_models.ChangeResourceGroupResponse:
        """
        @summary 修改资源所属资源组
        
        @param request: ChangeResourceGroupRequest
        @return: ChangeResourceGroupResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.change_resource_group_with_options(request, headers, runtime)

    async def change_resource_group_async(
        self,
        request: cms_20240330_models.ChangeResourceGroupRequest,
    ) -> cms_20240330_models.ChangeResourceGroupResponse:
        """
        @summary 修改资源所属资源组
        
        @param request: ChangeResourceGroupRequest
        @return: ChangeResourceGroupResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.change_resource_group_with_options_async(request, headers, runtime)

    def check_dispatch_role_with_options(
        self,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CheckDispatchRoleResponse:
        """
        @summary 检查用户是否已经开通了 AliyunLogDispatchRole 角色
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CheckDispatchRoleResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='CheckDispatchRole',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alert/user/dispatchRole/checkAuth',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CheckDispatchRoleResponse(),
            self.call_api(params, req, runtime)
        )

    async def check_dispatch_role_with_options_async(
        self,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CheckDispatchRoleResponse:
        """
        @summary 检查用户是否已经开通了 AliyunLogDispatchRole 角色
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CheckDispatchRoleResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='CheckDispatchRole',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alert/user/dispatchRole/checkAuth',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CheckDispatchRoleResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def check_dispatch_role(self) -> cms_20240330_models.CheckDispatchRoleResponse:
        """
        @summary 检查用户是否已经开通了 AliyunLogDispatchRole 角色
        
        @return: CheckDispatchRoleResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.check_dispatch_role_with_options(headers, runtime)

    async def check_dispatch_role_async(self) -> cms_20240330_models.CheckDispatchRoleResponse:
        """
        @summary 检查用户是否已经开通了 AliyunLogDispatchRole 角色
        
        @return: CheckDispatchRoleResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.check_dispatch_role_with_options_async(headers, runtime)

    def count_alert_histories_by_fields_with_options(
        self,
        tmp_req: cms_20240330_models.CountAlertHistoriesByFieldsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CountAlertHistoriesByFieldsResponse:
        """
        @summary 根据告警历史的字段取值(group by)统计告警历史的数量
        
        @param tmp_req: CountAlertHistoriesByFieldsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CountAlertHistoriesByFieldsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.CountAlertHistoriesByFieldsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.field_list):
            request.field_list_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.field_list, 'fieldList', 'json')
        if not UtilClient.is_unset(tmp_req.label_filter):
            request.label_filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.label_filter, 'labelFilter', 'json')
        if not UtilClient.is_unset(tmp_req.notification_filter):
            request.notification_filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.notification_filter, 'notificationFilter', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_rule_id):
            query['alertRuleId'] = request.alert_rule_id
        if not UtilClient.is_unset(request.biz_source):
            query['bizSource'] = request.biz_source
        if not UtilClient.is_unset(request.display_name_key_word):
            query['displayNameKeyWord'] = request.display_name_key_word
        if not UtilClient.is_unset(request.field_list_shrink):
            query['fieldList'] = request.field_list_shrink
        if not UtilClient.is_unset(request.instance_key):
            query['instanceKey'] = request.instance_key
        if not UtilClient.is_unset(request.label_filter_shrink):
            query['labelFilter'] = request.label_filter_shrink
        if not UtilClient.is_unset(request.latest_level):
            query['latestLevel'] = request.latest_level
        if not UtilClient.is_unset(request.max_level):
            query['maxLevel'] = request.max_level
        if not UtilClient.is_unset(request.notification_filter_shrink):
            query['notificationFilter'] = request.notification_filter_shrink
        if not UtilClient.is_unset(request.start_time_from):
            query['startTimeFrom'] = request.start_time_from
        if not UtilClient.is_unset(request.start_time_to):
            query['startTimeTo'] = request.start_time_to
        if not UtilClient.is_unset(request.status):
            query['status'] = request.status
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='CountAlertHistoriesByFields',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertHistories/countByFields',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CountAlertHistoriesByFieldsResponse(),
            self.call_api(params, req, runtime)
        )

    async def count_alert_histories_by_fields_with_options_async(
        self,
        tmp_req: cms_20240330_models.CountAlertHistoriesByFieldsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CountAlertHistoriesByFieldsResponse:
        """
        @summary 根据告警历史的字段取值(group by)统计告警历史的数量
        
        @param tmp_req: CountAlertHistoriesByFieldsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CountAlertHistoriesByFieldsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.CountAlertHistoriesByFieldsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.field_list):
            request.field_list_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.field_list, 'fieldList', 'json')
        if not UtilClient.is_unset(tmp_req.label_filter):
            request.label_filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.label_filter, 'labelFilter', 'json')
        if not UtilClient.is_unset(tmp_req.notification_filter):
            request.notification_filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.notification_filter, 'notificationFilter', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_rule_id):
            query['alertRuleId'] = request.alert_rule_id
        if not UtilClient.is_unset(request.biz_source):
            query['bizSource'] = request.biz_source
        if not UtilClient.is_unset(request.display_name_key_word):
            query['displayNameKeyWord'] = request.display_name_key_word
        if not UtilClient.is_unset(request.field_list_shrink):
            query['fieldList'] = request.field_list_shrink
        if not UtilClient.is_unset(request.instance_key):
            query['instanceKey'] = request.instance_key
        if not UtilClient.is_unset(request.label_filter_shrink):
            query['labelFilter'] = request.label_filter_shrink
        if not UtilClient.is_unset(request.latest_level):
            query['latestLevel'] = request.latest_level
        if not UtilClient.is_unset(request.max_level):
            query['maxLevel'] = request.max_level
        if not UtilClient.is_unset(request.notification_filter_shrink):
            query['notificationFilter'] = request.notification_filter_shrink
        if not UtilClient.is_unset(request.start_time_from):
            query['startTimeFrom'] = request.start_time_from
        if not UtilClient.is_unset(request.start_time_to):
            query['startTimeTo'] = request.start_time_to
        if not UtilClient.is_unset(request.status):
            query['status'] = request.status
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='CountAlertHistoriesByFields',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertHistories/countByFields',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CountAlertHistoriesByFieldsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def count_alert_histories_by_fields(
        self,
        request: cms_20240330_models.CountAlertHistoriesByFieldsRequest,
    ) -> cms_20240330_models.CountAlertHistoriesByFieldsResponse:
        """
        @summary 根据告警历史的字段取值(group by)统计告警历史的数量
        
        @param request: CountAlertHistoriesByFieldsRequest
        @return: CountAlertHistoriesByFieldsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.count_alert_histories_by_fields_with_options(request, headers, runtime)

    async def count_alert_histories_by_fields_async(
        self,
        request: cms_20240330_models.CountAlertHistoriesByFieldsRequest,
    ) -> cms_20240330_models.CountAlertHistoriesByFieldsResponse:
        """
        @summary 根据告警历史的字段取值(group by)统计告警历史的数量
        
        @param request: CountAlertHistoriesByFieldsRequest
        @return: CountAlertHistoriesByFieldsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.count_alert_histories_by_fields_with_options_async(request, headers, runtime)

    def count_alert_histories_by_time_with_options(
        self,
        tmp_req: cms_20240330_models.CountAlertHistoriesByTimeRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CountAlertHistoriesByTimeResponse:
        """
        @summary 按告警时间统计告警历史
        
        @param tmp_req: CountAlertHistoriesByTimeRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CountAlertHistoriesByTimeResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.CountAlertHistoriesByTimeShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.label_filter):
            request.label_filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.label_filter, 'labelFilter', 'json')
        if not UtilClient.is_unset(tmp_req.notification_filter):
            request.notification_filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.notification_filter, 'notificationFilter', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_rule_id):
            query['alertRuleId'] = request.alert_rule_id
        if not UtilClient.is_unset(request.biz_source):
            query['bizSource'] = request.biz_source
        if not UtilClient.is_unset(request.display_name_key_word):
            query['displayNameKeyWord'] = request.display_name_key_word
        if not UtilClient.is_unset(request.instance_key):
            query['instanceKey'] = request.instance_key
        if not UtilClient.is_unset(request.interval):
            query['interval'] = request.interval
        if not UtilClient.is_unset(request.label_filter_shrink):
            query['labelFilter'] = request.label_filter_shrink
        if not UtilClient.is_unset(request.latest_level):
            query['latestLevel'] = request.latest_level
        if not UtilClient.is_unset(request.max_level):
            query['maxLevel'] = request.max_level
        if not UtilClient.is_unset(request.notification_filter_shrink):
            query['notificationFilter'] = request.notification_filter_shrink
        if not UtilClient.is_unset(request.start_time_from):
            query['startTimeFrom'] = request.start_time_from
        if not UtilClient.is_unset(request.start_time_to):
            query['startTimeTo'] = request.start_time_to
        if not UtilClient.is_unset(request.status):
            query['status'] = request.status
        if not UtilClient.is_unset(request.sub_group_by_field):
            query['subGroupByField'] = request.sub_group_by_field
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='CountAlertHistoriesByTime',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertHistories/countByTime',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CountAlertHistoriesByTimeResponse(),
            self.call_api(params, req, runtime)
        )

    async def count_alert_histories_by_time_with_options_async(
        self,
        tmp_req: cms_20240330_models.CountAlertHistoriesByTimeRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CountAlertHistoriesByTimeResponse:
        """
        @summary 按告警时间统计告警历史
        
        @param tmp_req: CountAlertHistoriesByTimeRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CountAlertHistoriesByTimeResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.CountAlertHistoriesByTimeShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.label_filter):
            request.label_filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.label_filter, 'labelFilter', 'json')
        if not UtilClient.is_unset(tmp_req.notification_filter):
            request.notification_filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.notification_filter, 'notificationFilter', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_rule_id):
            query['alertRuleId'] = request.alert_rule_id
        if not UtilClient.is_unset(request.biz_source):
            query['bizSource'] = request.biz_source
        if not UtilClient.is_unset(request.display_name_key_word):
            query['displayNameKeyWord'] = request.display_name_key_word
        if not UtilClient.is_unset(request.instance_key):
            query['instanceKey'] = request.instance_key
        if not UtilClient.is_unset(request.interval):
            query['interval'] = request.interval
        if not UtilClient.is_unset(request.label_filter_shrink):
            query['labelFilter'] = request.label_filter_shrink
        if not UtilClient.is_unset(request.latest_level):
            query['latestLevel'] = request.latest_level
        if not UtilClient.is_unset(request.max_level):
            query['maxLevel'] = request.max_level
        if not UtilClient.is_unset(request.notification_filter_shrink):
            query['notificationFilter'] = request.notification_filter_shrink
        if not UtilClient.is_unset(request.start_time_from):
            query['startTimeFrom'] = request.start_time_from
        if not UtilClient.is_unset(request.start_time_to):
            query['startTimeTo'] = request.start_time_to
        if not UtilClient.is_unset(request.status):
            query['status'] = request.status
        if not UtilClient.is_unset(request.sub_group_by_field):
            query['subGroupByField'] = request.sub_group_by_field
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='CountAlertHistoriesByTime',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertHistories/countByTime',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CountAlertHistoriesByTimeResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def count_alert_histories_by_time(
        self,
        request: cms_20240330_models.CountAlertHistoriesByTimeRequest,
    ) -> cms_20240330_models.CountAlertHistoriesByTimeResponse:
        """
        @summary 按告警时间统计告警历史
        
        @param request: CountAlertHistoriesByTimeRequest
        @return: CountAlertHistoriesByTimeResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.count_alert_histories_by_time_with_options(request, headers, runtime)

    async def count_alert_histories_by_time_async(
        self,
        request: cms_20240330_models.CountAlertHistoriesByTimeRequest,
    ) -> cms_20240330_models.CountAlertHistoriesByTimeResponse:
        """
        @summary 按告警时间统计告警历史
        
        @param request: CountAlertHistoriesByTimeRequest
        @return: CountAlertHistoriesByTimeResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.count_alert_histories_by_time_with_options_async(request, headers, runtime)

    def count_alert_rules_by_fields_with_options(
        self,
        tmp_req: cms_20240330_models.CountAlertRulesByFieldsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CountAlertRulesByFieldsResponse:
        """
        @summary 根据字段统计告警规则数量
        
        @param tmp_req: CountAlertRulesByFieldsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CountAlertRulesByFieldsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.CountAlertRulesByFieldsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.field_list):
            request.field_list_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.field_list, 'fieldList', 'json')
        if not UtilClient.is_unset(tmp_req.label_filter):
            request.label_filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.label_filter, 'labelFilter', 'json')
        if not UtilClient.is_unset(tmp_req.notification_filter):
            request.notification_filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.notification_filter, 'notificationFilter', 'json')
        query = {}
        if not UtilClient.is_unset(request.biz_source):
            query['bizSource'] = request.biz_source
        if not UtilClient.is_unset(request.display_name_key_word):
            query['displayNameKeyWord'] = request.display_name_key_word
        if not UtilClient.is_unset(request.enabled):
            query['enabled'] = request.enabled
        if not UtilClient.is_unset(request.field_list_shrink):
            query['fieldList'] = request.field_list_shrink
        if not UtilClient.is_unset(request.label_filter_shrink):
            query['labelFilter'] = request.label_filter_shrink
        if not UtilClient.is_unset(request.notification_filter_shrink):
            query['notificationFilter'] = request.notification_filter_shrink
        if not UtilClient.is_unset(request.status):
            query['status'] = request.status
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='CountAlertRulesByFields',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules/countByFields',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CountAlertRulesByFieldsResponse(),
            self.call_api(params, req, runtime)
        )

    async def count_alert_rules_by_fields_with_options_async(
        self,
        tmp_req: cms_20240330_models.CountAlertRulesByFieldsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CountAlertRulesByFieldsResponse:
        """
        @summary 根据字段统计告警规则数量
        
        @param tmp_req: CountAlertRulesByFieldsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CountAlertRulesByFieldsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.CountAlertRulesByFieldsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.field_list):
            request.field_list_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.field_list, 'fieldList', 'json')
        if not UtilClient.is_unset(tmp_req.label_filter):
            request.label_filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.label_filter, 'labelFilter', 'json')
        if not UtilClient.is_unset(tmp_req.notification_filter):
            request.notification_filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.notification_filter, 'notificationFilter', 'json')
        query = {}
        if not UtilClient.is_unset(request.biz_source):
            query['bizSource'] = request.biz_source
        if not UtilClient.is_unset(request.display_name_key_word):
            query['displayNameKeyWord'] = request.display_name_key_word
        if not UtilClient.is_unset(request.enabled):
            query['enabled'] = request.enabled
        if not UtilClient.is_unset(request.field_list_shrink):
            query['fieldList'] = request.field_list_shrink
        if not UtilClient.is_unset(request.label_filter_shrink):
            query['labelFilter'] = request.label_filter_shrink
        if not UtilClient.is_unset(request.notification_filter_shrink):
            query['notificationFilter'] = request.notification_filter_shrink
        if not UtilClient.is_unset(request.status):
            query['status'] = request.status
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='CountAlertRulesByFields',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules/countByFields',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CountAlertRulesByFieldsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def count_alert_rules_by_fields(
        self,
        request: cms_20240330_models.CountAlertRulesByFieldsRequest,
    ) -> cms_20240330_models.CountAlertRulesByFieldsResponse:
        """
        @summary 根据字段统计告警规则数量
        
        @param request: CountAlertRulesByFieldsRequest
        @return: CountAlertRulesByFieldsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.count_alert_rules_by_fields_with_options(request, headers, runtime)

    async def count_alert_rules_by_fields_async(
        self,
        request: cms_20240330_models.CountAlertRulesByFieldsRequest,
    ) -> cms_20240330_models.CountAlertRulesByFieldsResponse:
        """
        @summary 根据字段统计告警规则数量
        
        @param request: CountAlertRulesByFieldsRequest
        @return: CountAlertRulesByFieldsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.count_alert_rules_by_fields_with_options_async(request, headers, runtime)

    def count_integration_event_with_options(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.CountIntegrationEventRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CountIntegrationEventResponse:
        """
        @summary 统计单个集成接入事件量
        
        @param request: CountIntegrationEventRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CountIntegrationEventResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='CountIntegrationEvent',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertEventIntegrationPolicies/{OpenApiUtilClient.get_encode_param(alert_event_integration_policy_id)}/count',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CountIntegrationEventResponse(),
            self.call_api(params, req, runtime)
        )

    async def count_integration_event_with_options_async(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.CountIntegrationEventRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CountIntegrationEventResponse:
        """
        @summary 统计单个集成接入事件量
        
        @param request: CountIntegrationEventRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CountIntegrationEventResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='CountIntegrationEvent',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertEventIntegrationPolicies/{OpenApiUtilClient.get_encode_param(alert_event_integration_policy_id)}/count',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CountIntegrationEventResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def count_integration_event(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.CountIntegrationEventRequest,
    ) -> cms_20240330_models.CountIntegrationEventResponse:
        """
        @summary 统计单个集成接入事件量
        
        @param request: CountIntegrationEventRequest
        @return: CountIntegrationEventResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.count_integration_event_with_options(alert_event_integration_policy_id, request, headers, runtime)

    async def count_integration_event_async(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.CountIntegrationEventRequest,
    ) -> cms_20240330_models.CountIntegrationEventResponse:
        """
        @summary 统计单个集成接入事件量
        
        @param request: CountIntegrationEventRequest
        @return: CountIntegrationEventResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.count_integration_event_with_options_async(alert_event_integration_policy_id, request, headers, runtime)

    def create_addon_release_with_options(
        self,
        policy_id: str,
        request: cms_20240330_models.CreateAddonReleaseRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateAddonReleaseResponse:
        """
        @summary Install the access component, representing a single access attempt
        
        @description Used to create a site monitoring task
        
        @param request: CreateAddonReleaseRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateAddonReleaseResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.addon_name):
            body['addonName'] = request.addon_name
        if not UtilClient.is_unset(request.aliyun_lang):
            body['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.dry_run):
            body['dryRun'] = request.dry_run
        if not UtilClient.is_unset(request.entity_rules):
            body['entityRules'] = request.entity_rules
        if not UtilClient.is_unset(request.env_type):
            body['envType'] = request.env_type
        if not UtilClient.is_unset(request.parent_addon_release_id):
            body['parentAddonReleaseId'] = request.parent_addon_release_id
        if not UtilClient.is_unset(request.release_name):
            body['releaseName'] = request.release_name
        if not UtilClient.is_unset(request.values):
            body['values'] = request.values
        if not UtilClient.is_unset(request.version):
            body['version'] = request.version
        if not UtilClient.is_unset(request.workspace):
            body['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateAddonRelease',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/addon-releases',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateAddonReleaseResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_addon_release_with_options_async(
        self,
        policy_id: str,
        request: cms_20240330_models.CreateAddonReleaseRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateAddonReleaseResponse:
        """
        @summary Install the access component, representing a single access attempt
        
        @description Used to create a site monitoring task
        
        @param request: CreateAddonReleaseRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateAddonReleaseResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.addon_name):
            body['addonName'] = request.addon_name
        if not UtilClient.is_unset(request.aliyun_lang):
            body['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.dry_run):
            body['dryRun'] = request.dry_run
        if not UtilClient.is_unset(request.entity_rules):
            body['entityRules'] = request.entity_rules
        if not UtilClient.is_unset(request.env_type):
            body['envType'] = request.env_type
        if not UtilClient.is_unset(request.parent_addon_release_id):
            body['parentAddonReleaseId'] = request.parent_addon_release_id
        if not UtilClient.is_unset(request.release_name):
            body['releaseName'] = request.release_name
        if not UtilClient.is_unset(request.values):
            body['values'] = request.values
        if not UtilClient.is_unset(request.version):
            body['version'] = request.version
        if not UtilClient.is_unset(request.workspace):
            body['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateAddonRelease',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/addon-releases',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateAddonReleaseResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_addon_release(
        self,
        policy_id: str,
        request: cms_20240330_models.CreateAddonReleaseRequest,
    ) -> cms_20240330_models.CreateAddonReleaseResponse:
        """
        @summary Install the access component, representing a single access attempt
        
        @description Used to create a site monitoring task
        
        @param request: CreateAddonReleaseRequest
        @return: CreateAddonReleaseResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_addon_release_with_options(policy_id, request, headers, runtime)

    async def create_addon_release_async(
        self,
        policy_id: str,
        request: cms_20240330_models.CreateAddonReleaseRequest,
    ) -> cms_20240330_models.CreateAddonReleaseResponse:
        """
        @summary Install the access component, representing a single access attempt
        
        @description Used to create a site monitoring task
        
        @param request: CreateAddonReleaseRequest
        @return: CreateAddonReleaseResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_addon_release_with_options_async(policy_id, request, headers, runtime)

    def create_agg_task_group_with_options(
        self,
        instance_id: str,
        request: cms_20240330_models.CreateAggTaskGroupRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateAggTaskGroupResponse:
        """
        @summary Create Aggregation Task Group
        
        @param request: CreateAggTaskGroupRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateAggTaskGroupResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.override_if_exists):
            query['overrideIfExists'] = request.override_if_exists
        body = {}
        if not UtilClient.is_unset(request.agg_task_group_config):
            body['aggTaskGroupConfig'] = request.agg_task_group_config
        if not UtilClient.is_unset(request.agg_task_group_config_type):
            body['aggTaskGroupConfigType'] = request.agg_task_group_config_type
        if not UtilClient.is_unset(request.agg_task_group_name):
            body['aggTaskGroupName'] = request.agg_task_group_name
        if not UtilClient.is_unset(request.cron_expr):
            body['cronExpr'] = request.cron_expr
        if not UtilClient.is_unset(request.delay):
            body['delay'] = request.delay
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.from_time):
            body['fromTime'] = request.from_time
        if not UtilClient.is_unset(request.max_retries):
            body['maxRetries'] = request.max_retries
        if not UtilClient.is_unset(request.max_run_time_in_seconds):
            body['maxRunTimeInSeconds'] = request.max_run_time_in_seconds
        if not UtilClient.is_unset(request.precheck_string):
            body['precheckString'] = request.precheck_string
        if not UtilClient.is_unset(request.schedule_mode):
            body['scheduleMode'] = request.schedule_mode
        if not UtilClient.is_unset(request.schedule_time_expr):
            body['scheduleTimeExpr'] = request.schedule_time_expr
        if not UtilClient.is_unset(request.status):
            body['status'] = request.status
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        if not UtilClient.is_unset(request.target_prometheus_id):
            body['targetPrometheusId'] = request.target_prometheus_id
        if not UtilClient.is_unset(request.to_time):
            body['toTime'] = request.to_time
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateAggTaskGroup',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(instance_id)}/agg-task-groups',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateAggTaskGroupResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_agg_task_group_with_options_async(
        self,
        instance_id: str,
        request: cms_20240330_models.CreateAggTaskGroupRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateAggTaskGroupResponse:
        """
        @summary Create Aggregation Task Group
        
        @param request: CreateAggTaskGroupRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateAggTaskGroupResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.override_if_exists):
            query['overrideIfExists'] = request.override_if_exists
        body = {}
        if not UtilClient.is_unset(request.agg_task_group_config):
            body['aggTaskGroupConfig'] = request.agg_task_group_config
        if not UtilClient.is_unset(request.agg_task_group_config_type):
            body['aggTaskGroupConfigType'] = request.agg_task_group_config_type
        if not UtilClient.is_unset(request.agg_task_group_name):
            body['aggTaskGroupName'] = request.agg_task_group_name
        if not UtilClient.is_unset(request.cron_expr):
            body['cronExpr'] = request.cron_expr
        if not UtilClient.is_unset(request.delay):
            body['delay'] = request.delay
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.from_time):
            body['fromTime'] = request.from_time
        if not UtilClient.is_unset(request.max_retries):
            body['maxRetries'] = request.max_retries
        if not UtilClient.is_unset(request.max_run_time_in_seconds):
            body['maxRunTimeInSeconds'] = request.max_run_time_in_seconds
        if not UtilClient.is_unset(request.precheck_string):
            body['precheckString'] = request.precheck_string
        if not UtilClient.is_unset(request.schedule_mode):
            body['scheduleMode'] = request.schedule_mode
        if not UtilClient.is_unset(request.schedule_time_expr):
            body['scheduleTimeExpr'] = request.schedule_time_expr
        if not UtilClient.is_unset(request.status):
            body['status'] = request.status
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        if not UtilClient.is_unset(request.target_prometheus_id):
            body['targetPrometheusId'] = request.target_prometheus_id
        if not UtilClient.is_unset(request.to_time):
            body['toTime'] = request.to_time
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateAggTaskGroup',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(instance_id)}/agg-task-groups',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateAggTaskGroupResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_agg_task_group(
        self,
        instance_id: str,
        request: cms_20240330_models.CreateAggTaskGroupRequest,
    ) -> cms_20240330_models.CreateAggTaskGroupResponse:
        """
        @summary Create Aggregation Task Group
        
        @param request: CreateAggTaskGroupRequest
        @return: CreateAggTaskGroupResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_agg_task_group_with_options(instance_id, request, headers, runtime)

    async def create_agg_task_group_async(
        self,
        instance_id: str,
        request: cms_20240330_models.CreateAggTaskGroupRequest,
    ) -> cms_20240330_models.CreateAggTaskGroupResponse:
        """
        @summary Create Aggregation Task Group
        
        @param request: CreateAggTaskGroupRequest
        @return: CreateAggTaskGroupResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_agg_task_group_with_options_async(instance_id, request, headers, runtime)

    def create_alert_action_with_options(
        self,
        request: cms_20240330_models.CreateAlertActionRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateAlertActionResponse:
        """
        @summary 创建告警动作
        
        @param request: CreateAlertActionRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateAlertActionResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.alert_action_id):
            body['alertActionId'] = request.alert_action_id
        if not UtilClient.is_unset(request.alert_action_name):
            body['alertActionName'] = request.alert_action_name
        if not UtilClient.is_unset(request.eb_param):
            body['ebParam'] = request.eb_param
        if not UtilClient.is_unset(request.ess_param):
            body['essParam'] = request.ess_param
        if not UtilClient.is_unset(request.fc_3param):
            body['fc3Param'] = request.fc_3param
        if not UtilClient.is_unset(request.fc_param):
            body['fcParam'] = request.fc_param
        if not UtilClient.is_unset(request.mns_param):
            body['mnsParam'] = request.mns_param
        if not UtilClient.is_unset(request.pager_duty_param):
            body['pagerDutyParam'] = request.pager_duty_param
        if not UtilClient.is_unset(request.sls_param):
            body['slsParam'] = request.sls_param
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        if not UtilClient.is_unset(request.type):
            body['type'] = request.type
        if not UtilClient.is_unset(request.webhook_param):
            body['webhookParam'] = request.webhook_param
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateAlertAction',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertAction',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateAlertActionResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_alert_action_with_options_async(
        self,
        request: cms_20240330_models.CreateAlertActionRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateAlertActionResponse:
        """
        @summary 创建告警动作
        
        @param request: CreateAlertActionRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateAlertActionResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.alert_action_id):
            body['alertActionId'] = request.alert_action_id
        if not UtilClient.is_unset(request.alert_action_name):
            body['alertActionName'] = request.alert_action_name
        if not UtilClient.is_unset(request.eb_param):
            body['ebParam'] = request.eb_param
        if not UtilClient.is_unset(request.ess_param):
            body['essParam'] = request.ess_param
        if not UtilClient.is_unset(request.fc_3param):
            body['fc3Param'] = request.fc_3param
        if not UtilClient.is_unset(request.fc_param):
            body['fcParam'] = request.fc_param
        if not UtilClient.is_unset(request.mns_param):
            body['mnsParam'] = request.mns_param
        if not UtilClient.is_unset(request.pager_duty_param):
            body['pagerDutyParam'] = request.pager_duty_param
        if not UtilClient.is_unset(request.sls_param):
            body['slsParam'] = request.sls_param
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        if not UtilClient.is_unset(request.type):
            body['type'] = request.type
        if not UtilClient.is_unset(request.webhook_param):
            body['webhookParam'] = request.webhook_param
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateAlertAction',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertAction',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateAlertActionResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_alert_action(
        self,
        request: cms_20240330_models.CreateAlertActionRequest,
    ) -> cms_20240330_models.CreateAlertActionResponse:
        """
        @summary 创建告警动作
        
        @param request: CreateAlertActionRequest
        @return: CreateAlertActionResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_alert_action_with_options(request, headers, runtime)

    async def create_alert_action_async(
        self,
        request: cms_20240330_models.CreateAlertActionRequest,
    ) -> cms_20240330_models.CreateAlertActionResponse:
        """
        @summary 创建告警动作
        
        @param request: CreateAlertActionRequest
        @return: CreateAlertActionResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_alert_action_with_options_async(request, headers, runtime)

    def create_alert_event_integration_policy_with_options(
        self,
        request: cms_20240330_models.CreateAlertEventIntegrationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateAlertEventIntegrationPolicyResponse:
        """
        @summary 创建集成
        
        @param request: CreateAlertEventIntegrationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateAlertEventIntegrationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='CreateAlertEventIntegrationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertEventIntegrationPolicies',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateAlertEventIntegrationPolicyResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_alert_event_integration_policy_with_options_async(
        self,
        request: cms_20240330_models.CreateAlertEventIntegrationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateAlertEventIntegrationPolicyResponse:
        """
        @summary 创建集成
        
        @param request: CreateAlertEventIntegrationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateAlertEventIntegrationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='CreateAlertEventIntegrationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertEventIntegrationPolicies',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateAlertEventIntegrationPolicyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_alert_event_integration_policy(
        self,
        request: cms_20240330_models.CreateAlertEventIntegrationPolicyRequest,
    ) -> cms_20240330_models.CreateAlertEventIntegrationPolicyResponse:
        """
        @summary 创建集成
        
        @param request: CreateAlertEventIntegrationPolicyRequest
        @return: CreateAlertEventIntegrationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_alert_event_integration_policy_with_options(request, headers, runtime)

    async def create_alert_event_integration_policy_async(
        self,
        request: cms_20240330_models.CreateAlertEventIntegrationPolicyRequest,
    ) -> cms_20240330_models.CreateAlertEventIntegrationPolicyResponse:
        """
        @summary 创建集成
        
        @param request: CreateAlertEventIntegrationPolicyRequest
        @return: CreateAlertEventIntegrationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_alert_event_integration_policy_with_options_async(request, headers, runtime)

    def create_alert_notify_template_with_options(
        self,
        request: cms_20240330_models.CreateAlertNotifyTemplateRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateAlertNotifyTemplateResponse:
        """
        @summary 创建通知模板
        
        @param request: CreateAlertNotifyTemplateRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateAlertNotifyTemplateResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.alert_notify_template_id):
            body['alertNotifyTemplateId'] = request.alert_notify_template_id
        if not UtilClient.is_unset(request.alert_notify_template_name):
            body['alertNotifyTemplateName'] = request.alert_notify_template_name
        if not UtilClient.is_unset(request.program_lang):
            body['programLang'] = request.program_lang
        if not UtilClient.is_unset(request.templates):
            body['templates'] = request.templates
        if not UtilClient.is_unset(request.type):
            body['type'] = request.type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateAlertNotifyTemplate',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertNotifyTemplate',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateAlertNotifyTemplateResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_alert_notify_template_with_options_async(
        self,
        request: cms_20240330_models.CreateAlertNotifyTemplateRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateAlertNotifyTemplateResponse:
        """
        @summary 创建通知模板
        
        @param request: CreateAlertNotifyTemplateRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateAlertNotifyTemplateResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.alert_notify_template_id):
            body['alertNotifyTemplateId'] = request.alert_notify_template_id
        if not UtilClient.is_unset(request.alert_notify_template_name):
            body['alertNotifyTemplateName'] = request.alert_notify_template_name
        if not UtilClient.is_unset(request.program_lang):
            body['programLang'] = request.program_lang
        if not UtilClient.is_unset(request.templates):
            body['templates'] = request.templates
        if not UtilClient.is_unset(request.type):
            body['type'] = request.type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateAlertNotifyTemplate',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertNotifyTemplate',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateAlertNotifyTemplateResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_alert_notify_template(
        self,
        request: cms_20240330_models.CreateAlertNotifyTemplateRequest,
    ) -> cms_20240330_models.CreateAlertNotifyTemplateResponse:
        """
        @summary 创建通知模板
        
        @param request: CreateAlertNotifyTemplateRequest
        @return: CreateAlertNotifyTemplateResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_alert_notify_template_with_options(request, headers, runtime)

    async def create_alert_notify_template_async(
        self,
        request: cms_20240330_models.CreateAlertNotifyTemplateRequest,
    ) -> cms_20240330_models.CreateAlertNotifyTemplateResponse:
        """
        @summary 创建通知模板
        
        @param request: CreateAlertNotifyTemplateRequest
        @return: CreateAlertNotifyTemplateResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_alert_notify_template_with_options_async(request, headers, runtime)

    def create_alert_robot_with_options(
        self,
        request: cms_20240330_models.CreateAlertRobotRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateAlertRobotResponse:
        """
        @summary 创建机器人
        
        @param request: CreateAlertRobotRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateAlertRobotResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.is_custom):
            body['isCustom'] = request.is_custom
        if not UtilClient.is_unset(request.lang):
            body['lang'] = request.lang
        if not UtilClient.is_unset(request.name):
            body['name'] = request.name
        if not UtilClient.is_unset(request.robot_id):
            body['robotId'] = request.robot_id
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        if not UtilClient.is_unset(request.type):
            body['type'] = request.type
        if not UtilClient.is_unset(request.url):
            body['url'] = request.url
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateAlertRobot',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/robot',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateAlertRobotResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_alert_robot_with_options_async(
        self,
        request: cms_20240330_models.CreateAlertRobotRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateAlertRobotResponse:
        """
        @summary 创建机器人
        
        @param request: CreateAlertRobotRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateAlertRobotResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.is_custom):
            body['isCustom'] = request.is_custom
        if not UtilClient.is_unset(request.lang):
            body['lang'] = request.lang
        if not UtilClient.is_unset(request.name):
            body['name'] = request.name
        if not UtilClient.is_unset(request.robot_id):
            body['robotId'] = request.robot_id
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        if not UtilClient.is_unset(request.type):
            body['type'] = request.type
        if not UtilClient.is_unset(request.url):
            body['url'] = request.url
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateAlertRobot',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/robot',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateAlertRobotResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_alert_robot(
        self,
        request: cms_20240330_models.CreateAlertRobotRequest,
    ) -> cms_20240330_models.CreateAlertRobotResponse:
        """
        @summary 创建机器人
        
        @param request: CreateAlertRobotRequest
        @return: CreateAlertRobotResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_alert_robot_with_options(request, headers, runtime)

    async def create_alert_robot_async(
        self,
        request: cms_20240330_models.CreateAlertRobotRequest,
    ) -> cms_20240330_models.CreateAlertRobotResponse:
        """
        @summary 创建机器人
        
        @param request: CreateAlertRobotRequest
        @return: CreateAlertRobotResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_alert_robot_with_options_async(request, headers, runtime)

    def create_alert_rule_with_options(
        self,
        request: cms_20240330_models.CreateAlertRuleRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateAlertRuleResponse:
        """
        @summary 创建云监控2.0告警规则
        
        @param request: CreateAlertRuleRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateAlertRuleResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.call_source):
            query['callSource'] = request.call_source
        body = {}
        if not UtilClient.is_unset(request.alert_metric_input):
            body['alertMetricInput'] = request.alert_metric_input
        if not UtilClient.is_unset(request.annotations):
            body['annotations'] = request.annotations
        if not UtilClient.is_unset(request.biz_source):
            body['bizSource'] = request.biz_source
        if not UtilClient.is_unset(request.condition):
            body['condition'] = request.condition
        if not UtilClient.is_unset(request.datasource):
            body['datasource'] = request.datasource
        if not UtilClient.is_unset(request.display_name):
            body['displayName'] = request.display_name
        if not UtilClient.is_unset(request.enabled):
            body['enabled'] = request.enabled
        if not UtilClient.is_unset(request.interval):
            body['interval'] = request.interval
        if not UtilClient.is_unset(request.labels):
            body['labels'] = request.labels
        if not UtilClient.is_unset(request.level):
            body['level'] = request.level
        if not UtilClient.is_unset(request.message):
            body['message'] = request.message
        if not UtilClient.is_unset(request.query):
            body['query'] = request.query
        if not UtilClient.is_unset(request.send):
            body['send'] = request.send
        if not UtilClient.is_unset(request.workspace):
            body['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateAlertRule',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateAlertRuleResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_alert_rule_with_options_async(
        self,
        request: cms_20240330_models.CreateAlertRuleRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateAlertRuleResponse:
        """
        @summary 创建云监控2.0告警规则
        
        @param request: CreateAlertRuleRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateAlertRuleResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.call_source):
            query['callSource'] = request.call_source
        body = {}
        if not UtilClient.is_unset(request.alert_metric_input):
            body['alertMetricInput'] = request.alert_metric_input
        if not UtilClient.is_unset(request.annotations):
            body['annotations'] = request.annotations
        if not UtilClient.is_unset(request.biz_source):
            body['bizSource'] = request.biz_source
        if not UtilClient.is_unset(request.condition):
            body['condition'] = request.condition
        if not UtilClient.is_unset(request.datasource):
            body['datasource'] = request.datasource
        if not UtilClient.is_unset(request.display_name):
            body['displayName'] = request.display_name
        if not UtilClient.is_unset(request.enabled):
            body['enabled'] = request.enabled
        if not UtilClient.is_unset(request.interval):
            body['interval'] = request.interval
        if not UtilClient.is_unset(request.labels):
            body['labels'] = request.labels
        if not UtilClient.is_unset(request.level):
            body['level'] = request.level
        if not UtilClient.is_unset(request.message):
            body['message'] = request.message
        if not UtilClient.is_unset(request.query):
            body['query'] = request.query
        if not UtilClient.is_unset(request.send):
            body['send'] = request.send
        if not UtilClient.is_unset(request.workspace):
            body['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateAlertRule',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateAlertRuleResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_alert_rule(
        self,
        request: cms_20240330_models.CreateAlertRuleRequest,
    ) -> cms_20240330_models.CreateAlertRuleResponse:
        """
        @summary 创建云监控2.0告警规则
        
        @param request: CreateAlertRuleRequest
        @return: CreateAlertRuleResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_alert_rule_with_options(request, headers, runtime)

    async def create_alert_rule_async(
        self,
        request: cms_20240330_models.CreateAlertRuleRequest,
    ) -> cms_20240330_models.CreateAlertRuleResponse:
        """
        @summary 创建云监控2.0告警规则
        
        @param request: CreateAlertRuleRequest
        @return: CreateAlertRuleResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_alert_rule_with_options_async(request, headers, runtime)

    def create_alert_webhook_with_options(
        self,
        request: cms_20240330_models.CreateAlertWebhookRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateAlertWebhookResponse:
        """
        @summary 创建Webhook
        
        @param request: CreateAlertWebhookRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateAlertWebhookResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.content_type):
            body['contentType'] = request.content_type
        if not UtilClient.is_unset(request.headers):
            body['headers'] = request.headers
        if not UtilClient.is_unset(request.is_custom):
            body['isCustom'] = request.is_custom
        if not UtilClient.is_unset(request.lang):
            body['lang'] = request.lang
        if not UtilClient.is_unset(request.method):
            body['method'] = request.method
        if not UtilClient.is_unset(request.name):
            body['name'] = request.name
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        if not UtilClient.is_unset(request.url):
            body['url'] = request.url
        if not UtilClient.is_unset(request.webhook_id):
            body['webhookId'] = request.webhook_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateAlertWebhook',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/webhook',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateAlertWebhookResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_alert_webhook_with_options_async(
        self,
        request: cms_20240330_models.CreateAlertWebhookRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateAlertWebhookResponse:
        """
        @summary 创建Webhook
        
        @param request: CreateAlertWebhookRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateAlertWebhookResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.content_type):
            body['contentType'] = request.content_type
        if not UtilClient.is_unset(request.headers):
            body['headers'] = request.headers
        if not UtilClient.is_unset(request.is_custom):
            body['isCustom'] = request.is_custom
        if not UtilClient.is_unset(request.lang):
            body['lang'] = request.lang
        if not UtilClient.is_unset(request.method):
            body['method'] = request.method
        if not UtilClient.is_unset(request.name):
            body['name'] = request.name
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        if not UtilClient.is_unset(request.url):
            body['url'] = request.url
        if not UtilClient.is_unset(request.webhook_id):
            body['webhookId'] = request.webhook_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateAlertWebhook',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/webhook',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateAlertWebhookResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_alert_webhook(
        self,
        request: cms_20240330_models.CreateAlertWebhookRequest,
    ) -> cms_20240330_models.CreateAlertWebhookResponse:
        """
        @summary 创建Webhook
        
        @param request: CreateAlertWebhookRequest
        @return: CreateAlertWebhookResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_alert_webhook_with_options(request, headers, runtime)

    async def create_alert_webhook_async(
        self,
        request: cms_20240330_models.CreateAlertWebhookRequest,
    ) -> cms_20240330_models.CreateAlertWebhookResponse:
        """
        @summary 创建Webhook
        
        @param request: CreateAlertWebhookRequest
        @return: CreateAlertWebhookResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_alert_webhook_with_options_async(request, headers, runtime)

    def create_biz_trace_with_options(
        self,
        request: cms_20240330_models.CreateBizTraceRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateBizTraceResponse:
        """
        @summary 创建业务链路
        
        @param request: CreateBizTraceRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateBizTraceResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.advanced_config):
            body['advancedConfig'] = request.advanced_config
        if not UtilClient.is_unset(request.biz_trace_code):
            body['bizTraceCode'] = request.biz_trace_code
        if not UtilClient.is_unset(request.biz_trace_name):
            body['bizTraceName'] = request.biz_trace_name
        if not UtilClient.is_unset(request.rule_config):
            body['ruleConfig'] = request.rule_config
        if not UtilClient.is_unset(request.workspace):
            body['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateBizTrace',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/bizTrace',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateBizTraceResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_biz_trace_with_options_async(
        self,
        request: cms_20240330_models.CreateBizTraceRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateBizTraceResponse:
        """
        @summary 创建业务链路
        
        @param request: CreateBizTraceRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateBizTraceResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.advanced_config):
            body['advancedConfig'] = request.advanced_config
        if not UtilClient.is_unset(request.biz_trace_code):
            body['bizTraceCode'] = request.biz_trace_code
        if not UtilClient.is_unset(request.biz_trace_name):
            body['bizTraceName'] = request.biz_trace_name
        if not UtilClient.is_unset(request.rule_config):
            body['ruleConfig'] = request.rule_config
        if not UtilClient.is_unset(request.workspace):
            body['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateBizTrace',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/bizTrace',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateBizTraceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_biz_trace(
        self,
        request: cms_20240330_models.CreateBizTraceRequest,
    ) -> cms_20240330_models.CreateBizTraceResponse:
        """
        @summary 创建业务链路
        
        @param request: CreateBizTraceRequest
        @return: CreateBizTraceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_biz_trace_with_options(request, headers, runtime)

    async def create_biz_trace_async(
        self,
        request: cms_20240330_models.CreateBizTraceRequest,
    ) -> cms_20240330_models.CreateBizTraceResponse:
        """
        @summary 创建业务链路
        
        @param request: CreateBizTraceRequest
        @return: CreateBizTraceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_biz_trace_with_options_async(request, headers, runtime)

    def create_chat_with_options(
        self,
        request: cms_20240330_models.CreateChatRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateChatResponse:
        """
        @summary 创建对话
        
        @param request: CreateChatRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateChatResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.action):
            body['action'] = request.action
        if not UtilClient.is_unset(request.digital_employee_name):
            body['digitalEmployeeName'] = request.digital_employee_name
        if not UtilClient.is_unset(request.messages):
            body['messages'] = request.messages
        if not UtilClient.is_unset(request.thread_id):
            body['threadId'] = request.thread_id
        if not UtilClient.is_unset(request.variables):
            body['variables'] = request.variables
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateChat',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/chat',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateChatResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_chat_with_options_async(
        self,
        request: cms_20240330_models.CreateChatRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateChatResponse:
        """
        @summary 创建对话
        
        @param request: CreateChatRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateChatResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.action):
            body['action'] = request.action
        if not UtilClient.is_unset(request.digital_employee_name):
            body['digitalEmployeeName'] = request.digital_employee_name
        if not UtilClient.is_unset(request.messages):
            body['messages'] = request.messages
        if not UtilClient.is_unset(request.thread_id):
            body['threadId'] = request.thread_id
        if not UtilClient.is_unset(request.variables):
            body['variables'] = request.variables
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateChat',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/chat',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateChatResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_chat(
        self,
        request: cms_20240330_models.CreateChatRequest,
    ) -> cms_20240330_models.CreateChatResponse:
        """
        @summary 创建对话
        
        @param request: CreateChatRequest
        @return: CreateChatResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_chat_with_options(request, headers, runtime)

    async def create_chat_async(
        self,
        request: cms_20240330_models.CreateChatRequest,
    ) -> cms_20240330_models.CreateChatResponse:
        """
        @summary 创建对话
        
        @param request: CreateChatRequest
        @return: CreateChatResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_chat_with_options_async(request, headers, runtime)

    def create_cloud_resource_with_options(
        self,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateCloudResourceResponse:
        """
        @summary 创建云资源中心
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateCloudResourceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='CreateCloudResource',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/cloudresource',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateCloudResourceResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_cloud_resource_with_options_async(
        self,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateCloudResourceResponse:
        """
        @summary 创建云资源中心
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateCloudResourceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='CreateCloudResource',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/cloudresource',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateCloudResourceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_cloud_resource(self) -> cms_20240330_models.CreateCloudResourceResponse:
        """
        @summary 创建云资源中心
        
        @return: CreateCloudResourceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_cloud_resource_with_options(headers, runtime)

    async def create_cloud_resource_async(self) -> cms_20240330_models.CreateCloudResourceResponse:
        """
        @summary 创建云资源中心
        
        @return: CreateCloudResourceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_cloud_resource_with_options_async(headers, runtime)

    def create_contact_with_options(
        self,
        request: cms_20240330_models.CreateContactRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateContactResponse:
        """
        @summary 创建联系人
        
        @param request: CreateContactRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateContactResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.contact_id):
            body['contactId'] = request.contact_id
        if not UtilClient.is_unset(request.email):
            body['email'] = request.email
        if not UtilClient.is_unset(request.im_user_ids):
            body['imUserIds'] = request.im_user_ids
        if not UtilClient.is_unset(request.is_inner_call):
            body['isInnerCall'] = request.is_inner_call
        if not UtilClient.is_unset(request.lang):
            body['lang'] = request.lang
        if not UtilClient.is_unset(request.name):
            body['name'] = request.name
        if not UtilClient.is_unset(request.phone):
            body['phone'] = request.phone
        if not UtilClient.is_unset(request.phone_code):
            body['phoneCode'] = request.phone_code
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateContact',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/contact',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateContactResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_contact_with_options_async(
        self,
        request: cms_20240330_models.CreateContactRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateContactResponse:
        """
        @summary 创建联系人
        
        @param request: CreateContactRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateContactResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.contact_id):
            body['contactId'] = request.contact_id
        if not UtilClient.is_unset(request.email):
            body['email'] = request.email
        if not UtilClient.is_unset(request.im_user_ids):
            body['imUserIds'] = request.im_user_ids
        if not UtilClient.is_unset(request.is_inner_call):
            body['isInnerCall'] = request.is_inner_call
        if not UtilClient.is_unset(request.lang):
            body['lang'] = request.lang
        if not UtilClient.is_unset(request.name):
            body['name'] = request.name
        if not UtilClient.is_unset(request.phone):
            body['phone'] = request.phone
        if not UtilClient.is_unset(request.phone_code):
            body['phoneCode'] = request.phone_code
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateContact',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/contact',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateContactResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_contact(
        self,
        request: cms_20240330_models.CreateContactRequest,
    ) -> cms_20240330_models.CreateContactResponse:
        """
        @summary 创建联系人
        
        @param request: CreateContactRequest
        @return: CreateContactResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_contact_with_options(request, headers, runtime)

    async def create_contact_async(
        self,
        request: cms_20240330_models.CreateContactRequest,
    ) -> cms_20240330_models.CreateContactResponse:
        """
        @summary 创建联系人
        
        @param request: CreateContactRequest
        @return: CreateContactResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_contact_with_options_async(request, headers, runtime)

    def create_contact_group_with_options(
        self,
        request: cms_20240330_models.CreateContactGroupRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateContactGroupResponse:
        """
        @summary 创建联系人组
        
        @param request: CreateContactGroupRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateContactGroupResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.contact_group_id):
            body['contactGroupId'] = request.contact_group_id
        if not UtilClient.is_unset(request.contacts):
            body['contacts'] = request.contacts
        if not UtilClient.is_unset(request.name):
            body['name'] = request.name
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateContactGroup',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/contactGroup',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateContactGroupResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_contact_group_with_options_async(
        self,
        request: cms_20240330_models.CreateContactGroupRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateContactGroupResponse:
        """
        @summary 创建联系人组
        
        @param request: CreateContactGroupRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateContactGroupResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.contact_group_id):
            body['contactGroupId'] = request.contact_group_id
        if not UtilClient.is_unset(request.contacts):
            body['contacts'] = request.contacts
        if not UtilClient.is_unset(request.name):
            body['name'] = request.name
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateContactGroup',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/contactGroup',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateContactGroupResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_contact_group(
        self,
        request: cms_20240330_models.CreateContactGroupRequest,
    ) -> cms_20240330_models.CreateContactGroupResponse:
        """
        @summary 创建联系人组
        
        @param request: CreateContactGroupRequest
        @return: CreateContactGroupResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_contact_group_with_options(request, headers, runtime)

    async def create_contact_group_async(
        self,
        request: cms_20240330_models.CreateContactGroupRequest,
    ) -> cms_20240330_models.CreateContactGroupResponse:
        """
        @summary 创建联系人组
        
        @param request: CreateContactGroupRequest
        @return: CreateContactGroupResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_contact_group_with_options_async(request, headers, runtime)

    def create_dataset_with_options(
        self,
        workspace: str,
        request: cms_20240330_models.CreateDatasetRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateDatasetResponse:
        """
        @summary 创建数据集
        
        @param request: CreateDatasetRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateDatasetResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.dataset_name):
            body['datasetName'] = request.dataset_name
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.schema):
            body['schema'] = request.schema
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateDataset',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/dataset',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateDatasetResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_dataset_with_options_async(
        self,
        workspace: str,
        request: cms_20240330_models.CreateDatasetRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateDatasetResponse:
        """
        @summary 创建数据集
        
        @param request: CreateDatasetRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateDatasetResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.dataset_name):
            body['datasetName'] = request.dataset_name
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.schema):
            body['schema'] = request.schema
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateDataset',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/dataset',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateDatasetResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_dataset(
        self,
        workspace: str,
        request: cms_20240330_models.CreateDatasetRequest,
    ) -> cms_20240330_models.CreateDatasetResponse:
        """
        @summary 创建数据集
        
        @param request: CreateDatasetRequest
        @return: CreateDatasetResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_dataset_with_options(workspace, request, headers, runtime)

    async def create_dataset_async(
        self,
        workspace: str,
        request: cms_20240330_models.CreateDatasetRequest,
    ) -> cms_20240330_models.CreateDatasetResponse:
        """
        @summary 创建数据集
        
        @param request: CreateDatasetRequest
        @return: CreateDatasetResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_dataset_with_options_async(workspace, request, headers, runtime)

    def create_delivery_task_with_options(
        self,
        request: cms_20240330_models.CreateDeliveryTaskRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateDeliveryTaskResponse:
        """
        @summary 创建数据投递任务
        
        @param request: CreateDeliveryTaskRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateDeliveryTaskResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.data_source_id):
            body['dataSourceId'] = request.data_source_id
        if not UtilClient.is_unset(request.external_labels):
            body['externalLabels'] = request.external_labels
        if not UtilClient.is_unset(request.label_filters):
            body['labelFilters'] = request.label_filters
        if not UtilClient.is_unset(request.label_filters_type):
            body['labelFiltersType'] = request.label_filters_type
        if not UtilClient.is_unset(request.resource_group_id):
            body['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.sink_list):
            body['sinkList'] = request.sink_list
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        if not UtilClient.is_unset(request.task_description):
            body['taskDescription'] = request.task_description
        if not UtilClient.is_unset(request.task_name):
            body['taskName'] = request.task_name
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateDeliveryTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/delivery-tasks',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateDeliveryTaskResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_delivery_task_with_options_async(
        self,
        request: cms_20240330_models.CreateDeliveryTaskRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateDeliveryTaskResponse:
        """
        @summary 创建数据投递任务
        
        @param request: CreateDeliveryTaskRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateDeliveryTaskResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.data_source_id):
            body['dataSourceId'] = request.data_source_id
        if not UtilClient.is_unset(request.external_labels):
            body['externalLabels'] = request.external_labels
        if not UtilClient.is_unset(request.label_filters):
            body['labelFilters'] = request.label_filters
        if not UtilClient.is_unset(request.label_filters_type):
            body['labelFiltersType'] = request.label_filters_type
        if not UtilClient.is_unset(request.resource_group_id):
            body['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.sink_list):
            body['sinkList'] = request.sink_list
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        if not UtilClient.is_unset(request.task_description):
            body['taskDescription'] = request.task_description
        if not UtilClient.is_unset(request.task_name):
            body['taskName'] = request.task_name
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateDeliveryTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/delivery-tasks',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateDeliveryTaskResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_delivery_task(
        self,
        request: cms_20240330_models.CreateDeliveryTaskRequest,
    ) -> cms_20240330_models.CreateDeliveryTaskResponse:
        """
        @summary 创建数据投递任务
        
        @param request: CreateDeliveryTaskRequest
        @return: CreateDeliveryTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_delivery_task_with_options(request, headers, runtime)

    async def create_delivery_task_async(
        self,
        request: cms_20240330_models.CreateDeliveryTaskRequest,
    ) -> cms_20240330_models.CreateDeliveryTaskResponse:
        """
        @summary 创建数据投递任务
        
        @param request: CreateDeliveryTaskRequest
        @return: CreateDeliveryTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_delivery_task_with_options_async(request, headers, runtime)

    def create_digital_employee_with_options(
        self,
        request: cms_20240330_models.CreateDigitalEmployeeRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateDigitalEmployeeResponse:
        """
        @summary 创建DigitalEmployee
        
        @param request: CreateDigitalEmployeeRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateDigitalEmployeeResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.default_rule):
            body['defaultRule'] = request.default_rule
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.display_name):
            body['displayName'] = request.display_name
        if not UtilClient.is_unset(request.knowledges):
            body['knowledges'] = request.knowledges
        if not UtilClient.is_unset(request.name):
            body['name'] = request.name
        if not UtilClient.is_unset(request.resource_group_id):
            body['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.role_arn):
            body['roleArn'] = request.role_arn
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateDigitalEmployee',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digital-employee',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateDigitalEmployeeResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_digital_employee_with_options_async(
        self,
        request: cms_20240330_models.CreateDigitalEmployeeRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateDigitalEmployeeResponse:
        """
        @summary 创建DigitalEmployee
        
        @param request: CreateDigitalEmployeeRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateDigitalEmployeeResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.default_rule):
            body['defaultRule'] = request.default_rule
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.display_name):
            body['displayName'] = request.display_name
        if not UtilClient.is_unset(request.knowledges):
            body['knowledges'] = request.knowledges
        if not UtilClient.is_unset(request.name):
            body['name'] = request.name
        if not UtilClient.is_unset(request.resource_group_id):
            body['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.role_arn):
            body['roleArn'] = request.role_arn
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateDigitalEmployee',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digital-employee',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateDigitalEmployeeResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_digital_employee(
        self,
        request: cms_20240330_models.CreateDigitalEmployeeRequest,
    ) -> cms_20240330_models.CreateDigitalEmployeeResponse:
        """
        @summary 创建DigitalEmployee
        
        @param request: CreateDigitalEmployeeRequest
        @return: CreateDigitalEmployeeResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_digital_employee_with_options(request, headers, runtime)

    async def create_digital_employee_async(
        self,
        request: cms_20240330_models.CreateDigitalEmployeeRequest,
    ) -> cms_20240330_models.CreateDigitalEmployeeResponse:
        """
        @summary 创建DigitalEmployee
        
        @param request: CreateDigitalEmployeeRequest
        @return: CreateDigitalEmployeeResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_digital_employee_with_options_async(request, headers, runtime)

    def create_digital_employee_skill_with_options(
        self,
        name: str,
        request: cms_20240330_models.CreateDigitalEmployeeSkillRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateDigitalEmployeeSkillResponse:
        """
        @summary 创建技能
        
        @param request: CreateDigitalEmployeeSkillRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateDigitalEmployeeSkillResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.display_name):
            body['displayName'] = request.display_name
        if not UtilClient.is_unset(request.enable):
            body['enable'] = request.enable
        if not UtilClient.is_unset(request.files):
            body['files'] = request.files
        if not UtilClient.is_unset(request.remark):
            body['remark'] = request.remark
        if not UtilClient.is_unset(request.skill_name):
            body['skillName'] = request.skill_name
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateDigitalEmployeeSkill',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/skill',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateDigitalEmployeeSkillResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_digital_employee_skill_with_options_async(
        self,
        name: str,
        request: cms_20240330_models.CreateDigitalEmployeeSkillRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateDigitalEmployeeSkillResponse:
        """
        @summary 创建技能
        
        @param request: CreateDigitalEmployeeSkillRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateDigitalEmployeeSkillResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.display_name):
            body['displayName'] = request.display_name
        if not UtilClient.is_unset(request.enable):
            body['enable'] = request.enable
        if not UtilClient.is_unset(request.files):
            body['files'] = request.files
        if not UtilClient.is_unset(request.remark):
            body['remark'] = request.remark
        if not UtilClient.is_unset(request.skill_name):
            body['skillName'] = request.skill_name
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateDigitalEmployeeSkill',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/skill',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateDigitalEmployeeSkillResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_digital_employee_skill(
        self,
        name: str,
        request: cms_20240330_models.CreateDigitalEmployeeSkillRequest,
    ) -> cms_20240330_models.CreateDigitalEmployeeSkillResponse:
        """
        @summary 创建技能
        
        @param request: CreateDigitalEmployeeSkillRequest
        @return: CreateDigitalEmployeeSkillResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_digital_employee_skill_with_options(name, request, headers, runtime)

    async def create_digital_employee_skill_async(
        self,
        name: str,
        request: cms_20240330_models.CreateDigitalEmployeeSkillRequest,
    ) -> cms_20240330_models.CreateDigitalEmployeeSkillResponse:
        """
        @summary 创建技能
        
        @param request: CreateDigitalEmployeeSkillRequest
        @return: CreateDigitalEmployeeSkillResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_digital_employee_skill_with_options_async(name, request, headers, runtime)

    def create_entity_store_with_options(
        self,
        workspace_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateEntityStoreResponse:
        """
        @summary Create storage related to EntityStore
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateEntityStoreResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='CreateEntityStore',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace_name)}/entitystore',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateEntityStoreResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_entity_store_with_options_async(
        self,
        workspace_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateEntityStoreResponse:
        """
        @summary Create storage related to EntityStore
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateEntityStoreResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='CreateEntityStore',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace_name)}/entitystore',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateEntityStoreResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_entity_store(
        self,
        workspace_name: str,
    ) -> cms_20240330_models.CreateEntityStoreResponse:
        """
        @summary Create storage related to EntityStore
        
        @return: CreateEntityStoreResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_entity_store_with_options(workspace_name, headers, runtime)

    async def create_entity_store_async(
        self,
        workspace_name: str,
    ) -> cms_20240330_models.CreateEntityStoreResponse:
        """
        @summary Create storage related to EntityStore
        
        @return: CreateEntityStoreResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_entity_store_with_options_async(workspace_name, headers, runtime)

    def create_escalation_policy_with_options(
        self,
        request: cms_20240330_models.CreateEscalationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateEscalationPolicyResponse:
        """
        @summary 创建升级策略
        
        @param request: CreateEscalationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateEscalationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='CreateEscalationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/escalationPolicies',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateEscalationPolicyResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_escalation_policy_with_options_async(
        self,
        request: cms_20240330_models.CreateEscalationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateEscalationPolicyResponse:
        """
        @summary 创建升级策略
        
        @param request: CreateEscalationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateEscalationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='CreateEscalationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/escalationPolicies',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateEscalationPolicyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_escalation_policy(
        self,
        request: cms_20240330_models.CreateEscalationPolicyRequest,
    ) -> cms_20240330_models.CreateEscalationPolicyResponse:
        """
        @summary 创建升级策略
        
        @param request: CreateEscalationPolicyRequest
        @return: CreateEscalationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_escalation_policy_with_options(request, headers, runtime)

    async def create_escalation_policy_async(
        self,
        request: cms_20240330_models.CreateEscalationPolicyRequest,
    ) -> cms_20240330_models.CreateEscalationPolicyResponse:
        """
        @summary 创建升级策略
        
        @param request: CreateEscalationPolicyRequest
        @return: CreateEscalationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_escalation_policy_with_options_async(request, headers, runtime)

    def create_evaluation_task_with_options(
        self,
        workspace: str,
        request: cms_20240330_models.CreateEvaluationTaskRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateEvaluationTaskResponse:
        """
        @summary 创建评估任务
        
        @param request: CreateEvaluationTaskRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateEvaluationTaskResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.channel):
            body['channel'] = request.channel
        if not UtilClient.is_unset(request.config):
            body['config'] = request.config
        if not UtilClient.is_unset(request.data_filter):
            body['dataFilter'] = request.data_filter
        if not UtilClient.is_unset(request.data_type):
            body['dataType'] = request.data_type
        if not UtilClient.is_unset(request.evaluators):
            body['evaluators'] = request.evaluators
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        if not UtilClient.is_unset(request.task_mode):
            body['taskMode'] = request.task_mode
        if not UtilClient.is_unset(request.task_name):
            body['taskName'] = request.task_name
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateEvaluationTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/evaluation-task/{OpenApiUtilClient.get_encode_param(workspace)}',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateEvaluationTaskResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_evaluation_task_with_options_async(
        self,
        workspace: str,
        request: cms_20240330_models.CreateEvaluationTaskRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateEvaluationTaskResponse:
        """
        @summary 创建评估任务
        
        @param request: CreateEvaluationTaskRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateEvaluationTaskResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.channel):
            body['channel'] = request.channel
        if not UtilClient.is_unset(request.config):
            body['config'] = request.config
        if not UtilClient.is_unset(request.data_filter):
            body['dataFilter'] = request.data_filter
        if not UtilClient.is_unset(request.data_type):
            body['dataType'] = request.data_type
        if not UtilClient.is_unset(request.evaluators):
            body['evaluators'] = request.evaluators
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        if not UtilClient.is_unset(request.task_mode):
            body['taskMode'] = request.task_mode
        if not UtilClient.is_unset(request.task_name):
            body['taskName'] = request.task_name
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateEvaluationTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/evaluation-task/{OpenApiUtilClient.get_encode_param(workspace)}',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateEvaluationTaskResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_evaluation_task(
        self,
        workspace: str,
        request: cms_20240330_models.CreateEvaluationTaskRequest,
    ) -> cms_20240330_models.CreateEvaluationTaskResponse:
        """
        @summary 创建评估任务
        
        @param request: CreateEvaluationTaskRequest
        @return: CreateEvaluationTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_evaluation_task_with_options(workspace, request, headers, runtime)

    async def create_evaluation_task_async(
        self,
        workspace: str,
        request: cms_20240330_models.CreateEvaluationTaskRequest,
    ) -> cms_20240330_models.CreateEvaluationTaskResponse:
        """
        @summary 创建评估任务
        
        @param request: CreateEvaluationTaskRequest
        @return: CreateEvaluationTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_evaluation_task_with_options_async(workspace, request, headers, runtime)

    def create_experiment_plan_with_options(
        self,
        workspace: str,
        request: cms_20240330_models.CreateExperimentPlanRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateExperimentPlanResponse:
        """
        @summary 创建模型实验计划
        
        @param request: CreateExperimentPlanRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateExperimentPlanResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.dataset_id):
            body['datasetId'] = request.dataset_id
        if not UtilClient.is_unset(request.dataset_project):
            body['datasetProject'] = request.dataset_project
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.experiments):
            body['experiments'] = request.experiments
        if not UtilClient.is_unset(request.plan_name):
            body['planName'] = request.plan_name
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateExperimentPlan',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/experiments/{OpenApiUtilClient.get_encode_param(workspace)}/plans',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='none'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateExperimentPlanResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_experiment_plan_with_options_async(
        self,
        workspace: str,
        request: cms_20240330_models.CreateExperimentPlanRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateExperimentPlanResponse:
        """
        @summary 创建模型实验计划
        
        @param request: CreateExperimentPlanRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateExperimentPlanResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.dataset_id):
            body['datasetId'] = request.dataset_id
        if not UtilClient.is_unset(request.dataset_project):
            body['datasetProject'] = request.dataset_project
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.experiments):
            body['experiments'] = request.experiments
        if not UtilClient.is_unset(request.plan_name):
            body['planName'] = request.plan_name
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateExperimentPlan',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/experiments/{OpenApiUtilClient.get_encode_param(workspace)}/plans',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='none'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateExperimentPlanResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_experiment_plan(
        self,
        workspace: str,
        request: cms_20240330_models.CreateExperimentPlanRequest,
    ) -> cms_20240330_models.CreateExperimentPlanResponse:
        """
        @summary 创建模型实验计划
        
        @param request: CreateExperimentPlanRequest
        @return: CreateExperimentPlanResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_experiment_plan_with_options(workspace, request, headers, runtime)

    async def create_experiment_plan_async(
        self,
        workspace: str,
        request: cms_20240330_models.CreateExperimentPlanRequest,
    ) -> cms_20240330_models.CreateExperimentPlanResponse:
        """
        @summary 创建模型实验计划
        
        @param request: CreateExperimentPlanRequest
        @return: CreateExperimentPlanResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_experiment_plan_with_options_async(workspace, request, headers, runtime)

    def create_experiment_task_with_options(
        self,
        workspace: str,
        request: cms_20240330_models.CreateExperimentTaskRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateExperimentTaskResponse:
        """
        @summary 创建执行实验
        
        @param request: CreateExperimentTaskRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateExperimentTaskResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.data_source):
            body['dataSource'] = request.data_source
        if not UtilClient.is_unset(request.experiment_plan_id):
            body['experimentPlanId'] = request.experiment_plan_id
        if not UtilClient.is_unset(request.experiments):
            body['experiments'] = request.experiments
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateExperimentTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/experiments/{OpenApiUtilClient.get_encode_param(workspace)}/execute',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateExperimentTaskResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_experiment_task_with_options_async(
        self,
        workspace: str,
        request: cms_20240330_models.CreateExperimentTaskRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateExperimentTaskResponse:
        """
        @summary 创建执行实验
        
        @param request: CreateExperimentTaskRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateExperimentTaskResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.data_source):
            body['dataSource'] = request.data_source
        if not UtilClient.is_unset(request.experiment_plan_id):
            body['experimentPlanId'] = request.experiment_plan_id
        if not UtilClient.is_unset(request.experiments):
            body['experiments'] = request.experiments
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateExperimentTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/experiments/{OpenApiUtilClient.get_encode_param(workspace)}/execute',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateExperimentTaskResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_experiment_task(
        self,
        workspace: str,
        request: cms_20240330_models.CreateExperimentTaskRequest,
    ) -> cms_20240330_models.CreateExperimentTaskResponse:
        """
        @summary 创建执行实验
        
        @param request: CreateExperimentTaskRequest
        @return: CreateExperimentTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_experiment_task_with_options(workspace, request, headers, runtime)

    async def create_experiment_task_async(
        self,
        workspace: str,
        request: cms_20240330_models.CreateExperimentTaskRequest,
    ) -> cms_20240330_models.CreateExperimentTaskResponse:
        """
        @summary 创建执行实验
        
        @param request: CreateExperimentTaskRequest
        @return: CreateExperimentTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_experiment_task_with_options_async(workspace, request, headers, runtime)

    def create_integration_policy_with_options(
        self,
        request: cms_20240330_models.CreateIntegrationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateIntegrationPolicyResponse:
        """
        @summary Create Access Center Policy
        
        @description This interface is used to support users in creating event integration.
        
        @param request: CreateIntegrationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateIntegrationPolicyResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.entity_group):
            body['entityGroup'] = request.entity_group
        if not UtilClient.is_unset(request.policy_name):
            body['policyName'] = request.policy_name
        if not UtilClient.is_unset(request.policy_type):
            body['policyType'] = request.policy_type
        if not UtilClient.is_unset(request.resource_group_id):
            body['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        if not UtilClient.is_unset(request.workspace):
            body['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateIntegrationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateIntegrationPolicyResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_integration_policy_with_options_async(
        self,
        request: cms_20240330_models.CreateIntegrationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateIntegrationPolicyResponse:
        """
        @summary Create Access Center Policy
        
        @description This interface is used to support users in creating event integration.
        
        @param request: CreateIntegrationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateIntegrationPolicyResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.entity_group):
            body['entityGroup'] = request.entity_group
        if not UtilClient.is_unset(request.policy_name):
            body['policyName'] = request.policy_name
        if not UtilClient.is_unset(request.policy_type):
            body['policyType'] = request.policy_type
        if not UtilClient.is_unset(request.resource_group_id):
            body['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        if not UtilClient.is_unset(request.workspace):
            body['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateIntegrationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateIntegrationPolicyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_integration_policy(
        self,
        request: cms_20240330_models.CreateIntegrationPolicyRequest,
    ) -> cms_20240330_models.CreateIntegrationPolicyResponse:
        """
        @summary Create Access Center Policy
        
        @description This interface is used to support users in creating event integration.
        
        @param request: CreateIntegrationPolicyRequest
        @return: CreateIntegrationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_integration_policy_with_options(request, headers, runtime)

    async def create_integration_policy_async(
        self,
        request: cms_20240330_models.CreateIntegrationPolicyRequest,
    ) -> cms_20240330_models.CreateIntegrationPolicyResponse:
        """
        @summary Create Access Center Policy
        
        @description This interface is used to support users in creating event integration.
        
        @param request: CreateIntegrationPolicyRequest
        @return: CreateIntegrationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_integration_policy_with_options_async(request, headers, runtime)

    def create_maintain_window_with_options(
        self,
        request: cms_20240330_models.CreateMaintainWindowRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateMaintainWindowResponse:
        """
        @summary 创建订阅
        
        @param request: CreateMaintainWindowRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateMaintainWindowResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='CreateMaintainWindow',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/maintainWindows',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateMaintainWindowResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_maintain_window_with_options_async(
        self,
        request: cms_20240330_models.CreateMaintainWindowRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateMaintainWindowResponse:
        """
        @summary 创建订阅
        
        @param request: CreateMaintainWindowRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateMaintainWindowResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='CreateMaintainWindow',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/maintainWindows',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateMaintainWindowResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_maintain_window(
        self,
        request: cms_20240330_models.CreateMaintainWindowRequest,
    ) -> cms_20240330_models.CreateMaintainWindowResponse:
        """
        @summary 创建订阅
        
        @param request: CreateMaintainWindowRequest
        @return: CreateMaintainWindowResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_maintain_window_with_options(request, headers, runtime)

    async def create_maintain_window_async(
        self,
        request: cms_20240330_models.CreateMaintainWindowRequest,
    ) -> cms_20240330_models.CreateMaintainWindowResponse:
        """
        @summary 创建订阅
        
        @param request: CreateMaintainWindowRequest
        @return: CreateMaintainWindowResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_maintain_window_with_options_async(request, headers, runtime)

    def create_memory_store_with_options(
        self,
        workspace: str,
        request: cms_20240330_models.CreateMemoryStoreRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateMemoryStoreResponse:
        """
        @summary 创建记忆库
        
        @param request: CreateMemoryStoreRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateMemoryStoreResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.custom_extraction_strategies):
            body['customExtractionStrategies'] = request.custom_extraction_strategies
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.enable_graph):
            body['enableGraph'] = request.enable_graph
        if not UtilClient.is_unset(request.extraction_strategies):
            body['extractionStrategies'] = request.extraction_strategies
        if not UtilClient.is_unset(request.memory_store_name):
            body['memoryStoreName'] = request.memory_store_name
        if not UtilClient.is_unset(request.short_term_ttl):
            body['shortTermTtl'] = request.short_term_ttl
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateMemoryStore',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateMemoryStoreResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_memory_store_with_options_async(
        self,
        workspace: str,
        request: cms_20240330_models.CreateMemoryStoreRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateMemoryStoreResponse:
        """
        @summary 创建记忆库
        
        @param request: CreateMemoryStoreRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateMemoryStoreResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.custom_extraction_strategies):
            body['customExtractionStrategies'] = request.custom_extraction_strategies
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.enable_graph):
            body['enableGraph'] = request.enable_graph
        if not UtilClient.is_unset(request.extraction_strategies):
            body['extractionStrategies'] = request.extraction_strategies
        if not UtilClient.is_unset(request.memory_store_name):
            body['memoryStoreName'] = request.memory_store_name
        if not UtilClient.is_unset(request.short_term_ttl):
            body['shortTermTtl'] = request.short_term_ttl
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateMemoryStore',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateMemoryStoreResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_memory_store(
        self,
        workspace: str,
        request: cms_20240330_models.CreateMemoryStoreRequest,
    ) -> cms_20240330_models.CreateMemoryStoreResponse:
        """
        @summary 创建记忆库
        
        @param request: CreateMemoryStoreRequest
        @return: CreateMemoryStoreResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_memory_store_with_options(workspace, request, headers, runtime)

    async def create_memory_store_async(
        self,
        workspace: str,
        request: cms_20240330_models.CreateMemoryStoreRequest,
    ) -> cms_20240330_models.CreateMemoryStoreResponse:
        """
        @summary 创建记忆库
        
        @param request: CreateMemoryStoreRequest
        @return: CreateMemoryStoreResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_memory_store_with_options_async(workspace, request, headers, runtime)

    def create_notify_strategy_with_options(
        self,
        request: cms_20240330_models.CreateNotifyStrategyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateNotifyStrategyResponse:
        """
        @summary 创建通知策略
        
        @param request: CreateNotifyStrategyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateNotifyStrategyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='CreateNotifyStrategy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/notifyStrategies',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateNotifyStrategyResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_notify_strategy_with_options_async(
        self,
        request: cms_20240330_models.CreateNotifyStrategyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateNotifyStrategyResponse:
        """
        @summary 创建通知策略
        
        @param request: CreateNotifyStrategyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateNotifyStrategyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='CreateNotifyStrategy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/notifyStrategies',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateNotifyStrategyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_notify_strategy(
        self,
        request: cms_20240330_models.CreateNotifyStrategyRequest,
    ) -> cms_20240330_models.CreateNotifyStrategyResponse:
        """
        @summary 创建通知策略
        
        @param request: CreateNotifyStrategyRequest
        @return: CreateNotifyStrategyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_notify_strategy_with_options(request, headers, runtime)

    async def create_notify_strategy_async(
        self,
        request: cms_20240330_models.CreateNotifyStrategyRequest,
    ) -> cms_20240330_models.CreateNotifyStrategyResponse:
        """
        @summary 创建通知策略
        
        @param request: CreateNotifyStrategyRequest
        @return: CreateNotifyStrategyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_notify_strategy_with_options_async(request, headers, runtime)

    def create_oncall_schedule_with_options(
        self,
        request: cms_20240330_models.CreateOncallScheduleRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateOncallScheduleResponse:
        """
        @summary 创建OncallSchedule
        
        @param request: CreateOncallScheduleRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateOncallScheduleResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.oncall_schedule_id):
            body['oncallScheduleId'] = request.oncall_schedule_id
        if not UtilClient.is_unset(request.oncall_schedule_name):
            body['oncallScheduleName'] = request.oncall_schedule_name
        if not UtilClient.is_unset(request.rotations):
            body['rotations'] = request.rotations
        if not UtilClient.is_unset(request.shift_robot_id):
            body['shiftRobotId'] = request.shift_robot_id
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateOncallSchedule',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/oncallschedule',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateOncallScheduleResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_oncall_schedule_with_options_async(
        self,
        request: cms_20240330_models.CreateOncallScheduleRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateOncallScheduleResponse:
        """
        @summary 创建OncallSchedule
        
        @param request: CreateOncallScheduleRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateOncallScheduleResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.oncall_schedule_id):
            body['oncallScheduleId'] = request.oncall_schedule_id
        if not UtilClient.is_unset(request.oncall_schedule_name):
            body['oncallScheduleName'] = request.oncall_schedule_name
        if not UtilClient.is_unset(request.rotations):
            body['rotations'] = request.rotations
        if not UtilClient.is_unset(request.shift_robot_id):
            body['shiftRobotId'] = request.shift_robot_id
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateOncallSchedule',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/oncallschedule',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateOncallScheduleResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_oncall_schedule(
        self,
        request: cms_20240330_models.CreateOncallScheduleRequest,
    ) -> cms_20240330_models.CreateOncallScheduleResponse:
        """
        @summary 创建OncallSchedule
        
        @param request: CreateOncallScheduleRequest
        @return: CreateOncallScheduleResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_oncall_schedule_with_options(request, headers, runtime)

    async def create_oncall_schedule_async(
        self,
        request: cms_20240330_models.CreateOncallScheduleRequest,
    ) -> cms_20240330_models.CreateOncallScheduleResponse:
        """
        @summary 创建OncallSchedule
        
        @param request: CreateOncallScheduleRequest
        @return: CreateOncallScheduleResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_oncall_schedule_with_options_async(request, headers, runtime)

    def create_pipeline_with_options(
        self,
        workspace: str,
        request: cms_20240330_models.CreatePipelineRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreatePipelineResponse:
        """
        @summary 创建流水线
        
        @param request: CreatePipelineRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreatePipelineResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.execute_policy):
            body['executePolicy'] = request.execute_policy
        if not UtilClient.is_unset(request.pipeline):
            body['pipeline'] = request.pipeline
        if not UtilClient.is_unset(request.pipeline_name):
            body['pipelineName'] = request.pipeline_name
        if not UtilClient.is_unset(request.sink):
            body['sink'] = request.sink
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreatePipeline',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/pipeline',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreatePipelineResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_pipeline_with_options_async(
        self,
        workspace: str,
        request: cms_20240330_models.CreatePipelineRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreatePipelineResponse:
        """
        @summary 创建流水线
        
        @param request: CreatePipelineRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreatePipelineResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.execute_policy):
            body['executePolicy'] = request.execute_policy
        if not UtilClient.is_unset(request.pipeline):
            body['pipeline'] = request.pipeline
        if not UtilClient.is_unset(request.pipeline_name):
            body['pipelineName'] = request.pipeline_name
        if not UtilClient.is_unset(request.sink):
            body['sink'] = request.sink
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreatePipeline',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/pipeline',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreatePipelineResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_pipeline(
        self,
        workspace: str,
        request: cms_20240330_models.CreatePipelineRequest,
    ) -> cms_20240330_models.CreatePipelineResponse:
        """
        @summary 创建流水线
        
        @param request: CreatePipelineRequest
        @return: CreatePipelineResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_pipeline_with_options(workspace, request, headers, runtime)

    async def create_pipeline_async(
        self,
        workspace: str,
        request: cms_20240330_models.CreatePipelineRequest,
    ) -> cms_20240330_models.CreatePipelineResponse:
        """
        @summary 创建流水线
        
        @param request: CreatePipelineRequest
        @return: CreatePipelineResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_pipeline_with_options_async(workspace, request, headers, runtime)

    def create_prometheus_cluster_with_options(
        self,
        request: cms_20240330_models.CreatePrometheusClusterRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreatePrometheusClusterResponse:
        """
        @summary 创建Prometheus集群实例
        
        @param request: CreatePrometheusClusterRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreatePrometheusClusterResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.auth_free_write_policy):
            body['authFreeWritePolicy'] = request.auth_free_write_policy
        if not UtilClient.is_unset(request.enable_auth_free_write):
            body['enableAuthFreeWrite'] = request.enable_auth_free_write
        if not UtilClient.is_unset(request.hash_label_key):
            body['hashLabelKey'] = request.hash_label_key
        if not UtilClient.is_unset(request.payment_type):
            body['paymentType'] = request.payment_type
        if not UtilClient.is_unset(request.prometheus_cluster_name):
            body['prometheusClusterName'] = request.prometheus_cluster_name
        if not UtilClient.is_unset(request.replicas):
            body['replicas'] = request.replicas
        if not UtilClient.is_unset(request.resource_group_id):
            body['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.storage_duration):
            body['storageDuration'] = request.storage_duration
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreatePrometheusCluster',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-clusters',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreatePrometheusClusterResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_prometheus_cluster_with_options_async(
        self,
        request: cms_20240330_models.CreatePrometheusClusterRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreatePrometheusClusterResponse:
        """
        @summary 创建Prometheus集群实例
        
        @param request: CreatePrometheusClusterRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreatePrometheusClusterResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.auth_free_write_policy):
            body['authFreeWritePolicy'] = request.auth_free_write_policy
        if not UtilClient.is_unset(request.enable_auth_free_write):
            body['enableAuthFreeWrite'] = request.enable_auth_free_write
        if not UtilClient.is_unset(request.hash_label_key):
            body['hashLabelKey'] = request.hash_label_key
        if not UtilClient.is_unset(request.payment_type):
            body['paymentType'] = request.payment_type
        if not UtilClient.is_unset(request.prometheus_cluster_name):
            body['prometheusClusterName'] = request.prometheus_cluster_name
        if not UtilClient.is_unset(request.replicas):
            body['replicas'] = request.replicas
        if not UtilClient.is_unset(request.resource_group_id):
            body['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.storage_duration):
            body['storageDuration'] = request.storage_duration
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreatePrometheusCluster',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-clusters',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreatePrometheusClusterResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_prometheus_cluster(
        self,
        request: cms_20240330_models.CreatePrometheusClusterRequest,
    ) -> cms_20240330_models.CreatePrometheusClusterResponse:
        """
        @summary 创建Prometheus集群实例
        
        @param request: CreatePrometheusClusterRequest
        @return: CreatePrometheusClusterResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_prometheus_cluster_with_options(request, headers, runtime)

    async def create_prometheus_cluster_async(
        self,
        request: cms_20240330_models.CreatePrometheusClusterRequest,
    ) -> cms_20240330_models.CreatePrometheusClusterResponse:
        """
        @summary 创建Prometheus集群实例
        
        @param request: CreatePrometheusClusterRequest
        @return: CreatePrometheusClusterResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_prometheus_cluster_with_options_async(request, headers, runtime)

    def create_prometheus_instance_with_options(
        self,
        request: cms_20240330_models.CreatePrometheusInstanceRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreatePrometheusInstanceResponse:
        """
        @summary Create a Prometheus monitoring instance
        
        @param request: CreatePrometheusInstanceRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreatePrometheusInstanceResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.archive_duration):
            body['archiveDuration'] = request.archive_duration
        if not UtilClient.is_unset(request.auth_free_read_policy):
            body['authFreeReadPolicy'] = request.auth_free_read_policy
        if not UtilClient.is_unset(request.auth_free_write_policy):
            body['authFreeWritePolicy'] = request.auth_free_write_policy
        if not UtilClient.is_unset(request.basic_metric_query_limit):
            body['basicMetricQueryLimit'] = request.basic_metric_query_limit
        if not UtilClient.is_unset(request.enable_auth_free_read):
            body['enableAuthFreeRead'] = request.enable_auth_free_read
        if not UtilClient.is_unset(request.enable_auth_free_write):
            body['enableAuthFreeWrite'] = request.enable_auth_free_write
        if not UtilClient.is_unset(request.enable_auth_token):
            body['enableAuthToken'] = request.enable_auth_token
        if not UtilClient.is_unset(request.payment_type):
            body['paymentType'] = request.payment_type
        if not UtilClient.is_unset(request.prometheus_instance_name):
            body['prometheusInstanceName'] = request.prometheus_instance_name
        if not UtilClient.is_unset(request.resource_group_id):
            body['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.status):
            body['status'] = request.status
        if not UtilClient.is_unset(request.storage_duration):
            body['storageDuration'] = request.storage_duration
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        if not UtilClient.is_unset(request.workspace):
            body['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreatePrometheusInstance',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreatePrometheusInstanceResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_prometheus_instance_with_options_async(
        self,
        request: cms_20240330_models.CreatePrometheusInstanceRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreatePrometheusInstanceResponse:
        """
        @summary Create a Prometheus monitoring instance
        
        @param request: CreatePrometheusInstanceRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreatePrometheusInstanceResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.archive_duration):
            body['archiveDuration'] = request.archive_duration
        if not UtilClient.is_unset(request.auth_free_read_policy):
            body['authFreeReadPolicy'] = request.auth_free_read_policy
        if not UtilClient.is_unset(request.auth_free_write_policy):
            body['authFreeWritePolicy'] = request.auth_free_write_policy
        if not UtilClient.is_unset(request.basic_metric_query_limit):
            body['basicMetricQueryLimit'] = request.basic_metric_query_limit
        if not UtilClient.is_unset(request.enable_auth_free_read):
            body['enableAuthFreeRead'] = request.enable_auth_free_read
        if not UtilClient.is_unset(request.enable_auth_free_write):
            body['enableAuthFreeWrite'] = request.enable_auth_free_write
        if not UtilClient.is_unset(request.enable_auth_token):
            body['enableAuthToken'] = request.enable_auth_token
        if not UtilClient.is_unset(request.payment_type):
            body['paymentType'] = request.payment_type
        if not UtilClient.is_unset(request.prometheus_instance_name):
            body['prometheusInstanceName'] = request.prometheus_instance_name
        if not UtilClient.is_unset(request.resource_group_id):
            body['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.status):
            body['status'] = request.status
        if not UtilClient.is_unset(request.storage_duration):
            body['storageDuration'] = request.storage_duration
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        if not UtilClient.is_unset(request.workspace):
            body['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreatePrometheusInstance',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreatePrometheusInstanceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_prometheus_instance(
        self,
        request: cms_20240330_models.CreatePrometheusInstanceRequest,
    ) -> cms_20240330_models.CreatePrometheusInstanceResponse:
        """
        @summary Create a Prometheus monitoring instance
        
        @param request: CreatePrometheusInstanceRequest
        @return: CreatePrometheusInstanceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_prometheus_instance_with_options(request, headers, runtime)

    async def create_prometheus_instance_async(
        self,
        request: cms_20240330_models.CreatePrometheusInstanceRequest,
    ) -> cms_20240330_models.CreatePrometheusInstanceResponse:
        """
        @summary Create a Prometheus monitoring instance
        
        @param request: CreatePrometheusInstanceRequest
        @return: CreatePrometheusInstanceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_prometheus_instance_with_options_async(request, headers, runtime)

    def create_prometheus_view_with_options(
        self,
        request: cms_20240330_models.CreatePrometheusViewRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreatePrometheusViewResponse:
        """
        @summary Create Prometheus View
        
        @description Used to create a site monitoring task
        
        @param request: CreatePrometheusViewRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreatePrometheusViewResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.auth_free_read_policy):
            body['authFreeReadPolicy'] = request.auth_free_read_policy
        if not UtilClient.is_unset(request.enable_auth_free_read):
            body['enableAuthFreeRead'] = request.enable_auth_free_read
        if not UtilClient.is_unset(request.enable_auth_token):
            body['enableAuthToken'] = request.enable_auth_token
        if not UtilClient.is_unset(request.prometheus_instances):
            body['prometheusInstances'] = request.prometheus_instances
        if not UtilClient.is_unset(request.prometheus_view_name):
            body['prometheusViewName'] = request.prometheus_view_name
        if not UtilClient.is_unset(request.resource_group_id):
            body['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.status):
            body['status'] = request.status
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        if not UtilClient.is_unset(request.version):
            body['version'] = request.version
        if not UtilClient.is_unset(request.workspace):
            body['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreatePrometheusView',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-views',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreatePrometheusViewResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_prometheus_view_with_options_async(
        self,
        request: cms_20240330_models.CreatePrometheusViewRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreatePrometheusViewResponse:
        """
        @summary Create Prometheus View
        
        @description Used to create a site monitoring task
        
        @param request: CreatePrometheusViewRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreatePrometheusViewResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.auth_free_read_policy):
            body['authFreeReadPolicy'] = request.auth_free_read_policy
        if not UtilClient.is_unset(request.enable_auth_free_read):
            body['enableAuthFreeRead'] = request.enable_auth_free_read
        if not UtilClient.is_unset(request.enable_auth_token):
            body['enableAuthToken'] = request.enable_auth_token
        if not UtilClient.is_unset(request.prometheus_instances):
            body['prometheusInstances'] = request.prometheus_instances
        if not UtilClient.is_unset(request.prometheus_view_name):
            body['prometheusViewName'] = request.prometheus_view_name
        if not UtilClient.is_unset(request.resource_group_id):
            body['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.status):
            body['status'] = request.status
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        if not UtilClient.is_unset(request.version):
            body['version'] = request.version
        if not UtilClient.is_unset(request.workspace):
            body['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreatePrometheusView',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-views',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreatePrometheusViewResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_prometheus_view(
        self,
        request: cms_20240330_models.CreatePrometheusViewRequest,
    ) -> cms_20240330_models.CreatePrometheusViewResponse:
        """
        @summary Create Prometheus View
        
        @description Used to create a site monitoring task
        
        @param request: CreatePrometheusViewRequest
        @return: CreatePrometheusViewResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_prometheus_view_with_options(request, headers, runtime)

    async def create_prometheus_view_async(
        self,
        request: cms_20240330_models.CreatePrometheusViewRequest,
    ) -> cms_20240330_models.CreatePrometheusViewResponse:
        """
        @summary Create Prometheus View
        
        @description Used to create a site monitoring task
        
        @param request: CreatePrometheusViewRequest
        @return: CreatePrometheusViewResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_prometheus_view_with_options_async(request, headers, runtime)

    def create_prometheus_virtual_instance_with_options(
        self,
        request: cms_20240330_models.CreatePrometheusVirtualInstanceRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreatePrometheusVirtualInstanceResponse:
        """
        @summary Create Prometheus Monitoring Instance
        
        @description Create a Prometheus monitoring virtual instance.
        
        @param request: CreatePrometheusVirtualInstanceRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreatePrometheusVirtualInstanceResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.namespace):
            body['namespace'] = request.namespace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreatePrometheusVirtualInstance',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/virtual-instances',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreatePrometheusVirtualInstanceResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_prometheus_virtual_instance_with_options_async(
        self,
        request: cms_20240330_models.CreatePrometheusVirtualInstanceRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreatePrometheusVirtualInstanceResponse:
        """
        @summary Create Prometheus Monitoring Instance
        
        @description Create a Prometheus monitoring virtual instance.
        
        @param request: CreatePrometheusVirtualInstanceRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreatePrometheusVirtualInstanceResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.namespace):
            body['namespace'] = request.namespace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreatePrometheusVirtualInstance',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/virtual-instances',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreatePrometheusVirtualInstanceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_prometheus_virtual_instance(
        self,
        request: cms_20240330_models.CreatePrometheusVirtualInstanceRequest,
    ) -> cms_20240330_models.CreatePrometheusVirtualInstanceResponse:
        """
        @summary Create Prometheus Monitoring Instance
        
        @description Create a Prometheus monitoring virtual instance.
        
        @param request: CreatePrometheusVirtualInstanceRequest
        @return: CreatePrometheusVirtualInstanceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_prometheus_virtual_instance_with_options(request, headers, runtime)

    async def create_prometheus_virtual_instance_async(
        self,
        request: cms_20240330_models.CreatePrometheusVirtualInstanceRequest,
    ) -> cms_20240330_models.CreatePrometheusVirtualInstanceResponse:
        """
        @summary Create Prometheus Monitoring Instance
        
        @description Create a Prometheus monitoring virtual instance.
        
        @param request: CreatePrometheusVirtualInstanceRequest
        @return: CreatePrometheusVirtualInstanceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_prometheus_virtual_instance_with_options_async(request, headers, runtime)

    def create_service_with_options(
        self,
        workspace: str,
        request: cms_20240330_models.CreateServiceRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateServiceResponse:
        """
        @summary Create Service
        
        @param request: CreateServiceRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateServiceResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.attributes):
            body['attributes'] = request.attributes
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.display_name):
            body['displayName'] = request.display_name
        if not UtilClient.is_unset(request.pid):
            body['pid'] = request.pid
        if not UtilClient.is_unset(request.resource_group_id):
            body['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.service_name):
            body['serviceName'] = request.service_name
        if not UtilClient.is_unset(request.service_status):
            body['serviceStatus'] = request.service_status
        if not UtilClient.is_unset(request.service_type):
            body['serviceType'] = request.service_type
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateService',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/service',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateServiceResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_service_with_options_async(
        self,
        workspace: str,
        request: cms_20240330_models.CreateServiceRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateServiceResponse:
        """
        @summary Create Service
        
        @param request: CreateServiceRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateServiceResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.attributes):
            body['attributes'] = request.attributes
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.display_name):
            body['displayName'] = request.display_name
        if not UtilClient.is_unset(request.pid):
            body['pid'] = request.pid
        if not UtilClient.is_unset(request.resource_group_id):
            body['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.service_name):
            body['serviceName'] = request.service_name
        if not UtilClient.is_unset(request.service_status):
            body['serviceStatus'] = request.service_status
        if not UtilClient.is_unset(request.service_type):
            body['serviceType'] = request.service_type
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateService',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/service',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateServiceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_service(
        self,
        workspace: str,
        request: cms_20240330_models.CreateServiceRequest,
    ) -> cms_20240330_models.CreateServiceResponse:
        """
        @summary Create Service
        
        @param request: CreateServiceRequest
        @return: CreateServiceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_service_with_options(workspace, request, headers, runtime)

    async def create_service_async(
        self,
        workspace: str,
        request: cms_20240330_models.CreateServiceRequest,
    ) -> cms_20240330_models.CreateServiceResponse:
        """
        @summary Create Service
        
        @param request: CreateServiceRequest
        @return: CreateServiceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_service_with_options_async(workspace, request, headers, runtime)

    def create_service_observability_with_options(
        self,
        workspace: str,
        type: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateServiceObservabilityResponse:
        """
        @summary 创建应用可观测实例
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateServiceObservabilityResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='CreateServiceObservability',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/service-observability/{OpenApiUtilClient.get_encode_param(type)}',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateServiceObservabilityResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_service_observability_with_options_async(
        self,
        workspace: str,
        type: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateServiceObservabilityResponse:
        """
        @summary 创建应用可观测实例
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateServiceObservabilityResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='CreateServiceObservability',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/service-observability/{OpenApiUtilClient.get_encode_param(type)}',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateServiceObservabilityResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_service_observability(
        self,
        workspace: str,
        type: str,
    ) -> cms_20240330_models.CreateServiceObservabilityResponse:
        """
        @summary 创建应用可观测实例
        
        @return: CreateServiceObservabilityResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_service_observability_with_options(workspace, type, headers, runtime)

    async def create_service_observability_async(
        self,
        workspace: str,
        type: str,
    ) -> cms_20240330_models.CreateServiceObservabilityResponse:
        """
        @summary 创建应用可观测实例
        
        @return: CreateServiceObservabilityResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_service_observability_with_options_async(workspace, type, headers, runtime)

    def create_service_task_with_options(
        self,
        workspace: str,
        service_id: str,
        request: cms_20240330_models.CreateServiceTaskRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateServiceTaskResponse:
        """
        @summary 创建ServiceTask
        
        @param request: CreateServiceTaskRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateServiceTaskResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.ip):
            body['ip'] = request.ip
        if not UtilClient.is_unset(request.type):
            body['type'] = request.type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateServiceTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/serviceTask/{OpenApiUtilClient.get_encode_param(workspace)}/{OpenApiUtilClient.get_encode_param(service_id)}/task',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateServiceTaskResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_service_task_with_options_async(
        self,
        workspace: str,
        service_id: str,
        request: cms_20240330_models.CreateServiceTaskRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateServiceTaskResponse:
        """
        @summary 创建ServiceTask
        
        @param request: CreateServiceTaskRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateServiceTaskResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.ip):
            body['ip'] = request.ip
        if not UtilClient.is_unset(request.type):
            body['type'] = request.type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateServiceTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/serviceTask/{OpenApiUtilClient.get_encode_param(workspace)}/{OpenApiUtilClient.get_encode_param(service_id)}/task',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateServiceTaskResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_service_task(
        self,
        workspace: str,
        service_id: str,
        request: cms_20240330_models.CreateServiceTaskRequest,
    ) -> cms_20240330_models.CreateServiceTaskResponse:
        """
        @summary 创建ServiceTask
        
        @param request: CreateServiceTaskRequest
        @return: CreateServiceTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_service_task_with_options(workspace, service_id, request, headers, runtime)

    async def create_service_task_async(
        self,
        workspace: str,
        service_id: str,
        request: cms_20240330_models.CreateServiceTaskRequest,
    ) -> cms_20240330_models.CreateServiceTaskResponse:
        """
        @summary 创建ServiceTask
        
        @param request: CreateServiceTaskRequest
        @return: CreateServiceTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_service_task_with_options_async(workspace, service_id, request, headers, runtime)

    def create_site_monitor_with_options(
        self,
        request: cms_20240330_models.CreateSiteMonitorRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateSiteMonitorResponse:
        """
        @summary 创建SiteMonitor
        
        @param request: CreateSiteMonitorRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateSiteMonitorResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        body = {}
        if not UtilClient.is_unset(request.address):
            body['address'] = request.address
        if not UtilClient.is_unset(request.agent_group):
            body['agentGroup'] = request.agent_group
        if not UtilClient.is_unset(request.custom_schedule):
            body['customSchedule'] = request.custom_schedule
        if not UtilClient.is_unset(request.interval):
            body['interval'] = request.interval
        if not UtilClient.is_unset(request.interval_unit):
            body['intervalUnit'] = request.interval_unit
        if not UtilClient.is_unset(request.isp_cities):
            body['ispCities'] = request.isp_cities
        if not UtilClient.is_unset(request.option):
            body['option'] = request.option
        if not UtilClient.is_unset(request.task_labels):
            body['taskLabels'] = request.task_labels
        if not UtilClient.is_unset(request.task_name):
            body['taskName'] = request.task_name
        if not UtilClient.is_unset(request.task_type):
            body['taskType'] = request.task_type
        if not UtilClient.is_unset(request.vpc_config):
            body['vpcConfig'] = request.vpc_config
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateSiteMonitor',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/sitemonitor',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateSiteMonitorResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_site_monitor_with_options_async(
        self,
        request: cms_20240330_models.CreateSiteMonitorRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateSiteMonitorResponse:
        """
        @summary 创建SiteMonitor
        
        @param request: CreateSiteMonitorRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateSiteMonitorResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        body = {}
        if not UtilClient.is_unset(request.address):
            body['address'] = request.address
        if not UtilClient.is_unset(request.agent_group):
            body['agentGroup'] = request.agent_group
        if not UtilClient.is_unset(request.custom_schedule):
            body['customSchedule'] = request.custom_schedule
        if not UtilClient.is_unset(request.interval):
            body['interval'] = request.interval
        if not UtilClient.is_unset(request.interval_unit):
            body['intervalUnit'] = request.interval_unit
        if not UtilClient.is_unset(request.isp_cities):
            body['ispCities'] = request.isp_cities
        if not UtilClient.is_unset(request.option):
            body['option'] = request.option
        if not UtilClient.is_unset(request.task_labels):
            body['taskLabels'] = request.task_labels
        if not UtilClient.is_unset(request.task_name):
            body['taskName'] = request.task_name
        if not UtilClient.is_unset(request.task_type):
            body['taskType'] = request.task_type
        if not UtilClient.is_unset(request.vpc_config):
            body['vpcConfig'] = request.vpc_config
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateSiteMonitor',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/sitemonitor',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateSiteMonitorResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_site_monitor(
        self,
        request: cms_20240330_models.CreateSiteMonitorRequest,
    ) -> cms_20240330_models.CreateSiteMonitorResponse:
        """
        @summary 创建SiteMonitor
        
        @param request: CreateSiteMonitorRequest
        @return: CreateSiteMonitorResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_site_monitor_with_options(request, headers, runtime)

    async def create_site_monitor_async(
        self,
        request: cms_20240330_models.CreateSiteMonitorRequest,
    ) -> cms_20240330_models.CreateSiteMonitorResponse:
        """
        @summary 创建SiteMonitor
        
        @param request: CreateSiteMonitorRequest
        @return: CreateSiteMonitorResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_site_monitor_with_options_async(request, headers, runtime)

    def create_subscription_with_options(
        self,
        request: cms_20240330_models.CreateSubscriptionRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateSubscriptionResponse:
        """
        @summary 创建订阅
        
        @param request: CreateSubscriptionRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateSubscriptionResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='CreateSubscription',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/subscriptions',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateSubscriptionResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_subscription_with_options_async(
        self,
        request: cms_20240330_models.CreateSubscriptionRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateSubscriptionResponse:
        """
        @summary 创建订阅
        
        @param request: CreateSubscriptionRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateSubscriptionResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='CreateSubscription',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/subscriptions',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateSubscriptionResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_subscription(
        self,
        request: cms_20240330_models.CreateSubscriptionRequest,
    ) -> cms_20240330_models.CreateSubscriptionResponse:
        """
        @summary 创建订阅
        
        @param request: CreateSubscriptionRequest
        @return: CreateSubscriptionResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_subscription_with_options(request, headers, runtime)

    async def create_subscription_async(
        self,
        request: cms_20240330_models.CreateSubscriptionRequest,
    ) -> cms_20240330_models.CreateSubscriptionResponse:
        """
        @summary 创建订阅
        
        @param request: CreateSubscriptionRequest
        @return: CreateSubscriptionResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_subscription_with_options_async(request, headers, runtime)

    def create_thread_with_options(
        self,
        name: str,
        request: cms_20240330_models.CreateThreadRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateThreadResponse:
        """
        @summary 创建会话
        
        @param request: CreateThreadRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateThreadResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.title):
            body['title'] = request.title
        if not UtilClient.is_unset(request.variables):
            body['variables'] = request.variables
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateThread',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/thread',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateThreadResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_thread_with_options_async(
        self,
        name: str,
        request: cms_20240330_models.CreateThreadRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateThreadResponse:
        """
        @summary 创建会话
        
        @param request: CreateThreadRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateThreadResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.title):
            body['title'] = request.title
        if not UtilClient.is_unset(request.variables):
            body['variables'] = request.variables
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateThread',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/thread',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateThreadResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_thread(
        self,
        name: str,
        request: cms_20240330_models.CreateThreadRequest,
    ) -> cms_20240330_models.CreateThreadResponse:
        """
        @summary 创建会话
        
        @param request: CreateThreadRequest
        @return: CreateThreadResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_thread_with_options(name, request, headers, runtime)

    async def create_thread_async(
        self,
        name: str,
        request: cms_20240330_models.CreateThreadRequest,
    ) -> cms_20240330_models.CreateThreadResponse:
        """
        @summary 创建会话
        
        @param request: CreateThreadRequest
        @return: CreateThreadResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_thread_with_options_async(name, request, headers, runtime)

    def create_ticket_with_options(
        self,
        request: cms_20240330_models.CreateTicketRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateTicketResponse:
        """
        @summary Create Ticket
        
        @param request: CreateTicketRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateTicketResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.access_token_expiration_time):
            query['accessTokenExpirationTime'] = request.access_token_expiration_time
        if not UtilClient.is_unset(request.expiration_time):
            query['expirationTime'] = request.expiration_time
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='CreateTicket',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/tickets',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateTicketResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_ticket_with_options_async(
        self,
        request: cms_20240330_models.CreateTicketRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateTicketResponse:
        """
        @summary Create Ticket
        
        @param request: CreateTicketRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateTicketResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.access_token_expiration_time):
            query['accessTokenExpirationTime'] = request.access_token_expiration_time
        if not UtilClient.is_unset(request.expiration_time):
            query['expirationTime'] = request.expiration_time
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='CreateTicket',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/tickets',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateTicketResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_ticket(
        self,
        request: cms_20240330_models.CreateTicketRequest,
    ) -> cms_20240330_models.CreateTicketResponse:
        """
        @summary Create Ticket
        
        @param request: CreateTicketRequest
        @return: CreateTicketResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_ticket_with_options(request, headers, runtime)

    async def create_ticket_async(
        self,
        request: cms_20240330_models.CreateTicketRequest,
    ) -> cms_20240330_models.CreateTicketResponse:
        """
        @summary Create Ticket
        
        @param request: CreateTicketRequest
        @return: CreateTicketResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_ticket_with_options_async(request, headers, runtime)

    def create_transformer_with_options(
        self,
        request: cms_20240330_models.CreateTransformerRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateTransformerResponse:
        """
        @summary 创建订阅
        
        @param request: CreateTransformerRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateTransformerResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='CreateTransformer',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/transformers',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateTransformerResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_transformer_with_options_async(
        self,
        request: cms_20240330_models.CreateTransformerRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateTransformerResponse:
        """
        @summary 创建订阅
        
        @param request: CreateTransformerRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateTransformerResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='CreateTransformer',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/transformers',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateTransformerResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_transformer(
        self,
        request: cms_20240330_models.CreateTransformerRequest,
    ) -> cms_20240330_models.CreateTransformerResponse:
        """
        @summary 创建订阅
        
        @param request: CreateTransformerRequest
        @return: CreateTransformerResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.create_transformer_with_options(request, headers, runtime)

    async def create_transformer_async(
        self,
        request: cms_20240330_models.CreateTransformerRequest,
    ) -> cms_20240330_models.CreateTransformerResponse:
        """
        @summary 创建订阅
        
        @param request: CreateTransformerRequest
        @return: CreateTransformerResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.create_transformer_with_options_async(request, headers, runtime)

    def create_umodel_with_options(
        self,
        workspace: str,
        request: cms_20240330_models.CreateUmodelRequest,
        headers: cms_20240330_models.CreateUmodelHeaders,
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateUmodelResponse:
        """
        @summary Create Umodel configuration
        
        @description Create Umodel configuration in the specified workspace
        
        @param request: CreateUmodelRequest
        @param headers: CreateUmodelHeaders
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateUmodelResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        real_headers = {}
        if not UtilClient.is_unset(headers.common_headers):
            real_headers = headers.common_headers
        if not UtilClient.is_unset(headers.log_version):
            real_headers['logVersion'] = UtilClient.to_jsonstring(headers.log_version)
        req = open_api_models.OpenApiRequest(
            headers=real_headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateUmodel',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/umodel',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateUmodelResponse(),
            self.call_api(params, req, runtime)
        )

    async def create_umodel_with_options_async(
        self,
        workspace: str,
        request: cms_20240330_models.CreateUmodelRequest,
        headers: cms_20240330_models.CreateUmodelHeaders,
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.CreateUmodelResponse:
        """
        @summary Create Umodel configuration
        
        @description Create Umodel configuration in the specified workspace
        
        @param request: CreateUmodelRequest
        @param headers: CreateUmodelHeaders
        @param runtime: runtime options for this request RuntimeOptions
        @return: CreateUmodelResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        real_headers = {}
        if not UtilClient.is_unset(headers.common_headers):
            real_headers = headers.common_headers
        if not UtilClient.is_unset(headers.log_version):
            real_headers['logVersion'] = UtilClient.to_jsonstring(headers.log_version)
        req = open_api_models.OpenApiRequest(
            headers=real_headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='CreateUmodel',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/umodel',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.CreateUmodelResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def create_umodel(
        self,
        workspace: str,
        request: cms_20240330_models.CreateUmodelRequest,
    ) -> cms_20240330_models.CreateUmodelResponse:
        """
        @summary Create Umodel configuration
        
        @description Create Umodel configuration in the specified workspace
        
        @param request: CreateUmodelRequest
        @return: CreateUmodelResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = cms_20240330_models.CreateUmodelHeaders()
        return self.create_umodel_with_options(workspace, request, headers, runtime)

    async def create_umodel_async(
        self,
        workspace: str,
        request: cms_20240330_models.CreateUmodelRequest,
    ) -> cms_20240330_models.CreateUmodelResponse:
        """
        @summary Create Umodel configuration
        
        @description Create Umodel configuration in the specified workspace
        
        @param request: CreateUmodelRequest
        @return: CreateUmodelResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = cms_20240330_models.CreateUmodelHeaders()
        return await self.create_umodel_with_options_async(workspace, request, headers, runtime)

    def delete_addon_release_with_options(
        self,
        policy_id: str,
        request: cms_20240330_models.DeleteAddonReleaseRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteAddonReleaseResponse:
        """
        @summary Delete addon release information
        
        @param request: DeleteAddonReleaseRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteAddonReleaseResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.addon_name):
            query['addonName'] = request.addon_name
        if not UtilClient.is_unset(request.force):
            query['force'] = request.force
        if not UtilClient.is_unset(request.release_name):
            query['releaseName'] = request.release_name
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteAddonRelease',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/addon-releases',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteAddonReleaseResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_addon_release_with_options_async(
        self,
        policy_id: str,
        request: cms_20240330_models.DeleteAddonReleaseRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteAddonReleaseResponse:
        """
        @summary Delete addon release information
        
        @param request: DeleteAddonReleaseRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteAddonReleaseResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.addon_name):
            query['addonName'] = request.addon_name
        if not UtilClient.is_unset(request.force):
            query['force'] = request.force
        if not UtilClient.is_unset(request.release_name):
            query['releaseName'] = request.release_name
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteAddonRelease',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/addon-releases',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteAddonReleaseResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_addon_release(
        self,
        policy_id: str,
        request: cms_20240330_models.DeleteAddonReleaseRequest,
    ) -> cms_20240330_models.DeleteAddonReleaseResponse:
        """
        @summary Delete addon release information
        
        @param request: DeleteAddonReleaseRequest
        @return: DeleteAddonReleaseResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_addon_release_with_options(policy_id, request, headers, runtime)

    async def delete_addon_release_async(
        self,
        policy_id: str,
        request: cms_20240330_models.DeleteAddonReleaseRequest,
    ) -> cms_20240330_models.DeleteAddonReleaseResponse:
        """
        @summary Delete addon release information
        
        @param request: DeleteAddonReleaseRequest
        @return: DeleteAddonReleaseResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_addon_release_with_options_async(policy_id, request, headers, runtime)

    def delete_agg_task_group_with_options(
        self,
        instance_id: str,
        group_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteAggTaskGroupResponse:
        """
        @summary Delete Aggregation Task Group
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteAggTaskGroupResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteAggTaskGroup',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(instance_id)}/agg-task-groups/{OpenApiUtilClient.get_encode_param(group_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteAggTaskGroupResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_agg_task_group_with_options_async(
        self,
        instance_id: str,
        group_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteAggTaskGroupResponse:
        """
        @summary Delete Aggregation Task Group
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteAggTaskGroupResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteAggTaskGroup',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(instance_id)}/agg-task-groups/{OpenApiUtilClient.get_encode_param(group_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteAggTaskGroupResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_agg_task_group(
        self,
        instance_id: str,
        group_id: str,
    ) -> cms_20240330_models.DeleteAggTaskGroupResponse:
        """
        @summary Delete Aggregation Task Group
        
        @return: DeleteAggTaskGroupResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_agg_task_group_with_options(instance_id, group_id, headers, runtime)

    async def delete_agg_task_group_async(
        self,
        instance_id: str,
        group_id: str,
    ) -> cms_20240330_models.DeleteAggTaskGroupResponse:
        """
        @summary Delete Aggregation Task Group
        
        @return: DeleteAggTaskGroupResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_agg_task_group_with_options_async(instance_id, group_id, headers, runtime)

    def delete_alert_actions_with_options(
        self,
        tmp_req: cms_20240330_models.DeleteAlertActionsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteAlertActionsResponse:
        """
        @summary 删除告警动作
        
        @param tmp_req: DeleteAlertActionsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteAlertActionsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.DeleteAlertActionsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.alert_action_ids):
            request.alert_action_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.alert_action_ids, 'alertActionIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_action_ids_shrink):
            query['alertActionIds'] = request.alert_action_ids_shrink
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteAlertActions',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertActions',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteAlertActionsResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_alert_actions_with_options_async(
        self,
        tmp_req: cms_20240330_models.DeleteAlertActionsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteAlertActionsResponse:
        """
        @summary 删除告警动作
        
        @param tmp_req: DeleteAlertActionsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteAlertActionsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.DeleteAlertActionsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.alert_action_ids):
            request.alert_action_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.alert_action_ids, 'alertActionIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_action_ids_shrink):
            query['alertActionIds'] = request.alert_action_ids_shrink
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteAlertActions',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertActions',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteAlertActionsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_alert_actions(
        self,
        request: cms_20240330_models.DeleteAlertActionsRequest,
    ) -> cms_20240330_models.DeleteAlertActionsResponse:
        """
        @summary 删除告警动作
        
        @param request: DeleteAlertActionsRequest
        @return: DeleteAlertActionsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_alert_actions_with_options(request, headers, runtime)

    async def delete_alert_actions_async(
        self,
        request: cms_20240330_models.DeleteAlertActionsRequest,
    ) -> cms_20240330_models.DeleteAlertActionsResponse:
        """
        @summary 删除告警动作
        
        @param request: DeleteAlertActionsRequest
        @return: DeleteAlertActionsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_alert_actions_with_options_async(request, headers, runtime)

    def delete_alert_event_integration_policy_with_options(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.DeleteAlertEventIntegrationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteAlertEventIntegrationPolicyResponse:
        """
        @summary 删除集成
        
        @param request: DeleteAlertEventIntegrationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteAlertEventIntegrationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteAlertEventIntegrationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertEventIntegrationPolicies/{OpenApiUtilClient.get_encode_param(alert_event_integration_policy_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteAlertEventIntegrationPolicyResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_alert_event_integration_policy_with_options_async(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.DeleteAlertEventIntegrationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteAlertEventIntegrationPolicyResponse:
        """
        @summary 删除集成
        
        @param request: DeleteAlertEventIntegrationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteAlertEventIntegrationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteAlertEventIntegrationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertEventIntegrationPolicies/{OpenApiUtilClient.get_encode_param(alert_event_integration_policy_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteAlertEventIntegrationPolicyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_alert_event_integration_policy(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.DeleteAlertEventIntegrationPolicyRequest,
    ) -> cms_20240330_models.DeleteAlertEventIntegrationPolicyResponse:
        """
        @summary 删除集成
        
        @param request: DeleteAlertEventIntegrationPolicyRequest
        @return: DeleteAlertEventIntegrationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_alert_event_integration_policy_with_options(alert_event_integration_policy_id, request, headers, runtime)

    async def delete_alert_event_integration_policy_async(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.DeleteAlertEventIntegrationPolicyRequest,
    ) -> cms_20240330_models.DeleteAlertEventIntegrationPolicyResponse:
        """
        @summary 删除集成
        
        @param request: DeleteAlertEventIntegrationPolicyRequest
        @return: DeleteAlertEventIntegrationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_alert_event_integration_policy_with_options_async(alert_event_integration_policy_id, request, headers, runtime)

    def delete_alert_notify_templates_with_options(
        self,
        tmp_req: cms_20240330_models.DeleteAlertNotifyTemplatesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteAlertNotifyTemplatesResponse:
        """
        @summary 删除报警通知模板
        
        @param tmp_req: DeleteAlertNotifyTemplatesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteAlertNotifyTemplatesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.DeleteAlertNotifyTemplatesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.alert_notify_template_ids):
            request.alert_notify_template_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.alert_notify_template_ids, 'alertNotifyTemplateIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_notify_template_ids_shrink):
            query['alertNotifyTemplateIds'] = request.alert_notify_template_ids_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteAlertNotifyTemplates',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertNotifyTemplates',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteAlertNotifyTemplatesResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_alert_notify_templates_with_options_async(
        self,
        tmp_req: cms_20240330_models.DeleteAlertNotifyTemplatesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteAlertNotifyTemplatesResponse:
        """
        @summary 删除报警通知模板
        
        @param tmp_req: DeleteAlertNotifyTemplatesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteAlertNotifyTemplatesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.DeleteAlertNotifyTemplatesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.alert_notify_template_ids):
            request.alert_notify_template_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.alert_notify_template_ids, 'alertNotifyTemplateIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_notify_template_ids_shrink):
            query['alertNotifyTemplateIds'] = request.alert_notify_template_ids_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteAlertNotifyTemplates',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertNotifyTemplates',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteAlertNotifyTemplatesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_alert_notify_templates(
        self,
        request: cms_20240330_models.DeleteAlertNotifyTemplatesRequest,
    ) -> cms_20240330_models.DeleteAlertNotifyTemplatesResponse:
        """
        @summary 删除报警通知模板
        
        @param request: DeleteAlertNotifyTemplatesRequest
        @return: DeleteAlertNotifyTemplatesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_alert_notify_templates_with_options(request, headers, runtime)

    async def delete_alert_notify_templates_async(
        self,
        request: cms_20240330_models.DeleteAlertNotifyTemplatesRequest,
    ) -> cms_20240330_models.DeleteAlertNotifyTemplatesResponse:
        """
        @summary 删除报警通知模板
        
        @param request: DeleteAlertNotifyTemplatesRequest
        @return: DeleteAlertNotifyTemplatesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_alert_notify_templates_with_options_async(request, headers, runtime)

    def delete_alert_robots_with_options(
        self,
        tmp_req: cms_20240330_models.DeleteAlertRobotsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteAlertRobotsResponse:
        """
        @summary 删除机器人
        
        @param tmp_req: DeleteAlertRobotsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteAlertRobotsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.DeleteAlertRobotsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.robot_ids):
            request.robot_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.robot_ids, 'robotIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.is_custom):
            query['isCustom'] = request.is_custom
        if not UtilClient.is_unset(request.robot_ids_shrink):
            query['robotIds'] = request.robot_ids_shrink
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        if not UtilClient.is_unset(request.type):
            query['type'] = request.type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteAlertRobots',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/robots',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteAlertRobotsResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_alert_robots_with_options_async(
        self,
        tmp_req: cms_20240330_models.DeleteAlertRobotsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteAlertRobotsResponse:
        """
        @summary 删除机器人
        
        @param tmp_req: DeleteAlertRobotsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteAlertRobotsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.DeleteAlertRobotsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.robot_ids):
            request.robot_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.robot_ids, 'robotIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.is_custom):
            query['isCustom'] = request.is_custom
        if not UtilClient.is_unset(request.robot_ids_shrink):
            query['robotIds'] = request.robot_ids_shrink
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        if not UtilClient.is_unset(request.type):
            query['type'] = request.type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteAlertRobots',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/robots',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteAlertRobotsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_alert_robots(
        self,
        request: cms_20240330_models.DeleteAlertRobotsRequest,
    ) -> cms_20240330_models.DeleteAlertRobotsResponse:
        """
        @summary 删除机器人
        
        @param request: DeleteAlertRobotsRequest
        @return: DeleteAlertRobotsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_alert_robots_with_options(request, headers, runtime)

    async def delete_alert_robots_async(
        self,
        request: cms_20240330_models.DeleteAlertRobotsRequest,
    ) -> cms_20240330_models.DeleteAlertRobotsResponse:
        """
        @summary 删除机器人
        
        @param request: DeleteAlertRobotsRequest
        @return: DeleteAlertRobotsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_alert_robots_with_options_async(request, headers, runtime)

    def delete_alert_rules_with_options(
        self,
        tmp_req: cms_20240330_models.DeleteAlertRulesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteAlertRulesResponse:
        """
        @summary 删除云监控2.0告警规则
        
        @param tmp_req: DeleteAlertRulesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteAlertRulesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.DeleteAlertRulesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.alert_rule_ids):
            request.alert_rule_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.alert_rule_ids, 'alertRuleIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_rule_ids_shrink):
            query['alertRuleIds'] = request.alert_rule_ids_shrink
        if not UtilClient.is_unset(request.call_source):
            query['callSource'] = request.call_source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteAlertRules',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules/action/delete',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteAlertRulesResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_alert_rules_with_options_async(
        self,
        tmp_req: cms_20240330_models.DeleteAlertRulesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteAlertRulesResponse:
        """
        @summary 删除云监控2.0告警规则
        
        @param tmp_req: DeleteAlertRulesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteAlertRulesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.DeleteAlertRulesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.alert_rule_ids):
            request.alert_rule_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.alert_rule_ids, 'alertRuleIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_rule_ids_shrink):
            query['alertRuleIds'] = request.alert_rule_ids_shrink
        if not UtilClient.is_unset(request.call_source):
            query['callSource'] = request.call_source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteAlertRules',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules/action/delete',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteAlertRulesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_alert_rules(
        self,
        request: cms_20240330_models.DeleteAlertRulesRequest,
    ) -> cms_20240330_models.DeleteAlertRulesResponse:
        """
        @summary 删除云监控2.0告警规则
        
        @param request: DeleteAlertRulesRequest
        @return: DeleteAlertRulesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_alert_rules_with_options(request, headers, runtime)

    async def delete_alert_rules_async(
        self,
        request: cms_20240330_models.DeleteAlertRulesRequest,
    ) -> cms_20240330_models.DeleteAlertRulesResponse:
        """
        @summary 删除云监控2.0告警规则
        
        @param request: DeleteAlertRulesRequest
        @return: DeleteAlertRulesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_alert_rules_with_options_async(request, headers, runtime)

    def delete_alert_webhooks_with_options(
        self,
        tmp_req: cms_20240330_models.DeleteAlertWebhooksRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteAlertWebhooksResponse:
        """
        @summary 删除Webhook
        
        @param tmp_req: DeleteAlertWebhooksRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteAlertWebhooksResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.DeleteAlertWebhooksShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.webhook_ids):
            request.webhook_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.webhook_ids, 'webhookIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.is_custom):
            query['isCustom'] = request.is_custom
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        if not UtilClient.is_unset(request.webhook_ids_shrink):
            query['webhookIds'] = request.webhook_ids_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteAlertWebhooks',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/webhooks',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteAlertWebhooksResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_alert_webhooks_with_options_async(
        self,
        tmp_req: cms_20240330_models.DeleteAlertWebhooksRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteAlertWebhooksResponse:
        """
        @summary 删除Webhook
        
        @param tmp_req: DeleteAlertWebhooksRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteAlertWebhooksResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.DeleteAlertWebhooksShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.webhook_ids):
            request.webhook_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.webhook_ids, 'webhookIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.is_custom):
            query['isCustom'] = request.is_custom
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        if not UtilClient.is_unset(request.webhook_ids_shrink):
            query['webhookIds'] = request.webhook_ids_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteAlertWebhooks',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/webhooks',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteAlertWebhooksResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_alert_webhooks(
        self,
        request: cms_20240330_models.DeleteAlertWebhooksRequest,
    ) -> cms_20240330_models.DeleteAlertWebhooksResponse:
        """
        @summary 删除Webhook
        
        @param request: DeleteAlertWebhooksRequest
        @return: DeleteAlertWebhooksResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_alert_webhooks_with_options(request, headers, runtime)

    async def delete_alert_webhooks_async(
        self,
        request: cms_20240330_models.DeleteAlertWebhooksRequest,
    ) -> cms_20240330_models.DeleteAlertWebhooksResponse:
        """
        @summary 删除Webhook
        
        @param request: DeleteAlertWebhooksRequest
        @return: DeleteAlertWebhooksResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_alert_webhooks_with_options_async(request, headers, runtime)

    def delete_biz_trace_with_options(
        self,
        biz_trace_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteBizTraceResponse:
        """
        @summary 删除业务链路
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteBizTraceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteBizTrace',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/bizTrace/{OpenApiUtilClient.get_encode_param(biz_trace_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteBizTraceResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_biz_trace_with_options_async(
        self,
        biz_trace_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteBizTraceResponse:
        """
        @summary 删除业务链路
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteBizTraceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteBizTrace',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/bizTrace/{OpenApiUtilClient.get_encode_param(biz_trace_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteBizTraceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_biz_trace(
        self,
        biz_trace_id: str,
    ) -> cms_20240330_models.DeleteBizTraceResponse:
        """
        @summary 删除业务链路
        
        @return: DeleteBizTraceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_biz_trace_with_options(biz_trace_id, headers, runtime)

    async def delete_biz_trace_async(
        self,
        biz_trace_id: str,
    ) -> cms_20240330_models.DeleteBizTraceResponse:
        """
        @summary 删除业务链路
        
        @return: DeleteBizTraceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_biz_trace_with_options_async(biz_trace_id, headers, runtime)

    def delete_cloud_resource_with_options(
        self,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteCloudResourceResponse:
        """
        @summary 删除云资源中心
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteCloudResourceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteCloudResource',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/cloudresource',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteCloudResourceResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_cloud_resource_with_options_async(
        self,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteCloudResourceResponse:
        """
        @summary 删除云资源中心
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteCloudResourceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteCloudResource',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/cloudresource',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteCloudResourceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_cloud_resource(self) -> cms_20240330_models.DeleteCloudResourceResponse:
        """
        @summary 删除云资源中心
        
        @return: DeleteCloudResourceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_cloud_resource_with_options(headers, runtime)

    async def delete_cloud_resource_async(self) -> cms_20240330_models.DeleteCloudResourceResponse:
        """
        @summary 删除云资源中心
        
        @return: DeleteCloudResourceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_cloud_resource_with_options_async(headers, runtime)

    def delete_contact_groups_with_options(
        self,
        tmp_req: cms_20240330_models.DeleteContactGroupsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteContactGroupsResponse:
        """
        @summary 删除联系人组
        
        @param tmp_req: DeleteContactGroupsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteContactGroupsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.DeleteContactGroupsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.contact_group_ids):
            request.contact_group_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.contact_group_ids, 'contactGroupIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.contact_group_ids_shrink):
            query['contactGroupIds'] = request.contact_group_ids_shrink
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteContactGroups',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/contactGroups',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteContactGroupsResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_contact_groups_with_options_async(
        self,
        tmp_req: cms_20240330_models.DeleteContactGroupsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteContactGroupsResponse:
        """
        @summary 删除联系人组
        
        @param tmp_req: DeleteContactGroupsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteContactGroupsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.DeleteContactGroupsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.contact_group_ids):
            request.contact_group_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.contact_group_ids, 'contactGroupIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.contact_group_ids_shrink):
            query['contactGroupIds'] = request.contact_group_ids_shrink
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteContactGroups',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/contactGroups',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteContactGroupsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_contact_groups(
        self,
        request: cms_20240330_models.DeleteContactGroupsRequest,
    ) -> cms_20240330_models.DeleteContactGroupsResponse:
        """
        @summary 删除联系人组
        
        @param request: DeleteContactGroupsRequest
        @return: DeleteContactGroupsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_contact_groups_with_options(request, headers, runtime)

    async def delete_contact_groups_async(
        self,
        request: cms_20240330_models.DeleteContactGroupsRequest,
    ) -> cms_20240330_models.DeleteContactGroupsResponse:
        """
        @summary 删除联系人组
        
        @param request: DeleteContactGroupsRequest
        @return: DeleteContactGroupsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_contact_groups_with_options_async(request, headers, runtime)

    def delete_contacts_with_options(
        self,
        tmp_req: cms_20240330_models.DeleteContactsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteContactsResponse:
        """
        @summary 删除联系人
        
        @param tmp_req: DeleteContactsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteContactsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.DeleteContactsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.contact_ids):
            request.contact_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.contact_ids, 'contactIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.contact_ids_shrink):
            query['contactIds'] = request.contact_ids_shrink
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteContacts',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/contacts',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteContactsResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_contacts_with_options_async(
        self,
        tmp_req: cms_20240330_models.DeleteContactsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteContactsResponse:
        """
        @summary 删除联系人
        
        @param tmp_req: DeleteContactsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteContactsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.DeleteContactsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.contact_ids):
            request.contact_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.contact_ids, 'contactIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.contact_ids_shrink):
            query['contactIds'] = request.contact_ids_shrink
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteContacts',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/contacts',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteContactsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_contacts(
        self,
        request: cms_20240330_models.DeleteContactsRequest,
    ) -> cms_20240330_models.DeleteContactsResponse:
        """
        @summary 删除联系人
        
        @param request: DeleteContactsRequest
        @return: DeleteContactsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_contacts_with_options(request, headers, runtime)

    async def delete_contacts_async(
        self,
        request: cms_20240330_models.DeleteContactsRequest,
    ) -> cms_20240330_models.DeleteContactsResponse:
        """
        @summary 删除联系人
        
        @param request: DeleteContactsRequest
        @return: DeleteContactsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_contacts_with_options_async(request, headers, runtime)

    def delete_dataset_with_options(
        self,
        workspace: str,
        dataset_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteDatasetResponse:
        """
        @summary 删除数据集
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteDatasetResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteDataset',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/dataset/{OpenApiUtilClient.get_encode_param(dataset_name)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteDatasetResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_dataset_with_options_async(
        self,
        workspace: str,
        dataset_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteDatasetResponse:
        """
        @summary 删除数据集
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteDatasetResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteDataset',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/dataset/{OpenApiUtilClient.get_encode_param(dataset_name)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteDatasetResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_dataset(
        self,
        workspace: str,
        dataset_name: str,
    ) -> cms_20240330_models.DeleteDatasetResponse:
        """
        @summary 删除数据集
        
        @return: DeleteDatasetResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_dataset_with_options(workspace, dataset_name, headers, runtime)

    async def delete_dataset_async(
        self,
        workspace: str,
        dataset_name: str,
    ) -> cms_20240330_models.DeleteDatasetResponse:
        """
        @summary 删除数据集
        
        @return: DeleteDatasetResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_dataset_with_options_async(workspace, dataset_name, headers, runtime)

    def delete_delivery_task_with_options(
        self,
        task_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteDeliveryTaskResponse:
        """
        @summary 删除数据投递任务
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteDeliveryTaskResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteDeliveryTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/delivery-task/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteDeliveryTaskResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_delivery_task_with_options_async(
        self,
        task_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteDeliveryTaskResponse:
        """
        @summary 删除数据投递任务
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteDeliveryTaskResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteDeliveryTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/delivery-task/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteDeliveryTaskResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_delivery_task(
        self,
        task_id: str,
    ) -> cms_20240330_models.DeleteDeliveryTaskResponse:
        """
        @summary 删除数据投递任务
        
        @return: DeleteDeliveryTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_delivery_task_with_options(task_id, headers, runtime)

    async def delete_delivery_task_async(
        self,
        task_id: str,
    ) -> cms_20240330_models.DeleteDeliveryTaskResponse:
        """
        @summary 删除数据投递任务
        
        @return: DeleteDeliveryTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_delivery_task_with_options_async(task_id, headers, runtime)

    def delete_digital_employee_with_options(
        self,
        name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteDigitalEmployeeResponse:
        """
        @summary 删除DigitalEmployee
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteDigitalEmployeeResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteDigitalEmployee',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digital-employee/{OpenApiUtilClient.get_encode_param(name)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteDigitalEmployeeResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_digital_employee_with_options_async(
        self,
        name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteDigitalEmployeeResponse:
        """
        @summary 删除DigitalEmployee
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteDigitalEmployeeResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteDigitalEmployee',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digital-employee/{OpenApiUtilClient.get_encode_param(name)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteDigitalEmployeeResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_digital_employee(
        self,
        name: str,
    ) -> cms_20240330_models.DeleteDigitalEmployeeResponse:
        """
        @summary 删除DigitalEmployee
        
        @return: DeleteDigitalEmployeeResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_digital_employee_with_options(name, headers, runtime)

    async def delete_digital_employee_async(
        self,
        name: str,
    ) -> cms_20240330_models.DeleteDigitalEmployeeResponse:
        """
        @summary 删除DigitalEmployee
        
        @return: DeleteDigitalEmployeeResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_digital_employee_with_options_async(name, headers, runtime)

    def delete_digital_employee_skill_with_options(
        self,
        name: str,
        skill_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteDigitalEmployeeSkillResponse:
        """
        @summary 删除技能
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteDigitalEmployeeSkillResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteDigitalEmployeeSkill',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/skill/{OpenApiUtilClient.get_encode_param(skill_name)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteDigitalEmployeeSkillResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_digital_employee_skill_with_options_async(
        self,
        name: str,
        skill_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteDigitalEmployeeSkillResponse:
        """
        @summary 删除技能
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteDigitalEmployeeSkillResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteDigitalEmployeeSkill',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/skill/{OpenApiUtilClient.get_encode_param(skill_name)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteDigitalEmployeeSkillResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_digital_employee_skill(
        self,
        name: str,
        skill_name: str,
    ) -> cms_20240330_models.DeleteDigitalEmployeeSkillResponse:
        """
        @summary 删除技能
        
        @return: DeleteDigitalEmployeeSkillResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_digital_employee_skill_with_options(name, skill_name, headers, runtime)

    async def delete_digital_employee_skill_async(
        self,
        name: str,
        skill_name: str,
    ) -> cms_20240330_models.DeleteDigitalEmployeeSkillResponse:
        """
        @summary 删除技能
        
        @return: DeleteDigitalEmployeeSkillResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_digital_employee_skill_with_options_async(name, skill_name, headers, runtime)

    def delete_entity_store_with_options(
        self,
        workspace_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteEntityStoreResponse:
        """
        @summary Delete EntityStore related storage
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteEntityStoreResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteEntityStore',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace_name)}/entitystore',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteEntityStoreResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_entity_store_with_options_async(
        self,
        workspace_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteEntityStoreResponse:
        """
        @summary Delete EntityStore related storage
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteEntityStoreResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteEntityStore',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace_name)}/entitystore',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteEntityStoreResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_entity_store(
        self,
        workspace_name: str,
    ) -> cms_20240330_models.DeleteEntityStoreResponse:
        """
        @summary Delete EntityStore related storage
        
        @return: DeleteEntityStoreResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_entity_store_with_options(workspace_name, headers, runtime)

    async def delete_entity_store_async(
        self,
        workspace_name: str,
    ) -> cms_20240330_models.DeleteEntityStoreResponse:
        """
        @summary Delete EntityStore related storage
        
        @return: DeleteEntityStoreResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_entity_store_with_options_async(workspace_name, headers, runtime)

    def delete_escalation_policy_with_options(
        self,
        uuid: str,
        request: cms_20240330_models.DeleteEscalationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteEscalationPolicyResponse:
        """
        @summary 删除订阅
        
        @param request: DeleteEscalationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteEscalationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteEscalationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/escalationPolicies/{OpenApiUtilClient.get_encode_param(uuid)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteEscalationPolicyResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_escalation_policy_with_options_async(
        self,
        uuid: str,
        request: cms_20240330_models.DeleteEscalationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteEscalationPolicyResponse:
        """
        @summary 删除订阅
        
        @param request: DeleteEscalationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteEscalationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteEscalationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/escalationPolicies/{OpenApiUtilClient.get_encode_param(uuid)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteEscalationPolicyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_escalation_policy(
        self,
        uuid: str,
        request: cms_20240330_models.DeleteEscalationPolicyRequest,
    ) -> cms_20240330_models.DeleteEscalationPolicyResponse:
        """
        @summary 删除订阅
        
        @param request: DeleteEscalationPolicyRequest
        @return: DeleteEscalationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_escalation_policy_with_options(uuid, request, headers, runtime)

    async def delete_escalation_policy_async(
        self,
        uuid: str,
        request: cms_20240330_models.DeleteEscalationPolicyRequest,
    ) -> cms_20240330_models.DeleteEscalationPolicyResponse:
        """
        @summary 删除订阅
        
        @param request: DeleteEscalationPolicyRequest
        @return: DeleteEscalationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_escalation_policy_with_options_async(uuid, request, headers, runtime)

    def delete_evaluation_task_with_options(
        self,
        workspace: str,
        task_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteEvaluationTaskResponse:
        """
        @summary 删除评估任务
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteEvaluationTaskResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteEvaluationTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/evaluation-task/{OpenApiUtilClient.get_encode_param(workspace)}/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteEvaluationTaskResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_evaluation_task_with_options_async(
        self,
        workspace: str,
        task_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteEvaluationTaskResponse:
        """
        @summary 删除评估任务
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteEvaluationTaskResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteEvaluationTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/evaluation-task/{OpenApiUtilClient.get_encode_param(workspace)}/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteEvaluationTaskResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_evaluation_task(
        self,
        workspace: str,
        task_id: str,
    ) -> cms_20240330_models.DeleteEvaluationTaskResponse:
        """
        @summary 删除评估任务
        
        @return: DeleteEvaluationTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_evaluation_task_with_options(workspace, task_id, headers, runtime)

    async def delete_evaluation_task_async(
        self,
        workspace: str,
        task_id: str,
    ) -> cms_20240330_models.DeleteEvaluationTaskResponse:
        """
        @summary 删除评估任务
        
        @return: DeleteEvaluationTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_evaluation_task_with_options_async(workspace, task_id, headers, runtime)

    def delete_experiment_plan_with_options(
        self,
        workspace: str,
        plan_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteExperimentPlanResponse:
        """
        @summary 删除实验计划
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteExperimentPlanResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteExperimentPlan',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/experiments/{OpenApiUtilClient.get_encode_param(workspace)}/plans/{OpenApiUtilClient.get_encode_param(plan_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteExperimentPlanResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_experiment_plan_with_options_async(
        self,
        workspace: str,
        plan_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteExperimentPlanResponse:
        """
        @summary 删除实验计划
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteExperimentPlanResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteExperimentPlan',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/experiments/{OpenApiUtilClient.get_encode_param(workspace)}/plans/{OpenApiUtilClient.get_encode_param(plan_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteExperimentPlanResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_experiment_plan(
        self,
        workspace: str,
        plan_id: str,
    ) -> cms_20240330_models.DeleteExperimentPlanResponse:
        """
        @summary 删除实验计划
        
        @return: DeleteExperimentPlanResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_experiment_plan_with_options(workspace, plan_id, headers, runtime)

    async def delete_experiment_plan_async(
        self,
        workspace: str,
        plan_id: str,
    ) -> cms_20240330_models.DeleteExperimentPlanResponse:
        """
        @summary 删除实验计划
        
        @return: DeleteExperimentPlanResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_experiment_plan_with_options_async(workspace, plan_id, headers, runtime)

    def delete_integration_policy_with_options(
        self,
        policy_id: str,
        request: cms_20240330_models.DeleteIntegrationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteIntegrationPolicyResponse:
        """
        @summary Delete Access Center Policy
        
        @param request: DeleteIntegrationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteIntegrationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.force):
            query['force'] = request.force
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteIntegrationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteIntegrationPolicyResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_integration_policy_with_options_async(
        self,
        policy_id: str,
        request: cms_20240330_models.DeleteIntegrationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteIntegrationPolicyResponse:
        """
        @summary Delete Access Center Policy
        
        @param request: DeleteIntegrationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteIntegrationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.force):
            query['force'] = request.force
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteIntegrationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteIntegrationPolicyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_integration_policy(
        self,
        policy_id: str,
        request: cms_20240330_models.DeleteIntegrationPolicyRequest,
    ) -> cms_20240330_models.DeleteIntegrationPolicyResponse:
        """
        @summary Delete Access Center Policy
        
        @param request: DeleteIntegrationPolicyRequest
        @return: DeleteIntegrationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_integration_policy_with_options(policy_id, request, headers, runtime)

    async def delete_integration_policy_async(
        self,
        policy_id: str,
        request: cms_20240330_models.DeleteIntegrationPolicyRequest,
    ) -> cms_20240330_models.DeleteIntegrationPolicyResponse:
        """
        @summary Delete Access Center Policy
        
        @param request: DeleteIntegrationPolicyRequest
        @return: DeleteIntegrationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_integration_policy_with_options_async(policy_id, request, headers, runtime)

    def delete_maintain_window_with_options(
        self,
        maintain_window_id: str,
        request: cms_20240330_models.DeleteMaintainWindowRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteMaintainWindowResponse:
        """
        @summary 删除转换器
        
        @param request: DeleteMaintainWindowRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteMaintainWindowResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteMaintainWindow',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/maintainWindows/{OpenApiUtilClient.get_encode_param(maintain_window_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteMaintainWindowResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_maintain_window_with_options_async(
        self,
        maintain_window_id: str,
        request: cms_20240330_models.DeleteMaintainWindowRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteMaintainWindowResponse:
        """
        @summary 删除转换器
        
        @param request: DeleteMaintainWindowRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteMaintainWindowResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteMaintainWindow',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/maintainWindows/{OpenApiUtilClient.get_encode_param(maintain_window_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteMaintainWindowResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_maintain_window(
        self,
        maintain_window_id: str,
        request: cms_20240330_models.DeleteMaintainWindowRequest,
    ) -> cms_20240330_models.DeleteMaintainWindowResponse:
        """
        @summary 删除转换器
        
        @param request: DeleteMaintainWindowRequest
        @return: DeleteMaintainWindowResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_maintain_window_with_options(maintain_window_id, request, headers, runtime)

    async def delete_maintain_window_async(
        self,
        maintain_window_id: str,
        request: cms_20240330_models.DeleteMaintainWindowRequest,
    ) -> cms_20240330_models.DeleteMaintainWindowResponse:
        """
        @summary 删除转换器
        
        @param request: DeleteMaintainWindowRequest
        @return: DeleteMaintainWindowResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_maintain_window_with_options_async(maintain_window_id, request, headers, runtime)

    def delete_memories_with_options(
        self,
        workspace: str,
        memory_store_name: str,
        request: cms_20240330_models.DeleteMemoriesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteMemoriesResponse:
        """
        @summary 批量删除记忆
        
        @param request: DeleteMemoriesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteMemoriesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.agent_id):
            query['agentId'] = request.agent_id
        if not UtilClient.is_unset(request.app_id):
            query['appId'] = request.app_id
        if not UtilClient.is_unset(request.run_id):
            query['runId'] = request.run_id
        if not UtilClient.is_unset(request.user_id):
            query['userId'] = request.user_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteMemories',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}/memory',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteMemoriesResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_memories_with_options_async(
        self,
        workspace: str,
        memory_store_name: str,
        request: cms_20240330_models.DeleteMemoriesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteMemoriesResponse:
        """
        @summary 批量删除记忆
        
        @param request: DeleteMemoriesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteMemoriesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.agent_id):
            query['agentId'] = request.agent_id
        if not UtilClient.is_unset(request.app_id):
            query['appId'] = request.app_id
        if not UtilClient.is_unset(request.run_id):
            query['runId'] = request.run_id
        if not UtilClient.is_unset(request.user_id):
            query['userId'] = request.user_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteMemories',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}/memory',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteMemoriesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_memories(
        self,
        workspace: str,
        memory_store_name: str,
        request: cms_20240330_models.DeleteMemoriesRequest,
    ) -> cms_20240330_models.DeleteMemoriesResponse:
        """
        @summary 批量删除记忆
        
        @param request: DeleteMemoriesRequest
        @return: DeleteMemoriesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_memories_with_options(workspace, memory_store_name, request, headers, runtime)

    async def delete_memories_async(
        self,
        workspace: str,
        memory_store_name: str,
        request: cms_20240330_models.DeleteMemoriesRequest,
    ) -> cms_20240330_models.DeleteMemoriesResponse:
        """
        @summary 批量删除记忆
        
        @param request: DeleteMemoriesRequest
        @return: DeleteMemoriesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_memories_with_options_async(workspace, memory_store_name, request, headers, runtime)

    def delete_memory_with_options(
        self,
        workspace: str,
        memory_store_name: str,
        memory_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteMemoryResponse:
        """
        @summary 删除记忆
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteMemoryResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteMemory',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}/memory/{OpenApiUtilClient.get_encode_param(memory_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteMemoryResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_memory_with_options_async(
        self,
        workspace: str,
        memory_store_name: str,
        memory_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteMemoryResponse:
        """
        @summary 删除记忆
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteMemoryResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteMemory',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}/memory/{OpenApiUtilClient.get_encode_param(memory_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteMemoryResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_memory(
        self,
        workspace: str,
        memory_store_name: str,
        memory_id: str,
    ) -> cms_20240330_models.DeleteMemoryResponse:
        """
        @summary 删除记忆
        
        @return: DeleteMemoryResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_memory_with_options(workspace, memory_store_name, memory_id, headers, runtime)

    async def delete_memory_async(
        self,
        workspace: str,
        memory_store_name: str,
        memory_id: str,
    ) -> cms_20240330_models.DeleteMemoryResponse:
        """
        @summary 删除记忆
        
        @return: DeleteMemoryResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_memory_with_options_async(workspace, memory_store_name, memory_id, headers, runtime)

    def delete_memory_store_with_options(
        self,
        workspace: str,
        memory_store_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteMemoryStoreResponse:
        """
        @summary 删除记忆库
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteMemoryStoreResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteMemoryStore',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteMemoryStoreResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_memory_store_with_options_async(
        self,
        workspace: str,
        memory_store_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteMemoryStoreResponse:
        """
        @summary 删除记忆库
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteMemoryStoreResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteMemoryStore',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteMemoryStoreResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_memory_store(
        self,
        workspace: str,
        memory_store_name: str,
    ) -> cms_20240330_models.DeleteMemoryStoreResponse:
        """
        @summary 删除记忆库
        
        @return: DeleteMemoryStoreResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_memory_store_with_options(workspace, memory_store_name, headers, runtime)

    async def delete_memory_store_async(
        self,
        workspace: str,
        memory_store_name: str,
    ) -> cms_20240330_models.DeleteMemoryStoreResponse:
        """
        @summary 删除记忆库
        
        @return: DeleteMemoryStoreResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_memory_store_with_options_async(workspace, memory_store_name, headers, runtime)

    def delete_notify_strategy_with_options(
        self,
        notify_strategy_id: str,
        request: cms_20240330_models.DeleteNotifyStrategyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteNotifyStrategyResponse:
        """
        @summary 删除订阅
        
        @param request: DeleteNotifyStrategyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteNotifyStrategyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteNotifyStrategy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/notifyStrategies/{OpenApiUtilClient.get_encode_param(notify_strategy_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteNotifyStrategyResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_notify_strategy_with_options_async(
        self,
        notify_strategy_id: str,
        request: cms_20240330_models.DeleteNotifyStrategyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteNotifyStrategyResponse:
        """
        @summary 删除订阅
        
        @param request: DeleteNotifyStrategyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteNotifyStrategyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteNotifyStrategy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/notifyStrategies/{OpenApiUtilClient.get_encode_param(notify_strategy_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteNotifyStrategyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_notify_strategy(
        self,
        notify_strategy_id: str,
        request: cms_20240330_models.DeleteNotifyStrategyRequest,
    ) -> cms_20240330_models.DeleteNotifyStrategyResponse:
        """
        @summary 删除订阅
        
        @param request: DeleteNotifyStrategyRequest
        @return: DeleteNotifyStrategyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_notify_strategy_with_options(notify_strategy_id, request, headers, runtime)

    async def delete_notify_strategy_async(
        self,
        notify_strategy_id: str,
        request: cms_20240330_models.DeleteNotifyStrategyRequest,
    ) -> cms_20240330_models.DeleteNotifyStrategyResponse:
        """
        @summary 删除订阅
        
        @param request: DeleteNotifyStrategyRequest
        @return: DeleteNotifyStrategyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_notify_strategy_with_options_async(notify_strategy_id, request, headers, runtime)

    def delete_oncall_schedules_with_options(
        self,
        tmp_req: cms_20240330_models.DeleteOncallSchedulesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteOncallSchedulesResponse:
        """
        @summary 删除OncallSchedule
        
        @param tmp_req: DeleteOncallSchedulesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteOncallSchedulesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.DeleteOncallSchedulesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.oncall_schedule_ids):
            request.oncall_schedule_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.oncall_schedule_ids, 'oncallScheduleIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.oncall_schedule_ids_shrink):
            query['oncallScheduleIds'] = request.oncall_schedule_ids_shrink
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteOncallSchedules',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/oncallSchedule',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteOncallSchedulesResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_oncall_schedules_with_options_async(
        self,
        tmp_req: cms_20240330_models.DeleteOncallSchedulesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteOncallSchedulesResponse:
        """
        @summary 删除OncallSchedule
        
        @param tmp_req: DeleteOncallSchedulesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteOncallSchedulesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.DeleteOncallSchedulesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.oncall_schedule_ids):
            request.oncall_schedule_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.oncall_schedule_ids, 'oncallScheduleIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.oncall_schedule_ids_shrink):
            query['oncallScheduleIds'] = request.oncall_schedule_ids_shrink
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteOncallSchedules',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/oncallSchedule',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteOncallSchedulesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_oncall_schedules(
        self,
        request: cms_20240330_models.DeleteOncallSchedulesRequest,
    ) -> cms_20240330_models.DeleteOncallSchedulesResponse:
        """
        @summary 删除OncallSchedule
        
        @param request: DeleteOncallSchedulesRequest
        @return: DeleteOncallSchedulesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_oncall_schedules_with_options(request, headers, runtime)

    async def delete_oncall_schedules_async(
        self,
        request: cms_20240330_models.DeleteOncallSchedulesRequest,
    ) -> cms_20240330_models.DeleteOncallSchedulesResponse:
        """
        @summary 删除OncallSchedule
        
        @param request: DeleteOncallSchedulesRequest
        @return: DeleteOncallSchedulesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_oncall_schedules_with_options_async(request, headers, runtime)

    def delete_pipeline_with_options(
        self,
        workspace: str,
        pipeline_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeletePipelineResponse:
        """
        @summary 删除流水线
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeletePipelineResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeletePipeline',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/pipeline/{OpenApiUtilClient.get_encode_param(pipeline_name)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeletePipelineResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_pipeline_with_options_async(
        self,
        workspace: str,
        pipeline_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeletePipelineResponse:
        """
        @summary 删除流水线
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeletePipelineResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeletePipeline',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/pipeline/{OpenApiUtilClient.get_encode_param(pipeline_name)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeletePipelineResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_pipeline(
        self,
        workspace: str,
        pipeline_name: str,
    ) -> cms_20240330_models.DeletePipelineResponse:
        """
        @summary 删除流水线
        
        @return: DeletePipelineResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_pipeline_with_options(workspace, pipeline_name, headers, runtime)

    async def delete_pipeline_async(
        self,
        workspace: str,
        pipeline_name: str,
    ) -> cms_20240330_models.DeletePipelineResponse:
        """
        @summary 删除流水线
        
        @return: DeletePipelineResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_pipeline_with_options_async(workspace, pipeline_name, headers, runtime)

    def delete_prometheus_cluster_with_options(
        self,
        prometheus_cluster_name: str,
        request: cms_20240330_models.DeletePrometheusClusterRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeletePrometheusClusterResponse:
        """
        @summary 删除prometheus集群
        
        @param request: DeletePrometheusClusterRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeletePrometheusClusterResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.force_delete):
            query['forceDelete'] = request.force_delete
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeletePrometheusCluster',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-clusters/{OpenApiUtilClient.get_encode_param(prometheus_cluster_name)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeletePrometheusClusterResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_prometheus_cluster_with_options_async(
        self,
        prometheus_cluster_name: str,
        request: cms_20240330_models.DeletePrometheusClusterRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeletePrometheusClusterResponse:
        """
        @summary 删除prometheus集群
        
        @param request: DeletePrometheusClusterRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeletePrometheusClusterResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.force_delete):
            query['forceDelete'] = request.force_delete
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeletePrometheusCluster',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-clusters/{OpenApiUtilClient.get_encode_param(prometheus_cluster_name)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeletePrometheusClusterResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_prometheus_cluster(
        self,
        prometheus_cluster_name: str,
        request: cms_20240330_models.DeletePrometheusClusterRequest,
    ) -> cms_20240330_models.DeletePrometheusClusterResponse:
        """
        @summary 删除prometheus集群
        
        @param request: DeletePrometheusClusterRequest
        @return: DeletePrometheusClusterResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_prometheus_cluster_with_options(prometheus_cluster_name, request, headers, runtime)

    async def delete_prometheus_cluster_async(
        self,
        prometheus_cluster_name: str,
        request: cms_20240330_models.DeletePrometheusClusterRequest,
    ) -> cms_20240330_models.DeletePrometheusClusterResponse:
        """
        @summary 删除prometheus集群
        
        @param request: DeletePrometheusClusterRequest
        @return: DeletePrometheusClusterResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_prometheus_cluster_with_options_async(prometheus_cluster_name, request, headers, runtime)

    def delete_prometheus_instance_with_options(
        self,
        prometheus_instance_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeletePrometheusInstanceResponse:
        """
        @summary Delete prom instance
        
        @description Delete a Prometheus instance.
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeletePrometheusInstanceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeletePrometheusInstance',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(prometheus_instance_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeletePrometheusInstanceResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_prometheus_instance_with_options_async(
        self,
        prometheus_instance_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeletePrometheusInstanceResponse:
        """
        @summary Delete prom instance
        
        @description Delete a Prometheus instance.
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeletePrometheusInstanceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeletePrometheusInstance',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(prometheus_instance_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeletePrometheusInstanceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_prometheus_instance(
        self,
        prometheus_instance_id: str,
    ) -> cms_20240330_models.DeletePrometheusInstanceResponse:
        """
        @summary Delete prom instance
        
        @description Delete a Prometheus instance.
        
        @return: DeletePrometheusInstanceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_prometheus_instance_with_options(prometheus_instance_id, headers, runtime)

    async def delete_prometheus_instance_async(
        self,
        prometheus_instance_id: str,
    ) -> cms_20240330_models.DeletePrometheusInstanceResponse:
        """
        @summary Delete prom instance
        
        @description Delete a Prometheus instance.
        
        @return: DeletePrometheusInstanceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_prometheus_instance_with_options_async(prometheus_instance_id, headers, runtime)

    def delete_prometheus_view_with_options(
        self,
        prometheus_view_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeletePrometheusViewResponse:
        """
        @summary Delete prometheus view instance
        
        @description Delete prometheus view instance.
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeletePrometheusViewResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeletePrometheusView',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-views/{OpenApiUtilClient.get_encode_param(prometheus_view_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeletePrometheusViewResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_prometheus_view_with_options_async(
        self,
        prometheus_view_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeletePrometheusViewResponse:
        """
        @summary Delete prometheus view instance
        
        @description Delete prometheus view instance.
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeletePrometheusViewResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeletePrometheusView',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-views/{OpenApiUtilClient.get_encode_param(prometheus_view_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeletePrometheusViewResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_prometheus_view(
        self,
        prometheus_view_id: str,
    ) -> cms_20240330_models.DeletePrometheusViewResponse:
        """
        @summary Delete prometheus view instance
        
        @description Delete prometheus view instance.
        
        @return: DeletePrometheusViewResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_prometheus_view_with_options(prometheus_view_id, headers, runtime)

    async def delete_prometheus_view_async(
        self,
        prometheus_view_id: str,
    ) -> cms_20240330_models.DeletePrometheusViewResponse:
        """
        @summary Delete prometheus view instance
        
        @description Delete prometheus view instance.
        
        @return: DeletePrometheusViewResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_prometheus_view_with_options_async(prometheus_view_id, headers, runtime)

    def delete_prometheus_virtual_instance_with_options(
        self,
        prometheus_instance_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeletePrometheusVirtualInstanceResponse:
        """
        @summary 删除 Prometheus 虚拟实例
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeletePrometheusVirtualInstanceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeletePrometheusVirtualInstance',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/virtual-instances/{OpenApiUtilClient.get_encode_param(prometheus_instance_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeletePrometheusVirtualInstanceResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_prometheus_virtual_instance_with_options_async(
        self,
        prometheus_instance_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeletePrometheusVirtualInstanceResponse:
        """
        @summary 删除 Prometheus 虚拟实例
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeletePrometheusVirtualInstanceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeletePrometheusVirtualInstance',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/virtual-instances/{OpenApiUtilClient.get_encode_param(prometheus_instance_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeletePrometheusVirtualInstanceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_prometheus_virtual_instance(
        self,
        prometheus_instance_id: str,
    ) -> cms_20240330_models.DeletePrometheusVirtualInstanceResponse:
        """
        @summary 删除 Prometheus 虚拟实例
        
        @return: DeletePrometheusVirtualInstanceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_prometheus_virtual_instance_with_options(prometheus_instance_id, headers, runtime)

    async def delete_prometheus_virtual_instance_async(
        self,
        prometheus_instance_id: str,
    ) -> cms_20240330_models.DeletePrometheusVirtualInstanceResponse:
        """
        @summary 删除 Prometheus 虚拟实例
        
        @return: DeletePrometheusVirtualInstanceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_prometheus_virtual_instance_with_options_async(prometheus_instance_id, headers, runtime)

    def delete_service_with_options(
        self,
        workspace: str,
        service_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteServiceResponse:
        """
        @summary Delete Service
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteServiceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteService',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/service/{OpenApiUtilClient.get_encode_param(service_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteServiceResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_service_with_options_async(
        self,
        workspace: str,
        service_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteServiceResponse:
        """
        @summary Delete Service
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteServiceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteService',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/service/{OpenApiUtilClient.get_encode_param(service_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteServiceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_service(
        self,
        workspace: str,
        service_id: str,
    ) -> cms_20240330_models.DeleteServiceResponse:
        """
        @summary Delete Service
        
        @return: DeleteServiceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_service_with_options(workspace, service_id, headers, runtime)

    async def delete_service_async(
        self,
        workspace: str,
        service_id: str,
    ) -> cms_20240330_models.DeleteServiceResponse:
        """
        @summary Delete Service
        
        @return: DeleteServiceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_service_with_options_async(workspace, service_id, headers, runtime)

    def delete_service_observability_with_options(
        self,
        workspace: str,
        type: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteServiceObservabilityResponse:
        """
        @summary 删除应用可观测实例
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteServiceObservabilityResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteServiceObservability',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/service-observability/{OpenApiUtilClient.get_encode_param(type)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteServiceObservabilityResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_service_observability_with_options_async(
        self,
        workspace: str,
        type: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteServiceObservabilityResponse:
        """
        @summary 删除应用可观测实例
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteServiceObservabilityResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteServiceObservability',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/service-observability/{OpenApiUtilClient.get_encode_param(type)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteServiceObservabilityResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_service_observability(
        self,
        workspace: str,
        type: str,
    ) -> cms_20240330_models.DeleteServiceObservabilityResponse:
        """
        @summary 删除应用可观测实例
        
        @return: DeleteServiceObservabilityResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_service_observability_with_options(workspace, type, headers, runtime)

    async def delete_service_observability_async(
        self,
        workspace: str,
        type: str,
    ) -> cms_20240330_models.DeleteServiceObservabilityResponse:
        """
        @summary 删除应用可观测实例
        
        @return: DeleteServiceObservabilityResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_service_observability_with_options_async(workspace, type, headers, runtime)

    def delete_service_task_with_options(
        self,
        workspace: str,
        service_id: str,
        task_id: str,
        request: cms_20240330_models.DeleteServiceTaskRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteServiceTaskResponse:
        """
        @summary 删除ServiceTask
        
        @param request: DeleteServiceTaskRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteServiceTaskResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.type):
            query['type'] = request.type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteServiceTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/serviceTask/{OpenApiUtilClient.get_encode_param(workspace)}/{OpenApiUtilClient.get_encode_param(service_id)}/task/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteServiceTaskResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_service_task_with_options_async(
        self,
        workspace: str,
        service_id: str,
        task_id: str,
        request: cms_20240330_models.DeleteServiceTaskRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteServiceTaskResponse:
        """
        @summary 删除ServiceTask
        
        @param request: DeleteServiceTaskRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteServiceTaskResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.type):
            query['type'] = request.type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteServiceTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/serviceTask/{OpenApiUtilClient.get_encode_param(workspace)}/{OpenApiUtilClient.get_encode_param(service_id)}/task/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteServiceTaskResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_service_task(
        self,
        workspace: str,
        service_id: str,
        task_id: str,
        request: cms_20240330_models.DeleteServiceTaskRequest,
    ) -> cms_20240330_models.DeleteServiceTaskResponse:
        """
        @summary 删除ServiceTask
        
        @param request: DeleteServiceTaskRequest
        @return: DeleteServiceTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_service_task_with_options(workspace, service_id, task_id, request, headers, runtime)

    async def delete_service_task_async(
        self,
        workspace: str,
        service_id: str,
        task_id: str,
        request: cms_20240330_models.DeleteServiceTaskRequest,
    ) -> cms_20240330_models.DeleteServiceTaskResponse:
        """
        @summary 删除ServiceTask
        
        @param request: DeleteServiceTaskRequest
        @return: DeleteServiceTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_service_task_with_options_async(workspace, service_id, task_id, request, headers, runtime)

    def delete_site_monitor_with_options(
        self,
        task_id: str,
        request: cms_20240330_models.DeleteSiteMonitorRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteSiteMonitorResponse:
        """
        @summary 删除SiteMonitor
        
        @param request: DeleteSiteMonitorRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteSiteMonitorResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteSiteMonitor',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/sitemonitor/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteSiteMonitorResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_site_monitor_with_options_async(
        self,
        task_id: str,
        request: cms_20240330_models.DeleteSiteMonitorRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteSiteMonitorResponse:
        """
        @summary 删除SiteMonitor
        
        @param request: DeleteSiteMonitorRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteSiteMonitorResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteSiteMonitor',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/sitemonitor/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteSiteMonitorResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_site_monitor(
        self,
        task_id: str,
        request: cms_20240330_models.DeleteSiteMonitorRequest,
    ) -> cms_20240330_models.DeleteSiteMonitorResponse:
        """
        @summary 删除SiteMonitor
        
        @param request: DeleteSiteMonitorRequest
        @return: DeleteSiteMonitorResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_site_monitor_with_options(task_id, request, headers, runtime)

    async def delete_site_monitor_async(
        self,
        task_id: str,
        request: cms_20240330_models.DeleteSiteMonitorRequest,
    ) -> cms_20240330_models.DeleteSiteMonitorResponse:
        """
        @summary 删除SiteMonitor
        
        @param request: DeleteSiteMonitorRequest
        @return: DeleteSiteMonitorResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_site_monitor_with_options_async(task_id, request, headers, runtime)

    def delete_subscription_with_options(
        self,
        subscription_id: str,
        request: cms_20240330_models.DeleteSubscriptionRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteSubscriptionResponse:
        """
        @summary 删除订阅
        
        @param request: DeleteSubscriptionRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteSubscriptionResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteSubscription',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/subscriptions/{OpenApiUtilClient.get_encode_param(subscription_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteSubscriptionResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_subscription_with_options_async(
        self,
        subscription_id: str,
        request: cms_20240330_models.DeleteSubscriptionRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteSubscriptionResponse:
        """
        @summary 删除订阅
        
        @param request: DeleteSubscriptionRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteSubscriptionResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteSubscription',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/subscriptions/{OpenApiUtilClient.get_encode_param(subscription_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteSubscriptionResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_subscription(
        self,
        subscription_id: str,
        request: cms_20240330_models.DeleteSubscriptionRequest,
    ) -> cms_20240330_models.DeleteSubscriptionResponse:
        """
        @summary 删除订阅
        
        @param request: DeleteSubscriptionRequest
        @return: DeleteSubscriptionResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_subscription_with_options(subscription_id, request, headers, runtime)

    async def delete_subscription_async(
        self,
        subscription_id: str,
        request: cms_20240330_models.DeleteSubscriptionRequest,
    ) -> cms_20240330_models.DeleteSubscriptionResponse:
        """
        @summary 删除订阅
        
        @param request: DeleteSubscriptionRequest
        @return: DeleteSubscriptionResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_subscription_with_options_async(subscription_id, request, headers, runtime)

    def delete_thread_with_options(
        self,
        name: str,
        thread_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteThreadResponse:
        """
        @summary 删除会话
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteThreadResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteThread',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/thread/{OpenApiUtilClient.get_encode_param(thread_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteThreadResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_thread_with_options_async(
        self,
        name: str,
        thread_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteThreadResponse:
        """
        @summary 删除会话
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteThreadResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteThread',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/thread/{OpenApiUtilClient.get_encode_param(thread_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteThreadResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_thread(
        self,
        name: str,
        thread_id: str,
    ) -> cms_20240330_models.DeleteThreadResponse:
        """
        @summary 删除会话
        
        @return: DeleteThreadResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_thread_with_options(name, thread_id, headers, runtime)

    async def delete_thread_async(
        self,
        name: str,
        thread_id: str,
    ) -> cms_20240330_models.DeleteThreadResponse:
        """
        @summary 删除会话
        
        @return: DeleteThreadResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_thread_with_options_async(name, thread_id, headers, runtime)

    def delete_transformer_with_options(
        self,
        transformer_id: str,
        request: cms_20240330_models.DeleteTransformerRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteTransformerResponse:
        """
        @summary 删除转换器
        
        @param request: DeleteTransformerRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteTransformerResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteTransformer',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/transformers/{OpenApiUtilClient.get_encode_param(transformer_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteTransformerResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_transformer_with_options_async(
        self,
        transformer_id: str,
        request: cms_20240330_models.DeleteTransformerRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteTransformerResponse:
        """
        @summary 删除转换器
        
        @param request: DeleteTransformerRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteTransformerResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteTransformer',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/transformers/{OpenApiUtilClient.get_encode_param(transformer_id)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteTransformerResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_transformer(
        self,
        transformer_id: str,
        request: cms_20240330_models.DeleteTransformerRequest,
    ) -> cms_20240330_models.DeleteTransformerResponse:
        """
        @summary 删除转换器
        
        @param request: DeleteTransformerRequest
        @return: DeleteTransformerResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_transformer_with_options(transformer_id, request, headers, runtime)

    async def delete_transformer_async(
        self,
        transformer_id: str,
        request: cms_20240330_models.DeleteTransformerRequest,
    ) -> cms_20240330_models.DeleteTransformerResponse:
        """
        @summary 删除转换器
        
        @param request: DeleteTransformerRequest
        @return: DeleteTransformerResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_transformer_with_options_async(transformer_id, request, headers, runtime)

    def delete_umodel_with_options(
        self,
        workspace: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteUmodelResponse:
        """
        @summary Delete Umodel configuration information
        
        @description Delete the Umodel under the specified workspace
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteUmodelResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteUmodel',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/umodel',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteUmodelResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_umodel_with_options_async(
        self,
        workspace: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteUmodelResponse:
        """
        @summary Delete Umodel configuration information
        
        @description Delete the Umodel under the specified workspace
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteUmodelResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteUmodel',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/umodel',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteUmodelResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_umodel(
        self,
        workspace: str,
    ) -> cms_20240330_models.DeleteUmodelResponse:
        """
        @summary Delete Umodel configuration information
        
        @description Delete the Umodel under the specified workspace
        
        @return: DeleteUmodelResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_umodel_with_options(workspace, headers, runtime)

    async def delete_umodel_async(
        self,
        workspace: str,
    ) -> cms_20240330_models.DeleteUmodelResponse:
        """
        @summary Delete Umodel configuration information
        
        @description Delete the Umodel under the specified workspace
        
        @return: DeleteUmodelResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_umodel_with_options_async(workspace, headers, runtime)

    def delete_umodel_common_schema_ref_with_options(
        self,
        workspace: str,
        request: cms_20240330_models.DeleteUmodelCommonSchemaRefRequest,
        headers: cms_20240330_models.DeleteUmodelCommonSchemaRefHeaders,
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteUmodelCommonSchemaRefResponse:
        """
        @summary 删除Umodel配置信息
        
        @param request: DeleteUmodelCommonSchemaRefRequest
        @param headers: DeleteUmodelCommonSchemaRefHeaders
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteUmodelCommonSchemaRefResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.group):
            query['group'] = request.group
        real_headers = {}
        if not UtilClient.is_unset(headers.common_headers):
            real_headers = headers.common_headers
        if not UtilClient.is_unset(headers.log_version):
            real_headers['logVersion'] = UtilClient.to_jsonstring(headers.log_version)
        req = open_api_models.OpenApiRequest(
            headers=real_headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteUmodelCommonSchemaRef',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/umodel/common-schema-ref',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteUmodelCommonSchemaRefResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_umodel_common_schema_ref_with_options_async(
        self,
        workspace: str,
        request: cms_20240330_models.DeleteUmodelCommonSchemaRefRequest,
        headers: cms_20240330_models.DeleteUmodelCommonSchemaRefHeaders,
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteUmodelCommonSchemaRefResponse:
        """
        @summary 删除Umodel配置信息
        
        @param request: DeleteUmodelCommonSchemaRefRequest
        @param headers: DeleteUmodelCommonSchemaRefHeaders
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteUmodelCommonSchemaRefResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.group):
            query['group'] = request.group
        real_headers = {}
        if not UtilClient.is_unset(headers.common_headers):
            real_headers = headers.common_headers
        if not UtilClient.is_unset(headers.log_version):
            real_headers['logVersion'] = UtilClient.to_jsonstring(headers.log_version)
        req = open_api_models.OpenApiRequest(
            headers=real_headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteUmodelCommonSchemaRef',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/umodel/common-schema-ref',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteUmodelCommonSchemaRefResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_umodel_common_schema_ref(
        self,
        workspace: str,
        request: cms_20240330_models.DeleteUmodelCommonSchemaRefRequest,
    ) -> cms_20240330_models.DeleteUmodelCommonSchemaRefResponse:
        """
        @summary 删除Umodel配置信息
        
        @param request: DeleteUmodelCommonSchemaRefRequest
        @return: DeleteUmodelCommonSchemaRefResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = cms_20240330_models.DeleteUmodelCommonSchemaRefHeaders()
        return self.delete_umodel_common_schema_ref_with_options(workspace, request, headers, runtime)

    async def delete_umodel_common_schema_ref_async(
        self,
        workspace: str,
        request: cms_20240330_models.DeleteUmodelCommonSchemaRefRequest,
    ) -> cms_20240330_models.DeleteUmodelCommonSchemaRefResponse:
        """
        @summary 删除Umodel配置信息
        
        @param request: DeleteUmodelCommonSchemaRefRequest
        @return: DeleteUmodelCommonSchemaRefResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = cms_20240330_models.DeleteUmodelCommonSchemaRefHeaders()
        return await self.delete_umodel_common_schema_ref_with_options_async(workspace, request, headers, runtime)

    def delete_umodel_data_with_options(
        self,
        workspace: str,
        request: cms_20240330_models.DeleteUmodelDataRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteUmodelDataResponse:
        """
        @summary Delete Umodel Elements
        
        @description Delete the Umodel Data under a specified workspace
        
        @param request: DeleteUmodelDataRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteUmodelDataResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.domain):
            query['domain'] = request.domain
        if not UtilClient.is_unset(request.kind):
            query['kind'] = request.kind
        if not UtilClient.is_unset(request.name):
            query['name'] = request.name
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteUmodelData',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/umodel/data',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteUmodelDataResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_umodel_data_with_options_async(
        self,
        workspace: str,
        request: cms_20240330_models.DeleteUmodelDataRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteUmodelDataResponse:
        """
        @summary Delete Umodel Elements
        
        @description Delete the Umodel Data under a specified workspace
        
        @param request: DeleteUmodelDataRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteUmodelDataResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.domain):
            query['domain'] = request.domain
        if not UtilClient.is_unset(request.kind):
            query['kind'] = request.kind
        if not UtilClient.is_unset(request.name):
            query['name'] = request.name
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DeleteUmodelData',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/umodel/data',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteUmodelDataResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_umodel_data(
        self,
        workspace: str,
        request: cms_20240330_models.DeleteUmodelDataRequest,
    ) -> cms_20240330_models.DeleteUmodelDataResponse:
        """
        @summary Delete Umodel Elements
        
        @description Delete the Umodel Data under a specified workspace
        
        @param request: DeleteUmodelDataRequest
        @return: DeleteUmodelDataResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_umodel_data_with_options(workspace, request, headers, runtime)

    async def delete_umodel_data_async(
        self,
        workspace: str,
        request: cms_20240330_models.DeleteUmodelDataRequest,
    ) -> cms_20240330_models.DeleteUmodelDataResponse:
        """
        @summary Delete Umodel Elements
        
        @description Delete the Umodel Data under a specified workspace
        
        @param request: DeleteUmodelDataRequest
        @return: DeleteUmodelDataResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_umodel_data_with_options_async(workspace, request, headers, runtime)

    def delete_workspace_with_options(
        self,
        workspace_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteWorkspaceResponse:
        """
        @summary Delete Workspace
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteWorkspaceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteWorkspace',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace_name)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteWorkspaceResponse(),
            self.call_api(params, req, runtime)
        )

    async def delete_workspace_with_options_async(
        self,
        workspace_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DeleteWorkspaceResponse:
        """
        @summary Delete Workspace
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DeleteWorkspaceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='DeleteWorkspace',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace_name)}',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DeleteWorkspaceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def delete_workspace(
        self,
        workspace_name: str,
    ) -> cms_20240330_models.DeleteWorkspaceResponse:
        """
        @summary Delete Workspace
        
        @return: DeleteWorkspaceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.delete_workspace_with_options(workspace_name, headers, runtime)

    async def delete_workspace_async(
        self,
        workspace_name: str,
    ) -> cms_20240330_models.DeleteWorkspaceResponse:
        """
        @summary Delete Workspace
        
        @return: DeleteWorkspaceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.delete_workspace_with_options_async(workspace_name, headers, runtime)

    def describe_metric_data_for_alert_preview_with_options(
        self,
        request: cms_20240330_models.DescribeMetricDataForAlertPreviewRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DescribeMetricDataForAlertPreviewResponse:
        """
        @summary 报警预览查询监控数据
        
        @param request: DescribeMetricDataForAlertPreviewRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DescribeMetricDataForAlertPreviewResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.datasource):
            query['datasource'] = request.datasource
        if not UtilClient.is_unset(request.end_time):
            query['endTime'] = request.end_time
        if not UtilClient.is_unset(request.limit):
            query['limit'] = request.limit
        if not UtilClient.is_unset(request.query):
            query['query'] = request.query
        if not UtilClient.is_unset(request.start_time):
            query['startTime'] = request.start_time
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DescribeMetricDataForAlertPreview',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/metric/preview/list',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DescribeMetricDataForAlertPreviewResponse(),
            self.call_api(params, req, runtime)
        )

    async def describe_metric_data_for_alert_preview_with_options_async(
        self,
        request: cms_20240330_models.DescribeMetricDataForAlertPreviewRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DescribeMetricDataForAlertPreviewResponse:
        """
        @summary 报警预览查询监控数据
        
        @param request: DescribeMetricDataForAlertPreviewRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DescribeMetricDataForAlertPreviewResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.datasource):
            query['datasource'] = request.datasource
        if not UtilClient.is_unset(request.end_time):
            query['endTime'] = request.end_time
        if not UtilClient.is_unset(request.limit):
            query['limit'] = request.limit
        if not UtilClient.is_unset(request.query):
            query['query'] = request.query
        if not UtilClient.is_unset(request.start_time):
            query['startTime'] = request.start_time
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DescribeMetricDataForAlertPreview',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/metric/preview/list',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DescribeMetricDataForAlertPreviewResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def describe_metric_data_for_alert_preview(
        self,
        request: cms_20240330_models.DescribeMetricDataForAlertPreviewRequest,
    ) -> cms_20240330_models.DescribeMetricDataForAlertPreviewResponse:
        """
        @summary 报警预览查询监控数据
        
        @param request: DescribeMetricDataForAlertPreviewRequest
        @return: DescribeMetricDataForAlertPreviewResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.describe_metric_data_for_alert_preview_with_options(request, headers, runtime)

    async def describe_metric_data_for_alert_preview_async(
        self,
        request: cms_20240330_models.DescribeMetricDataForAlertPreviewRequest,
    ) -> cms_20240330_models.DescribeMetricDataForAlertPreviewResponse:
        """
        @summary 报警预览查询监控数据
        
        @param request: DescribeMetricDataForAlertPreviewRequest
        @return: DescribeMetricDataForAlertPreviewResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.describe_metric_data_for_alert_preview_with_options_async(request, headers, runtime)

    def describe_regions_with_options(
        self,
        request: cms_20240330_models.DescribeRegionsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DescribeRegionsResponse:
        """
        @summary 查询地域信息列表
        
        @param request: DescribeRegionsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DescribeRegionsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.language):
            query['language'] = request.language
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DescribeRegions',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/regions',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DescribeRegionsResponse(),
            self.call_api(params, req, runtime)
        )

    async def describe_regions_with_options_async(
        self,
        request: cms_20240330_models.DescribeRegionsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DescribeRegionsResponse:
        """
        @summary 查询地域信息列表
        
        @param request: DescribeRegionsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DescribeRegionsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.language):
            query['language'] = request.language
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DescribeRegions',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/regions',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DescribeRegionsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def describe_regions(
        self,
        request: cms_20240330_models.DescribeRegionsRequest,
    ) -> cms_20240330_models.DescribeRegionsResponse:
        """
        @summary 查询地域信息列表
        
        @param request: DescribeRegionsRequest
        @return: DescribeRegionsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.describe_regions_with_options(request, headers, runtime)

    async def describe_regions_async(
        self,
        request: cms_20240330_models.DescribeRegionsRequest,
    ) -> cms_20240330_models.DescribeRegionsResponse:
        """
        @summary 查询地域信息列表
        
        @param request: DescribeRegionsRequest
        @return: DescribeRegionsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.describe_regions_with_options_async(request, headers, runtime)

    def disable_alert_event_integration_policy_with_options(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.DisableAlertEventIntegrationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DisableAlertEventIntegrationPolicyResponse:
        """
        @summary 暂停集成
        
        @param request: DisableAlertEventIntegrationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DisableAlertEventIntegrationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DisableAlertEventIntegrationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertEventIntegrationPolicies/{OpenApiUtilClient.get_encode_param(alert_event_integration_policy_id)}/disable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DisableAlertEventIntegrationPolicyResponse(),
            self.call_api(params, req, runtime)
        )

    async def disable_alert_event_integration_policy_with_options_async(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.DisableAlertEventIntegrationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DisableAlertEventIntegrationPolicyResponse:
        """
        @summary 暂停集成
        
        @param request: DisableAlertEventIntegrationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DisableAlertEventIntegrationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DisableAlertEventIntegrationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertEventIntegrationPolicies/{OpenApiUtilClient.get_encode_param(alert_event_integration_policy_id)}/disable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DisableAlertEventIntegrationPolicyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def disable_alert_event_integration_policy(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.DisableAlertEventIntegrationPolicyRequest,
    ) -> cms_20240330_models.DisableAlertEventIntegrationPolicyResponse:
        """
        @summary 暂停集成
        
        @param request: DisableAlertEventIntegrationPolicyRequest
        @return: DisableAlertEventIntegrationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.disable_alert_event_integration_policy_with_options(alert_event_integration_policy_id, request, headers, runtime)

    async def disable_alert_event_integration_policy_async(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.DisableAlertEventIntegrationPolicyRequest,
    ) -> cms_20240330_models.DisableAlertEventIntegrationPolicyResponse:
        """
        @summary 暂停集成
        
        @param request: DisableAlertEventIntegrationPolicyRequest
        @return: DisableAlertEventIntegrationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.disable_alert_event_integration_policy_with_options_async(alert_event_integration_policy_id, request, headers, runtime)

    def disable_alert_rules_with_options(
        self,
        tmp_req: cms_20240330_models.DisableAlertRulesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DisableAlertRulesResponse:
        """
        @summary 禁用云监控2.0告警规则
        
        @param tmp_req: DisableAlertRulesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DisableAlertRulesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.DisableAlertRulesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.alert_rule_ids):
            request.alert_rule_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.alert_rule_ids, 'alertRuleIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_rule_ids_shrink):
            query['alertRuleIds'] = request.alert_rule_ids_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DisableAlertRules',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules/action/disable',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DisableAlertRulesResponse(),
            self.call_api(params, req, runtime)
        )

    async def disable_alert_rules_with_options_async(
        self,
        tmp_req: cms_20240330_models.DisableAlertRulesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DisableAlertRulesResponse:
        """
        @summary 禁用云监控2.0告警规则
        
        @param tmp_req: DisableAlertRulesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DisableAlertRulesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.DisableAlertRulesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.alert_rule_ids):
            request.alert_rule_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.alert_rule_ids, 'alertRuleIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_rule_ids_shrink):
            query['alertRuleIds'] = request.alert_rule_ids_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DisableAlertRules',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules/action/disable',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DisableAlertRulesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def disable_alert_rules(
        self,
        request: cms_20240330_models.DisableAlertRulesRequest,
    ) -> cms_20240330_models.DisableAlertRulesResponse:
        """
        @summary 禁用云监控2.0告警规则
        
        @param request: DisableAlertRulesRequest
        @return: DisableAlertRulesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.disable_alert_rules_with_options(request, headers, runtime)

    async def disable_alert_rules_async(
        self,
        request: cms_20240330_models.DisableAlertRulesRequest,
    ) -> cms_20240330_models.DisableAlertRulesResponse:
        """
        @summary 禁用云监控2.0告警规则
        
        @param request: DisableAlertRulesRequest
        @return: DisableAlertRulesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.disable_alert_rules_with_options_async(request, headers, runtime)

    def disable_escalation_policy_with_options(
        self,
        uuid: str,
        request: cms_20240330_models.DisableEscalationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DisableEscalationPolicyResponse:
        """
        @summary 暂停升级
        
        @param request: DisableEscalationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DisableEscalationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DisableEscalationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/escalationPolicies/{OpenApiUtilClient.get_encode_param(uuid)}/disable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DisableEscalationPolicyResponse(),
            self.call_api(params, req, runtime)
        )

    async def disable_escalation_policy_with_options_async(
        self,
        uuid: str,
        request: cms_20240330_models.DisableEscalationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DisableEscalationPolicyResponse:
        """
        @summary 暂停升级
        
        @param request: DisableEscalationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DisableEscalationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DisableEscalationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/escalationPolicies/{OpenApiUtilClient.get_encode_param(uuid)}/disable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DisableEscalationPolicyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def disable_escalation_policy(
        self,
        uuid: str,
        request: cms_20240330_models.DisableEscalationPolicyRequest,
    ) -> cms_20240330_models.DisableEscalationPolicyResponse:
        """
        @summary 暂停升级
        
        @param request: DisableEscalationPolicyRequest
        @return: DisableEscalationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.disable_escalation_policy_with_options(uuid, request, headers, runtime)

    async def disable_escalation_policy_async(
        self,
        uuid: str,
        request: cms_20240330_models.DisableEscalationPolicyRequest,
    ) -> cms_20240330_models.DisableEscalationPolicyResponse:
        """
        @summary 暂停升级
        
        @param request: DisableEscalationPolicyRequest
        @return: DisableEscalationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.disable_escalation_policy_with_options_async(uuid, request, headers, runtime)

    def disable_maintain_window_with_options(
        self,
        maintain_window_id: str,
        request: cms_20240330_models.DisableMaintainWindowRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DisableMaintainWindowResponse:
        """
        @summary 暂停转换器
        
        @param request: DisableMaintainWindowRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DisableMaintainWindowResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DisableMaintainWindow',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/maintainWindows/{OpenApiUtilClient.get_encode_param(maintain_window_id)}/disable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DisableMaintainWindowResponse(),
            self.call_api(params, req, runtime)
        )

    async def disable_maintain_window_with_options_async(
        self,
        maintain_window_id: str,
        request: cms_20240330_models.DisableMaintainWindowRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DisableMaintainWindowResponse:
        """
        @summary 暂停转换器
        
        @param request: DisableMaintainWindowRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DisableMaintainWindowResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DisableMaintainWindow',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/maintainWindows/{OpenApiUtilClient.get_encode_param(maintain_window_id)}/disable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DisableMaintainWindowResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def disable_maintain_window(
        self,
        maintain_window_id: str,
        request: cms_20240330_models.DisableMaintainWindowRequest,
    ) -> cms_20240330_models.DisableMaintainWindowResponse:
        """
        @summary 暂停转换器
        
        @param request: DisableMaintainWindowRequest
        @return: DisableMaintainWindowResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.disable_maintain_window_with_options(maintain_window_id, request, headers, runtime)

    async def disable_maintain_window_async(
        self,
        maintain_window_id: str,
        request: cms_20240330_models.DisableMaintainWindowRequest,
    ) -> cms_20240330_models.DisableMaintainWindowResponse:
        """
        @summary 暂停转换器
        
        @param request: DisableMaintainWindowRequest
        @return: DisableMaintainWindowResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.disable_maintain_window_with_options_async(maintain_window_id, request, headers, runtime)

    def disable_notify_strategy_with_options(
        self,
        notify_strategy_id: str,
        request: cms_20240330_models.DisableNotifyStrategyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DisableNotifyStrategyResponse:
        """
        @summary 暂停订阅
        
        @param request: DisableNotifyStrategyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DisableNotifyStrategyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DisableNotifyStrategy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/notifyStrategies/{OpenApiUtilClient.get_encode_param(notify_strategy_id)}/disable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DisableNotifyStrategyResponse(),
            self.call_api(params, req, runtime)
        )

    async def disable_notify_strategy_with_options_async(
        self,
        notify_strategy_id: str,
        request: cms_20240330_models.DisableNotifyStrategyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DisableNotifyStrategyResponse:
        """
        @summary 暂停订阅
        
        @param request: DisableNotifyStrategyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DisableNotifyStrategyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DisableNotifyStrategy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/notifyStrategies/{OpenApiUtilClient.get_encode_param(notify_strategy_id)}/disable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DisableNotifyStrategyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def disable_notify_strategy(
        self,
        notify_strategy_id: str,
        request: cms_20240330_models.DisableNotifyStrategyRequest,
    ) -> cms_20240330_models.DisableNotifyStrategyResponse:
        """
        @summary 暂停订阅
        
        @param request: DisableNotifyStrategyRequest
        @return: DisableNotifyStrategyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.disable_notify_strategy_with_options(notify_strategy_id, request, headers, runtime)

    async def disable_notify_strategy_async(
        self,
        notify_strategy_id: str,
        request: cms_20240330_models.DisableNotifyStrategyRequest,
    ) -> cms_20240330_models.DisableNotifyStrategyResponse:
        """
        @summary 暂停订阅
        
        @param request: DisableNotifyStrategyRequest
        @return: DisableNotifyStrategyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.disable_notify_strategy_with_options_async(notify_strategy_id, request, headers, runtime)

    def disable_site_monitor_with_options(
        self,
        task_id: str,
        request: cms_20240330_models.DisableSiteMonitorRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DisableSiteMonitorResponse:
        """
        @summary 停止站点监控任务
        
        @param request: DisableSiteMonitorRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DisableSiteMonitorResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DisableSiteMonitor',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/disableSiteMonitor/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DisableSiteMonitorResponse(),
            self.call_api(params, req, runtime)
        )

    async def disable_site_monitor_with_options_async(
        self,
        task_id: str,
        request: cms_20240330_models.DisableSiteMonitorRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DisableSiteMonitorResponse:
        """
        @summary 停止站点监控任务
        
        @param request: DisableSiteMonitorRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DisableSiteMonitorResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DisableSiteMonitor',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/disableSiteMonitor/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DisableSiteMonitorResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def disable_site_monitor(
        self,
        task_id: str,
        request: cms_20240330_models.DisableSiteMonitorRequest,
    ) -> cms_20240330_models.DisableSiteMonitorResponse:
        """
        @summary 停止站点监控任务
        
        @param request: DisableSiteMonitorRequest
        @return: DisableSiteMonitorResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.disable_site_monitor_with_options(task_id, request, headers, runtime)

    async def disable_site_monitor_async(
        self,
        task_id: str,
        request: cms_20240330_models.DisableSiteMonitorRequest,
    ) -> cms_20240330_models.DisableSiteMonitorResponse:
        """
        @summary 停止站点监控任务
        
        @param request: DisableSiteMonitorRequest
        @return: DisableSiteMonitorResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.disable_site_monitor_with_options_async(task_id, request, headers, runtime)

    def disable_subscription_with_options(
        self,
        subscription_id: str,
        request: cms_20240330_models.DisableSubscriptionRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DisableSubscriptionResponse:
        """
        @summary 暂停订阅
        
        @param request: DisableSubscriptionRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DisableSubscriptionResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DisableSubscription',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/subscriptions/{OpenApiUtilClient.get_encode_param(subscription_id)}/disable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DisableSubscriptionResponse(),
            self.call_api(params, req, runtime)
        )

    async def disable_subscription_with_options_async(
        self,
        subscription_id: str,
        request: cms_20240330_models.DisableSubscriptionRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DisableSubscriptionResponse:
        """
        @summary 暂停订阅
        
        @param request: DisableSubscriptionRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DisableSubscriptionResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DisableSubscription',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/subscriptions/{OpenApiUtilClient.get_encode_param(subscription_id)}/disable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DisableSubscriptionResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def disable_subscription(
        self,
        subscription_id: str,
        request: cms_20240330_models.DisableSubscriptionRequest,
    ) -> cms_20240330_models.DisableSubscriptionResponse:
        """
        @summary 暂停订阅
        
        @param request: DisableSubscriptionRequest
        @return: DisableSubscriptionResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.disable_subscription_with_options(subscription_id, request, headers, runtime)

    async def disable_subscription_async(
        self,
        subscription_id: str,
        request: cms_20240330_models.DisableSubscriptionRequest,
    ) -> cms_20240330_models.DisableSubscriptionResponse:
        """
        @summary 暂停订阅
        
        @param request: DisableSubscriptionRequest
        @return: DisableSubscriptionResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.disable_subscription_with_options_async(subscription_id, request, headers, runtime)

    def disable_transformer_with_options(
        self,
        transformer_id: str,
        request: cms_20240330_models.DisableTransformerRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DisableTransformerResponse:
        """
        @summary 暂停转换器
        
        @param request: DisableTransformerRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DisableTransformerResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DisableTransformer',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/transformers/{OpenApiUtilClient.get_encode_param(transformer_id)}/disable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DisableTransformerResponse(),
            self.call_api(params, req, runtime)
        )

    async def disable_transformer_with_options_async(
        self,
        transformer_id: str,
        request: cms_20240330_models.DisableTransformerRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.DisableTransformerResponse:
        """
        @summary 暂停转换器
        
        @param request: DisableTransformerRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: DisableTransformerResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='DisableTransformer',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/transformers/{OpenApiUtilClient.get_encode_param(transformer_id)}/disable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.DisableTransformerResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def disable_transformer(
        self,
        transformer_id: str,
        request: cms_20240330_models.DisableTransformerRequest,
    ) -> cms_20240330_models.DisableTransformerResponse:
        """
        @summary 暂停转换器
        
        @param request: DisableTransformerRequest
        @return: DisableTransformerResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.disable_transformer_with_options(transformer_id, request, headers, runtime)

    async def disable_transformer_async(
        self,
        transformer_id: str,
        request: cms_20240330_models.DisableTransformerRequest,
    ) -> cms_20240330_models.DisableTransformerResponse:
        """
        @summary 暂停转换器
        
        @param request: DisableTransformerRequest
        @return: DisableTransformerResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.disable_transformer_with_options_async(transformer_id, request, headers, runtime)

    def enable_alert_event_integration_policy_with_options(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.EnableAlertEventIntegrationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.EnableAlertEventIntegrationPolicyResponse:
        """
        @summary 启动集成
        
        @param request: EnableAlertEventIntegrationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: EnableAlertEventIntegrationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='EnableAlertEventIntegrationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertEventIntegrationPolicies/{OpenApiUtilClient.get_encode_param(alert_event_integration_policy_id)}/enable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.EnableAlertEventIntegrationPolicyResponse(),
            self.call_api(params, req, runtime)
        )

    async def enable_alert_event_integration_policy_with_options_async(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.EnableAlertEventIntegrationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.EnableAlertEventIntegrationPolicyResponse:
        """
        @summary 启动集成
        
        @param request: EnableAlertEventIntegrationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: EnableAlertEventIntegrationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='EnableAlertEventIntegrationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertEventIntegrationPolicies/{OpenApiUtilClient.get_encode_param(alert_event_integration_policy_id)}/enable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.EnableAlertEventIntegrationPolicyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def enable_alert_event_integration_policy(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.EnableAlertEventIntegrationPolicyRequest,
    ) -> cms_20240330_models.EnableAlertEventIntegrationPolicyResponse:
        """
        @summary 启动集成
        
        @param request: EnableAlertEventIntegrationPolicyRequest
        @return: EnableAlertEventIntegrationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.enable_alert_event_integration_policy_with_options(alert_event_integration_policy_id, request, headers, runtime)

    async def enable_alert_event_integration_policy_async(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.EnableAlertEventIntegrationPolicyRequest,
    ) -> cms_20240330_models.EnableAlertEventIntegrationPolicyResponse:
        """
        @summary 启动集成
        
        @param request: EnableAlertEventIntegrationPolicyRequest
        @return: EnableAlertEventIntegrationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.enable_alert_event_integration_policy_with_options_async(alert_event_integration_policy_id, request, headers, runtime)

    def enable_alert_rules_with_options(
        self,
        tmp_req: cms_20240330_models.EnableAlertRulesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.EnableAlertRulesResponse:
        """
        @summary 启用云监控2.0告警规则
        
        @param tmp_req: EnableAlertRulesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: EnableAlertRulesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.EnableAlertRulesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.alert_rule_ids):
            request.alert_rule_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.alert_rule_ids, 'alertRuleIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_rule_ids_shrink):
            query['alertRuleIds'] = request.alert_rule_ids_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='EnableAlertRules',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules/action/enable',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.EnableAlertRulesResponse(),
            self.call_api(params, req, runtime)
        )

    async def enable_alert_rules_with_options_async(
        self,
        tmp_req: cms_20240330_models.EnableAlertRulesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.EnableAlertRulesResponse:
        """
        @summary 启用云监控2.0告警规则
        
        @param tmp_req: EnableAlertRulesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: EnableAlertRulesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.EnableAlertRulesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.alert_rule_ids):
            request.alert_rule_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.alert_rule_ids, 'alertRuleIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_rule_ids_shrink):
            query['alertRuleIds'] = request.alert_rule_ids_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='EnableAlertRules',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules/action/enable',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.EnableAlertRulesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def enable_alert_rules(
        self,
        request: cms_20240330_models.EnableAlertRulesRequest,
    ) -> cms_20240330_models.EnableAlertRulesResponse:
        """
        @summary 启用云监控2.0告警规则
        
        @param request: EnableAlertRulesRequest
        @return: EnableAlertRulesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.enable_alert_rules_with_options(request, headers, runtime)

    async def enable_alert_rules_async(
        self,
        request: cms_20240330_models.EnableAlertRulesRequest,
    ) -> cms_20240330_models.EnableAlertRulesResponse:
        """
        @summary 启用云监控2.0告警规则
        
        @param request: EnableAlertRulesRequest
        @return: EnableAlertRulesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.enable_alert_rules_with_options_async(request, headers, runtime)

    def enable_escalation_policy_with_options(
        self,
        uuid: str,
        request: cms_20240330_models.EnableEscalationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.EnableEscalationPolicyResponse:
        """
        @summary 启动升级策略
        
        @param request: EnableEscalationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: EnableEscalationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='EnableEscalationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/escalationPolicies/{OpenApiUtilClient.get_encode_param(uuid)}/enable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.EnableEscalationPolicyResponse(),
            self.call_api(params, req, runtime)
        )

    async def enable_escalation_policy_with_options_async(
        self,
        uuid: str,
        request: cms_20240330_models.EnableEscalationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.EnableEscalationPolicyResponse:
        """
        @summary 启动升级策略
        
        @param request: EnableEscalationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: EnableEscalationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='EnableEscalationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/escalationPolicies/{OpenApiUtilClient.get_encode_param(uuid)}/enable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.EnableEscalationPolicyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def enable_escalation_policy(
        self,
        uuid: str,
        request: cms_20240330_models.EnableEscalationPolicyRequest,
    ) -> cms_20240330_models.EnableEscalationPolicyResponse:
        """
        @summary 启动升级策略
        
        @param request: EnableEscalationPolicyRequest
        @return: EnableEscalationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.enable_escalation_policy_with_options(uuid, request, headers, runtime)

    async def enable_escalation_policy_async(
        self,
        uuid: str,
        request: cms_20240330_models.EnableEscalationPolicyRequest,
    ) -> cms_20240330_models.EnableEscalationPolicyResponse:
        """
        @summary 启动升级策略
        
        @param request: EnableEscalationPolicyRequest
        @return: EnableEscalationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.enable_escalation_policy_with_options_async(uuid, request, headers, runtime)

    def enable_maintain_window_with_options(
        self,
        maintain_window_id: str,
        request: cms_20240330_models.EnableMaintainWindowRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.EnableMaintainWindowResponse:
        """
        @summary 启动转换器
        
        @param request: EnableMaintainWindowRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: EnableMaintainWindowResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='EnableMaintainWindow',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/maintainWindows/{OpenApiUtilClient.get_encode_param(maintain_window_id)}/enable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.EnableMaintainWindowResponse(),
            self.call_api(params, req, runtime)
        )

    async def enable_maintain_window_with_options_async(
        self,
        maintain_window_id: str,
        request: cms_20240330_models.EnableMaintainWindowRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.EnableMaintainWindowResponse:
        """
        @summary 启动转换器
        
        @param request: EnableMaintainWindowRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: EnableMaintainWindowResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='EnableMaintainWindow',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/maintainWindows/{OpenApiUtilClient.get_encode_param(maintain_window_id)}/enable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.EnableMaintainWindowResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def enable_maintain_window(
        self,
        maintain_window_id: str,
        request: cms_20240330_models.EnableMaintainWindowRequest,
    ) -> cms_20240330_models.EnableMaintainWindowResponse:
        """
        @summary 启动转换器
        
        @param request: EnableMaintainWindowRequest
        @return: EnableMaintainWindowResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.enable_maintain_window_with_options(maintain_window_id, request, headers, runtime)

    async def enable_maintain_window_async(
        self,
        maintain_window_id: str,
        request: cms_20240330_models.EnableMaintainWindowRequest,
    ) -> cms_20240330_models.EnableMaintainWindowResponse:
        """
        @summary 启动转换器
        
        @param request: EnableMaintainWindowRequest
        @return: EnableMaintainWindowResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.enable_maintain_window_with_options_async(maintain_window_id, request, headers, runtime)

    def enable_notify_strategy_with_options(
        self,
        notify_strategy_id: str,
        request: cms_20240330_models.EnableNotifyStrategyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.EnableNotifyStrategyResponse:
        """
        @summary 启动订阅
        
        @param request: EnableNotifyStrategyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: EnableNotifyStrategyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='EnableNotifyStrategy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/notifyStrategies/{OpenApiUtilClient.get_encode_param(notify_strategy_id)}/enable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.EnableNotifyStrategyResponse(),
            self.call_api(params, req, runtime)
        )

    async def enable_notify_strategy_with_options_async(
        self,
        notify_strategy_id: str,
        request: cms_20240330_models.EnableNotifyStrategyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.EnableNotifyStrategyResponse:
        """
        @summary 启动订阅
        
        @param request: EnableNotifyStrategyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: EnableNotifyStrategyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='EnableNotifyStrategy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/notifyStrategies/{OpenApiUtilClient.get_encode_param(notify_strategy_id)}/enable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.EnableNotifyStrategyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def enable_notify_strategy(
        self,
        notify_strategy_id: str,
        request: cms_20240330_models.EnableNotifyStrategyRequest,
    ) -> cms_20240330_models.EnableNotifyStrategyResponse:
        """
        @summary 启动订阅
        
        @param request: EnableNotifyStrategyRequest
        @return: EnableNotifyStrategyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.enable_notify_strategy_with_options(notify_strategy_id, request, headers, runtime)

    async def enable_notify_strategy_async(
        self,
        notify_strategy_id: str,
        request: cms_20240330_models.EnableNotifyStrategyRequest,
    ) -> cms_20240330_models.EnableNotifyStrategyResponse:
        """
        @summary 启动订阅
        
        @param request: EnableNotifyStrategyRequest
        @return: EnableNotifyStrategyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.enable_notify_strategy_with_options_async(notify_strategy_id, request, headers, runtime)

    def enable_site_monitor_with_options(
        self,
        task_id: str,
        request: cms_20240330_models.EnableSiteMonitorRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.EnableSiteMonitorResponse:
        """
        @summary 启动站点监控任务
        
        @param request: EnableSiteMonitorRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: EnableSiteMonitorResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='EnableSiteMonitor',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/enableSiteMonitor/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.EnableSiteMonitorResponse(),
            self.call_api(params, req, runtime)
        )

    async def enable_site_monitor_with_options_async(
        self,
        task_id: str,
        request: cms_20240330_models.EnableSiteMonitorRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.EnableSiteMonitorResponse:
        """
        @summary 启动站点监控任务
        
        @param request: EnableSiteMonitorRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: EnableSiteMonitorResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='EnableSiteMonitor',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/enableSiteMonitor/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.EnableSiteMonitorResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def enable_site_monitor(
        self,
        task_id: str,
        request: cms_20240330_models.EnableSiteMonitorRequest,
    ) -> cms_20240330_models.EnableSiteMonitorResponse:
        """
        @summary 启动站点监控任务
        
        @param request: EnableSiteMonitorRequest
        @return: EnableSiteMonitorResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.enable_site_monitor_with_options(task_id, request, headers, runtime)

    async def enable_site_monitor_async(
        self,
        task_id: str,
        request: cms_20240330_models.EnableSiteMonitorRequest,
    ) -> cms_20240330_models.EnableSiteMonitorResponse:
        """
        @summary 启动站点监控任务
        
        @param request: EnableSiteMonitorRequest
        @return: EnableSiteMonitorResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.enable_site_monitor_with_options_async(task_id, request, headers, runtime)

    def enable_subscription_with_options(
        self,
        subscription_id: str,
        request: cms_20240330_models.EnableSubscriptionRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.EnableSubscriptionResponse:
        """
        @summary 启动订阅
        
        @param request: EnableSubscriptionRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: EnableSubscriptionResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='EnableSubscription',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/subscriptions/{OpenApiUtilClient.get_encode_param(subscription_id)}/enable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.EnableSubscriptionResponse(),
            self.call_api(params, req, runtime)
        )

    async def enable_subscription_with_options_async(
        self,
        subscription_id: str,
        request: cms_20240330_models.EnableSubscriptionRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.EnableSubscriptionResponse:
        """
        @summary 启动订阅
        
        @param request: EnableSubscriptionRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: EnableSubscriptionResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='EnableSubscription',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/subscriptions/{OpenApiUtilClient.get_encode_param(subscription_id)}/enable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.EnableSubscriptionResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def enable_subscription(
        self,
        subscription_id: str,
        request: cms_20240330_models.EnableSubscriptionRequest,
    ) -> cms_20240330_models.EnableSubscriptionResponse:
        """
        @summary 启动订阅
        
        @param request: EnableSubscriptionRequest
        @return: EnableSubscriptionResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.enable_subscription_with_options(subscription_id, request, headers, runtime)

    async def enable_subscription_async(
        self,
        subscription_id: str,
        request: cms_20240330_models.EnableSubscriptionRequest,
    ) -> cms_20240330_models.EnableSubscriptionResponse:
        """
        @summary 启动订阅
        
        @param request: EnableSubscriptionRequest
        @return: EnableSubscriptionResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.enable_subscription_with_options_async(subscription_id, request, headers, runtime)

    def enable_transformer_with_options(
        self,
        transformer_id: str,
        request: cms_20240330_models.EnableTransformerRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.EnableTransformerResponse:
        """
        @summary 启动转换器
        
        @param request: EnableTransformerRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: EnableTransformerResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='EnableTransformer',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/transformers/{OpenApiUtilClient.get_encode_param(transformer_id)}/enable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.EnableTransformerResponse(),
            self.call_api(params, req, runtime)
        )

    async def enable_transformer_with_options_async(
        self,
        transformer_id: str,
        request: cms_20240330_models.EnableTransformerRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.EnableTransformerResponse:
        """
        @summary 启动转换器
        
        @param request: EnableTransformerRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: EnableTransformerResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='EnableTransformer',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/transformers/{OpenApiUtilClient.get_encode_param(transformer_id)}/enable',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.EnableTransformerResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def enable_transformer(
        self,
        transformer_id: str,
        request: cms_20240330_models.EnableTransformerRequest,
    ) -> cms_20240330_models.EnableTransformerResponse:
        """
        @summary 启动转换器
        
        @param request: EnableTransformerRequest
        @return: EnableTransformerResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.enable_transformer_with_options(transformer_id, request, headers, runtime)

    async def enable_transformer_async(
        self,
        transformer_id: str,
        request: cms_20240330_models.EnableTransformerRequest,
    ) -> cms_20240330_models.EnableTransformerResponse:
        """
        @summary 启动转换器
        
        @param request: EnableTransformerRequest
        @return: EnableTransformerResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.enable_transformer_with_options_async(transformer_id, request, headers, runtime)

    def enqueue_custom_event_with_options(
        self,
        enqueue_id: str,
        request: cms_20240330_models.EnqueueCustomEventRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.EnqueueCustomEventResponse:
        """
        @summary 用户自定义事件上报
        
        @param request: EnqueueCustomEventRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: EnqueueCustomEventResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.debug):
            query['debug'] = request.debug
        if not UtilClient.is_unset(request.sign):
            query['sign'] = request.sign
        if not UtilClient.is_unset(request.timestamp):
            query['timestamp'] = request.timestamp
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=request.body
        )
        params = open_api_models.Params(
            action='EnqueueCustomEvent',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/v1/enqueue/{OpenApiUtilClient.get_encode_param(enqueue_id)}',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.EnqueueCustomEventResponse(),
            self.call_api(params, req, runtime)
        )

    async def enqueue_custom_event_with_options_async(
        self,
        enqueue_id: str,
        request: cms_20240330_models.EnqueueCustomEventRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.EnqueueCustomEventResponse:
        """
        @summary 用户自定义事件上报
        
        @param request: EnqueueCustomEventRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: EnqueueCustomEventResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.debug):
            query['debug'] = request.debug
        if not UtilClient.is_unset(request.sign):
            query['sign'] = request.sign
        if not UtilClient.is_unset(request.timestamp):
            query['timestamp'] = request.timestamp
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=request.body
        )
        params = open_api_models.Params(
            action='EnqueueCustomEvent',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/v1/enqueue/{OpenApiUtilClient.get_encode_param(enqueue_id)}',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.EnqueueCustomEventResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def enqueue_custom_event(
        self,
        enqueue_id: str,
        request: cms_20240330_models.EnqueueCustomEventRequest,
    ) -> cms_20240330_models.EnqueueCustomEventResponse:
        """
        @summary 用户自定义事件上报
        
        @param request: EnqueueCustomEventRequest
        @return: EnqueueCustomEventResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.enqueue_custom_event_with_options(enqueue_id, request, headers, runtime)

    async def enqueue_custom_event_async(
        self,
        enqueue_id: str,
        request: cms_20240330_models.EnqueueCustomEventRequest,
    ) -> cms_20240330_models.EnqueueCustomEventResponse:
        """
        @summary 用户自定义事件上报
        
        @param request: EnqueueCustomEventRequest
        @return: EnqueueCustomEventResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.enqueue_custom_event_with_options_async(enqueue_id, request, headers, runtime)

    def execute_query_with_options(
        self,
        workspace: str,
        dataset_name: str,
        request: cms_20240330_models.ExecuteQueryRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ExecuteQueryResponse:
        """
        @summary 执行查询语句
        
        @param request: ExecuteQueryRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ExecuteQueryResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.query):
            body['query'] = request.query
        if not UtilClient.is_unset(request.type):
            body['type'] = request.type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='ExecuteQuery',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/dataset/{OpenApiUtilClient.get_encode_param(dataset_name)}/query',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ExecuteQueryResponse(),
            self.call_api(params, req, runtime)
        )

    async def execute_query_with_options_async(
        self,
        workspace: str,
        dataset_name: str,
        request: cms_20240330_models.ExecuteQueryRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ExecuteQueryResponse:
        """
        @summary 执行查询语句
        
        @param request: ExecuteQueryRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ExecuteQueryResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.query):
            body['query'] = request.query
        if not UtilClient.is_unset(request.type):
            body['type'] = request.type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='ExecuteQuery',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/dataset/{OpenApiUtilClient.get_encode_param(dataset_name)}/query',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ExecuteQueryResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def execute_query(
        self,
        workspace: str,
        dataset_name: str,
        request: cms_20240330_models.ExecuteQueryRequest,
    ) -> cms_20240330_models.ExecuteQueryResponse:
        """
        @summary 执行查询语句
        
        @param request: ExecuteQueryRequest
        @return: ExecuteQueryResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.execute_query_with_options(workspace, dataset_name, request, headers, runtime)

    async def execute_query_async(
        self,
        workspace: str,
        dataset_name: str,
        request: cms_20240330_models.ExecuteQueryRequest,
    ) -> cms_20240330_models.ExecuteQueryResponse:
        """
        @summary 执行查询语句
        
        @param request: ExecuteQueryRequest
        @return: ExecuteQueryResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.execute_query_with_options_async(workspace, dataset_name, request, headers, runtime)

    def export_alert_rules_with_options(
        self,
        tmp_req: cms_20240330_models.ExportAlertRulesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ExportAlertRulesResponse:
        """
        @summary 批量导出云监控2.0告警规则
        
        @param tmp_req: ExportAlertRulesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ExportAlertRulesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ExportAlertRulesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.alert_rule_ids):
            request.alert_rule_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.alert_rule_ids, 'alertRuleIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_rule_ids_shrink):
            query['alertRuleIds'] = request.alert_rule_ids_shrink
        if not UtilClient.is_unset(request.format):
            query['format'] = request.format
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ExportAlertRules',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules/action/export',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ExportAlertRulesResponse(),
            self.call_api(params, req, runtime)
        )

    async def export_alert_rules_with_options_async(
        self,
        tmp_req: cms_20240330_models.ExportAlertRulesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ExportAlertRulesResponse:
        """
        @summary 批量导出云监控2.0告警规则
        
        @param tmp_req: ExportAlertRulesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ExportAlertRulesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ExportAlertRulesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.alert_rule_ids):
            request.alert_rule_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.alert_rule_ids, 'alertRuleIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_rule_ids_shrink):
            query['alertRuleIds'] = request.alert_rule_ids_shrink
        if not UtilClient.is_unset(request.format):
            query['format'] = request.format
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ExportAlertRules',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules/action/export',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ExportAlertRulesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def export_alert_rules(
        self,
        request: cms_20240330_models.ExportAlertRulesRequest,
    ) -> cms_20240330_models.ExportAlertRulesResponse:
        """
        @summary 批量导出云监控2.0告警规则
        
        @param request: ExportAlertRulesRequest
        @return: ExportAlertRulesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.export_alert_rules_with_options(request, headers, runtime)

    async def export_alert_rules_async(
        self,
        request: cms_20240330_models.ExportAlertRulesRequest,
    ) -> cms_20240330_models.ExportAlertRulesResponse:
        """
        @summary 批量导出云监控2.0告警规则
        
        @param request: ExportAlertRulesRequest
        @return: ExportAlertRulesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.export_alert_rules_with_options_async(request, headers, runtime)

    def get_addon_with_options(
        self,
        addon_name: str,
        request: cms_20240330_models.GetAddonRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetAddonResponse:
        """
        @summary 插件详情(Addon)
        
        @param request: GetAddonRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetAddonResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.version):
            query['version'] = request.version
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetAddon',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/addons/{OpenApiUtilClient.get_encode_param(addon_name)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetAddonResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_addon_with_options_async(
        self,
        addon_name: str,
        request: cms_20240330_models.GetAddonRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetAddonResponse:
        """
        @summary 插件详情(Addon)
        
        @param request: GetAddonRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetAddonResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.version):
            query['version'] = request.version
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetAddon',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/addons/{OpenApiUtilClient.get_encode_param(addon_name)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetAddonResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_addon(
        self,
        addon_name: str,
        request: cms_20240330_models.GetAddonRequest,
    ) -> cms_20240330_models.GetAddonResponse:
        """
        @summary 插件详情(Addon)
        
        @param request: GetAddonRequest
        @return: GetAddonResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_addon_with_options(addon_name, request, headers, runtime)

    async def get_addon_async(
        self,
        addon_name: str,
        request: cms_20240330_models.GetAddonRequest,
    ) -> cms_20240330_models.GetAddonResponse:
        """
        @summary 插件详情(Addon)
        
        @param request: GetAddonRequest
        @return: GetAddonResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_addon_with_options_async(addon_name, request, headers, runtime)

    def get_addon_alert_templates_with_options(
        self,
        addon_name: str,
        request: cms_20240330_models.GetAddonAlertTemplatesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetAddonAlertTemplatesResponse:
        """
        @summary 插件metrics详情(Addon)
        
        @param request: GetAddonAlertTemplatesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetAddonAlertTemplatesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.addon_version):
            query['addonVersion'] = request.addon_version
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.environment_type):
            query['environmentType'] = request.environment_type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetAddonAlertTemplates',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/addons/{OpenApiUtilClient.get_encode_param(addon_name)}/alert-templates',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetAddonAlertTemplatesResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_addon_alert_templates_with_options_async(
        self,
        addon_name: str,
        request: cms_20240330_models.GetAddonAlertTemplatesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetAddonAlertTemplatesResponse:
        """
        @summary 插件metrics详情(Addon)
        
        @param request: GetAddonAlertTemplatesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetAddonAlertTemplatesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.addon_version):
            query['addonVersion'] = request.addon_version
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.environment_type):
            query['environmentType'] = request.environment_type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetAddonAlertTemplates',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/addons/{OpenApiUtilClient.get_encode_param(addon_name)}/alert-templates',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetAddonAlertTemplatesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_addon_alert_templates(
        self,
        addon_name: str,
        request: cms_20240330_models.GetAddonAlertTemplatesRequest,
    ) -> cms_20240330_models.GetAddonAlertTemplatesResponse:
        """
        @summary 插件metrics详情(Addon)
        
        @param request: GetAddonAlertTemplatesRequest
        @return: GetAddonAlertTemplatesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_addon_alert_templates_with_options(addon_name, request, headers, runtime)

    async def get_addon_alert_templates_async(
        self,
        addon_name: str,
        request: cms_20240330_models.GetAddonAlertTemplatesRequest,
    ) -> cms_20240330_models.GetAddonAlertTemplatesResponse:
        """
        @summary 插件metrics详情(Addon)
        
        @param request: GetAddonAlertTemplatesRequest
        @return: GetAddonAlertTemplatesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_addon_alert_templates_with_options_async(addon_name, request, headers, runtime)

    def get_addon_code_template_with_options(
        self,
        addon_name: str,
        request: cms_20240330_models.GetAddonCodeTemplateRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetAddonCodeTemplateResponse:
        """
        @summary 插件schema详情(Addon)
        
        @param request: GetAddonCodeTemplateRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetAddonCodeTemplateResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.environment_type):
            query['environmentType'] = request.environment_type
        if not UtilClient.is_unset(request.version):
            query['version'] = request.version
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetAddonCodeTemplate',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/addons/{OpenApiUtilClient.get_encode_param(addon_name)}/alert-code-template',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetAddonCodeTemplateResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_addon_code_template_with_options_async(
        self,
        addon_name: str,
        request: cms_20240330_models.GetAddonCodeTemplateRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetAddonCodeTemplateResponse:
        """
        @summary 插件schema详情(Addon)
        
        @param request: GetAddonCodeTemplateRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetAddonCodeTemplateResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.environment_type):
            query['environmentType'] = request.environment_type
        if not UtilClient.is_unset(request.version):
            query['version'] = request.version
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetAddonCodeTemplate',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/addons/{OpenApiUtilClient.get_encode_param(addon_name)}/alert-code-template',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetAddonCodeTemplateResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_addon_code_template(
        self,
        addon_name: str,
        request: cms_20240330_models.GetAddonCodeTemplateRequest,
    ) -> cms_20240330_models.GetAddonCodeTemplateResponse:
        """
        @summary 插件schema详情(Addon)
        
        @param request: GetAddonCodeTemplateRequest
        @return: GetAddonCodeTemplateResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_addon_code_template_with_options(addon_name, request, headers, runtime)

    async def get_addon_code_template_async(
        self,
        addon_name: str,
        request: cms_20240330_models.GetAddonCodeTemplateRequest,
    ) -> cms_20240330_models.GetAddonCodeTemplateResponse:
        """
        @summary 插件schema详情(Addon)
        
        @param request: GetAddonCodeTemplateRequest
        @return: GetAddonCodeTemplateResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_addon_code_template_with_options_async(addon_name, request, headers, runtime)

    def get_addon_metrics_with_options(
        self,
        addon_name: str,
        request: cms_20240330_models.GetAddonMetricsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetAddonMetricsResponse:
        """
        @summary 插件metrics详情(Addon)
        
        @param request: GetAddonMetricsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetAddonMetricsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.environment_type):
            query['environmentType'] = request.environment_type
        if not UtilClient.is_unset(request.version):
            query['version'] = request.version
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetAddonMetrics',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/addons/{OpenApiUtilClient.get_encode_param(addon_name)}/metrics',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetAddonMetricsResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_addon_metrics_with_options_async(
        self,
        addon_name: str,
        request: cms_20240330_models.GetAddonMetricsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetAddonMetricsResponse:
        """
        @summary 插件metrics详情(Addon)
        
        @param request: GetAddonMetricsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetAddonMetricsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.environment_type):
            query['environmentType'] = request.environment_type
        if not UtilClient.is_unset(request.version):
            query['version'] = request.version
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetAddonMetrics',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/addons/{OpenApiUtilClient.get_encode_param(addon_name)}/metrics',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetAddonMetricsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_addon_metrics(
        self,
        addon_name: str,
        request: cms_20240330_models.GetAddonMetricsRequest,
    ) -> cms_20240330_models.GetAddonMetricsResponse:
        """
        @summary 插件metrics详情(Addon)
        
        @param request: GetAddonMetricsRequest
        @return: GetAddonMetricsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_addon_metrics_with_options(addon_name, request, headers, runtime)

    async def get_addon_metrics_async(
        self,
        addon_name: str,
        request: cms_20240330_models.GetAddonMetricsRequest,
    ) -> cms_20240330_models.GetAddonMetricsResponse:
        """
        @summary 插件metrics详情(Addon)
        
        @param request: GetAddonMetricsRequest
        @return: GetAddonMetricsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_addon_metrics_with_options_async(addon_name, request, headers, runtime)

    def get_addon_release_with_options(
        self,
        release_name: str,
        policy_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetAddonReleaseResponse:
        """
        @summary Check addon release (view connection status)
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetAddonReleaseResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetAddonRelease',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/addon-releases/{OpenApiUtilClient.get_encode_param(release_name)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetAddonReleaseResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_addon_release_with_options_async(
        self,
        release_name: str,
        policy_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetAddonReleaseResponse:
        """
        @summary Check addon release (view connection status)
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetAddonReleaseResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetAddonRelease',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/addon-releases/{OpenApiUtilClient.get_encode_param(release_name)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetAddonReleaseResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_addon_release(
        self,
        release_name: str,
        policy_id: str,
    ) -> cms_20240330_models.GetAddonReleaseResponse:
        """
        @summary Check addon release (view connection status)
        
        @return: GetAddonReleaseResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_addon_release_with_options(release_name, policy_id, headers, runtime)

    async def get_addon_release_async(
        self,
        release_name: str,
        policy_id: str,
    ) -> cms_20240330_models.GetAddonReleaseResponse:
        """
        @summary Check addon release (view connection status)
        
        @return: GetAddonReleaseResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_addon_release_with_options_async(release_name, policy_id, headers, runtime)

    def get_addon_schema_with_options(
        self,
        addon_name: str,
        request: cms_20240330_models.GetAddonSchemaRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetAddonSchemaResponse:
        """
        @summary 插件schema详情(Addon)
        
        @param request: GetAddonSchemaRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetAddonSchemaResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.environment_type):
            query['environmentType'] = request.environment_type
        if not UtilClient.is_unset(request.version):
            query['version'] = request.version
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetAddonSchema',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/addons/{OpenApiUtilClient.get_encode_param(addon_name)}/schema',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetAddonSchemaResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_addon_schema_with_options_async(
        self,
        addon_name: str,
        request: cms_20240330_models.GetAddonSchemaRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetAddonSchemaResponse:
        """
        @summary 插件schema详情(Addon)
        
        @param request: GetAddonSchemaRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetAddonSchemaResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.environment_type):
            query['environmentType'] = request.environment_type
        if not UtilClient.is_unset(request.version):
            query['version'] = request.version
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetAddonSchema',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/addons/{OpenApiUtilClient.get_encode_param(addon_name)}/schema',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetAddonSchemaResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_addon_schema(
        self,
        addon_name: str,
        request: cms_20240330_models.GetAddonSchemaRequest,
    ) -> cms_20240330_models.GetAddonSchemaResponse:
        """
        @summary 插件schema详情(Addon)
        
        @param request: GetAddonSchemaRequest
        @return: GetAddonSchemaResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_addon_schema_with_options(addon_name, request, headers, runtime)

    async def get_addon_schema_async(
        self,
        addon_name: str,
        request: cms_20240330_models.GetAddonSchemaRequest,
    ) -> cms_20240330_models.GetAddonSchemaResponse:
        """
        @summary 插件schema详情(Addon)
        
        @param request: GetAddonSchemaRequest
        @return: GetAddonSchemaResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_addon_schema_with_options_async(addon_name, request, headers, runtime)

    def get_agg_task_group_with_options(
        self,
        instance_id: str,
        group_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetAggTaskGroupResponse:
        """
        @summary Describes the aggregation task group
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetAggTaskGroupResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetAggTaskGroup',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(instance_id)}/agg-task-groups/{OpenApiUtilClient.get_encode_param(group_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetAggTaskGroupResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_agg_task_group_with_options_async(
        self,
        instance_id: str,
        group_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetAggTaskGroupResponse:
        """
        @summary Describes the aggregation task group
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetAggTaskGroupResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetAggTaskGroup',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(instance_id)}/agg-task-groups/{OpenApiUtilClient.get_encode_param(group_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetAggTaskGroupResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_agg_task_group(
        self,
        instance_id: str,
        group_id: str,
    ) -> cms_20240330_models.GetAggTaskGroupResponse:
        """
        @summary Describes the aggregation task group
        
        @return: GetAggTaskGroupResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_agg_task_group_with_options(instance_id, group_id, headers, runtime)

    async def get_agg_task_group_async(
        self,
        instance_id: str,
        group_id: str,
    ) -> cms_20240330_models.GetAggTaskGroupResponse:
        """
        @summary Describes the aggregation task group
        
        @return: GetAggTaskGroupResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_agg_task_group_with_options_async(instance_id, group_id, headers, runtime)

    def get_alert_action_with_options(
        self,
        alert_action_id: str,
        request: cms_20240330_models.GetAlertActionRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetAlertActionResponse:
        """
        @summary 查询告警动作
        
        @param request: GetAlertActionRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetAlertActionResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetAlertAction',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertAction/{OpenApiUtilClient.get_encode_param(alert_action_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetAlertActionResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_alert_action_with_options_async(
        self,
        alert_action_id: str,
        request: cms_20240330_models.GetAlertActionRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetAlertActionResponse:
        """
        @summary 查询告警动作
        
        @param request: GetAlertActionRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetAlertActionResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetAlertAction',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertAction/{OpenApiUtilClient.get_encode_param(alert_action_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetAlertActionResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_alert_action(
        self,
        alert_action_id: str,
        request: cms_20240330_models.GetAlertActionRequest,
    ) -> cms_20240330_models.GetAlertActionResponse:
        """
        @summary 查询告警动作
        
        @param request: GetAlertActionRequest
        @return: GetAlertActionResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_alert_action_with_options(alert_action_id, request, headers, runtime)

    async def get_alert_action_async(
        self,
        alert_action_id: str,
        request: cms_20240330_models.GetAlertActionRequest,
    ) -> cms_20240330_models.GetAlertActionResponse:
        """
        @summary 查询告警动作
        
        @param request: GetAlertActionRequest
        @return: GetAlertActionResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_alert_action_with_options_async(alert_action_id, request, headers, runtime)

    def get_alert_event_integration_policy_with_options(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.GetAlertEventIntegrationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetAlertEventIntegrationPolicyResponse:
        """
        @summary 获取订阅
        
        @param request: GetAlertEventIntegrationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetAlertEventIntegrationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetAlertEventIntegrationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertEventIntegrationPolicies/{OpenApiUtilClient.get_encode_param(alert_event_integration_policy_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetAlertEventIntegrationPolicyResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_alert_event_integration_policy_with_options_async(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.GetAlertEventIntegrationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetAlertEventIntegrationPolicyResponse:
        """
        @summary 获取订阅
        
        @param request: GetAlertEventIntegrationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetAlertEventIntegrationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetAlertEventIntegrationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertEventIntegrationPolicies/{OpenApiUtilClient.get_encode_param(alert_event_integration_policy_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetAlertEventIntegrationPolicyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_alert_event_integration_policy(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.GetAlertEventIntegrationPolicyRequest,
    ) -> cms_20240330_models.GetAlertEventIntegrationPolicyResponse:
        """
        @summary 获取订阅
        
        @param request: GetAlertEventIntegrationPolicyRequest
        @return: GetAlertEventIntegrationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_alert_event_integration_policy_with_options(alert_event_integration_policy_id, request, headers, runtime)

    async def get_alert_event_integration_policy_async(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.GetAlertEventIntegrationPolicyRequest,
    ) -> cms_20240330_models.GetAlertEventIntegrationPolicyResponse:
        """
        @summary 获取订阅
        
        @param request: GetAlertEventIntegrationPolicyRequest
        @return: GetAlertEventIntegrationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_alert_event_integration_policy_with_options_async(alert_event_integration_policy_id, request, headers, runtime)

    def get_biz_trace_with_options(
        self,
        biz_trace_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetBizTraceResponse:
        """
        @summary 查询业务链路
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetBizTraceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetBizTrace',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/bizTrace/{OpenApiUtilClient.get_encode_param(biz_trace_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetBizTraceResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_biz_trace_with_options_async(
        self,
        biz_trace_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetBizTraceResponse:
        """
        @summary 查询业务链路
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetBizTraceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetBizTrace',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/bizTrace/{OpenApiUtilClient.get_encode_param(biz_trace_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetBizTraceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_biz_trace(
        self,
        biz_trace_id: str,
    ) -> cms_20240330_models.GetBizTraceResponse:
        """
        @summary 查询业务链路
        
        @return: GetBizTraceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_biz_trace_with_options(biz_trace_id, headers, runtime)

    async def get_biz_trace_async(
        self,
        biz_trace_id: str,
    ) -> cms_20240330_models.GetBizTraceResponse:
        """
        @summary 查询业务链路
        
        @return: GetBizTraceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_biz_trace_with_options_async(biz_trace_id, headers, runtime)

    def get_cloud_resource_with_options(
        self,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetCloudResourceResponse:
        """
        @summary 查询云资源中心
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetCloudResourceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetCloudResource',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/cloudresource',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetCloudResourceResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_cloud_resource_with_options_async(
        self,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetCloudResourceResponse:
        """
        @summary 查询云资源中心
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetCloudResourceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetCloudResource',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/cloudresource',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetCloudResourceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_cloud_resource(self) -> cms_20240330_models.GetCloudResourceResponse:
        """
        @summary 查询云资源中心
        
        @return: GetCloudResourceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_cloud_resource_with_options(headers, runtime)

    async def get_cloud_resource_async(self) -> cms_20240330_models.GetCloudResourceResponse:
        """
        @summary 查询云资源中心
        
        @return: GetCloudResourceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_cloud_resource_with_options_async(headers, runtime)

    def get_cloud_resource_data_with_options(
        self,
        request: cms_20240330_models.GetCloudResourceDataRequest,
        headers: cms_20240330_models.GetCloudResourceDataHeaders,
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetCloudResourceDataResponse:
        """
        @summary 查询云资源中心数据
        
        @param request: GetCloudResourceDataRequest
        @param headers: GetCloudResourceDataHeaders
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetCloudResourceDataResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.from_):
            query['from'] = request.from_
        if not UtilClient.is_unset(request.query):
            query['query'] = request.query
        if not UtilClient.is_unset(request.to):
            query['to'] = request.to
        real_headers = {}
        if not UtilClient.is_unset(headers.common_headers):
            real_headers = headers.common_headers
        if not UtilClient.is_unset(headers.accept_encoding):
            real_headers['Accept-Encoding'] = UtilClient.to_jsonstring(headers.accept_encoding)
        req = open_api_models.OpenApiRequest(
            headers=real_headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetCloudResourceData',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/cloudresource/data',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetCloudResourceDataResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_cloud_resource_data_with_options_async(
        self,
        request: cms_20240330_models.GetCloudResourceDataRequest,
        headers: cms_20240330_models.GetCloudResourceDataHeaders,
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetCloudResourceDataResponse:
        """
        @summary 查询云资源中心数据
        
        @param request: GetCloudResourceDataRequest
        @param headers: GetCloudResourceDataHeaders
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetCloudResourceDataResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.from_):
            query['from'] = request.from_
        if not UtilClient.is_unset(request.query):
            query['query'] = request.query
        if not UtilClient.is_unset(request.to):
            query['to'] = request.to
        real_headers = {}
        if not UtilClient.is_unset(headers.common_headers):
            real_headers = headers.common_headers
        if not UtilClient.is_unset(headers.accept_encoding):
            real_headers['Accept-Encoding'] = UtilClient.to_jsonstring(headers.accept_encoding)
        req = open_api_models.OpenApiRequest(
            headers=real_headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetCloudResourceData',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/cloudresource/data',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetCloudResourceDataResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_cloud_resource_data(
        self,
        request: cms_20240330_models.GetCloudResourceDataRequest,
    ) -> cms_20240330_models.GetCloudResourceDataResponse:
        """
        @summary 查询云资源中心数据
        
        @param request: GetCloudResourceDataRequest
        @return: GetCloudResourceDataResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = cms_20240330_models.GetCloudResourceDataHeaders()
        return self.get_cloud_resource_data_with_options(request, headers, runtime)

    async def get_cloud_resource_data_async(
        self,
        request: cms_20240330_models.GetCloudResourceDataRequest,
    ) -> cms_20240330_models.GetCloudResourceDataResponse:
        """
        @summary 查询云资源中心数据
        
        @param request: GetCloudResourceDataRequest
        @return: GetCloudResourceDataResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = cms_20240330_models.GetCloudResourceDataHeaders()
        return await self.get_cloud_resource_data_with_options_async(request, headers, runtime)

    def get_cms_service_with_options(
        self,
        request: cms_20240330_models.GetCmsServiceRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetCmsServiceResponse:
        """
        @summary 获取云监控开通状态
        
        @param request: GetCmsServiceRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetCmsServiceResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.product):
            query['product'] = request.product
        if not UtilClient.is_unset(request.service):
            query['service'] = request.service
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetCmsService',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/cmsservice',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetCmsServiceResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_cms_service_with_options_async(
        self,
        request: cms_20240330_models.GetCmsServiceRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetCmsServiceResponse:
        """
        @summary 获取云监控开通状态
        
        @param request: GetCmsServiceRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetCmsServiceResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.product):
            query['product'] = request.product
        if not UtilClient.is_unset(request.service):
            query['service'] = request.service
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetCmsService',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/cmsservice',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetCmsServiceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_cms_service(
        self,
        request: cms_20240330_models.GetCmsServiceRequest,
    ) -> cms_20240330_models.GetCmsServiceResponse:
        """
        @summary 获取云监控开通状态
        
        @param request: GetCmsServiceRequest
        @return: GetCmsServiceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_cms_service_with_options(request, headers, runtime)

    async def get_cms_service_async(
        self,
        request: cms_20240330_models.GetCmsServiceRequest,
    ) -> cms_20240330_models.GetCmsServiceResponse:
        """
        @summary 获取云监控开通状态
        
        @param request: GetCmsServiceRequest
        @return: GetCmsServiceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_cms_service_with_options_async(request, headers, runtime)

    def get_dataset_with_options(
        self,
        workspace: str,
        dataset_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetDatasetResponse:
        """
        @summary 查询数据集
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetDatasetResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetDataset',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/dataset/{OpenApiUtilClient.get_encode_param(dataset_name)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetDatasetResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_dataset_with_options_async(
        self,
        workspace: str,
        dataset_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetDatasetResponse:
        """
        @summary 查询数据集
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetDatasetResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetDataset',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/dataset/{OpenApiUtilClient.get_encode_param(dataset_name)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetDatasetResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_dataset(
        self,
        workspace: str,
        dataset_name: str,
    ) -> cms_20240330_models.GetDatasetResponse:
        """
        @summary 查询数据集
        
        @return: GetDatasetResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_dataset_with_options(workspace, dataset_name, headers, runtime)

    async def get_dataset_async(
        self,
        workspace: str,
        dataset_name: str,
    ) -> cms_20240330_models.GetDatasetResponse:
        """
        @summary 查询数据集
        
        @return: GetDatasetResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_dataset_with_options_async(workspace, dataset_name, headers, runtime)

    def get_delivery_task_with_options(
        self,
        task_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetDeliveryTaskResponse:
        """
        @summary 获取数据投递任务详情
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetDeliveryTaskResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetDeliveryTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/delivery-task/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetDeliveryTaskResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_delivery_task_with_options_async(
        self,
        task_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetDeliveryTaskResponse:
        """
        @summary 获取数据投递任务详情
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetDeliveryTaskResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetDeliveryTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/delivery-task/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetDeliveryTaskResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_delivery_task(
        self,
        task_id: str,
    ) -> cms_20240330_models.GetDeliveryTaskResponse:
        """
        @summary 获取数据投递任务详情
        
        @return: GetDeliveryTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_delivery_task_with_options(task_id, headers, runtime)

    async def get_delivery_task_async(
        self,
        task_id: str,
    ) -> cms_20240330_models.GetDeliveryTaskResponse:
        """
        @summary 获取数据投递任务详情
        
        @return: GetDeliveryTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_delivery_task_with_options_async(task_id, headers, runtime)

    def get_digital_employee_with_options(
        self,
        name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetDigitalEmployeeResponse:
        """
        @summary 查询 DigitalEmployee
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetDigitalEmployeeResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetDigitalEmployee',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digital-employee/{OpenApiUtilClient.get_encode_param(name)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetDigitalEmployeeResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_digital_employee_with_options_async(
        self,
        name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetDigitalEmployeeResponse:
        """
        @summary 查询 DigitalEmployee
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetDigitalEmployeeResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetDigitalEmployee',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digital-employee/{OpenApiUtilClient.get_encode_param(name)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetDigitalEmployeeResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_digital_employee(
        self,
        name: str,
    ) -> cms_20240330_models.GetDigitalEmployeeResponse:
        """
        @summary 查询 DigitalEmployee
        
        @return: GetDigitalEmployeeResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_digital_employee_with_options(name, headers, runtime)

    async def get_digital_employee_async(
        self,
        name: str,
    ) -> cms_20240330_models.GetDigitalEmployeeResponse:
        """
        @summary 查询 DigitalEmployee
        
        @return: GetDigitalEmployeeResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_digital_employee_with_options_async(name, headers, runtime)

    def get_digital_employee_skill_with_options(
        self,
        name: str,
        skill_name: str,
        request: cms_20240330_models.GetDigitalEmployeeSkillRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetDigitalEmployeeSkillResponse:
        """
        @summary 获取技能详情
        
        @param request: GetDigitalEmployeeSkillRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetDigitalEmployeeSkillResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.version):
            query['version'] = request.version
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetDigitalEmployeeSkill',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/skill/{OpenApiUtilClient.get_encode_param(skill_name)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetDigitalEmployeeSkillResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_digital_employee_skill_with_options_async(
        self,
        name: str,
        skill_name: str,
        request: cms_20240330_models.GetDigitalEmployeeSkillRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetDigitalEmployeeSkillResponse:
        """
        @summary 获取技能详情
        
        @param request: GetDigitalEmployeeSkillRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetDigitalEmployeeSkillResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.version):
            query['version'] = request.version
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetDigitalEmployeeSkill',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/skill/{OpenApiUtilClient.get_encode_param(skill_name)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetDigitalEmployeeSkillResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_digital_employee_skill(
        self,
        name: str,
        skill_name: str,
        request: cms_20240330_models.GetDigitalEmployeeSkillRequest,
    ) -> cms_20240330_models.GetDigitalEmployeeSkillResponse:
        """
        @summary 获取技能详情
        
        @param request: GetDigitalEmployeeSkillRequest
        @return: GetDigitalEmployeeSkillResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_digital_employee_skill_with_options(name, skill_name, request, headers, runtime)

    async def get_digital_employee_skill_async(
        self,
        name: str,
        skill_name: str,
        request: cms_20240330_models.GetDigitalEmployeeSkillRequest,
    ) -> cms_20240330_models.GetDigitalEmployeeSkillResponse:
        """
        @summary 获取技能详情
        
        @param request: GetDigitalEmployeeSkillRequest
        @return: GetDigitalEmployeeSkillResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_digital_employee_skill_with_options_async(name, skill_name, request, headers, runtime)

    def get_entity_store_with_options(
        self,
        workspace_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetEntityStoreResponse:
        """
        @summary Get EntityStore related storage information
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetEntityStoreResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetEntityStore',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace_name)}/entitystore',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetEntityStoreResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_entity_store_with_options_async(
        self,
        workspace_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetEntityStoreResponse:
        """
        @summary Get EntityStore related storage information
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetEntityStoreResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetEntityStore',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace_name)}/entitystore',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetEntityStoreResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_entity_store(
        self,
        workspace_name: str,
    ) -> cms_20240330_models.GetEntityStoreResponse:
        """
        @summary Get EntityStore related storage information
        
        @return: GetEntityStoreResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_entity_store_with_options(workspace_name, headers, runtime)

    async def get_entity_store_async(
        self,
        workspace_name: str,
    ) -> cms_20240330_models.GetEntityStoreResponse:
        """
        @summary Get EntityStore related storage information
        
        @return: GetEntityStoreResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_entity_store_with_options_async(workspace_name, headers, runtime)

    def get_entity_store_data_with_options(
        self,
        workspace: str,
        request: cms_20240330_models.GetEntityStoreDataRequest,
        headers: cms_20240330_models.GetEntityStoreDataHeaders,
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetEntityStoreDataResponse:
        """
        @summary Query the entity and relationship data under a specified Workspace, returning the entity data within a certain time range (the returned result is transmitted after compression).
        
        @param request: GetEntityStoreDataRequest
        @param headers: GetEntityStoreDataHeaders
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetEntityStoreDataResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.from_):
            body['from'] = request.from_
        if not UtilClient.is_unset(request.query):
            body['query'] = request.query
        if not UtilClient.is_unset(request.to):
            body['to'] = request.to
        real_headers = {}
        if not UtilClient.is_unset(headers.common_headers):
            real_headers = headers.common_headers
        if not UtilClient.is_unset(headers.accept_encoding):
            real_headers['acceptEncoding'] = UtilClient.to_jsonstring(headers.accept_encoding)
        req = open_api_models.OpenApiRequest(
            headers=real_headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='GetEntityStoreData',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/entitiesAndRelations',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetEntityStoreDataResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_entity_store_data_with_options_async(
        self,
        workspace: str,
        request: cms_20240330_models.GetEntityStoreDataRequest,
        headers: cms_20240330_models.GetEntityStoreDataHeaders,
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetEntityStoreDataResponse:
        """
        @summary Query the entity and relationship data under a specified Workspace, returning the entity data within a certain time range (the returned result is transmitted after compression).
        
        @param request: GetEntityStoreDataRequest
        @param headers: GetEntityStoreDataHeaders
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetEntityStoreDataResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.from_):
            body['from'] = request.from_
        if not UtilClient.is_unset(request.query):
            body['query'] = request.query
        if not UtilClient.is_unset(request.to):
            body['to'] = request.to
        real_headers = {}
        if not UtilClient.is_unset(headers.common_headers):
            real_headers = headers.common_headers
        if not UtilClient.is_unset(headers.accept_encoding):
            real_headers['acceptEncoding'] = UtilClient.to_jsonstring(headers.accept_encoding)
        req = open_api_models.OpenApiRequest(
            headers=real_headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='GetEntityStoreData',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/entitiesAndRelations',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetEntityStoreDataResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_entity_store_data(
        self,
        workspace: str,
        request: cms_20240330_models.GetEntityStoreDataRequest,
    ) -> cms_20240330_models.GetEntityStoreDataResponse:
        """
        @summary Query the entity and relationship data under a specified Workspace, returning the entity data within a certain time range (the returned result is transmitted after compression).
        
        @param request: GetEntityStoreDataRequest
        @return: GetEntityStoreDataResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = cms_20240330_models.GetEntityStoreDataHeaders()
        return self.get_entity_store_data_with_options(workspace, request, headers, runtime)

    async def get_entity_store_data_async(
        self,
        workspace: str,
        request: cms_20240330_models.GetEntityStoreDataRequest,
    ) -> cms_20240330_models.GetEntityStoreDataResponse:
        """
        @summary Query the entity and relationship data under a specified Workspace, returning the entity data within a certain time range (the returned result is transmitted after compression).
        
        @param request: GetEntityStoreDataRequest
        @return: GetEntityStoreDataResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = cms_20240330_models.GetEntityStoreDataHeaders()
        return await self.get_entity_store_data_with_options_async(workspace, request, headers, runtime)

    def get_escalation_policy_with_options(
        self,
        uuid: str,
        request: cms_20240330_models.GetEscalationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetEscalationPolicyResponse:
        """
        @summary 获取升级策略
        
        @param request: GetEscalationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetEscalationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetEscalationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/escalationPolicies/{OpenApiUtilClient.get_encode_param(uuid)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetEscalationPolicyResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_escalation_policy_with_options_async(
        self,
        uuid: str,
        request: cms_20240330_models.GetEscalationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetEscalationPolicyResponse:
        """
        @summary 获取升级策略
        
        @param request: GetEscalationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetEscalationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetEscalationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/escalationPolicies/{OpenApiUtilClient.get_encode_param(uuid)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetEscalationPolicyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_escalation_policy(
        self,
        uuid: str,
        request: cms_20240330_models.GetEscalationPolicyRequest,
    ) -> cms_20240330_models.GetEscalationPolicyResponse:
        """
        @summary 获取升级策略
        
        @param request: GetEscalationPolicyRequest
        @return: GetEscalationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_escalation_policy_with_options(uuid, request, headers, runtime)

    async def get_escalation_policy_async(
        self,
        uuid: str,
        request: cms_20240330_models.GetEscalationPolicyRequest,
    ) -> cms_20240330_models.GetEscalationPolicyResponse:
        """
        @summary 获取升级策略
        
        @param request: GetEscalationPolicyRequest
        @return: GetEscalationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_escalation_policy_with_options_async(uuid, request, headers, runtime)

    def get_evaluation_task_with_options(
        self,
        workspace: str,
        task_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetEvaluationTaskResponse:
        """
        @summary 获取评估任务详情
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetEvaluationTaskResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetEvaluationTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/evaluation-task/{OpenApiUtilClient.get_encode_param(workspace)}/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetEvaluationTaskResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_evaluation_task_with_options_async(
        self,
        workspace: str,
        task_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetEvaluationTaskResponse:
        """
        @summary 获取评估任务详情
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetEvaluationTaskResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetEvaluationTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/evaluation-task/{OpenApiUtilClient.get_encode_param(workspace)}/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetEvaluationTaskResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_evaluation_task(
        self,
        workspace: str,
        task_id: str,
    ) -> cms_20240330_models.GetEvaluationTaskResponse:
        """
        @summary 获取评估任务详情
        
        @return: GetEvaluationTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_evaluation_task_with_options(workspace, task_id, headers, runtime)

    async def get_evaluation_task_async(
        self,
        workspace: str,
        task_id: str,
    ) -> cms_20240330_models.GetEvaluationTaskResponse:
        """
        @summary 获取评估任务详情
        
        @return: GetEvaluationTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_evaluation_task_with_options_async(workspace, task_id, headers, runtime)

    def get_experiment_plan_with_options(
        self,
        workspace: str,
        plan_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetExperimentPlanResponse:
        """
        @summary 查询实验计划
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetExperimentPlanResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetExperimentPlan',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/experiments/{OpenApiUtilClient.get_encode_param(workspace)}/plans/{OpenApiUtilClient.get_encode_param(plan_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetExperimentPlanResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_experiment_plan_with_options_async(
        self,
        workspace: str,
        plan_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetExperimentPlanResponse:
        """
        @summary 查询实验计划
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetExperimentPlanResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetExperimentPlan',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/experiments/{OpenApiUtilClient.get_encode_param(workspace)}/plans/{OpenApiUtilClient.get_encode_param(plan_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetExperimentPlanResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_experiment_plan(
        self,
        workspace: str,
        plan_id: str,
    ) -> cms_20240330_models.GetExperimentPlanResponse:
        """
        @summary 查询实验计划
        
        @return: GetExperimentPlanResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_experiment_plan_with_options(workspace, plan_id, headers, runtime)

    async def get_experiment_plan_async(
        self,
        workspace: str,
        plan_id: str,
    ) -> cms_20240330_models.GetExperimentPlanResponse:
        """
        @summary 查询实验计划
        
        @return: GetExperimentPlanResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_experiment_plan_with_options_async(workspace, plan_id, headers, runtime)

    def get_experiment_task_with_options(
        self,
        workspace: str,
        record_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetExperimentTaskResponse:
        """
        @summary 查询实验详情
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetExperimentTaskResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetExperimentTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/experiments/{OpenApiUtilClient.get_encode_param(workspace)}/records/{OpenApiUtilClient.get_encode_param(record_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetExperimentTaskResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_experiment_task_with_options_async(
        self,
        workspace: str,
        record_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetExperimentTaskResponse:
        """
        @summary 查询实验详情
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetExperimentTaskResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetExperimentTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/experiments/{OpenApiUtilClient.get_encode_param(workspace)}/records/{OpenApiUtilClient.get_encode_param(record_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetExperimentTaskResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_experiment_task(
        self,
        workspace: str,
        record_id: str,
    ) -> cms_20240330_models.GetExperimentTaskResponse:
        """
        @summary 查询实验详情
        
        @return: GetExperimentTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_experiment_task_with_options(workspace, record_id, headers, runtime)

    async def get_experiment_task_async(
        self,
        workspace: str,
        record_id: str,
    ) -> cms_20240330_models.GetExperimentTaskResponse:
        """
        @summary 查询实验详情
        
        @return: GetExperimentTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_experiment_task_with_options_async(workspace, record_id, headers, runtime)

    def get_incident_with_options(
        self,
        uuid: str,
        request: cms_20240330_models.GetIncidentRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetIncidentResponse:
        """
        @summary 执行Incident动作
        
        @param request: GetIncidentRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetIncidentResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetIncident',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/incident/{OpenApiUtilClient.get_encode_param(uuid)}/get',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetIncidentResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_incident_with_options_async(
        self,
        uuid: str,
        request: cms_20240330_models.GetIncidentRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetIncidentResponse:
        """
        @summary 执行Incident动作
        
        @param request: GetIncidentRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetIncidentResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetIncident',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/incident/{OpenApiUtilClient.get_encode_param(uuid)}/get',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetIncidentResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_incident(
        self,
        uuid: str,
        request: cms_20240330_models.GetIncidentRequest,
    ) -> cms_20240330_models.GetIncidentResponse:
        """
        @summary 执行Incident动作
        
        @param request: GetIncidentRequest
        @return: GetIncidentResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_incident_with_options(uuid, request, headers, runtime)

    async def get_incident_async(
        self,
        uuid: str,
        request: cms_20240330_models.GetIncidentRequest,
    ) -> cms_20240330_models.GetIncidentResponse:
        """
        @summary 执行Incident动作
        
        @param request: GetIncidentRequest
        @return: GetIncidentResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_incident_with_options_async(uuid, request, headers, runtime)

    def get_integration_policy_with_options(
        self,
        policy_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetIntegrationPolicyResponse:
        """
        @summary Query the list of access center policies
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetIntegrationPolicyResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetIntegrationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetIntegrationPolicyResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_integration_policy_with_options_async(
        self,
        policy_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetIntegrationPolicyResponse:
        """
        @summary Query the list of access center policies
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetIntegrationPolicyResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetIntegrationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetIntegrationPolicyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_integration_policy(
        self,
        policy_id: str,
    ) -> cms_20240330_models.GetIntegrationPolicyResponse:
        """
        @summary Query the list of access center policies
        
        @return: GetIntegrationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_integration_policy_with_options(policy_id, headers, runtime)

    async def get_integration_policy_async(
        self,
        policy_id: str,
    ) -> cms_20240330_models.GetIntegrationPolicyResponse:
        """
        @summary Query the list of access center policies
        
        @return: GetIntegrationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_integration_policy_with_options_async(policy_id, headers, runtime)

    def get_integration_version_for_cswith_options(
        self,
        request: cms_20240330_models.GetIntegrationVersionForCSRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetIntegrationVersionForCSResponse:
        """
        @summary 查询接入中心在CS的版本
        
        @param request: GetIntegrationVersionForCSRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetIntegrationVersionForCSResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.cluster_id):
            query['clusterId'] = request.cluster_id
        if not UtilClient.is_unset(request.cluster_type):
            query['clusterType'] = request.cluster_type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetIntegrationVersionForCS',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-version/cs',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetIntegrationVersionForCSResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_integration_version_for_cswith_options_async(
        self,
        request: cms_20240330_models.GetIntegrationVersionForCSRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetIntegrationVersionForCSResponse:
        """
        @summary 查询接入中心在CS的版本
        
        @param request: GetIntegrationVersionForCSRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetIntegrationVersionForCSResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.cluster_id):
            query['clusterId'] = request.cluster_id
        if not UtilClient.is_unset(request.cluster_type):
            query['clusterType'] = request.cluster_type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetIntegrationVersionForCS',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-version/cs',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetIntegrationVersionForCSResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_integration_version_for_cs(
        self,
        request: cms_20240330_models.GetIntegrationVersionForCSRequest,
    ) -> cms_20240330_models.GetIntegrationVersionForCSResponse:
        """
        @summary 查询接入中心在CS的版本
        
        @param request: GetIntegrationVersionForCSRequest
        @return: GetIntegrationVersionForCSResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_integration_version_for_cswith_options(request, headers, runtime)

    async def get_integration_version_for_cs_async(
        self,
        request: cms_20240330_models.GetIntegrationVersionForCSRequest,
    ) -> cms_20240330_models.GetIntegrationVersionForCSResponse:
        """
        @summary 查询接入中心在CS的版本
        
        @param request: GetIntegrationVersionForCSRequest
        @return: GetIntegrationVersionForCSResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_integration_version_for_cswith_options_async(request, headers, runtime)

    def get_kube_config_with_options(
        self,
        request: cms_20240330_models.GetKubeConfigRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetKubeConfigResponse:
        """
        @summary 获取KubeConfig
        
        @param request: GetKubeConfigRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetKubeConfigResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.cluster_id):
            query['clusterId'] = request.cluster_id
        if not UtilClient.is_unset(request.cluster_region_id):
            query['clusterRegionId'] = request.cluster_region_id
        if not UtilClient.is_unset(request.user_id):
            query['userId'] = request.user_id
        if not UtilClient.is_unset(request.user_token):
            query['userToken'] = request.user_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetKubeConfig',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/inner/v1/kube-config',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetKubeConfigResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_kube_config_with_options_async(
        self,
        request: cms_20240330_models.GetKubeConfigRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetKubeConfigResponse:
        """
        @summary 获取KubeConfig
        
        @param request: GetKubeConfigRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetKubeConfigResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.cluster_id):
            query['clusterId'] = request.cluster_id
        if not UtilClient.is_unset(request.cluster_region_id):
            query['clusterRegionId'] = request.cluster_region_id
        if not UtilClient.is_unset(request.user_id):
            query['userId'] = request.user_id
        if not UtilClient.is_unset(request.user_token):
            query['userToken'] = request.user_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetKubeConfig',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/inner/v1/kube-config',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetKubeConfigResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_kube_config(
        self,
        request: cms_20240330_models.GetKubeConfigRequest,
    ) -> cms_20240330_models.GetKubeConfigResponse:
        """
        @summary 获取KubeConfig
        
        @param request: GetKubeConfigRequest
        @return: GetKubeConfigResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_kube_config_with_options(request, headers, runtime)

    async def get_kube_config_async(
        self,
        request: cms_20240330_models.GetKubeConfigRequest,
    ) -> cms_20240330_models.GetKubeConfigResponse:
        """
        @summary 获取KubeConfig
        
        @param request: GetKubeConfigRequest
        @return: GetKubeConfigResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_kube_config_with_options_async(request, headers, runtime)

    def get_maintain_window_with_options(
        self,
        maintain_window_id: str,
        request: cms_20240330_models.GetMaintainWindowRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetMaintainWindowResponse:
        """
        @summary 获取订阅
        
        @param request: GetMaintainWindowRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetMaintainWindowResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetMaintainWindow',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/maintainWindows/{OpenApiUtilClient.get_encode_param(maintain_window_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetMaintainWindowResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_maintain_window_with_options_async(
        self,
        maintain_window_id: str,
        request: cms_20240330_models.GetMaintainWindowRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetMaintainWindowResponse:
        """
        @summary 获取订阅
        
        @param request: GetMaintainWindowRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetMaintainWindowResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetMaintainWindow',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/maintainWindows/{OpenApiUtilClient.get_encode_param(maintain_window_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetMaintainWindowResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_maintain_window(
        self,
        maintain_window_id: str,
        request: cms_20240330_models.GetMaintainWindowRequest,
    ) -> cms_20240330_models.GetMaintainWindowResponse:
        """
        @summary 获取订阅
        
        @param request: GetMaintainWindowRequest
        @return: GetMaintainWindowResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_maintain_window_with_options(maintain_window_id, request, headers, runtime)

    async def get_maintain_window_async(
        self,
        maintain_window_id: str,
        request: cms_20240330_models.GetMaintainWindowRequest,
    ) -> cms_20240330_models.GetMaintainWindowResponse:
        """
        @summary 获取订阅
        
        @param request: GetMaintainWindowRequest
        @return: GetMaintainWindowResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_maintain_window_with_options_async(maintain_window_id, request, headers, runtime)

    def get_memories_with_options(
        self,
        workspace: str,
        memory_store_name: str,
        request: cms_20240330_models.GetMemoriesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetMemoriesResponse:
        """
        @summary 查询全部记忆
        
        @param request: GetMemoriesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetMemoriesResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.agent_id):
            body['agentId'] = request.agent_id
        if not UtilClient.is_unset(request.app_id):
            body['appId'] = request.app_id
        if not UtilClient.is_unset(request.limit):
            body['limit'] = request.limit
        if not UtilClient.is_unset(request.metadata):
            body['metadata'] = request.metadata
        if not UtilClient.is_unset(request.page):
            body['page'] = request.page
        if not UtilClient.is_unset(request.page_size):
            body['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.run_id):
            body['runId'] = request.run_id
        if not UtilClient.is_unset(request.user_id):
            body['userId'] = request.user_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='GetMemories',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}/memory/query',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetMemoriesResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_memories_with_options_async(
        self,
        workspace: str,
        memory_store_name: str,
        request: cms_20240330_models.GetMemoriesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetMemoriesResponse:
        """
        @summary 查询全部记忆
        
        @param request: GetMemoriesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetMemoriesResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.agent_id):
            body['agentId'] = request.agent_id
        if not UtilClient.is_unset(request.app_id):
            body['appId'] = request.app_id
        if not UtilClient.is_unset(request.limit):
            body['limit'] = request.limit
        if not UtilClient.is_unset(request.metadata):
            body['metadata'] = request.metadata
        if not UtilClient.is_unset(request.page):
            body['page'] = request.page
        if not UtilClient.is_unset(request.page_size):
            body['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.run_id):
            body['runId'] = request.run_id
        if not UtilClient.is_unset(request.user_id):
            body['userId'] = request.user_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='GetMemories',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}/memory/query',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetMemoriesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_memories(
        self,
        workspace: str,
        memory_store_name: str,
        request: cms_20240330_models.GetMemoriesRequest,
    ) -> cms_20240330_models.GetMemoriesResponse:
        """
        @summary 查询全部记忆
        
        @param request: GetMemoriesRequest
        @return: GetMemoriesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_memories_with_options(workspace, memory_store_name, request, headers, runtime)

    async def get_memories_async(
        self,
        workspace: str,
        memory_store_name: str,
        request: cms_20240330_models.GetMemoriesRequest,
    ) -> cms_20240330_models.GetMemoriesResponse:
        """
        @summary 查询全部记忆
        
        @param request: GetMemoriesRequest
        @return: GetMemoriesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_memories_with_options_async(workspace, memory_store_name, request, headers, runtime)

    def get_memory_with_options(
        self,
        workspace: str,
        memory_store_name: str,
        memory_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetMemoryResponse:
        """
        @summary 查询记忆
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetMemoryResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetMemory',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}/memory/{OpenApiUtilClient.get_encode_param(memory_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetMemoryResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_memory_with_options_async(
        self,
        workspace: str,
        memory_store_name: str,
        memory_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetMemoryResponse:
        """
        @summary 查询记忆
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetMemoryResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetMemory',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}/memory/{OpenApiUtilClient.get_encode_param(memory_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetMemoryResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_memory(
        self,
        workspace: str,
        memory_store_name: str,
        memory_id: str,
    ) -> cms_20240330_models.GetMemoryResponse:
        """
        @summary 查询记忆
        
        @return: GetMemoryResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_memory_with_options(workspace, memory_store_name, memory_id, headers, runtime)

    async def get_memory_async(
        self,
        workspace: str,
        memory_store_name: str,
        memory_id: str,
    ) -> cms_20240330_models.GetMemoryResponse:
        """
        @summary 查询记忆
        
        @return: GetMemoryResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_memory_with_options_async(workspace, memory_store_name, memory_id, headers, runtime)

    def get_memory_history_with_options(
        self,
        workspace: str,
        memory_store_name: str,
        memory_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetMemoryHistoryResponse:
        """
        @summary 查询记忆历史记录
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetMemoryHistoryResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetMemoryHistory',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}/memory/{OpenApiUtilClient.get_encode_param(memory_id)}/history',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetMemoryHistoryResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_memory_history_with_options_async(
        self,
        workspace: str,
        memory_store_name: str,
        memory_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetMemoryHistoryResponse:
        """
        @summary 查询记忆历史记录
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetMemoryHistoryResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetMemoryHistory',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}/memory/{OpenApiUtilClient.get_encode_param(memory_id)}/history',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetMemoryHistoryResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_memory_history(
        self,
        workspace: str,
        memory_store_name: str,
        memory_id: str,
    ) -> cms_20240330_models.GetMemoryHistoryResponse:
        """
        @summary 查询记忆历史记录
        
        @return: GetMemoryHistoryResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_memory_history_with_options(workspace, memory_store_name, memory_id, headers, runtime)

    async def get_memory_history_async(
        self,
        workspace: str,
        memory_store_name: str,
        memory_id: str,
    ) -> cms_20240330_models.GetMemoryHistoryResponse:
        """
        @summary 查询记忆历史记录
        
        @return: GetMemoryHistoryResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_memory_history_with_options_async(workspace, memory_store_name, memory_id, headers, runtime)

    def get_memory_store_with_options(
        self,
        workspace: str,
        memory_store_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetMemoryStoreResponse:
        """
        @summary 查询记忆库
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetMemoryStoreResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetMemoryStore',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetMemoryStoreResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_memory_store_with_options_async(
        self,
        workspace: str,
        memory_store_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetMemoryStoreResponse:
        """
        @summary 查询记忆库
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetMemoryStoreResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetMemoryStore',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetMemoryStoreResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_memory_store(
        self,
        workspace: str,
        memory_store_name: str,
    ) -> cms_20240330_models.GetMemoryStoreResponse:
        """
        @summary 查询记忆库
        
        @return: GetMemoryStoreResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_memory_store_with_options(workspace, memory_store_name, headers, runtime)

    async def get_memory_store_async(
        self,
        workspace: str,
        memory_store_name: str,
    ) -> cms_20240330_models.GetMemoryStoreResponse:
        """
        @summary 查询记忆库
        
        @return: GetMemoryStoreResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_memory_store_with_options_async(workspace, memory_store_name, headers, runtime)

    def get_notify_strategy_with_options(
        self,
        notify_strategy_id: str,
        request: cms_20240330_models.GetNotifyStrategyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetNotifyStrategyResponse:
        """
        @summary 获取订阅
        
        @param request: GetNotifyStrategyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetNotifyStrategyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetNotifyStrategy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/notifyStrategies/{OpenApiUtilClient.get_encode_param(notify_strategy_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetNotifyStrategyResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_notify_strategy_with_options_async(
        self,
        notify_strategy_id: str,
        request: cms_20240330_models.GetNotifyStrategyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetNotifyStrategyResponse:
        """
        @summary 获取订阅
        
        @param request: GetNotifyStrategyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetNotifyStrategyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetNotifyStrategy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/notifyStrategies/{OpenApiUtilClient.get_encode_param(notify_strategy_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetNotifyStrategyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_notify_strategy(
        self,
        notify_strategy_id: str,
        request: cms_20240330_models.GetNotifyStrategyRequest,
    ) -> cms_20240330_models.GetNotifyStrategyResponse:
        """
        @summary 获取订阅
        
        @param request: GetNotifyStrategyRequest
        @return: GetNotifyStrategyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_notify_strategy_with_options(notify_strategy_id, request, headers, runtime)

    async def get_notify_strategy_async(
        self,
        notify_strategy_id: str,
        request: cms_20240330_models.GetNotifyStrategyRequest,
    ) -> cms_20240330_models.GetNotifyStrategyResponse:
        """
        @summary 获取订阅
        
        @param request: GetNotifyStrategyRequest
        @return: GetNotifyStrategyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_notify_strategy_with_options_async(notify_strategy_id, request, headers, runtime)

    def get_oncall_schedule_with_options(
        self,
        oncall_schedule_id: str,
        request: cms_20240330_models.GetOncallScheduleRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetOncallScheduleResponse:
        """
        @summary 查询 OncallSchedule
        
        @param request: GetOncallScheduleRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetOncallScheduleResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetOncallSchedule',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/oncallSchedule/{OpenApiUtilClient.get_encode_param(oncall_schedule_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetOncallScheduleResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_oncall_schedule_with_options_async(
        self,
        oncall_schedule_id: str,
        request: cms_20240330_models.GetOncallScheduleRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetOncallScheduleResponse:
        """
        @summary 查询 OncallSchedule
        
        @param request: GetOncallScheduleRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetOncallScheduleResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetOncallSchedule',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/oncallSchedule/{OpenApiUtilClient.get_encode_param(oncall_schedule_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetOncallScheduleResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_oncall_schedule(
        self,
        oncall_schedule_id: str,
        request: cms_20240330_models.GetOncallScheduleRequest,
    ) -> cms_20240330_models.GetOncallScheduleResponse:
        """
        @summary 查询 OncallSchedule
        
        @param request: GetOncallScheduleRequest
        @return: GetOncallScheduleResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_oncall_schedule_with_options(oncall_schedule_id, request, headers, runtime)

    async def get_oncall_schedule_async(
        self,
        oncall_schedule_id: str,
        request: cms_20240330_models.GetOncallScheduleRequest,
    ) -> cms_20240330_models.GetOncallScheduleResponse:
        """
        @summary 查询 OncallSchedule
        
        @param request: GetOncallScheduleRequest
        @return: GetOncallScheduleResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_oncall_schedule_with_options_async(oncall_schedule_id, request, headers, runtime)

    def get_pipeline_with_options(
        self,
        workspace: str,
        pipeline_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetPipelineResponse:
        """
        @summary 查询流水线
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetPipelineResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetPipeline',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/pipeline/{OpenApiUtilClient.get_encode_param(pipeline_name)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetPipelineResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_pipeline_with_options_async(
        self,
        workspace: str,
        pipeline_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetPipelineResponse:
        """
        @summary 查询流水线
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetPipelineResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetPipeline',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/pipeline/{OpenApiUtilClient.get_encode_param(pipeline_name)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetPipelineResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_pipeline(
        self,
        workspace: str,
        pipeline_name: str,
    ) -> cms_20240330_models.GetPipelineResponse:
        """
        @summary 查询流水线
        
        @return: GetPipelineResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_pipeline_with_options(workspace, pipeline_name, headers, runtime)

    async def get_pipeline_async(
        self,
        workspace: str,
        pipeline_name: str,
    ) -> cms_20240330_models.GetPipelineResponse:
        """
        @summary 查询流水线
        
        @return: GetPipelineResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_pipeline_with_options_async(workspace, pipeline_name, headers, runtime)

    def get_prometheus_cluster_with_options(
        self,
        prometheus_cluster_name: str,
        request: cms_20240330_models.GetPrometheusClusterRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetPrometheusClusterResponse:
        """
        @summary 查询指定prometheus集群实例
        
        @param request: GetPrometheusClusterRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetPrometheusClusterResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetPrometheusCluster',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-clusters/{OpenApiUtilClient.get_encode_param(prometheus_cluster_name)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetPrometheusClusterResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_prometheus_cluster_with_options_async(
        self,
        prometheus_cluster_name: str,
        request: cms_20240330_models.GetPrometheusClusterRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetPrometheusClusterResponse:
        """
        @summary 查询指定prometheus集群实例
        
        @param request: GetPrometheusClusterRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetPrometheusClusterResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetPrometheusCluster',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-clusters/{OpenApiUtilClient.get_encode_param(prometheus_cluster_name)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetPrometheusClusterResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_prometheus_cluster(
        self,
        prometheus_cluster_name: str,
        request: cms_20240330_models.GetPrometheusClusterRequest,
    ) -> cms_20240330_models.GetPrometheusClusterResponse:
        """
        @summary 查询指定prometheus集群实例
        
        @param request: GetPrometheusClusterRequest
        @return: GetPrometheusClusterResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_prometheus_cluster_with_options(prometheus_cluster_name, request, headers, runtime)

    async def get_prometheus_cluster_async(
        self,
        prometheus_cluster_name: str,
        request: cms_20240330_models.GetPrometheusClusterRequest,
    ) -> cms_20240330_models.GetPrometheusClusterResponse:
        """
        @summary 查询指定prometheus集群实例
        
        @param request: GetPrometheusClusterRequest
        @return: GetPrometheusClusterResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_prometheus_cluster_with_options_async(prometheus_cluster_name, request, headers, runtime)

    def get_prometheus_instance_with_options(
        self,
        prometheus_instance_id: str,
        request: cms_20240330_models.GetPrometheusInstanceRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetPrometheusInstanceResponse:
        """
        @summary Query the instance in a specified environment
        
        @description Retrieve details of a Prometheus instance.
        
        @param request: GetPrometheusInstanceRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetPrometheusInstanceResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetPrometheusInstance',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(prometheus_instance_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetPrometheusInstanceResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_prometheus_instance_with_options_async(
        self,
        prometheus_instance_id: str,
        request: cms_20240330_models.GetPrometheusInstanceRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetPrometheusInstanceResponse:
        """
        @summary Query the instance in a specified environment
        
        @description Retrieve details of a Prometheus instance.
        
        @param request: GetPrometheusInstanceRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetPrometheusInstanceResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetPrometheusInstance',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(prometheus_instance_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetPrometheusInstanceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_prometheus_instance(
        self,
        prometheus_instance_id: str,
        request: cms_20240330_models.GetPrometheusInstanceRequest,
    ) -> cms_20240330_models.GetPrometheusInstanceResponse:
        """
        @summary Query the instance in a specified environment
        
        @description Retrieve details of a Prometheus instance.
        
        @param request: GetPrometheusInstanceRequest
        @return: GetPrometheusInstanceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_prometheus_instance_with_options(prometheus_instance_id, request, headers, runtime)

    async def get_prometheus_instance_async(
        self,
        prometheus_instance_id: str,
        request: cms_20240330_models.GetPrometheusInstanceRequest,
    ) -> cms_20240330_models.GetPrometheusInstanceResponse:
        """
        @summary Query the instance in a specified environment
        
        @description Retrieve details of a Prometheus instance.
        
        @param request: GetPrometheusInstanceRequest
        @return: GetPrometheusInstanceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_prometheus_instance_with_options_async(prometheus_instance_id, request, headers, runtime)

    def get_prometheus_user_setting_with_options(
        self,
        request: cms_20240330_models.GetPrometheusUserSettingRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetPrometheusUserSettingResponse:
        """
        @summary 查询指定环境实例
        
        @param request: GetPrometheusUserSettingRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetPrometheusUserSettingResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetPrometheusUserSetting',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-user-setting',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetPrometheusUserSettingResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_prometheus_user_setting_with_options_async(
        self,
        request: cms_20240330_models.GetPrometheusUserSettingRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetPrometheusUserSettingResponse:
        """
        @summary 查询指定环境实例
        
        @param request: GetPrometheusUserSettingRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetPrometheusUserSettingResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetPrometheusUserSetting',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-user-setting',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetPrometheusUserSettingResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_prometheus_user_setting(
        self,
        request: cms_20240330_models.GetPrometheusUserSettingRequest,
    ) -> cms_20240330_models.GetPrometheusUserSettingResponse:
        """
        @summary 查询指定环境实例
        
        @param request: GetPrometheusUserSettingRequest
        @return: GetPrometheusUserSettingResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_prometheus_user_setting_with_options(request, headers, runtime)

    async def get_prometheus_user_setting_async(
        self,
        request: cms_20240330_models.GetPrometheusUserSettingRequest,
    ) -> cms_20240330_models.GetPrometheusUserSettingResponse:
        """
        @summary 查询指定环境实例
        
        @param request: GetPrometheusUserSettingRequest
        @return: GetPrometheusUserSettingResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_prometheus_user_setting_with_options_async(request, headers, runtime)

    def get_prometheus_view_with_options(
        self,
        prometheus_view_id: str,
        request: cms_20240330_models.GetPrometheusViewRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetPrometheusViewResponse:
        """
        @summary Query a specified Prometheus view instance
        
        @description Query a specified Prometheus view instance.
        
        @param request: GetPrometheusViewRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetPrometheusViewResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetPrometheusView',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-views/{OpenApiUtilClient.get_encode_param(prometheus_view_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetPrometheusViewResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_prometheus_view_with_options_async(
        self,
        prometheus_view_id: str,
        request: cms_20240330_models.GetPrometheusViewRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetPrometheusViewResponse:
        """
        @summary Query a specified Prometheus view instance
        
        @description Query a specified Prometheus view instance.
        
        @param request: GetPrometheusViewRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetPrometheusViewResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetPrometheusView',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-views/{OpenApiUtilClient.get_encode_param(prometheus_view_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetPrometheusViewResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_prometheus_view(
        self,
        prometheus_view_id: str,
        request: cms_20240330_models.GetPrometheusViewRequest,
    ) -> cms_20240330_models.GetPrometheusViewResponse:
        """
        @summary Query a specified Prometheus view instance
        
        @description Query a specified Prometheus view instance.
        
        @param request: GetPrometheusViewRequest
        @return: GetPrometheusViewResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_prometheus_view_with_options(prometheus_view_id, request, headers, runtime)

    async def get_prometheus_view_async(
        self,
        prometheus_view_id: str,
        request: cms_20240330_models.GetPrometheusViewRequest,
    ) -> cms_20240330_models.GetPrometheusViewResponse:
        """
        @summary Query a specified Prometheus view instance
        
        @description Query a specified Prometheus view instance.
        
        @param request: GetPrometheusViewRequest
        @return: GetPrometheusViewResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_prometheus_view_with_options_async(prometheus_view_id, request, headers, runtime)

    def get_service_with_options(
        self,
        workspace: str,
        service_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetServiceResponse:
        """
        @summary Query Service
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetServiceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetService',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/service/{OpenApiUtilClient.get_encode_param(service_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetServiceResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_service_with_options_async(
        self,
        workspace: str,
        service_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetServiceResponse:
        """
        @summary Query Service
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetServiceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetService',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/service/{OpenApiUtilClient.get_encode_param(service_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetServiceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_service(
        self,
        workspace: str,
        service_id: str,
    ) -> cms_20240330_models.GetServiceResponse:
        """
        @summary Query Service
        
        @return: GetServiceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_service_with_options(workspace, service_id, headers, runtime)

    async def get_service_async(
        self,
        workspace: str,
        service_id: str,
    ) -> cms_20240330_models.GetServiceResponse:
        """
        @summary Query Service
        
        @return: GetServiceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_service_with_options_async(workspace, service_id, headers, runtime)

    def get_service_dictionary_with_options(
        self,
        workspace: str,
        type: str,
        request: cms_20240330_models.GetServiceDictionaryRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetServiceDictionaryResponse:
        """
        @summary 查询可观测应用字典编码信息等
        
        @param request: GetServiceDictionaryRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetServiceDictionaryResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.meta_keys):
            body['metaKeys'] = request.meta_keys
        if not UtilClient.is_unset(request.meta_type):
            body['metaType'] = request.meta_type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='GetServiceDictionary',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/service-dictionary/{OpenApiUtilClient.get_encode_param(type)}',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetServiceDictionaryResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_service_dictionary_with_options_async(
        self,
        workspace: str,
        type: str,
        request: cms_20240330_models.GetServiceDictionaryRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetServiceDictionaryResponse:
        """
        @summary 查询可观测应用字典编码信息等
        
        @param request: GetServiceDictionaryRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetServiceDictionaryResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.meta_keys):
            body['metaKeys'] = request.meta_keys
        if not UtilClient.is_unset(request.meta_type):
            body['metaType'] = request.meta_type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='GetServiceDictionary',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/service-dictionary/{OpenApiUtilClient.get_encode_param(type)}',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetServiceDictionaryResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_service_dictionary(
        self,
        workspace: str,
        type: str,
        request: cms_20240330_models.GetServiceDictionaryRequest,
    ) -> cms_20240330_models.GetServiceDictionaryResponse:
        """
        @summary 查询可观测应用字典编码信息等
        
        @param request: GetServiceDictionaryRequest
        @return: GetServiceDictionaryResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_service_dictionary_with_options(workspace, type, request, headers, runtime)

    async def get_service_dictionary_async(
        self,
        workspace: str,
        type: str,
        request: cms_20240330_models.GetServiceDictionaryRequest,
    ) -> cms_20240330_models.GetServiceDictionaryResponse:
        """
        @summary 查询可观测应用字典编码信息等
        
        @param request: GetServiceDictionaryRequest
        @return: GetServiceDictionaryResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_service_dictionary_with_options_async(workspace, type, request, headers, runtime)

    def get_service_observability_with_options(
        self,
        workspace: str,
        type: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetServiceObservabilityResponse:
        """
        @summary Get Application Observability Instance
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetServiceObservabilityResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetServiceObservability',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/service-observability/{OpenApiUtilClient.get_encode_param(type)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetServiceObservabilityResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_service_observability_with_options_async(
        self,
        workspace: str,
        type: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetServiceObservabilityResponse:
        """
        @summary Get Application Observability Instance
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetServiceObservabilityResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetServiceObservability',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/service-observability/{OpenApiUtilClient.get_encode_param(type)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetServiceObservabilityResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_service_observability(
        self,
        workspace: str,
        type: str,
    ) -> cms_20240330_models.GetServiceObservabilityResponse:
        """
        @summary Get Application Observability Instance
        
        @return: GetServiceObservabilityResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_service_observability_with_options(workspace, type, headers, runtime)

    async def get_service_observability_async(
        self,
        workspace: str,
        type: str,
    ) -> cms_20240330_models.GetServiceObservabilityResponse:
        """
        @summary Get Application Observability Instance
        
        @return: GetServiceObservabilityResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_service_observability_with_options_async(workspace, type, headers, runtime)

    def get_service_task_with_options(
        self,
        workspace: str,
        service_id: str,
        task_id: str,
        request: cms_20240330_models.GetServiceTaskRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetServiceTaskResponse:
        """
        @summary 查询ServiceTask
        
        @param request: GetServiceTaskRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetServiceTaskResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.type):
            query['type'] = request.type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetServiceTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/serviceTask/{OpenApiUtilClient.get_encode_param(workspace)}/{OpenApiUtilClient.get_encode_param(service_id)}/task/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetServiceTaskResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_service_task_with_options_async(
        self,
        workspace: str,
        service_id: str,
        task_id: str,
        request: cms_20240330_models.GetServiceTaskRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetServiceTaskResponse:
        """
        @summary 查询ServiceTask
        
        @param request: GetServiceTaskRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetServiceTaskResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.type):
            query['type'] = request.type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetServiceTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/serviceTask/{OpenApiUtilClient.get_encode_param(workspace)}/{OpenApiUtilClient.get_encode_param(service_id)}/task/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetServiceTaskResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_service_task(
        self,
        workspace: str,
        service_id: str,
        task_id: str,
        request: cms_20240330_models.GetServiceTaskRequest,
    ) -> cms_20240330_models.GetServiceTaskResponse:
        """
        @summary 查询ServiceTask
        
        @param request: GetServiceTaskRequest
        @return: GetServiceTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_service_task_with_options(workspace, service_id, task_id, request, headers, runtime)

    async def get_service_task_async(
        self,
        workspace: str,
        service_id: str,
        task_id: str,
        request: cms_20240330_models.GetServiceTaskRequest,
    ) -> cms_20240330_models.GetServiceTaskResponse:
        """
        @summary 查询ServiceTask
        
        @param request: GetServiceTaskRequest
        @return: GetServiceTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_service_task_with_options_async(workspace, service_id, task_id, request, headers, runtime)

    def get_site_monitor_with_options(
        self,
        task_id: str,
        request: cms_20240330_models.GetSiteMonitorRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetSiteMonitorResponse:
        """
        @summary 查询 SiteMonitor
        
        @param request: GetSiteMonitorRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetSiteMonitorResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetSiteMonitor',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/sitemonitor/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetSiteMonitorResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_site_monitor_with_options_async(
        self,
        task_id: str,
        request: cms_20240330_models.GetSiteMonitorRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetSiteMonitorResponse:
        """
        @summary 查询 SiteMonitor
        
        @param request: GetSiteMonitorRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetSiteMonitorResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetSiteMonitor',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/sitemonitor/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetSiteMonitorResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_site_monitor(
        self,
        task_id: str,
        request: cms_20240330_models.GetSiteMonitorRequest,
    ) -> cms_20240330_models.GetSiteMonitorResponse:
        """
        @summary 查询 SiteMonitor
        
        @param request: GetSiteMonitorRequest
        @return: GetSiteMonitorResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_site_monitor_with_options(task_id, request, headers, runtime)

    async def get_site_monitor_async(
        self,
        task_id: str,
        request: cms_20240330_models.GetSiteMonitorRequest,
    ) -> cms_20240330_models.GetSiteMonitorResponse:
        """
        @summary 查询 SiteMonitor
        
        @param request: GetSiteMonitorRequest
        @return: GetSiteMonitorResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_site_monitor_with_options_async(task_id, request, headers, runtime)

    def get_subscription_with_options(
        self,
        subscription_id: str,
        request: cms_20240330_models.GetSubscriptionRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetSubscriptionResponse:
        """
        @summary 获取订阅
        
        @param request: GetSubscriptionRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetSubscriptionResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetSubscription',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/subscriptions/{OpenApiUtilClient.get_encode_param(subscription_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetSubscriptionResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_subscription_with_options_async(
        self,
        subscription_id: str,
        request: cms_20240330_models.GetSubscriptionRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetSubscriptionResponse:
        """
        @summary 获取订阅
        
        @param request: GetSubscriptionRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetSubscriptionResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetSubscription',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/subscriptions/{OpenApiUtilClient.get_encode_param(subscription_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetSubscriptionResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_subscription(
        self,
        subscription_id: str,
        request: cms_20240330_models.GetSubscriptionRequest,
    ) -> cms_20240330_models.GetSubscriptionResponse:
        """
        @summary 获取订阅
        
        @param request: GetSubscriptionRequest
        @return: GetSubscriptionResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_subscription_with_options(subscription_id, request, headers, runtime)

    async def get_subscription_async(
        self,
        subscription_id: str,
        request: cms_20240330_models.GetSubscriptionRequest,
    ) -> cms_20240330_models.GetSubscriptionResponse:
        """
        @summary 获取订阅
        
        @param request: GetSubscriptionRequest
        @return: GetSubscriptionResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_subscription_with_options_async(subscription_id, request, headers, runtime)

    def get_thread_with_options(
        self,
        name: str,
        thread_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetThreadResponse:
        """
        @summary 获取会话
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetThreadResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetThread',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/thread/{OpenApiUtilClient.get_encode_param(thread_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetThreadResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_thread_with_options_async(
        self,
        name: str,
        thread_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetThreadResponse:
        """
        @summary 获取会话
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetThreadResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetThread',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/thread/{OpenApiUtilClient.get_encode_param(thread_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetThreadResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_thread(
        self,
        name: str,
        thread_id: str,
    ) -> cms_20240330_models.GetThreadResponse:
        """
        @summary 获取会话
        
        @return: GetThreadResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_thread_with_options(name, thread_id, headers, runtime)

    async def get_thread_async(
        self,
        name: str,
        thread_id: str,
    ) -> cms_20240330_models.GetThreadResponse:
        """
        @summary 获取会话
        
        @return: GetThreadResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_thread_with_options_async(name, thread_id, headers, runtime)

    def get_thread_data_with_options(
        self,
        name: str,
        thread_id: str,
        request: cms_20240330_models.GetThreadDataRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetThreadDataResponse:
        """
        @summary 获取会话数据
        
        @param request: GetThreadDataRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetThreadDataResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetThreadData',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/thread/{OpenApiUtilClient.get_encode_param(thread_id)}/data',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetThreadDataResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_thread_data_with_options_async(
        self,
        name: str,
        thread_id: str,
        request: cms_20240330_models.GetThreadDataRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetThreadDataResponse:
        """
        @summary 获取会话数据
        
        @param request: GetThreadDataRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetThreadDataResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetThreadData',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/thread/{OpenApiUtilClient.get_encode_param(thread_id)}/data',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetThreadDataResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_thread_data(
        self,
        name: str,
        thread_id: str,
        request: cms_20240330_models.GetThreadDataRequest,
    ) -> cms_20240330_models.GetThreadDataResponse:
        """
        @summary 获取会话数据
        
        @param request: GetThreadDataRequest
        @return: GetThreadDataResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_thread_data_with_options(name, thread_id, request, headers, runtime)

    async def get_thread_data_async(
        self,
        name: str,
        thread_id: str,
        request: cms_20240330_models.GetThreadDataRequest,
    ) -> cms_20240330_models.GetThreadDataResponse:
        """
        @summary 获取会话数据
        
        @param request: GetThreadDataRequest
        @return: GetThreadDataResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_thread_data_with_options_async(name, thread_id, request, headers, runtime)

    def get_transformer_with_options(
        self,
        transformer_id: str,
        request: cms_20240330_models.GetTransformerRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetTransformerResponse:
        """
        @summary 获取订阅
        
        @param request: GetTransformerRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetTransformerResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetTransformer',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/transformers/{OpenApiUtilClient.get_encode_param(transformer_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetTransformerResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_transformer_with_options_async(
        self,
        transformer_id: str,
        request: cms_20240330_models.GetTransformerRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetTransformerResponse:
        """
        @summary 获取订阅
        
        @param request: GetTransformerRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetTransformerResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetTransformer',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/transformers/{OpenApiUtilClient.get_encode_param(transformer_id)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetTransformerResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_transformer(
        self,
        transformer_id: str,
        request: cms_20240330_models.GetTransformerRequest,
    ) -> cms_20240330_models.GetTransformerResponse:
        """
        @summary 获取订阅
        
        @param request: GetTransformerRequest
        @return: GetTransformerResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_transformer_with_options(transformer_id, request, headers, runtime)

    async def get_transformer_async(
        self,
        transformer_id: str,
        request: cms_20240330_models.GetTransformerRequest,
    ) -> cms_20240330_models.GetTransformerResponse:
        """
        @summary 获取订阅
        
        @param request: GetTransformerRequest
        @return: GetTransformerResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_transformer_with_options_async(transformer_id, request, headers, runtime)

    def get_umodel_with_options(
        self,
        workspace: str,
        headers: cms_20240330_models.GetUmodelHeaders,
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetUmodelResponse:
        """
        @summary Get Umodel configuration information
        
        @description Get Umodel configuration information
        
        @param headers: GetUmodelHeaders
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetUmodelResponse
        """
        real_headers = {}
        if not UtilClient.is_unset(headers.common_headers):
            real_headers = headers.common_headers
        if not UtilClient.is_unset(headers.log_version):
            real_headers['logVersion'] = UtilClient.to_jsonstring(headers.log_version)
        req = open_api_models.OpenApiRequest(
            headers=real_headers
        )
        params = open_api_models.Params(
            action='GetUmodel',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/umodel',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetUmodelResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_umodel_with_options_async(
        self,
        workspace: str,
        headers: cms_20240330_models.GetUmodelHeaders,
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetUmodelResponse:
        """
        @summary Get Umodel configuration information
        
        @description Get Umodel configuration information
        
        @param headers: GetUmodelHeaders
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetUmodelResponse
        """
        real_headers = {}
        if not UtilClient.is_unset(headers.common_headers):
            real_headers = headers.common_headers
        if not UtilClient.is_unset(headers.log_version):
            real_headers['logVersion'] = UtilClient.to_jsonstring(headers.log_version)
        req = open_api_models.OpenApiRequest(
            headers=real_headers
        )
        params = open_api_models.Params(
            action='GetUmodel',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/umodel',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetUmodelResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_umodel(
        self,
        workspace: str,
    ) -> cms_20240330_models.GetUmodelResponse:
        """
        @summary Get Umodel configuration information
        
        @description Get Umodel configuration information
        
        @return: GetUmodelResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = cms_20240330_models.GetUmodelHeaders()
        return self.get_umodel_with_options(workspace, headers, runtime)

    async def get_umodel_async(
        self,
        workspace: str,
    ) -> cms_20240330_models.GetUmodelResponse:
        """
        @summary Get Umodel configuration information
        
        @description Get Umodel configuration information
        
        @return: GetUmodelResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = cms_20240330_models.GetUmodelHeaders()
        return await self.get_umodel_with_options_async(workspace, headers, runtime)

    def get_umodel_common_schema_ref_with_options(
        self,
        workspace: str,
        headers: cms_20240330_models.GetUmodelCommonSchemaRefHeaders,
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetUmodelCommonSchemaRefResponse:
        """
        @summary 获取Umodel配置信息
        
        @param headers: GetUmodelCommonSchemaRefHeaders
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetUmodelCommonSchemaRefResponse
        """
        real_headers = {}
        if not UtilClient.is_unset(headers.common_headers):
            real_headers = headers.common_headers
        if not UtilClient.is_unset(headers.log_version):
            real_headers['logVersion'] = UtilClient.to_jsonstring(headers.log_version)
        req = open_api_models.OpenApiRequest(
            headers=real_headers
        )
        params = open_api_models.Params(
            action='GetUmodelCommonSchemaRef',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/umodel/common-schema-ref',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetUmodelCommonSchemaRefResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_umodel_common_schema_ref_with_options_async(
        self,
        workspace: str,
        headers: cms_20240330_models.GetUmodelCommonSchemaRefHeaders,
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetUmodelCommonSchemaRefResponse:
        """
        @summary 获取Umodel配置信息
        
        @param headers: GetUmodelCommonSchemaRefHeaders
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetUmodelCommonSchemaRefResponse
        """
        real_headers = {}
        if not UtilClient.is_unset(headers.common_headers):
            real_headers = headers.common_headers
        if not UtilClient.is_unset(headers.log_version):
            real_headers['logVersion'] = UtilClient.to_jsonstring(headers.log_version)
        req = open_api_models.OpenApiRequest(
            headers=real_headers
        )
        params = open_api_models.Params(
            action='GetUmodelCommonSchemaRef',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/umodel/common-schema-ref',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetUmodelCommonSchemaRefResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_umodel_common_schema_ref(
        self,
        workspace: str,
    ) -> cms_20240330_models.GetUmodelCommonSchemaRefResponse:
        """
        @summary 获取Umodel配置信息
        
        @return: GetUmodelCommonSchemaRefResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = cms_20240330_models.GetUmodelCommonSchemaRefHeaders()
        return self.get_umodel_common_schema_ref_with_options(workspace, headers, runtime)

    async def get_umodel_common_schema_ref_async(
        self,
        workspace: str,
    ) -> cms_20240330_models.GetUmodelCommonSchemaRefResponse:
        """
        @summary 获取Umodel配置信息
        
        @return: GetUmodelCommonSchemaRefResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = cms_20240330_models.GetUmodelCommonSchemaRefHeaders()
        return await self.get_umodel_common_schema_ref_with_options_async(workspace, headers, runtime)

    def get_umodel_data_with_options(
        self,
        workspace: str,
        request: cms_20240330_models.GetUmodelDataRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetUmodelDataResponse:
        """
        @summary Retrieve associated Umodel graph data
        
        @description Find Umodel
        
        @param request: GetUmodelDataRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetUmodelDataResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.method):
            query['method'] = request.method
        body = {}
        if not UtilClient.is_unset(request.content):
            body['content'] = request.content
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='GetUmodelData',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/umodel/graph',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetUmodelDataResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_umodel_data_with_options_async(
        self,
        workspace: str,
        request: cms_20240330_models.GetUmodelDataRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetUmodelDataResponse:
        """
        @summary Retrieve associated Umodel graph data
        
        @description Find Umodel
        
        @param request: GetUmodelDataRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetUmodelDataResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.method):
            query['method'] = request.method
        body = {}
        if not UtilClient.is_unset(request.content):
            body['content'] = request.content
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='GetUmodelData',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/umodel/graph',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetUmodelDataResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_umodel_data(
        self,
        workspace: str,
        request: cms_20240330_models.GetUmodelDataRequest,
    ) -> cms_20240330_models.GetUmodelDataResponse:
        """
        @summary Retrieve associated Umodel graph data
        
        @description Find Umodel
        
        @param request: GetUmodelDataRequest
        @return: GetUmodelDataResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_umodel_data_with_options(workspace, request, headers, runtime)

    async def get_umodel_data_async(
        self,
        workspace: str,
        request: cms_20240330_models.GetUmodelDataRequest,
    ) -> cms_20240330_models.GetUmodelDataResponse:
        """
        @summary Retrieve associated Umodel graph data
        
        @description Find Umodel
        
        @param request: GetUmodelDataRequest
        @return: GetUmodelDataResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_umodel_data_with_options_async(workspace, request, headers, runtime)

    def get_user_token_for_role_with_options(
        self,
        request: cms_20240330_models.GetUserTokenForRoleRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetUserTokenForRoleResponse:
        """
        @summary 托管集群根据用户的信息获取stsToken
        
        @param request: GetUserTokenForRoleRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetUserTokenForRoleResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.role_name):
            query['roleName'] = request.role_name
        if not UtilClient.is_unset(request.user_id):
            query['userId'] = request.user_id
        if not UtilClient.is_unset(request.user_token):
            query['userToken'] = request.user_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetUserTokenForRole',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/config/sts-tokens',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetUserTokenForRoleResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_user_token_for_role_with_options_async(
        self,
        request: cms_20240330_models.GetUserTokenForRoleRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetUserTokenForRoleResponse:
        """
        @summary 托管集群根据用户的信息获取stsToken
        
        @param request: GetUserTokenForRoleRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetUserTokenForRoleResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.role_name):
            query['roleName'] = request.role_name
        if not UtilClient.is_unset(request.user_id):
            query['userId'] = request.user_id
        if not UtilClient.is_unset(request.user_token):
            query['userToken'] = request.user_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='GetUserTokenForRole',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/config/sts-tokens',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetUserTokenForRoleResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_user_token_for_role(
        self,
        request: cms_20240330_models.GetUserTokenForRoleRequest,
    ) -> cms_20240330_models.GetUserTokenForRoleResponse:
        """
        @summary 托管集群根据用户的信息获取stsToken
        
        @param request: GetUserTokenForRoleRequest
        @return: GetUserTokenForRoleResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_user_token_for_role_with_options(request, headers, runtime)

    async def get_user_token_for_role_async(
        self,
        request: cms_20240330_models.GetUserTokenForRoleRequest,
    ) -> cms_20240330_models.GetUserTokenForRoleResponse:
        """
        @summary 托管集群根据用户的信息获取stsToken
        
        @param request: GetUserTokenForRoleRequest
        @return: GetUserTokenForRoleResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_user_token_for_role_with_options_async(request, headers, runtime)

    def get_workspace_with_options(
        self,
        workspace_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetWorkspaceResponse:
        """
        @summary Get Workspace
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetWorkspaceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetWorkspace',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace_name)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetWorkspaceResponse(),
            self.call_api(params, req, runtime)
        )

    async def get_workspace_with_options_async(
        self,
        workspace_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.GetWorkspaceResponse:
        """
        @summary Get Workspace
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: GetWorkspaceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='GetWorkspace',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace_name)}',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.GetWorkspaceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def get_workspace(
        self,
        workspace_name: str,
    ) -> cms_20240330_models.GetWorkspaceResponse:
        """
        @summary Get Workspace
        
        @return: GetWorkspaceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.get_workspace_with_options(workspace_name, headers, runtime)

    async def get_workspace_async(
        self,
        workspace_name: str,
    ) -> cms_20240330_models.GetWorkspaceResponse:
        """
        @summary Get Workspace
        
        @return: GetWorkspaceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.get_workspace_with_options_async(workspace_name, headers, runtime)

    def import_alert_rules_with_options(
        self,
        request: cms_20240330_models.ImportAlertRulesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ImportAlertRulesResponse:
        """
        @summary 批量导入云监控2.0告警规则
        
        @param request: ImportAlertRulesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ImportAlertRulesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.format):
            query['format'] = request.format
        body = {}
        if not UtilClient.is_unset(request.body):
            body['body'] = request.body
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='ImportAlertRules',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules/action/import',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='formData',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ImportAlertRulesResponse(),
            self.call_api(params, req, runtime)
        )

    async def import_alert_rules_with_options_async(
        self,
        request: cms_20240330_models.ImportAlertRulesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ImportAlertRulesResponse:
        """
        @summary 批量导入云监控2.0告警规则
        
        @param request: ImportAlertRulesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ImportAlertRulesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.format):
            query['format'] = request.format
        body = {}
        if not UtilClient.is_unset(request.body):
            body['body'] = request.body
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='ImportAlertRules',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules/action/import',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='formData',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ImportAlertRulesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def import_alert_rules(
        self,
        request: cms_20240330_models.ImportAlertRulesRequest,
    ) -> cms_20240330_models.ImportAlertRulesResponse:
        """
        @summary 批量导入云监控2.0告警规则
        
        @param request: ImportAlertRulesRequest
        @return: ImportAlertRulesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.import_alert_rules_with_options(request, headers, runtime)

    async def import_alert_rules_async(
        self,
        request: cms_20240330_models.ImportAlertRulesRequest,
    ) -> cms_20240330_models.ImportAlertRulesResponse:
        """
        @summary 批量导入云监控2.0告警规则
        
        @param request: ImportAlertRulesRequest
        @return: ImportAlertRulesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.import_alert_rules_with_options_async(request, headers, runtime)

    def init_cms_alert_resources_with_options(
        self,
        request: cms_20240330_models.InitCmsAlertResourcesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.InitCmsAlertResourcesResponse:
        """
        @summary 初始化工作空间下告警相关的资源
        
        @param request: InitCmsAlertResourcesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: InitCmsAlertResourcesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='InitCmsAlertResources',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/cms/alert/init',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.InitCmsAlertResourcesResponse(),
            self.call_api(params, req, runtime)
        )

    async def init_cms_alert_resources_with_options_async(
        self,
        request: cms_20240330_models.InitCmsAlertResourcesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.InitCmsAlertResourcesResponse:
        """
        @summary 初始化工作空间下告警相关的资源
        
        @param request: InitCmsAlertResourcesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: InitCmsAlertResourcesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='InitCmsAlertResources',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/cms/alert/init',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.InitCmsAlertResourcesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def init_cms_alert_resources(
        self,
        request: cms_20240330_models.InitCmsAlertResourcesRequest,
    ) -> cms_20240330_models.InitCmsAlertResourcesResponse:
        """
        @summary 初始化工作空间下告警相关的资源
        
        @param request: InitCmsAlertResourcesRequest
        @return: InitCmsAlertResourcesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.init_cms_alert_resources_with_options(request, headers, runtime)

    async def init_cms_alert_resources_async(
        self,
        request: cms_20240330_models.InitCmsAlertResourcesRequest,
    ) -> cms_20240330_models.InitCmsAlertResourcesResponse:
        """
        @summary 初始化工作空间下告警相关的资源
        
        @param request: InitCmsAlertResourcesRequest
        @return: InitCmsAlertResourcesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.init_cms_alert_resources_with_options_async(request, headers, runtime)

    def initialize_synthetics_resources_with_options(
        self,
        request: cms_20240330_models.InitializeSyntheticsResourcesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.InitializeSyntheticsResourcesResponse:
        """
        @summary 初始化工作空间下拨测相关的资源
        
        @param request: InitializeSyntheticsResourcesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: InitializeSyntheticsResourcesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        if not UtilClient.is_unset(request.workspace_region):
            query['workspaceRegion'] = request.workspace_region
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='InitializeSyntheticsResources',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/synthetics/initialization',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.InitializeSyntheticsResourcesResponse(),
            self.call_api(params, req, runtime)
        )

    async def initialize_synthetics_resources_with_options_async(
        self,
        request: cms_20240330_models.InitializeSyntheticsResourcesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.InitializeSyntheticsResourcesResponse:
        """
        @summary 初始化工作空间下拨测相关的资源
        
        @param request: InitializeSyntheticsResourcesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: InitializeSyntheticsResourcesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        if not UtilClient.is_unset(request.workspace_region):
            query['workspaceRegion'] = request.workspace_region
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='InitializeSyntheticsResources',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/synthetics/initialization',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.InitializeSyntheticsResourcesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def initialize_synthetics_resources(
        self,
        request: cms_20240330_models.InitializeSyntheticsResourcesRequest,
    ) -> cms_20240330_models.InitializeSyntheticsResourcesResponse:
        """
        @summary 初始化工作空间下拨测相关的资源
        
        @param request: InitializeSyntheticsResourcesRequest
        @return: InitializeSyntheticsResourcesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.initialize_synthetics_resources_with_options(request, headers, runtime)

    async def initialize_synthetics_resources_async(
        self,
        request: cms_20240330_models.InitializeSyntheticsResourcesRequest,
    ) -> cms_20240330_models.InitializeSyntheticsResourcesResponse:
        """
        @summary 初始化工作空间下拨测相关的资源
        
        @param request: InitializeSyntheticsResourcesRequest
        @return: InitializeSyntheticsResourcesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.initialize_synthetics_resources_with_options_async(request, headers, runtime)

    def list_addon_releases_with_options(
        self,
        policy_id: str,
        request: cms_20240330_models.ListAddonReleasesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAddonReleasesResponse:
        """
        @summary List of addon releases
        
        @description Query the list of access configurations
        
        @param request: ListAddonReleasesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAddonReleasesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.addon_name):
            query['addonName'] = request.addon_name
        if not UtilClient.is_unset(request.parent_addon_release_id):
            query['parentAddonReleaseId'] = request.parent_addon_release_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAddonReleases',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/addon-releases',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAddonReleasesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_addon_releases_with_options_async(
        self,
        policy_id: str,
        request: cms_20240330_models.ListAddonReleasesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAddonReleasesResponse:
        """
        @summary List of addon releases
        
        @description Query the list of access configurations
        
        @param request: ListAddonReleasesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAddonReleasesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.addon_name):
            query['addonName'] = request.addon_name
        if not UtilClient.is_unset(request.parent_addon_release_id):
            query['parentAddonReleaseId'] = request.parent_addon_release_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAddonReleases',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/addon-releases',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAddonReleasesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_addon_releases(
        self,
        policy_id: str,
        request: cms_20240330_models.ListAddonReleasesRequest,
    ) -> cms_20240330_models.ListAddonReleasesResponse:
        """
        @summary List of addon releases
        
        @description Query the list of access configurations
        
        @param request: ListAddonReleasesRequest
        @return: ListAddonReleasesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_addon_releases_with_options(policy_id, request, headers, runtime)

    async def list_addon_releases_async(
        self,
        policy_id: str,
        request: cms_20240330_models.ListAddonReleasesRequest,
    ) -> cms_20240330_models.ListAddonReleasesResponse:
        """
        @summary List of addon releases
        
        @description Query the list of access configurations
        
        @param request: ListAddonReleasesRequest
        @return: ListAddonReleasesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_addon_releases_with_options_async(policy_id, request, headers, runtime)

    def list_addons_with_options(
        self,
        request: cms_20240330_models.ListAddonsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAddonsResponse:
        """
        @summary 新版接入中心产品列表(分组)
        
        @param request: ListAddonsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAddonsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.category):
            query['category'] = request.category
        if not UtilClient.is_unset(request.regexp):
            query['regexp'] = request.regexp
        if not UtilClient.is_unset(request.search):
            query['search'] = request.search
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAddons',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/addons',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAddonsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_addons_with_options_async(
        self,
        request: cms_20240330_models.ListAddonsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAddonsResponse:
        """
        @summary 新版接入中心产品列表(分组)
        
        @param request: ListAddonsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAddonsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.category):
            query['category'] = request.category
        if not UtilClient.is_unset(request.regexp):
            query['regexp'] = request.regexp
        if not UtilClient.is_unset(request.search):
            query['search'] = request.search
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAddons',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/addons',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAddonsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_addons(
        self,
        request: cms_20240330_models.ListAddonsRequest,
    ) -> cms_20240330_models.ListAddonsResponse:
        """
        @summary 新版接入中心产品列表(分组)
        
        @param request: ListAddonsRequest
        @return: ListAddonsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_addons_with_options(request, headers, runtime)

    async def list_addons_async(
        self,
        request: cms_20240330_models.ListAddonsRequest,
    ) -> cms_20240330_models.ListAddonsResponse:
        """
        @summary 新版接入中心产品列表(分组)
        
        @param request: ListAddonsRequest
        @return: ListAddonsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_addons_with_options_async(request, headers, runtime)

    def list_agg_task_groups_with_options(
        self,
        instance_id: str,
        tmp_req: cms_20240330_models.ListAggTaskGroupsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAggTaskGroupsResponse:
        """
        @summary List Aggregation Task Groups
        
        @param tmp_req: ListAggTaskGroupsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAggTaskGroupsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListAggTaskGroupsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.tags):
            request.tags_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tags, 'tags', 'json')
        query = {}
        if not UtilClient.is_unset(request.filter_agg_task_group_ids):
            query['filterAggTaskGroupIds'] = request.filter_agg_task_group_ids
        if not UtilClient.is_unset(request.filter_agg_task_group_names):
            query['filterAggTaskGroupNames'] = request.filter_agg_task_group_names
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.query):
            query['query'] = request.query
        if not UtilClient.is_unset(request.status):
            query['status'] = request.status
        if not UtilClient.is_unset(request.tags_shrink):
            query['tags'] = request.tags_shrink
        if not UtilClient.is_unset(request.target_prometheus_id):
            query['targetPrometheusId'] = request.target_prometheus_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAggTaskGroups',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(instance_id)}/agg-task-groups',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAggTaskGroupsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_agg_task_groups_with_options_async(
        self,
        instance_id: str,
        tmp_req: cms_20240330_models.ListAggTaskGroupsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAggTaskGroupsResponse:
        """
        @summary List Aggregation Task Groups
        
        @param tmp_req: ListAggTaskGroupsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAggTaskGroupsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListAggTaskGroupsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.tags):
            request.tags_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tags, 'tags', 'json')
        query = {}
        if not UtilClient.is_unset(request.filter_agg_task_group_ids):
            query['filterAggTaskGroupIds'] = request.filter_agg_task_group_ids
        if not UtilClient.is_unset(request.filter_agg_task_group_names):
            query['filterAggTaskGroupNames'] = request.filter_agg_task_group_names
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.query):
            query['query'] = request.query
        if not UtilClient.is_unset(request.status):
            query['status'] = request.status
        if not UtilClient.is_unset(request.tags_shrink):
            query['tags'] = request.tags_shrink
        if not UtilClient.is_unset(request.target_prometheus_id):
            query['targetPrometheusId'] = request.target_prometheus_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAggTaskGroups',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(instance_id)}/agg-task-groups',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAggTaskGroupsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_agg_task_groups(
        self,
        instance_id: str,
        request: cms_20240330_models.ListAggTaskGroupsRequest,
    ) -> cms_20240330_models.ListAggTaskGroupsResponse:
        """
        @summary List Aggregation Task Groups
        
        @param request: ListAggTaskGroupsRequest
        @return: ListAggTaskGroupsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_agg_task_groups_with_options(instance_id, request, headers, runtime)

    async def list_agg_task_groups_async(
        self,
        instance_id: str,
        request: cms_20240330_models.ListAggTaskGroupsRequest,
    ) -> cms_20240330_models.ListAggTaskGroupsResponse:
        """
        @summary List Aggregation Task Groups
        
        @param request: ListAggTaskGroupsRequest
        @return: ListAggTaskGroupsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_agg_task_groups_with_options_async(instance_id, request, headers, runtime)

    def list_alert_actions_with_options(
        self,
        tmp_req: cms_20240330_models.ListAlertActionsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAlertActionsResponse:
        """
        @summary Query Alert Actions
        
        @param tmp_req: ListAlertActionsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAlertActionsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListAlertActionsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.alert_action_ids):
            request.alert_action_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.alert_action_ids, 'alertActionIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_action_ids_shrink):
            query['alertActionIds'] = request.alert_action_ids_shrink
        if not UtilClient.is_unset(request.alert_action_name):
            query['alertActionName'] = request.alert_action_name
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.page_number):
            query['pageNumber'] = request.page_number
        if not UtilClient.is_unset(request.page_size):
            query['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        if not UtilClient.is_unset(request.type):
            query['type'] = request.type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAlertActions',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertActions',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAlertActionsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_alert_actions_with_options_async(
        self,
        tmp_req: cms_20240330_models.ListAlertActionsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAlertActionsResponse:
        """
        @summary Query Alert Actions
        
        @param tmp_req: ListAlertActionsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAlertActionsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListAlertActionsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.alert_action_ids):
            request.alert_action_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.alert_action_ids, 'alertActionIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_action_ids_shrink):
            query['alertActionIds'] = request.alert_action_ids_shrink
        if not UtilClient.is_unset(request.alert_action_name):
            query['alertActionName'] = request.alert_action_name
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.page_number):
            query['pageNumber'] = request.page_number
        if not UtilClient.is_unset(request.page_size):
            query['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        if not UtilClient.is_unset(request.type):
            query['type'] = request.type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAlertActions',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertActions',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAlertActionsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_alert_actions(
        self,
        request: cms_20240330_models.ListAlertActionsRequest,
    ) -> cms_20240330_models.ListAlertActionsResponse:
        """
        @summary Query Alert Actions
        
        @param request: ListAlertActionsRequest
        @return: ListAlertActionsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_alert_actions_with_options(request, headers, runtime)

    async def list_alert_actions_async(
        self,
        request: cms_20240330_models.ListAlertActionsRequest,
    ) -> cms_20240330_models.ListAlertActionsResponse:
        """
        @summary Query Alert Actions
        
        @param request: ListAlertActionsRequest
        @return: ListAlertActionsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_alert_actions_with_options_async(request, headers, runtime)

    def list_alert_event_integration_policies_with_options(
        self,
        request: cms_20240330_models.ListAlertEventIntegrationPoliciesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAlertEventIntegrationPoliciesResponse:
        """
        @summary List AlertEventIntegrationPolicy
        
        @param request: ListAlertEventIntegrationPoliciesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAlertEventIntegrationPoliciesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.alert_event_integration_policy_id):
            query['alertEventIntegrationPolicyId'] = request.alert_event_integration_policy_id
        if not UtilClient.is_unset(request.alert_event_integration_policy_name):
            query['alertEventIntegrationPolicyName'] = request.alert_event_integration_policy_name
        if not UtilClient.is_unset(request.direction):
            query['direction'] = request.direction
        if not UtilClient.is_unset(request.enable):
            query['enable'] = request.enable
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.order_by):
            query['orderBy'] = request.order_by
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAlertEventIntegrationPolicies',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertEventIntegrationPolicies',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAlertEventIntegrationPoliciesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_alert_event_integration_policies_with_options_async(
        self,
        request: cms_20240330_models.ListAlertEventIntegrationPoliciesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAlertEventIntegrationPoliciesResponse:
        """
        @summary List AlertEventIntegrationPolicy
        
        @param request: ListAlertEventIntegrationPoliciesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAlertEventIntegrationPoliciesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.alert_event_integration_policy_id):
            query['alertEventIntegrationPolicyId'] = request.alert_event_integration_policy_id
        if not UtilClient.is_unset(request.alert_event_integration_policy_name):
            query['alertEventIntegrationPolicyName'] = request.alert_event_integration_policy_name
        if not UtilClient.is_unset(request.direction):
            query['direction'] = request.direction
        if not UtilClient.is_unset(request.enable):
            query['enable'] = request.enable
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.order_by):
            query['orderBy'] = request.order_by
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAlertEventIntegrationPolicies',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertEventIntegrationPolicies',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAlertEventIntegrationPoliciesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_alert_event_integration_policies(
        self,
        request: cms_20240330_models.ListAlertEventIntegrationPoliciesRequest,
    ) -> cms_20240330_models.ListAlertEventIntegrationPoliciesResponse:
        """
        @summary List AlertEventIntegrationPolicy
        
        @param request: ListAlertEventIntegrationPoliciesRequest
        @return: ListAlertEventIntegrationPoliciesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_alert_event_integration_policies_with_options(request, headers, runtime)

    async def list_alert_event_integration_policies_async(
        self,
        request: cms_20240330_models.ListAlertEventIntegrationPoliciesRequest,
    ) -> cms_20240330_models.ListAlertEventIntegrationPoliciesResponse:
        """
        @summary List AlertEventIntegrationPolicy
        
        @param request: ListAlertEventIntegrationPoliciesRequest
        @return: ListAlertEventIntegrationPoliciesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_alert_event_integration_policies_with_options_async(request, headers, runtime)

    def list_alert_histories_with_options(
        self,
        tmp_req: cms_20240330_models.ListAlertHistoriesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAlertHistoriesResponse:
        """
        @summary 查询云监控2.0告警历史
        
        @param tmp_req: ListAlertHistoriesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAlertHistoriesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListAlertHistoriesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.label_filter):
            request.label_filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.label_filter, 'labelFilter', 'json')
        if not UtilClient.is_unset(tmp_req.notification_filter):
            request.notification_filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.notification_filter, 'notificationFilter', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_history_id):
            query['alertHistoryId'] = request.alert_history_id
        if not UtilClient.is_unset(request.alert_rule_id):
            query['alertRuleId'] = request.alert_rule_id
        if not UtilClient.is_unset(request.biz_source):
            query['bizSource'] = request.biz_source
        if not UtilClient.is_unset(request.display_name_key_word):
            query['displayNameKeyWord'] = request.display_name_key_word
        if not UtilClient.is_unset(request.instance_key):
            query['instanceKey'] = request.instance_key
        if not UtilClient.is_unset(request.label_filter_shrink):
            query['labelFilter'] = request.label_filter_shrink
        if not UtilClient.is_unset(request.latest_level):
            query['latestLevel'] = request.latest_level
        if not UtilClient.is_unset(request.max_level):
            query['maxLevel'] = request.max_level
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.notification_filter_shrink):
            query['notificationFilter'] = request.notification_filter_shrink
        if not UtilClient.is_unset(request.page_number):
            query['pageNumber'] = request.page_number
        if not UtilClient.is_unset(request.page_size):
            query['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.start_time_from):
            query['startTimeFrom'] = request.start_time_from
        if not UtilClient.is_unset(request.start_time_to):
            query['startTimeTo'] = request.start_time_to
        if not UtilClient.is_unset(request.status):
            query['status'] = request.status
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAlertHistories',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertHistories',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAlertHistoriesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_alert_histories_with_options_async(
        self,
        tmp_req: cms_20240330_models.ListAlertHistoriesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAlertHistoriesResponse:
        """
        @summary 查询云监控2.0告警历史
        
        @param tmp_req: ListAlertHistoriesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAlertHistoriesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListAlertHistoriesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.label_filter):
            request.label_filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.label_filter, 'labelFilter', 'json')
        if not UtilClient.is_unset(tmp_req.notification_filter):
            request.notification_filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.notification_filter, 'notificationFilter', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_history_id):
            query['alertHistoryId'] = request.alert_history_id
        if not UtilClient.is_unset(request.alert_rule_id):
            query['alertRuleId'] = request.alert_rule_id
        if not UtilClient.is_unset(request.biz_source):
            query['bizSource'] = request.biz_source
        if not UtilClient.is_unset(request.display_name_key_word):
            query['displayNameKeyWord'] = request.display_name_key_word
        if not UtilClient.is_unset(request.instance_key):
            query['instanceKey'] = request.instance_key
        if not UtilClient.is_unset(request.label_filter_shrink):
            query['labelFilter'] = request.label_filter_shrink
        if not UtilClient.is_unset(request.latest_level):
            query['latestLevel'] = request.latest_level
        if not UtilClient.is_unset(request.max_level):
            query['maxLevel'] = request.max_level
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.notification_filter_shrink):
            query['notificationFilter'] = request.notification_filter_shrink
        if not UtilClient.is_unset(request.page_number):
            query['pageNumber'] = request.page_number
        if not UtilClient.is_unset(request.page_size):
            query['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.start_time_from):
            query['startTimeFrom'] = request.start_time_from
        if not UtilClient.is_unset(request.start_time_to):
            query['startTimeTo'] = request.start_time_to
        if not UtilClient.is_unset(request.status):
            query['status'] = request.status
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAlertHistories',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertHistories',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAlertHistoriesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_alert_histories(
        self,
        request: cms_20240330_models.ListAlertHistoriesRequest,
    ) -> cms_20240330_models.ListAlertHistoriesResponse:
        """
        @summary 查询云监控2.0告警历史
        
        @param request: ListAlertHistoriesRequest
        @return: ListAlertHistoriesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_alert_histories_with_options(request, headers, runtime)

    async def list_alert_histories_async(
        self,
        request: cms_20240330_models.ListAlertHistoriesRequest,
    ) -> cms_20240330_models.ListAlertHistoriesResponse:
        """
        @summary 查询云监控2.0告警历史
        
        @param request: ListAlertHistoriesRequest
        @return: ListAlertHistoriesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_alert_histories_with_options_async(request, headers, runtime)

    def list_alert_metric_groups_with_options(
        self,
        request: cms_20240330_models.ListAlertMetricGroupsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAlertMetricGroupsResponse:
        """
        @summary 查询云监控2.0告警指标分组
        
        @param request: ListAlertMetricGroupsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAlertMetricGroupsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.alert_metric_group_id):
            query['alertMetricGroupId'] = request.alert_metric_group_id
        if not UtilClient.is_unset(request.datasource_type):
            query['datasourceType'] = request.datasource_type
        if not UtilClient.is_unset(request.include_details):
            query['includeDetails'] = request.include_details
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAlertMetricGroups',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertMetricGroups',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAlertMetricGroupsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_alert_metric_groups_with_options_async(
        self,
        request: cms_20240330_models.ListAlertMetricGroupsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAlertMetricGroupsResponse:
        """
        @summary 查询云监控2.0告警指标分组
        
        @param request: ListAlertMetricGroupsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAlertMetricGroupsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.alert_metric_group_id):
            query['alertMetricGroupId'] = request.alert_metric_group_id
        if not UtilClient.is_unset(request.datasource_type):
            query['datasourceType'] = request.datasource_type
        if not UtilClient.is_unset(request.include_details):
            query['includeDetails'] = request.include_details
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAlertMetricGroups',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertMetricGroups',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAlertMetricGroupsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_alert_metric_groups(
        self,
        request: cms_20240330_models.ListAlertMetricGroupsRequest,
    ) -> cms_20240330_models.ListAlertMetricGroupsResponse:
        """
        @summary 查询云监控2.0告警指标分组
        
        @param request: ListAlertMetricGroupsRequest
        @return: ListAlertMetricGroupsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_alert_metric_groups_with_options(request, headers, runtime)

    async def list_alert_metric_groups_async(
        self,
        request: cms_20240330_models.ListAlertMetricGroupsRequest,
    ) -> cms_20240330_models.ListAlertMetricGroupsResponse:
        """
        @summary 查询云监控2.0告警指标分组
        
        @param request: ListAlertMetricGroupsRequest
        @return: ListAlertMetricGroupsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_alert_metric_groups_with_options_async(request, headers, runtime)

    def list_alert_metrics_with_options(
        self,
        request: cms_20240330_models.ListAlertMetricsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAlertMetricsResponse:
        """
        @summary 查询云监控2.0告警指标列表
        
        @param request: ListAlertMetricsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAlertMetricsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.alert_metric_id):
            query['alertMetricId'] = request.alert_metric_id
        if not UtilClient.is_unset(request.group):
            query['group'] = request.group
        if not UtilClient.is_unset(request.include_details):
            query['includeDetails'] = request.include_details
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAlertMetrics',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertMetrics',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAlertMetricsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_alert_metrics_with_options_async(
        self,
        request: cms_20240330_models.ListAlertMetricsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAlertMetricsResponse:
        """
        @summary 查询云监控2.0告警指标列表
        
        @param request: ListAlertMetricsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAlertMetricsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.alert_metric_id):
            query['alertMetricId'] = request.alert_metric_id
        if not UtilClient.is_unset(request.group):
            query['group'] = request.group
        if not UtilClient.is_unset(request.include_details):
            query['includeDetails'] = request.include_details
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAlertMetrics',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertMetrics',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAlertMetricsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_alert_metrics(
        self,
        request: cms_20240330_models.ListAlertMetricsRequest,
    ) -> cms_20240330_models.ListAlertMetricsResponse:
        """
        @summary 查询云监控2.0告警指标列表
        
        @param request: ListAlertMetricsRequest
        @return: ListAlertMetricsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_alert_metrics_with_options(request, headers, runtime)

    async def list_alert_metrics_async(
        self,
        request: cms_20240330_models.ListAlertMetricsRequest,
    ) -> cms_20240330_models.ListAlertMetricsResponse:
        """
        @summary 查询云监控2.0告警指标列表
        
        @param request: ListAlertMetricsRequest
        @return: ListAlertMetricsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_alert_metrics_with_options_async(request, headers, runtime)

    def list_alert_notify_templates_with_options(
        self,
        tmp_req: cms_20240330_models.ListAlertNotifyTemplatesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAlertNotifyTemplatesResponse:
        """
        @summary 查询通知模板
        
        @param tmp_req: ListAlertNotifyTemplatesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAlertNotifyTemplatesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListAlertNotifyTemplatesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.alert_notify_template_ids):
            request.alert_notify_template_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.alert_notify_template_ids, 'alertNotifyTemplateIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_notify_template_ids_shrink):
            query['alertNotifyTemplateIds'] = request.alert_notify_template_ids_shrink
        if not UtilClient.is_unset(request.alert_notify_template_name):
            query['alertNotifyTemplateName'] = request.alert_notify_template_name
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.page_number):
            query['pageNumber'] = request.page_number
        if not UtilClient.is_unset(request.page_size):
            query['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.program_lang):
            query['programLang'] = request.program_lang
        if not UtilClient.is_unset(request.type):
            query['type'] = request.type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAlertNotifyTemplates',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertNotifyTemplate',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAlertNotifyTemplatesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_alert_notify_templates_with_options_async(
        self,
        tmp_req: cms_20240330_models.ListAlertNotifyTemplatesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAlertNotifyTemplatesResponse:
        """
        @summary 查询通知模板
        
        @param tmp_req: ListAlertNotifyTemplatesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAlertNotifyTemplatesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListAlertNotifyTemplatesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.alert_notify_template_ids):
            request.alert_notify_template_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.alert_notify_template_ids, 'alertNotifyTemplateIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_notify_template_ids_shrink):
            query['alertNotifyTemplateIds'] = request.alert_notify_template_ids_shrink
        if not UtilClient.is_unset(request.alert_notify_template_name):
            query['alertNotifyTemplateName'] = request.alert_notify_template_name
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.page_number):
            query['pageNumber'] = request.page_number
        if not UtilClient.is_unset(request.page_size):
            query['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.program_lang):
            query['programLang'] = request.program_lang
        if not UtilClient.is_unset(request.type):
            query['type'] = request.type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAlertNotifyTemplates',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertNotifyTemplate',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAlertNotifyTemplatesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_alert_notify_templates(
        self,
        request: cms_20240330_models.ListAlertNotifyTemplatesRequest,
    ) -> cms_20240330_models.ListAlertNotifyTemplatesResponse:
        """
        @summary 查询通知模板
        
        @param request: ListAlertNotifyTemplatesRequest
        @return: ListAlertNotifyTemplatesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_alert_notify_templates_with_options(request, headers, runtime)

    async def list_alert_notify_templates_async(
        self,
        request: cms_20240330_models.ListAlertNotifyTemplatesRequest,
    ) -> cms_20240330_models.ListAlertNotifyTemplatesResponse:
        """
        @summary 查询通知模板
        
        @param request: ListAlertNotifyTemplatesRequest
        @return: ListAlertNotifyTemplatesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_alert_notify_templates_with_options_async(request, headers, runtime)

    def list_alert_robots_with_options(
        self,
        tmp_req: cms_20240330_models.ListAlertRobotsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAlertRobotsResponse:
        """
        @summary 查询机器人
        
        @param tmp_req: ListAlertRobotsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAlertRobotsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListAlertRobotsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.robot_ids):
            request.robot_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.robot_ids, 'robotIds', 'json')
        if not UtilClient.is_unset(tmp_req.types):
            request.types_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.types, 'types', 'json')
        query = {}
        if not UtilClient.is_unset(request.is_custom):
            query['isCustom'] = request.is_custom
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.name):
            query['name'] = request.name
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.page_number):
            query['pageNumber'] = request.page_number
        if not UtilClient.is_unset(request.page_size):
            query['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.robot_ids_shrink):
            query['robotIds'] = request.robot_ids_shrink
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        if not UtilClient.is_unset(request.types_shrink):
            query['types'] = request.types_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAlertRobots',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/robots',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAlertRobotsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_alert_robots_with_options_async(
        self,
        tmp_req: cms_20240330_models.ListAlertRobotsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAlertRobotsResponse:
        """
        @summary 查询机器人
        
        @param tmp_req: ListAlertRobotsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAlertRobotsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListAlertRobotsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.robot_ids):
            request.robot_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.robot_ids, 'robotIds', 'json')
        if not UtilClient.is_unset(tmp_req.types):
            request.types_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.types, 'types', 'json')
        query = {}
        if not UtilClient.is_unset(request.is_custom):
            query['isCustom'] = request.is_custom
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.name):
            query['name'] = request.name
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.page_number):
            query['pageNumber'] = request.page_number
        if not UtilClient.is_unset(request.page_size):
            query['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.robot_ids_shrink):
            query['robotIds'] = request.robot_ids_shrink
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        if not UtilClient.is_unset(request.types_shrink):
            query['types'] = request.types_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAlertRobots',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/robots',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAlertRobotsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_alert_robots(
        self,
        request: cms_20240330_models.ListAlertRobotsRequest,
    ) -> cms_20240330_models.ListAlertRobotsResponse:
        """
        @summary 查询机器人
        
        @param request: ListAlertRobotsRequest
        @return: ListAlertRobotsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_alert_robots_with_options(request, headers, runtime)

    async def list_alert_robots_async(
        self,
        request: cms_20240330_models.ListAlertRobotsRequest,
    ) -> cms_20240330_models.ListAlertRobotsResponse:
        """
        @summary 查询机器人
        
        @param request: ListAlertRobotsRequest
        @return: ListAlertRobotsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_alert_robots_with_options_async(request, headers, runtime)

    def list_alert_rule_templates_with_options(
        self,
        request: cms_20240330_models.ListAlertRuleTemplatesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAlertRuleTemplatesResponse:
        """
        @summary 查询告警规则模板
        
        @param request: ListAlertRuleTemplatesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAlertRuleTemplatesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.alert_rule_template_id):
            query['alertRuleTemplateId'] = request.alert_rule_template_id
        if not UtilClient.is_unset(request.biz_source):
            query['bizSource'] = request.biz_source
        if not UtilClient.is_unset(request.include_details):
            query['includeDetails'] = request.include_details
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAlertRuleTemplates',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRuleTemplates',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAlertRuleTemplatesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_alert_rule_templates_with_options_async(
        self,
        request: cms_20240330_models.ListAlertRuleTemplatesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAlertRuleTemplatesResponse:
        """
        @summary 查询告警规则模板
        
        @param request: ListAlertRuleTemplatesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAlertRuleTemplatesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.alert_rule_template_id):
            query['alertRuleTemplateId'] = request.alert_rule_template_id
        if not UtilClient.is_unset(request.biz_source):
            query['bizSource'] = request.biz_source
        if not UtilClient.is_unset(request.include_details):
            query['includeDetails'] = request.include_details
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAlertRuleTemplates',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRuleTemplates',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAlertRuleTemplatesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_alert_rule_templates(
        self,
        request: cms_20240330_models.ListAlertRuleTemplatesRequest,
    ) -> cms_20240330_models.ListAlertRuleTemplatesResponse:
        """
        @summary 查询告警规则模板
        
        @param request: ListAlertRuleTemplatesRequest
        @return: ListAlertRuleTemplatesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_alert_rule_templates_with_options(request, headers, runtime)

    async def list_alert_rule_templates_async(
        self,
        request: cms_20240330_models.ListAlertRuleTemplatesRequest,
    ) -> cms_20240330_models.ListAlertRuleTemplatesResponse:
        """
        @summary 查询告警规则模板
        
        @param request: ListAlertRuleTemplatesRequest
        @return: ListAlertRuleTemplatesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_alert_rule_templates_with_options_async(request, headers, runtime)

    def list_alert_rules_with_options(
        self,
        tmp_req: cms_20240330_models.ListAlertRulesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAlertRulesResponse:
        """
        @summary 查询云监控2.0告警规则
        
        @param tmp_req: ListAlertRulesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAlertRulesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListAlertRulesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.label_filter):
            request.label_filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.label_filter, 'labelFilter', 'json')
        if not UtilClient.is_unset(tmp_req.notification_filter):
            request.notification_filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.notification_filter, 'notificationFilter', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_rule_id):
            query['alertRuleId'] = request.alert_rule_id
        if not UtilClient.is_unset(request.biz_source):
            query['bizSource'] = request.biz_source
        if not UtilClient.is_unset(request.display_name_key_word):
            query['displayNameKeyWord'] = request.display_name_key_word
        if not UtilClient.is_unset(request.enabled):
            query['enabled'] = request.enabled
        if not UtilClient.is_unset(request.group):
            query['group'] = request.group
        if not UtilClient.is_unset(request.label_filter_shrink):
            query['labelFilter'] = request.label_filter_shrink
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.notification_filter_shrink):
            query['notificationFilter'] = request.notification_filter_shrink
        if not UtilClient.is_unset(request.page_number):
            query['pageNumber'] = request.page_number
        if not UtilClient.is_unset(request.page_size):
            query['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.status):
            query['status'] = request.status
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAlertRules',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAlertRulesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_alert_rules_with_options_async(
        self,
        tmp_req: cms_20240330_models.ListAlertRulesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAlertRulesResponse:
        """
        @summary 查询云监控2.0告警规则
        
        @param tmp_req: ListAlertRulesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAlertRulesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListAlertRulesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.label_filter):
            request.label_filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.label_filter, 'labelFilter', 'json')
        if not UtilClient.is_unset(tmp_req.notification_filter):
            request.notification_filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.notification_filter, 'notificationFilter', 'json')
        query = {}
        if not UtilClient.is_unset(request.alert_rule_id):
            query['alertRuleId'] = request.alert_rule_id
        if not UtilClient.is_unset(request.biz_source):
            query['bizSource'] = request.biz_source
        if not UtilClient.is_unset(request.display_name_key_word):
            query['displayNameKeyWord'] = request.display_name_key_word
        if not UtilClient.is_unset(request.enabled):
            query['enabled'] = request.enabled
        if not UtilClient.is_unset(request.group):
            query['group'] = request.group
        if not UtilClient.is_unset(request.label_filter_shrink):
            query['labelFilter'] = request.label_filter_shrink
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.notification_filter_shrink):
            query['notificationFilter'] = request.notification_filter_shrink
        if not UtilClient.is_unset(request.page_number):
            query['pageNumber'] = request.page_number
        if not UtilClient.is_unset(request.page_size):
            query['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.status):
            query['status'] = request.status
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAlertRules',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAlertRulesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_alert_rules(
        self,
        request: cms_20240330_models.ListAlertRulesRequest,
    ) -> cms_20240330_models.ListAlertRulesResponse:
        """
        @summary 查询云监控2.0告警规则
        
        @param request: ListAlertRulesRequest
        @return: ListAlertRulesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_alert_rules_with_options(request, headers, runtime)

    async def list_alert_rules_async(
        self,
        request: cms_20240330_models.ListAlertRulesRequest,
    ) -> cms_20240330_models.ListAlertRulesResponse:
        """
        @summary 查询云监控2.0告警规则
        
        @param request: ListAlertRulesRequest
        @return: ListAlertRulesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_alert_rules_with_options_async(request, headers, runtime)

    def list_alert_webhooks_with_options(
        self,
        tmp_req: cms_20240330_models.ListAlertWebhooksRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAlertWebhooksResponse:
        """
        @summary 查询Webhook
        
        @param tmp_req: ListAlertWebhooksRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAlertWebhooksResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListAlertWebhooksShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.webhook_ids):
            request.webhook_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.webhook_ids, 'webhookIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.is_custom):
            query['isCustom'] = request.is_custom
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.name):
            query['name'] = request.name
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.page_number):
            query['pageNumber'] = request.page_number
        if not UtilClient.is_unset(request.page_size):
            query['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        if not UtilClient.is_unset(request.webhook_ids_shrink):
            query['webhookIds'] = request.webhook_ids_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAlertWebhooks',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/webhooks',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAlertWebhooksResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_alert_webhooks_with_options_async(
        self,
        tmp_req: cms_20240330_models.ListAlertWebhooksRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAlertWebhooksResponse:
        """
        @summary 查询Webhook
        
        @param tmp_req: ListAlertWebhooksRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAlertWebhooksResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListAlertWebhooksShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.webhook_ids):
            request.webhook_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.webhook_ids, 'webhookIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.is_custom):
            query['isCustom'] = request.is_custom
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.name):
            query['name'] = request.name
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.page_number):
            query['pageNumber'] = request.page_number
        if not UtilClient.is_unset(request.page_size):
            query['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        if not UtilClient.is_unset(request.webhook_ids_shrink):
            query['webhookIds'] = request.webhook_ids_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAlertWebhooks',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/webhooks',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAlertWebhooksResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_alert_webhooks(
        self,
        request: cms_20240330_models.ListAlertWebhooksRequest,
    ) -> cms_20240330_models.ListAlertWebhooksResponse:
        """
        @summary 查询Webhook
        
        @param request: ListAlertWebhooksRequest
        @return: ListAlertWebhooksResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_alert_webhooks_with_options(request, headers, runtime)

    async def list_alert_webhooks_async(
        self,
        request: cms_20240330_models.ListAlertWebhooksRequest,
    ) -> cms_20240330_models.ListAlertWebhooksResponse:
        """
        @summary 查询Webhook
        
        @param request: ListAlertWebhooksRequest
        @return: ListAlertWebhooksResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_alert_webhooks_with_options_async(request, headers, runtime)

    def list_available_regions_for_synthetics_with_options(
        self,
        request: cms_20240330_models.ListAvailableRegionsForSyntheticsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAvailableRegionsForSyntheticsResponse:
        """
        @summary 获取拨测支持的地域
        
        @param request: ListAvailableRegionsForSyntheticsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAvailableRegionsForSyntheticsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.related_service):
            query['relatedService'] = request.related_service
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAvailableRegionsForSynthetics',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/synthetics/regions',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAvailableRegionsForSyntheticsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_available_regions_for_synthetics_with_options_async(
        self,
        request: cms_20240330_models.ListAvailableRegionsForSyntheticsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListAvailableRegionsForSyntheticsResponse:
        """
        @summary 获取拨测支持的地域
        
        @param request: ListAvailableRegionsForSyntheticsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListAvailableRegionsForSyntheticsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.related_service):
            query['relatedService'] = request.related_service
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListAvailableRegionsForSynthetics',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/synthetics/regions',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListAvailableRegionsForSyntheticsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_available_regions_for_synthetics(
        self,
        request: cms_20240330_models.ListAvailableRegionsForSyntheticsRequest,
    ) -> cms_20240330_models.ListAvailableRegionsForSyntheticsResponse:
        """
        @summary 获取拨测支持的地域
        
        @param request: ListAvailableRegionsForSyntheticsRequest
        @return: ListAvailableRegionsForSyntheticsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_available_regions_for_synthetics_with_options(request, headers, runtime)

    async def list_available_regions_for_synthetics_async(
        self,
        request: cms_20240330_models.ListAvailableRegionsForSyntheticsRequest,
    ) -> cms_20240330_models.ListAvailableRegionsForSyntheticsResponse:
        """
        @summary 获取拨测支持的地域
        
        @param request: ListAvailableRegionsForSyntheticsRequest
        @return: ListAvailableRegionsForSyntheticsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_available_regions_for_synthetics_with_options_async(request, headers, runtime)

    def list_biz_traces_with_options(
        self,
        request: cms_20240330_models.ListBizTracesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListBizTracesResponse:
        """
        @summary 业务链路列表
        
        @param request: ListBizTracesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListBizTracesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListBizTraces',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/bizTraces',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListBizTracesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_biz_traces_with_options_async(
        self,
        request: cms_20240330_models.ListBizTracesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListBizTracesResponse:
        """
        @summary 业务链路列表
        
        @param request: ListBizTracesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListBizTracesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListBizTraces',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/bizTraces',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListBizTracesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_biz_traces(
        self,
        request: cms_20240330_models.ListBizTracesRequest,
    ) -> cms_20240330_models.ListBizTracesResponse:
        """
        @summary 业务链路列表
        
        @param request: ListBizTracesRequest
        @return: ListBizTracesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_biz_traces_with_options(request, headers, runtime)

    async def list_biz_traces_async(
        self,
        request: cms_20240330_models.ListBizTracesRequest,
    ) -> cms_20240330_models.ListBizTracesResponse:
        """
        @summary 业务链路列表
        
        @param request: ListBizTracesRequest
        @return: ListBizTracesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_biz_traces_with_options_async(request, headers, runtime)

    def list_contact_groups_with_options(
        self,
        tmp_req: cms_20240330_models.ListContactGroupsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListContactGroupsResponse:
        """
        @summary 查询联系人组
        
        @param tmp_req: ListContactGroupsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListContactGroupsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListContactGroupsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.contact_group_ids):
            request.contact_group_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.contact_group_ids, 'contactGroupIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.contact_group_ids_shrink):
            query['contactGroupIds'] = request.contact_group_ids_shrink
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.name):
            query['name'] = request.name
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.page_number):
            query['pageNumber'] = request.page_number
        if not UtilClient.is_unset(request.page_size):
            query['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListContactGroups',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/contactGroups',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListContactGroupsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_contact_groups_with_options_async(
        self,
        tmp_req: cms_20240330_models.ListContactGroupsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListContactGroupsResponse:
        """
        @summary 查询联系人组
        
        @param tmp_req: ListContactGroupsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListContactGroupsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListContactGroupsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.contact_group_ids):
            request.contact_group_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.contact_group_ids, 'contactGroupIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.contact_group_ids_shrink):
            query['contactGroupIds'] = request.contact_group_ids_shrink
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.name):
            query['name'] = request.name
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.page_number):
            query['pageNumber'] = request.page_number
        if not UtilClient.is_unset(request.page_size):
            query['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListContactGroups',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/contactGroups',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListContactGroupsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_contact_groups(
        self,
        request: cms_20240330_models.ListContactGroupsRequest,
    ) -> cms_20240330_models.ListContactGroupsResponse:
        """
        @summary 查询联系人组
        
        @param request: ListContactGroupsRequest
        @return: ListContactGroupsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_contact_groups_with_options(request, headers, runtime)

    async def list_contact_groups_async(
        self,
        request: cms_20240330_models.ListContactGroupsRequest,
    ) -> cms_20240330_models.ListContactGroupsResponse:
        """
        @summary 查询联系人组
        
        @param request: ListContactGroupsRequest
        @return: ListContactGroupsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_contact_groups_with_options_async(request, headers, runtime)

    def list_contacts_with_options(
        self,
        tmp_req: cms_20240330_models.ListContactsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListContactsResponse:
        """
        @summary 查询联系人
        
        @param tmp_req: ListContactsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListContactsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListContactsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.contact_ids):
            request.contact_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.contact_ids, 'contactIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.contact_ids_shrink):
            query['contactIds'] = request.contact_ids_shrink
        if not UtilClient.is_unset(request.email):
            query['email'] = request.email
        if not UtilClient.is_unset(request.group_id):
            query['groupId'] = request.group_id
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.name):
            query['name'] = request.name
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.page_number):
            query['pageNumber'] = request.page_number
        if not UtilClient.is_unset(request.page_size):
            query['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.phone):
            query['phone'] = request.phone
        if not UtilClient.is_unset(request.query_ungrouped_contacts):
            query['queryUngroupedContacts'] = request.query_ungrouped_contacts
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListContacts',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/contact',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListContactsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_contacts_with_options_async(
        self,
        tmp_req: cms_20240330_models.ListContactsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListContactsResponse:
        """
        @summary 查询联系人
        
        @param tmp_req: ListContactsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListContactsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListContactsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.contact_ids):
            request.contact_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.contact_ids, 'contactIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.contact_ids_shrink):
            query['contactIds'] = request.contact_ids_shrink
        if not UtilClient.is_unset(request.email):
            query['email'] = request.email
        if not UtilClient.is_unset(request.group_id):
            query['groupId'] = request.group_id
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.name):
            query['name'] = request.name
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.page_number):
            query['pageNumber'] = request.page_number
        if not UtilClient.is_unset(request.page_size):
            query['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.phone):
            query['phone'] = request.phone
        if not UtilClient.is_unset(request.query_ungrouped_contacts):
            query['queryUngroupedContacts'] = request.query_ungrouped_contacts
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListContacts',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/contact',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListContactsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_contacts(
        self,
        request: cms_20240330_models.ListContactsRequest,
    ) -> cms_20240330_models.ListContactsResponse:
        """
        @summary 查询联系人
        
        @param request: ListContactsRequest
        @return: ListContactsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_contacts_with_options(request, headers, runtime)

    async def list_contacts_async(
        self,
        request: cms_20240330_models.ListContactsRequest,
    ) -> cms_20240330_models.ListContactsResponse:
        """
        @summary 查询联系人
        
        @param request: ListContactsRequest
        @return: ListContactsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_contacts_with_options_async(request, headers, runtime)

    def list_custom_raw_event_top_nwith_options(
        self,
        enqueue_id: str,
        request: cms_20240330_models.ListCustomRawEventTopNRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListCustomRawEventTopNResponse:
        """
        @summary 列表获取最近用户上报原始事件内容
        
        @param request: ListCustomRawEventTopNRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListCustomRawEventTopNResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListCustomRawEventTopN',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/v1/enqueue/{OpenApiUtilClient.get_encode_param(enqueue_id)}/topn',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListCustomRawEventTopNResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_custom_raw_event_top_nwith_options_async(
        self,
        enqueue_id: str,
        request: cms_20240330_models.ListCustomRawEventTopNRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListCustomRawEventTopNResponse:
        """
        @summary 列表获取最近用户上报原始事件内容
        
        @param request: ListCustomRawEventTopNRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListCustomRawEventTopNResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListCustomRawEventTopN',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/v1/enqueue/{OpenApiUtilClient.get_encode_param(enqueue_id)}/topn',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListCustomRawEventTopNResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_custom_raw_event_top_n(
        self,
        enqueue_id: str,
        request: cms_20240330_models.ListCustomRawEventTopNRequest,
    ) -> cms_20240330_models.ListCustomRawEventTopNResponse:
        """
        @summary 列表获取最近用户上报原始事件内容
        
        @param request: ListCustomRawEventTopNRequest
        @return: ListCustomRawEventTopNResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_custom_raw_event_top_nwith_options(enqueue_id, request, headers, runtime)

    async def list_custom_raw_event_top_n_async(
        self,
        enqueue_id: str,
        request: cms_20240330_models.ListCustomRawEventTopNRequest,
    ) -> cms_20240330_models.ListCustomRawEventTopNResponse:
        """
        @summary 列表获取最近用户上报原始事件内容
        
        @param request: ListCustomRawEventTopNRequest
        @return: ListCustomRawEventTopNResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_custom_raw_event_top_nwith_options_async(enqueue_id, request, headers, runtime)

    def list_datasets_with_options(
        self,
        workspace: str,
        request: cms_20240330_models.ListDatasetsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListDatasetsResponse:
        """
        @summary 查询数据集列表
        
        @param request: ListDatasetsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListDatasetsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.dataset_name):
            query['datasetName'] = request.dataset_name
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListDatasets',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/dataset',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListDatasetsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_datasets_with_options_async(
        self,
        workspace: str,
        request: cms_20240330_models.ListDatasetsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListDatasetsResponse:
        """
        @summary 查询数据集列表
        
        @param request: ListDatasetsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListDatasetsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.dataset_name):
            query['datasetName'] = request.dataset_name
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListDatasets',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/dataset',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListDatasetsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_datasets(
        self,
        workspace: str,
        request: cms_20240330_models.ListDatasetsRequest,
    ) -> cms_20240330_models.ListDatasetsResponse:
        """
        @summary 查询数据集列表
        
        @param request: ListDatasetsRequest
        @return: ListDatasetsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_datasets_with_options(workspace, request, headers, runtime)

    async def list_datasets_async(
        self,
        workspace: str,
        request: cms_20240330_models.ListDatasetsRequest,
    ) -> cms_20240330_models.ListDatasetsResponse:
        """
        @summary 查询数据集列表
        
        @param request: ListDatasetsRequest
        @return: ListDatasetsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_datasets_with_options_async(workspace, request, headers, runtime)

    def list_delivery_tasks_with_options(
        self,
        request: cms_20240330_models.ListDeliveryTasksRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListDeliveryTasksResponse:
        """
        @summary 获取数据投递任务列表
        
        @param request: ListDeliveryTasksRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListDeliveryTasksResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.key_words):
            query['keyWords'] = request.key_words
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.tag):
            query['tag'] = request.tag
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListDeliveryTasks',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/delivery-tasks',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListDeliveryTasksResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_delivery_tasks_with_options_async(
        self,
        request: cms_20240330_models.ListDeliveryTasksRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListDeliveryTasksResponse:
        """
        @summary 获取数据投递任务列表
        
        @param request: ListDeliveryTasksRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListDeliveryTasksResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.key_words):
            query['keyWords'] = request.key_words
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.tag):
            query['tag'] = request.tag
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListDeliveryTasks',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/delivery-tasks',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListDeliveryTasksResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_delivery_tasks(
        self,
        request: cms_20240330_models.ListDeliveryTasksRequest,
    ) -> cms_20240330_models.ListDeliveryTasksResponse:
        """
        @summary 获取数据投递任务列表
        
        @param request: ListDeliveryTasksRequest
        @return: ListDeliveryTasksResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_delivery_tasks_with_options(request, headers, runtime)

    async def list_delivery_tasks_async(
        self,
        request: cms_20240330_models.ListDeliveryTasksRequest,
    ) -> cms_20240330_models.ListDeliveryTasksResponse:
        """
        @summary 获取数据投递任务列表
        
        @param request: ListDeliveryTasksRequest
        @return: ListDeliveryTasksResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_delivery_tasks_with_options_async(request, headers, runtime)

    def list_digital_employee_skill_versions_with_options(
        self,
        name: str,
        skill_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListDigitalEmployeeSkillVersionsResponse:
        """
        @summary 列出技能版本
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListDigitalEmployeeSkillVersionsResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='ListDigitalEmployeeSkillVersions',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/skill/{OpenApiUtilClient.get_encode_param(skill_name)}/versions',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListDigitalEmployeeSkillVersionsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_digital_employee_skill_versions_with_options_async(
        self,
        name: str,
        skill_name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListDigitalEmployeeSkillVersionsResponse:
        """
        @summary 列出技能版本
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListDigitalEmployeeSkillVersionsResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='ListDigitalEmployeeSkillVersions',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/skill/{OpenApiUtilClient.get_encode_param(skill_name)}/versions',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListDigitalEmployeeSkillVersionsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_digital_employee_skill_versions(
        self,
        name: str,
        skill_name: str,
    ) -> cms_20240330_models.ListDigitalEmployeeSkillVersionsResponse:
        """
        @summary 列出技能版本
        
        @return: ListDigitalEmployeeSkillVersionsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_digital_employee_skill_versions_with_options(name, skill_name, headers, runtime)

    async def list_digital_employee_skill_versions_async(
        self,
        name: str,
        skill_name: str,
    ) -> cms_20240330_models.ListDigitalEmployeeSkillVersionsResponse:
        """
        @summary 列出技能版本
        
        @return: ListDigitalEmployeeSkillVersionsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_digital_employee_skill_versions_with_options_async(name, skill_name, headers, runtime)

    def list_digital_employee_skills_with_options(
        self,
        name: str,
        request: cms_20240330_models.ListDigitalEmployeeSkillsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListDigitalEmployeeSkillsResponse:
        """
        @summary 列出技能
        
        @param request: ListDigitalEmployeeSkillsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListDigitalEmployeeSkillsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.skill_name):
            query['skillName'] = request.skill_name
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListDigitalEmployeeSkills',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/skills',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListDigitalEmployeeSkillsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_digital_employee_skills_with_options_async(
        self,
        name: str,
        request: cms_20240330_models.ListDigitalEmployeeSkillsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListDigitalEmployeeSkillsResponse:
        """
        @summary 列出技能
        
        @param request: ListDigitalEmployeeSkillsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListDigitalEmployeeSkillsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.skill_name):
            query['skillName'] = request.skill_name
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListDigitalEmployeeSkills',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/skills',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListDigitalEmployeeSkillsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_digital_employee_skills(
        self,
        name: str,
        request: cms_20240330_models.ListDigitalEmployeeSkillsRequest,
    ) -> cms_20240330_models.ListDigitalEmployeeSkillsResponse:
        """
        @summary 列出技能
        
        @param request: ListDigitalEmployeeSkillsRequest
        @return: ListDigitalEmployeeSkillsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_digital_employee_skills_with_options(name, request, headers, runtime)

    async def list_digital_employee_skills_async(
        self,
        name: str,
        request: cms_20240330_models.ListDigitalEmployeeSkillsRequest,
    ) -> cms_20240330_models.ListDigitalEmployeeSkillsResponse:
        """
        @summary 列出技能
        
        @param request: ListDigitalEmployeeSkillsRequest
        @return: ListDigitalEmployeeSkillsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_digital_employee_skills_with_options_async(name, request, headers, runtime)

    def list_digital_employee_tools_with_options(
        self,
        name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListDigitalEmployeeToolsResponse:
        """
        @summary 查询当前数字员工下的工具列表
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListDigitalEmployeeToolsResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='ListDigitalEmployeeTools',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/tools',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListDigitalEmployeeToolsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_digital_employee_tools_with_options_async(
        self,
        name: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListDigitalEmployeeToolsResponse:
        """
        @summary 查询当前数字员工下的工具列表
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListDigitalEmployeeToolsResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='ListDigitalEmployeeTools',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/tools',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListDigitalEmployeeToolsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_digital_employee_tools(
        self,
        name: str,
    ) -> cms_20240330_models.ListDigitalEmployeeToolsResponse:
        """
        @summary 查询当前数字员工下的工具列表
        
        @return: ListDigitalEmployeeToolsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_digital_employee_tools_with_options(name, headers, runtime)

    async def list_digital_employee_tools_async(
        self,
        name: str,
    ) -> cms_20240330_models.ListDigitalEmployeeToolsResponse:
        """
        @summary 查询当前数字员工下的工具列表
        
        @return: ListDigitalEmployeeToolsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_digital_employee_tools_with_options_async(name, headers, runtime)

    def list_digital_employees_with_options(
        self,
        tmp_req: cms_20240330_models.ListDigitalEmployeesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListDigitalEmployeesResponse:
        """
        @summary 列出资源DigitalEmployee
        
        @param tmp_req: ListDigitalEmployeesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListDigitalEmployeesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListDigitalEmployeesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.tags):
            request.tags_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tags, 'tags', 'json')
        query = {}
        if not UtilClient.is_unset(request.display_name):
            query['displayName'] = request.display_name
        if not UtilClient.is_unset(request.employee_type):
            query['employeeType'] = request.employee_type
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.name):
            query['name'] = request.name
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.tags_shrink):
            query['tags'] = request.tags_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListDigitalEmployees',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digital-employee',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListDigitalEmployeesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_digital_employees_with_options_async(
        self,
        tmp_req: cms_20240330_models.ListDigitalEmployeesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListDigitalEmployeesResponse:
        """
        @summary 列出资源DigitalEmployee
        
        @param tmp_req: ListDigitalEmployeesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListDigitalEmployeesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListDigitalEmployeesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.tags):
            request.tags_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tags, 'tags', 'json')
        query = {}
        if not UtilClient.is_unset(request.display_name):
            query['displayName'] = request.display_name
        if not UtilClient.is_unset(request.employee_type):
            query['employeeType'] = request.employee_type
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.name):
            query['name'] = request.name
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.tags_shrink):
            query['tags'] = request.tags_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListDigitalEmployees',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digital-employee',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListDigitalEmployeesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_digital_employees(
        self,
        request: cms_20240330_models.ListDigitalEmployeesRequest,
    ) -> cms_20240330_models.ListDigitalEmployeesResponse:
        """
        @summary 列出资源DigitalEmployee
        
        @param request: ListDigitalEmployeesRequest
        @return: ListDigitalEmployeesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_digital_employees_with_options(request, headers, runtime)

    async def list_digital_employees_async(
        self,
        request: cms_20240330_models.ListDigitalEmployeesRequest,
    ) -> cms_20240330_models.ListDigitalEmployeesResponse:
        """
        @summary 列出资源DigitalEmployee
        
        @param request: ListDigitalEmployeesRequest
        @return: ListDigitalEmployeesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_digital_employees_with_options_async(request, headers, runtime)

    def list_escalation_policies_with_options(
        self,
        request: cms_20240330_models.ListEscalationPoliciesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListEscalationPoliciesResponse:
        """
        @summary List escalation policies
        
        @param request: ListEscalationPoliciesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListEscalationPoliciesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.direction):
            query['direction'] = request.direction
        if not UtilClient.is_unset(request.enable):
            query['enable'] = request.enable
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.name):
            query['name'] = request.name
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.order_by):
            query['orderBy'] = request.order_by
        if not UtilClient.is_unset(request.uuid):
            query['uuid'] = request.uuid
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListEscalationPolicies',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/escalationPolicies',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListEscalationPoliciesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_escalation_policies_with_options_async(
        self,
        request: cms_20240330_models.ListEscalationPoliciesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListEscalationPoliciesResponse:
        """
        @summary List escalation policies
        
        @param request: ListEscalationPoliciesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListEscalationPoliciesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.direction):
            query['direction'] = request.direction
        if not UtilClient.is_unset(request.enable):
            query['enable'] = request.enable
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.name):
            query['name'] = request.name
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.order_by):
            query['orderBy'] = request.order_by
        if not UtilClient.is_unset(request.uuid):
            query['uuid'] = request.uuid
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListEscalationPolicies',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/escalationPolicies',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListEscalationPoliciesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_escalation_policies(
        self,
        request: cms_20240330_models.ListEscalationPoliciesRequest,
    ) -> cms_20240330_models.ListEscalationPoliciesResponse:
        """
        @summary List escalation policies
        
        @param request: ListEscalationPoliciesRequest
        @return: ListEscalationPoliciesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_escalation_policies_with_options(request, headers, runtime)

    async def list_escalation_policies_async(
        self,
        request: cms_20240330_models.ListEscalationPoliciesRequest,
    ) -> cms_20240330_models.ListEscalationPoliciesResponse:
        """
        @summary List escalation policies
        
        @param request: ListEscalationPoliciesRequest
        @return: ListEscalationPoliciesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_escalation_policies_with_options_async(request, headers, runtime)

    def list_evaluation_tasks_with_options(
        self,
        request: cms_20240330_models.ListEvaluationTasksRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListEvaluationTasksResponse:
        """
        @summary 查询评估任务列表
        
        @param request: ListEvaluationTasksRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListEvaluationTasksResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.channel):
            query['channel'] = request.channel
        if not UtilClient.is_unset(request.data_type):
            query['dataType'] = request.data_type
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.status):
            query['status'] = request.status
        if not UtilClient.is_unset(request.tags):
            query['tags'] = request.tags
        if not UtilClient.is_unset(request.task_mode):
            query['taskMode'] = request.task_mode
        if not UtilClient.is_unset(request.task_name):
            query['taskName'] = request.task_name
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListEvaluationTasks',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/evaluation-tasks',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListEvaluationTasksResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_evaluation_tasks_with_options_async(
        self,
        request: cms_20240330_models.ListEvaluationTasksRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListEvaluationTasksResponse:
        """
        @summary 查询评估任务列表
        
        @param request: ListEvaluationTasksRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListEvaluationTasksResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.channel):
            query['channel'] = request.channel
        if not UtilClient.is_unset(request.data_type):
            query['dataType'] = request.data_type
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.status):
            query['status'] = request.status
        if not UtilClient.is_unset(request.tags):
            query['tags'] = request.tags
        if not UtilClient.is_unset(request.task_mode):
            query['taskMode'] = request.task_mode
        if not UtilClient.is_unset(request.task_name):
            query['taskName'] = request.task_name
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListEvaluationTasks',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/evaluation-tasks',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListEvaluationTasksResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_evaluation_tasks(
        self,
        request: cms_20240330_models.ListEvaluationTasksRequest,
    ) -> cms_20240330_models.ListEvaluationTasksResponse:
        """
        @summary 查询评估任务列表
        
        @param request: ListEvaluationTasksRequest
        @return: ListEvaluationTasksResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_evaluation_tasks_with_options(request, headers, runtime)

    async def list_evaluation_tasks_async(
        self,
        request: cms_20240330_models.ListEvaluationTasksRequest,
    ) -> cms_20240330_models.ListEvaluationTasksResponse:
        """
        @summary 查询评估任务列表
        
        @param request: ListEvaluationTasksRequest
        @return: ListEvaluationTasksResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_evaluation_tasks_with_options_async(request, headers, runtime)

    def list_event_label_cache_keys_with_options(
        self,
        request: cms_20240330_models.ListEventLabelCacheKeysRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListEventLabelCacheKeysResponse:
        """
        @summary 从缓存中获取最近60天内所有获取到的事件标签Key
        
        @param request: ListEventLabelCacheKeysRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListEventLabelCacheKeysResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.key):
            query['key'] = request.key
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListEventLabelCacheKeys',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/label/keys',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListEventLabelCacheKeysResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_event_label_cache_keys_with_options_async(
        self,
        request: cms_20240330_models.ListEventLabelCacheKeysRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListEventLabelCacheKeysResponse:
        """
        @summary 从缓存中获取最近60天内所有获取到的事件标签Key
        
        @param request: ListEventLabelCacheKeysRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListEventLabelCacheKeysResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.key):
            query['key'] = request.key
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListEventLabelCacheKeys',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/label/keys',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListEventLabelCacheKeysResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_event_label_cache_keys(
        self,
        request: cms_20240330_models.ListEventLabelCacheKeysRequest,
    ) -> cms_20240330_models.ListEventLabelCacheKeysResponse:
        """
        @summary 从缓存中获取最近60天内所有获取到的事件标签Key
        
        @param request: ListEventLabelCacheKeysRequest
        @return: ListEventLabelCacheKeysResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_event_label_cache_keys_with_options(request, headers, runtime)

    async def list_event_label_cache_keys_async(
        self,
        request: cms_20240330_models.ListEventLabelCacheKeysRequest,
    ) -> cms_20240330_models.ListEventLabelCacheKeysResponse:
        """
        @summary 从缓存中获取最近60天内所有获取到的事件标签Key
        
        @param request: ListEventLabelCacheKeysRequest
        @return: ListEventLabelCacheKeysResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_event_label_cache_keys_with_options_async(request, headers, runtime)

    def list_event_label_cache_values_with_options(
        self,
        request: cms_20240330_models.ListEventLabelCacheValuesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListEventLabelCacheValuesResponse:
        """
        @summary 获取近60天一个key TOP N 可能value
        
        @param request: ListEventLabelCacheValuesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListEventLabelCacheValuesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.key):
            query['key'] = request.key
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.value):
            query['value'] = request.value
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListEventLabelCacheValues',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/label/values',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListEventLabelCacheValuesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_event_label_cache_values_with_options_async(
        self,
        request: cms_20240330_models.ListEventLabelCacheValuesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListEventLabelCacheValuesResponse:
        """
        @summary 获取近60天一个key TOP N 可能value
        
        @param request: ListEventLabelCacheValuesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListEventLabelCacheValuesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.key):
            query['key'] = request.key
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.value):
            query['value'] = request.value
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListEventLabelCacheValues',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/label/values',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListEventLabelCacheValuesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_event_label_cache_values(
        self,
        request: cms_20240330_models.ListEventLabelCacheValuesRequest,
    ) -> cms_20240330_models.ListEventLabelCacheValuesResponse:
        """
        @summary 获取近60天一个key TOP N 可能value
        
        @param request: ListEventLabelCacheValuesRequest
        @return: ListEventLabelCacheValuesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_event_label_cache_values_with_options(request, headers, runtime)

    async def list_event_label_cache_values_async(
        self,
        request: cms_20240330_models.ListEventLabelCacheValuesRequest,
    ) -> cms_20240330_models.ListEventLabelCacheValuesResponse:
        """
        @summary 获取近60天一个key TOP N 可能value
        
        @param request: ListEventLabelCacheValuesRequest
        @return: ListEventLabelCacheValuesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_event_label_cache_values_with_options_async(request, headers, runtime)

    def list_experiment_plans_with_options(
        self,
        workspace: str,
        request: cms_20240330_models.ListExperimentPlansRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListExperimentPlansResponse:
        """
        @summary 查询实验计划列表
        
        @param request: ListExperimentPlansRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListExperimentPlansResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.limit):
            query['limit'] = request.limit
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.offset):
            query['offset'] = request.offset
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListExperimentPlans',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/experiments/{OpenApiUtilClient.get_encode_param(workspace)}/plans',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListExperimentPlansResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_experiment_plans_with_options_async(
        self,
        workspace: str,
        request: cms_20240330_models.ListExperimentPlansRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListExperimentPlansResponse:
        """
        @summary 查询实验计划列表
        
        @param request: ListExperimentPlansRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListExperimentPlansResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.limit):
            query['limit'] = request.limit
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.offset):
            query['offset'] = request.offset
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListExperimentPlans',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/experiments/{OpenApiUtilClient.get_encode_param(workspace)}/plans',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListExperimentPlansResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_experiment_plans(
        self,
        workspace: str,
        request: cms_20240330_models.ListExperimentPlansRequest,
    ) -> cms_20240330_models.ListExperimentPlansResponse:
        """
        @summary 查询实验计划列表
        
        @param request: ListExperimentPlansRequest
        @return: ListExperimentPlansResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_experiment_plans_with_options(workspace, request, headers, runtime)

    async def list_experiment_plans_async(
        self,
        workspace: str,
        request: cms_20240330_models.ListExperimentPlansRequest,
    ) -> cms_20240330_models.ListExperimentPlansResponse:
        """
        @summary 查询实验计划列表
        
        @param request: ListExperimentPlansRequest
        @return: ListExperimentPlansResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_experiment_plans_with_options_async(workspace, request, headers, runtime)

    def list_experiment_tasks_with_options(
        self,
        workspace: str,
        request: cms_20240330_models.ListExperimentTasksRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListExperimentTasksResponse:
        """
        @summary 查询实验记录列表
        
        @param request: ListExperimentTasksRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListExperimentTasksResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.dataset_id):
            query['datasetId'] = request.dataset_id
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.page):
            query['page'] = request.page
        if not UtilClient.is_unset(request.page_size):
            query['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.status):
            query['status'] = request.status
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListExperimentTasks',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/experiments/{OpenApiUtilClient.get_encode_param(workspace)}/records',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListExperimentTasksResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_experiment_tasks_with_options_async(
        self,
        workspace: str,
        request: cms_20240330_models.ListExperimentTasksRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListExperimentTasksResponse:
        """
        @summary 查询实验记录列表
        
        @param request: ListExperimentTasksRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListExperimentTasksResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.dataset_id):
            query['datasetId'] = request.dataset_id
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.page):
            query['page'] = request.page
        if not UtilClient.is_unset(request.page_size):
            query['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.status):
            query['status'] = request.status
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListExperimentTasks',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/experiments/{OpenApiUtilClient.get_encode_param(workspace)}/records',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListExperimentTasksResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_experiment_tasks(
        self,
        workspace: str,
        request: cms_20240330_models.ListExperimentTasksRequest,
    ) -> cms_20240330_models.ListExperimentTasksResponse:
        """
        @summary 查询实验记录列表
        
        @param request: ListExperimentTasksRequest
        @return: ListExperimentTasksResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_experiment_tasks_with_options(workspace, request, headers, runtime)

    async def list_experiment_tasks_async(
        self,
        workspace: str,
        request: cms_20240330_models.ListExperimentTasksRequest,
    ) -> cms_20240330_models.ListExperimentTasksResponse:
        """
        @summary 查询实验记录列表
        
        @param request: ListExperimentTasksRequest
        @return: ListExperimentTasksResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_experiment_tasks_with_options_async(workspace, request, headers, runtime)

    def list_incident_events_with_options(
        self,
        request: cms_20240330_models.ListIncidentEventsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIncidentEventsResponse:
        """
        @summary List incident events
        
        @param request: ListIncidentEventsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIncidentEventsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.array_index):
            query['arrayIndex'] = request.array_index
        if not UtilClient.is_unset(request.dimension):
            query['dimension'] = request.dimension
        if not UtilClient.is_unset(request.end_time):
            query['endTime'] = request.end_time
        if not UtilClient.is_unset(request.group_by):
            query['groupBy'] = request.group_by
        if not UtilClient.is_unset(request.incident_uuid):
            query['incidentUuid'] = request.incident_uuid
        if not UtilClient.is_unset(request.labels):
            query['labels'] = request.labels
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.resource_domain):
            query['resourceDomain'] = request.resource_domain
        if not UtilClient.is_unset(request.resource_entity_id):
            query['resourceEntityId'] = request.resource_entity_id
        if not UtilClient.is_unset(request.resource_entity_type):
            query['resourceEntityType'] = request.resource_entity_type
        if not UtilClient.is_unset(request.resource_props):
            query['resourceProps'] = request.resource_props
        if not UtilClient.is_unset(request.resource_tags):
            query['resourceTags'] = request.resource_tags
        if not UtilClient.is_unset(request.severity):
            query['severity'] = request.severity
        if not UtilClient.is_unset(request.start_time):
            query['startTime'] = request.start_time
        if not UtilClient.is_unset(request.status):
            query['status'] = request.status
        if not UtilClient.is_unset(request.text_index):
            query['textIndex'] = request.text_index
        if not UtilClient.is_unset(request.title):
            query['title'] = request.title
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIncidentEvents',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/incident/event',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIncidentEventsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_incident_events_with_options_async(
        self,
        request: cms_20240330_models.ListIncidentEventsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIncidentEventsResponse:
        """
        @summary List incident events
        
        @param request: ListIncidentEventsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIncidentEventsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.array_index):
            query['arrayIndex'] = request.array_index
        if not UtilClient.is_unset(request.dimension):
            query['dimension'] = request.dimension
        if not UtilClient.is_unset(request.end_time):
            query['endTime'] = request.end_time
        if not UtilClient.is_unset(request.group_by):
            query['groupBy'] = request.group_by
        if not UtilClient.is_unset(request.incident_uuid):
            query['incidentUuid'] = request.incident_uuid
        if not UtilClient.is_unset(request.labels):
            query['labels'] = request.labels
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.resource_domain):
            query['resourceDomain'] = request.resource_domain
        if not UtilClient.is_unset(request.resource_entity_id):
            query['resourceEntityId'] = request.resource_entity_id
        if not UtilClient.is_unset(request.resource_entity_type):
            query['resourceEntityType'] = request.resource_entity_type
        if not UtilClient.is_unset(request.resource_props):
            query['resourceProps'] = request.resource_props
        if not UtilClient.is_unset(request.resource_tags):
            query['resourceTags'] = request.resource_tags
        if not UtilClient.is_unset(request.severity):
            query['severity'] = request.severity
        if not UtilClient.is_unset(request.start_time):
            query['startTime'] = request.start_time
        if not UtilClient.is_unset(request.status):
            query['status'] = request.status
        if not UtilClient.is_unset(request.text_index):
            query['textIndex'] = request.text_index
        if not UtilClient.is_unset(request.title):
            query['title'] = request.title
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIncidentEvents',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/incident/event',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIncidentEventsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_incident_events(
        self,
        request: cms_20240330_models.ListIncidentEventsRequest,
    ) -> cms_20240330_models.ListIncidentEventsResponse:
        """
        @summary List incident events
        
        @param request: ListIncidentEventsRequest
        @return: ListIncidentEventsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_incident_events_with_options(request, headers, runtime)

    async def list_incident_events_async(
        self,
        request: cms_20240330_models.ListIncidentEventsRequest,
    ) -> cms_20240330_models.ListIncidentEventsResponse:
        """
        @summary List incident events
        
        @param request: ListIncidentEventsRequest
        @return: ListIncidentEventsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_incident_events_with_options_async(request, headers, runtime)

    def list_incident_timelines_with_options(
        self,
        request: cms_20240330_models.ListIncidentTimelinesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIncidentTimelinesResponse:
        """
        @summary List incidents
        
        @param request: ListIncidentTimelinesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIncidentTimelinesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.change_type):
            query['changeType'] = request.change_type
        if not UtilClient.is_unset(request.end_time):
            query['endTime'] = request.end_time
        if not UtilClient.is_unset(request.incident_uuid):
            query['incidentUuid'] = request.incident_uuid
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.operator):
            query['operator'] = request.operator
        if not UtilClient.is_unset(request.start_time):
            query['startTime'] = request.start_time
        if not UtilClient.is_unset(request.title):
            query['title'] = request.title
        if not UtilClient.is_unset(request.type):
            query['type'] = request.type
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIncidentTimelines',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/incident/timeline',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIncidentTimelinesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_incident_timelines_with_options_async(
        self,
        request: cms_20240330_models.ListIncidentTimelinesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIncidentTimelinesResponse:
        """
        @summary List incidents
        
        @param request: ListIncidentTimelinesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIncidentTimelinesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.change_type):
            query['changeType'] = request.change_type
        if not UtilClient.is_unset(request.end_time):
            query['endTime'] = request.end_time
        if not UtilClient.is_unset(request.incident_uuid):
            query['incidentUuid'] = request.incident_uuid
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.operator):
            query['operator'] = request.operator
        if not UtilClient.is_unset(request.start_time):
            query['startTime'] = request.start_time
        if not UtilClient.is_unset(request.title):
            query['title'] = request.title
        if not UtilClient.is_unset(request.type):
            query['type'] = request.type
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIncidentTimelines',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/incident/timeline',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIncidentTimelinesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_incident_timelines(
        self,
        request: cms_20240330_models.ListIncidentTimelinesRequest,
    ) -> cms_20240330_models.ListIncidentTimelinesResponse:
        """
        @summary List incidents
        
        @param request: ListIncidentTimelinesRequest
        @return: ListIncidentTimelinesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_incident_timelines_with_options(request, headers, runtime)

    async def list_incident_timelines_async(
        self,
        request: cms_20240330_models.ListIncidentTimelinesRequest,
    ) -> cms_20240330_models.ListIncidentTimelinesResponse:
        """
        @summary List incidents
        
        @param request: ListIncidentTimelinesRequest
        @return: ListIncidentTimelinesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_incident_timelines_with_options_async(request, headers, runtime)

    def list_incidents_with_options(
        self,
        request: cms_20240330_models.ListIncidentsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIncidentsResponse:
        """
        @summary List incidents
        
        @param request: ListIncidentsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIncidentsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.array_index):
            query['arrayIndex'] = request.array_index
        if not UtilClient.is_unset(request.end_time):
            query['endTime'] = request.end_time
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.operator):
            query['operator'] = request.operator
        if not UtilClient.is_unset(request.owner):
            query['owner'] = request.owner
        if not UtilClient.is_unset(request.participant):
            query['participant'] = request.participant
        if not UtilClient.is_unset(request.plan_id):
            query['planId'] = request.plan_id
        if not UtilClient.is_unset(request.resource_domain):
            query['resourceDomain'] = request.resource_domain
        if not UtilClient.is_unset(request.resource_entity_id):
            query['resourceEntityId'] = request.resource_entity_id
        if not UtilClient.is_unset(request.resource_entity_type):
            query['resourceEntityType'] = request.resource_entity_type
        if not UtilClient.is_unset(request.resource_props):
            query['resourceProps'] = request.resource_props
        if not UtilClient.is_unset(request.resource_tags):
            query['resourceTags'] = request.resource_tags
        if not UtilClient.is_unset(request.root_cause_category):
            query['rootCauseCategory'] = request.root_cause_category
        if not UtilClient.is_unset(request.severity):
            query['severity'] = request.severity
        if not UtilClient.is_unset(request.solution):
            query['solution'] = request.solution
        if not UtilClient.is_unset(request.start_time):
            query['startTime'] = request.start_time
        if not UtilClient.is_unset(request.state):
            query['state'] = request.state
        if not UtilClient.is_unset(request.text_index):
            query['textIndex'] = request.text_index
        if not UtilClient.is_unset(request.title):
            query['title'] = request.title
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIncidents',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/incident',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIncidentsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_incidents_with_options_async(
        self,
        request: cms_20240330_models.ListIncidentsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIncidentsResponse:
        """
        @summary List incidents
        
        @param request: ListIncidentsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIncidentsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.array_index):
            query['arrayIndex'] = request.array_index
        if not UtilClient.is_unset(request.end_time):
            query['endTime'] = request.end_time
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.operator):
            query['operator'] = request.operator
        if not UtilClient.is_unset(request.owner):
            query['owner'] = request.owner
        if not UtilClient.is_unset(request.participant):
            query['participant'] = request.participant
        if not UtilClient.is_unset(request.plan_id):
            query['planId'] = request.plan_id
        if not UtilClient.is_unset(request.resource_domain):
            query['resourceDomain'] = request.resource_domain
        if not UtilClient.is_unset(request.resource_entity_id):
            query['resourceEntityId'] = request.resource_entity_id
        if not UtilClient.is_unset(request.resource_entity_type):
            query['resourceEntityType'] = request.resource_entity_type
        if not UtilClient.is_unset(request.resource_props):
            query['resourceProps'] = request.resource_props
        if not UtilClient.is_unset(request.resource_tags):
            query['resourceTags'] = request.resource_tags
        if not UtilClient.is_unset(request.root_cause_category):
            query['rootCauseCategory'] = request.root_cause_category
        if not UtilClient.is_unset(request.severity):
            query['severity'] = request.severity
        if not UtilClient.is_unset(request.solution):
            query['solution'] = request.solution
        if not UtilClient.is_unset(request.start_time):
            query['startTime'] = request.start_time
        if not UtilClient.is_unset(request.state):
            query['state'] = request.state
        if not UtilClient.is_unset(request.text_index):
            query['textIndex'] = request.text_index
        if not UtilClient.is_unset(request.title):
            query['title'] = request.title
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIncidents',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/incident',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIncidentsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_incidents(
        self,
        request: cms_20240330_models.ListIncidentsRequest,
    ) -> cms_20240330_models.ListIncidentsResponse:
        """
        @summary List incidents
        
        @param request: ListIncidentsRequest
        @return: ListIncidentsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_incidents_with_options(request, headers, runtime)

    async def list_incidents_async(
        self,
        request: cms_20240330_models.ListIncidentsRequest,
    ) -> cms_20240330_models.ListIncidentsResponse:
        """
        @summary List incidents
        
        @param request: ListIncidentsRequest
        @return: ListIncidentsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_incidents_with_options_async(request, headers, runtime)

    def list_integration_policies_with_options(
        self,
        tmp_req: cms_20240330_models.ListIntegrationPoliciesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIntegrationPoliciesResponse:
        """
        @summary Query Access Center Policy List Information
        
        @description Query integration list
        
        @param tmp_req: ListIntegrationPoliciesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIntegrationPoliciesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListIntegrationPoliciesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.tag):
            request.tag_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tag, 'tag', 'json')
        query = {}
        if not UtilClient.is_unset(request.addon_name):
            query['addonName'] = request.addon_name
        if not UtilClient.is_unset(request.bind_resource_id):
            query['bindResourceId'] = request.bind_resource_id
        if not UtilClient.is_unset(request.entity_group_ids):
            query['entityGroupIds'] = request.entity_group_ids
        if not UtilClient.is_unset(request.filter_region_ids):
            query['filterRegionIds'] = request.filter_region_ids
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.policy_id):
            query['policyId'] = request.policy_id
        if not UtilClient.is_unset(request.policy_name):
            query['policyName'] = request.policy_name
        if not UtilClient.is_unset(request.policy_type):
            query['policyType'] = request.policy_type
        if not UtilClient.is_unset(request.prometheus_instance_id):
            query['prometheusInstanceId'] = request.prometheus_instance_id
        if not UtilClient.is_unset(request.query):
            query['query'] = request.query
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.tag_shrink):
            query['tag'] = request.tag_shrink
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIntegrationPolicies',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIntegrationPoliciesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_integration_policies_with_options_async(
        self,
        tmp_req: cms_20240330_models.ListIntegrationPoliciesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIntegrationPoliciesResponse:
        """
        @summary Query Access Center Policy List Information
        
        @description Query integration list
        
        @param tmp_req: ListIntegrationPoliciesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIntegrationPoliciesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListIntegrationPoliciesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.tag):
            request.tag_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tag, 'tag', 'json')
        query = {}
        if not UtilClient.is_unset(request.addon_name):
            query['addonName'] = request.addon_name
        if not UtilClient.is_unset(request.bind_resource_id):
            query['bindResourceId'] = request.bind_resource_id
        if not UtilClient.is_unset(request.entity_group_ids):
            query['entityGroupIds'] = request.entity_group_ids
        if not UtilClient.is_unset(request.filter_region_ids):
            query['filterRegionIds'] = request.filter_region_ids
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.policy_id):
            query['policyId'] = request.policy_id
        if not UtilClient.is_unset(request.policy_name):
            query['policyName'] = request.policy_name
        if not UtilClient.is_unset(request.policy_type):
            query['policyType'] = request.policy_type
        if not UtilClient.is_unset(request.prometheus_instance_id):
            query['prometheusInstanceId'] = request.prometheus_instance_id
        if not UtilClient.is_unset(request.query):
            query['query'] = request.query
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.tag_shrink):
            query['tag'] = request.tag_shrink
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIntegrationPolicies',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIntegrationPoliciesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_integration_policies(
        self,
        request: cms_20240330_models.ListIntegrationPoliciesRequest,
    ) -> cms_20240330_models.ListIntegrationPoliciesResponse:
        """
        @summary Query Access Center Policy List Information
        
        @description Query integration list
        
        @param request: ListIntegrationPoliciesRequest
        @return: ListIntegrationPoliciesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_integration_policies_with_options(request, headers, runtime)

    async def list_integration_policies_async(
        self,
        request: cms_20240330_models.ListIntegrationPoliciesRequest,
    ) -> cms_20240330_models.ListIntegrationPoliciesResponse:
        """
        @summary Query Access Center Policy List Information
        
        @description Query integration list
        
        @param request: ListIntegrationPoliciesRequest
        @return: ListIntegrationPoliciesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_integration_policies_with_options_async(request, headers, runtime)

    def list_integration_policy_addons_with_options(
        self,
        policy_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIntegrationPolicyAddonsResponse:
        """
        @summary 策略addon列表
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIntegrationPolicyAddonsResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='ListIntegrationPolicyAddons',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/addons',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIntegrationPolicyAddonsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_integration_policy_addons_with_options_async(
        self,
        policy_id: str,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIntegrationPolicyAddonsResponse:
        """
        @summary 策略addon列表
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIntegrationPolicyAddonsResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='ListIntegrationPolicyAddons',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/addons',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIntegrationPolicyAddonsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_integration_policy_addons(
        self,
        policy_id: str,
    ) -> cms_20240330_models.ListIntegrationPolicyAddonsResponse:
        """
        @summary 策略addon列表
        
        @return: ListIntegrationPolicyAddonsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_integration_policy_addons_with_options(policy_id, headers, runtime)

    async def list_integration_policy_addons_async(
        self,
        policy_id: str,
    ) -> cms_20240330_models.ListIntegrationPolicyAddonsResponse:
        """
        @summary 策略addon列表
        
        @return: ListIntegrationPolicyAddonsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_integration_policy_addons_with_options_async(policy_id, headers, runtime)

    def list_integration_policy_alert_rules_with_options(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyAlertRulesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIntegrationPolicyAlertRulesResponse:
        """
        @summary 环境的告警组列表
        
        @param request: ListIntegrationPolicyAlertRulesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIntegrationPolicyAlertRulesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.addon_name):
            query['addonName'] = request.addon_name
        if not UtilClient.is_unset(request.scene):
            query['scene'] = request.scene
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIntegrationPolicyAlertRules',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/alert-rules',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIntegrationPolicyAlertRulesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_integration_policy_alert_rules_with_options_async(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyAlertRulesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIntegrationPolicyAlertRulesResponse:
        """
        @summary 环境的告警组列表
        
        @param request: ListIntegrationPolicyAlertRulesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIntegrationPolicyAlertRulesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.addon_name):
            query['addonName'] = request.addon_name
        if not UtilClient.is_unset(request.scene):
            query['scene'] = request.scene
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIntegrationPolicyAlertRules',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/alert-rules',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIntegrationPolicyAlertRulesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_integration_policy_alert_rules(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyAlertRulesRequest,
    ) -> cms_20240330_models.ListIntegrationPolicyAlertRulesResponse:
        """
        @summary 环境的告警组列表
        
        @param request: ListIntegrationPolicyAlertRulesRequest
        @return: ListIntegrationPolicyAlertRulesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_integration_policy_alert_rules_with_options(policy_id, request, headers, runtime)

    async def list_integration_policy_alert_rules_async(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyAlertRulesRequest,
    ) -> cms_20240330_models.ListIntegrationPolicyAlertRulesResponse:
        """
        @summary 环境的告警组列表
        
        @param request: ListIntegrationPolicyAlertRulesRequest
        @return: ListIntegrationPolicyAlertRulesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_integration_policy_alert_rules_with_options_async(policy_id, request, headers, runtime)

    def list_integration_policy_collectors_with_options(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyCollectorsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIntegrationPolicyCollectorsResponse:
        """
        @summary 获取接入中心策略的存储要求信息
        
        @param request: ListIntegrationPolicyCollectorsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIntegrationPolicyCollectorsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.addon_release_name):
            query['addonReleaseName'] = request.addon_release_name
        if not UtilClient.is_unset(request.collector_type):
            query['collectorType'] = request.collector_type
        if not UtilClient.is_unset(request.language):
            query['language'] = request.language
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIntegrationPolicyCollectors',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/collectors',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIntegrationPolicyCollectorsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_integration_policy_collectors_with_options_async(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyCollectorsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIntegrationPolicyCollectorsResponse:
        """
        @summary 获取接入中心策略的存储要求信息
        
        @param request: ListIntegrationPolicyCollectorsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIntegrationPolicyCollectorsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.addon_release_name):
            query['addonReleaseName'] = request.addon_release_name
        if not UtilClient.is_unset(request.collector_type):
            query['collectorType'] = request.collector_type
        if not UtilClient.is_unset(request.language):
            query['language'] = request.language
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIntegrationPolicyCollectors',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/collectors',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIntegrationPolicyCollectorsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_integration_policy_collectors(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyCollectorsRequest,
    ) -> cms_20240330_models.ListIntegrationPolicyCollectorsResponse:
        """
        @summary 获取接入中心策略的存储要求信息
        
        @param request: ListIntegrationPolicyCollectorsRequest
        @return: ListIntegrationPolicyCollectorsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_integration_policy_collectors_with_options(policy_id, request, headers, runtime)

    async def list_integration_policy_collectors_async(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyCollectorsRequest,
    ) -> cms_20240330_models.ListIntegrationPolicyCollectorsResponse:
        """
        @summary 获取接入中心策略的存储要求信息
        
        @param request: ListIntegrationPolicyCollectorsRequest
        @return: ListIntegrationPolicyCollectorsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_integration_policy_collectors_with_options_async(policy_id, request, headers, runtime)

    def list_integration_policy_custom_scrape_job_rules_with_options(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyCustomScrapeJobRulesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIntegrationPolicyCustomScrapeJobRulesResponse:
        """
        @summary Get storage requirement information for the access center policy
        
        @param request: ListIntegrationPolicyCustomScrapeJobRulesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIntegrationPolicyCustomScrapeJobRulesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.addon_release_name):
            query['addonReleaseName'] = request.addon_release_name
        if not UtilClient.is_unset(request.encrypt_yaml):
            query['encryptYaml'] = request.encrypt_yaml
        if not UtilClient.is_unset(request.namespace):
            query['namespace'] = request.namespace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIntegrationPolicyCustomScrapeJobRules',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/custom-scrape-job-rules',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIntegrationPolicyCustomScrapeJobRulesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_integration_policy_custom_scrape_job_rules_with_options_async(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyCustomScrapeJobRulesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIntegrationPolicyCustomScrapeJobRulesResponse:
        """
        @summary Get storage requirement information for the access center policy
        
        @param request: ListIntegrationPolicyCustomScrapeJobRulesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIntegrationPolicyCustomScrapeJobRulesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.addon_release_name):
            query['addonReleaseName'] = request.addon_release_name
        if not UtilClient.is_unset(request.encrypt_yaml):
            query['encryptYaml'] = request.encrypt_yaml
        if not UtilClient.is_unset(request.namespace):
            query['namespace'] = request.namespace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIntegrationPolicyCustomScrapeJobRules',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/custom-scrape-job-rules',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIntegrationPolicyCustomScrapeJobRulesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_integration_policy_custom_scrape_job_rules(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyCustomScrapeJobRulesRequest,
    ) -> cms_20240330_models.ListIntegrationPolicyCustomScrapeJobRulesResponse:
        """
        @summary Get storage requirement information for the access center policy
        
        @param request: ListIntegrationPolicyCustomScrapeJobRulesRequest
        @return: ListIntegrationPolicyCustomScrapeJobRulesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_integration_policy_custom_scrape_job_rules_with_options(policy_id, request, headers, runtime)

    async def list_integration_policy_custom_scrape_job_rules_async(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyCustomScrapeJobRulesRequest,
    ) -> cms_20240330_models.ListIntegrationPolicyCustomScrapeJobRulesResponse:
        """
        @summary Get storage requirement information for the access center policy
        
        @param request: ListIntegrationPolicyCustomScrapeJobRulesRequest
        @return: ListIntegrationPolicyCustomScrapeJobRulesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_integration_policy_custom_scrape_job_rules_with_options_async(policy_id, request, headers, runtime)

    def list_integration_policy_dashboards_with_options(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyDashboardsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIntegrationPolicyDashboardsResponse:
        """
        @summary Policy Dashboard List
        
        @description This article provides an example of querying the alarm template list. The result shows that there are 2 alarm templates in the list, which are `ECS_Template1` and `ECS_Template2`.
        
        @param request: ListIntegrationPolicyDashboardsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIntegrationPolicyDashboardsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.addon_name):
            query['addonName'] = request.addon_name
        if not UtilClient.is_unset(request.language):
            query['language'] = request.language
        if not UtilClient.is_unset(request.scene):
            query['scene'] = request.scene
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIntegrationPolicyDashboards',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/dashboards',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIntegrationPolicyDashboardsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_integration_policy_dashboards_with_options_async(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyDashboardsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIntegrationPolicyDashboardsResponse:
        """
        @summary Policy Dashboard List
        
        @description This article provides an example of querying the alarm template list. The result shows that there are 2 alarm templates in the list, which are `ECS_Template1` and `ECS_Template2`.
        
        @param request: ListIntegrationPolicyDashboardsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIntegrationPolicyDashboardsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.addon_name):
            query['addonName'] = request.addon_name
        if not UtilClient.is_unset(request.language):
            query['language'] = request.language
        if not UtilClient.is_unset(request.scene):
            query['scene'] = request.scene
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIntegrationPolicyDashboards',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/dashboards',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIntegrationPolicyDashboardsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_integration_policy_dashboards(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyDashboardsRequest,
    ) -> cms_20240330_models.ListIntegrationPolicyDashboardsResponse:
        """
        @summary Policy Dashboard List
        
        @description This article provides an example of querying the alarm template list. The result shows that there are 2 alarm templates in the list, which are `ECS_Template1` and `ECS_Template2`.
        
        @param request: ListIntegrationPolicyDashboardsRequest
        @return: ListIntegrationPolicyDashboardsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_integration_policy_dashboards_with_options(policy_id, request, headers, runtime)

    async def list_integration_policy_dashboards_async(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyDashboardsRequest,
    ) -> cms_20240330_models.ListIntegrationPolicyDashboardsResponse:
        """
        @summary Policy Dashboard List
        
        @description This article provides an example of querying the alarm template list. The result shows that there are 2 alarm templates in the list, which are `ECS_Template1` and `ECS_Template2`.
        
        @param request: ListIntegrationPolicyDashboardsRequest
        @return: ListIntegrationPolicyDashboardsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_integration_policy_dashboards_with_options_async(policy_id, request, headers, runtime)

    def list_integration_policy_pod_monitors_with_options(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyPodMonitorsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIntegrationPolicyPodMonitorsResponse:
        """
        @summary Get PodMonitor Resources of Access Center Policy
        
        @description This article provides an example to query the alarm template list. The result shows that there are 2 alarm templates in the alarm template list, which are `ECS_Template1` and `ECS_Template2`.
        
        @param request: ListIntegrationPolicyPodMonitorsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIntegrationPolicyPodMonitorsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.addon_release_name):
            query['addonReleaseName'] = request.addon_release_name
        if not UtilClient.is_unset(request.encrypt_yaml):
            query['encryptYaml'] = request.encrypt_yaml
        if not UtilClient.is_unset(request.namespace):
            query['namespace'] = request.namespace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIntegrationPolicyPodMonitors',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/pod-monitors',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIntegrationPolicyPodMonitorsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_integration_policy_pod_monitors_with_options_async(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyPodMonitorsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIntegrationPolicyPodMonitorsResponse:
        """
        @summary Get PodMonitor Resources of Access Center Policy
        
        @description This article provides an example to query the alarm template list. The result shows that there are 2 alarm templates in the alarm template list, which are `ECS_Template1` and `ECS_Template2`.
        
        @param request: ListIntegrationPolicyPodMonitorsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIntegrationPolicyPodMonitorsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.addon_release_name):
            query['addonReleaseName'] = request.addon_release_name
        if not UtilClient.is_unset(request.encrypt_yaml):
            query['encryptYaml'] = request.encrypt_yaml
        if not UtilClient.is_unset(request.namespace):
            query['namespace'] = request.namespace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIntegrationPolicyPodMonitors',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/pod-monitors',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIntegrationPolicyPodMonitorsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_integration_policy_pod_monitors(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyPodMonitorsRequest,
    ) -> cms_20240330_models.ListIntegrationPolicyPodMonitorsResponse:
        """
        @summary Get PodMonitor Resources of Access Center Policy
        
        @description This article provides an example to query the alarm template list. The result shows that there are 2 alarm templates in the alarm template list, which are `ECS_Template1` and `ECS_Template2`.
        
        @param request: ListIntegrationPolicyPodMonitorsRequest
        @return: ListIntegrationPolicyPodMonitorsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_integration_policy_pod_monitors_with_options(policy_id, request, headers, runtime)

    async def list_integration_policy_pod_monitors_async(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyPodMonitorsRequest,
    ) -> cms_20240330_models.ListIntegrationPolicyPodMonitorsResponse:
        """
        @summary Get PodMonitor Resources of Access Center Policy
        
        @description This article provides an example to query the alarm template list. The result shows that there are 2 alarm templates in the alarm template list, which are `ECS_Template1` and `ECS_Template2`.
        
        @param request: ListIntegrationPolicyPodMonitorsRequest
        @return: ListIntegrationPolicyPodMonitorsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_integration_policy_pod_monitors_with_options_async(policy_id, request, headers, runtime)

    def list_integration_policy_resources_with_options(
        self,
        policy_id: str,
        tmp_req: cms_20240330_models.ListIntegrationPolicyResourcesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIntegrationPolicyResourcesResponse:
        """
        @summary 获取接入中心策略的资源信息
        
        @param tmp_req: ListIntegrationPolicyResourcesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIntegrationPolicyResourcesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListIntegrationPolicyResourcesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.label_selectors):
            request.label_selectors_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.label_selectors, 'labelSelectors', 'json')
        query = {}
        if not UtilClient.is_unset(request.kind):
            query['kind'] = request.kind
        if not UtilClient.is_unset(request.label_selectors_shrink):
            query['labelSelectors'] = request.label_selectors_shrink
        if not UtilClient.is_unset(request.namespace):
            query['namespace'] = request.namespace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIntegrationPolicyResources',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/resources',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIntegrationPolicyResourcesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_integration_policy_resources_with_options_async(
        self,
        policy_id: str,
        tmp_req: cms_20240330_models.ListIntegrationPolicyResourcesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIntegrationPolicyResourcesResponse:
        """
        @summary 获取接入中心策略的资源信息
        
        @param tmp_req: ListIntegrationPolicyResourcesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIntegrationPolicyResourcesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListIntegrationPolicyResourcesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.label_selectors):
            request.label_selectors_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.label_selectors, 'labelSelectors', 'json')
        query = {}
        if not UtilClient.is_unset(request.kind):
            query['kind'] = request.kind
        if not UtilClient.is_unset(request.label_selectors_shrink):
            query['labelSelectors'] = request.label_selectors_shrink
        if not UtilClient.is_unset(request.namespace):
            query['namespace'] = request.namespace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIntegrationPolicyResources',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/resources',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIntegrationPolicyResourcesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_integration_policy_resources(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyResourcesRequest,
    ) -> cms_20240330_models.ListIntegrationPolicyResourcesResponse:
        """
        @summary 获取接入中心策略的资源信息
        
        @param request: ListIntegrationPolicyResourcesRequest
        @return: ListIntegrationPolicyResourcesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_integration_policy_resources_with_options(policy_id, request, headers, runtime)

    async def list_integration_policy_resources_async(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyResourcesRequest,
    ) -> cms_20240330_models.ListIntegrationPolicyResourcesResponse:
        """
        @summary 获取接入中心策略的资源信息
        
        @param request: ListIntegrationPolicyResourcesRequest
        @return: ListIntegrationPolicyResourcesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_integration_policy_resources_with_options_async(policy_id, request, headers, runtime)

    def list_integration_policy_service_monitors_with_options(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyServiceMonitorsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIntegrationPolicyServiceMonitorsResponse:
        """
        @summary 获取接入中心策略的存储要求信息
        
        @param request: ListIntegrationPolicyServiceMonitorsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIntegrationPolicyServiceMonitorsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.addon_release_name):
            query['addonReleaseName'] = request.addon_release_name
        if not UtilClient.is_unset(request.encrypt_yaml):
            query['encryptYaml'] = request.encrypt_yaml
        if not UtilClient.is_unset(request.namespace):
            query['namespace'] = request.namespace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIntegrationPolicyServiceMonitors',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/service-monitors',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIntegrationPolicyServiceMonitorsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_integration_policy_service_monitors_with_options_async(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyServiceMonitorsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIntegrationPolicyServiceMonitorsResponse:
        """
        @summary 获取接入中心策略的存储要求信息
        
        @param request: ListIntegrationPolicyServiceMonitorsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIntegrationPolicyServiceMonitorsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.addon_release_name):
            query['addonReleaseName'] = request.addon_release_name
        if not UtilClient.is_unset(request.encrypt_yaml):
            query['encryptYaml'] = request.encrypt_yaml
        if not UtilClient.is_unset(request.namespace):
            query['namespace'] = request.namespace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIntegrationPolicyServiceMonitors',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/service-monitors',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIntegrationPolicyServiceMonitorsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_integration_policy_service_monitors(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyServiceMonitorsRequest,
    ) -> cms_20240330_models.ListIntegrationPolicyServiceMonitorsResponse:
        """
        @summary 获取接入中心策略的存储要求信息
        
        @param request: ListIntegrationPolicyServiceMonitorsRequest
        @return: ListIntegrationPolicyServiceMonitorsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_integration_policy_service_monitors_with_options(policy_id, request, headers, runtime)

    async def list_integration_policy_service_monitors_async(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyServiceMonitorsRequest,
    ) -> cms_20240330_models.ListIntegrationPolicyServiceMonitorsResponse:
        """
        @summary 获取接入中心策略的存储要求信息
        
        @param request: ListIntegrationPolicyServiceMonitorsRequest
        @return: ListIntegrationPolicyServiceMonitorsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_integration_policy_service_monitors_with_options_async(policy_id, request, headers, runtime)

    def list_integration_policy_storage_requirements_with_options(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyStorageRequirementsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIntegrationPolicyStorageRequirementsResponse:
        """
        @summary Get Storage Requirements Information for Access Center Policy
        
        @description During the effective period of the policy, all alarms within the application group will no longer send notifications.
        
        This article provides an example of creating a pause alarm notification policy `PauseNotify` for the application group `7301***`. This application group will pause alarms from `1622949300000` to `1623208500000` (Beijing Time `2021-06-06 11:15:00` to `2021-06-09 11:15:00`).
        
        @param request: ListIntegrationPolicyStorageRequirementsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIntegrationPolicyStorageRequirementsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.addon_name):
            query['addonName'] = request.addon_name
        if not UtilClient.is_unset(request.addon_release_name):
            query['addonReleaseName'] = request.addon_release_name
        if not UtilClient.is_unset(request.storage_type):
            query['storageType'] = request.storage_type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIntegrationPolicyStorageRequirements',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/storage-requirements',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIntegrationPolicyStorageRequirementsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_integration_policy_storage_requirements_with_options_async(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyStorageRequirementsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListIntegrationPolicyStorageRequirementsResponse:
        """
        @summary Get Storage Requirements Information for Access Center Policy
        
        @description During the effective period of the policy, all alarms within the application group will no longer send notifications.
        
        This article provides an example of creating a pause alarm notification policy `PauseNotify` for the application group `7301***`. This application group will pause alarms from `1622949300000` to `1623208500000` (Beijing Time `2021-06-06 11:15:00` to `2021-06-09 11:15:00`).
        
        @param request: ListIntegrationPolicyStorageRequirementsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListIntegrationPolicyStorageRequirementsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.addon_name):
            query['addonName'] = request.addon_name
        if not UtilClient.is_unset(request.addon_release_name):
            query['addonReleaseName'] = request.addon_release_name
        if not UtilClient.is_unset(request.storage_type):
            query['storageType'] = request.storage_type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListIntegrationPolicyStorageRequirements',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/storage-requirements',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListIntegrationPolicyStorageRequirementsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_integration_policy_storage_requirements(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyStorageRequirementsRequest,
    ) -> cms_20240330_models.ListIntegrationPolicyStorageRequirementsResponse:
        """
        @summary Get Storage Requirements Information for Access Center Policy
        
        @description During the effective period of the policy, all alarms within the application group will no longer send notifications.
        
        This article provides an example of creating a pause alarm notification policy `PauseNotify` for the application group `7301***`. This application group will pause alarms from `1622949300000` to `1623208500000` (Beijing Time `2021-06-06 11:15:00` to `2021-06-09 11:15:00`).
        
        @param request: ListIntegrationPolicyStorageRequirementsRequest
        @return: ListIntegrationPolicyStorageRequirementsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_integration_policy_storage_requirements_with_options(policy_id, request, headers, runtime)

    async def list_integration_policy_storage_requirements_async(
        self,
        policy_id: str,
        request: cms_20240330_models.ListIntegrationPolicyStorageRequirementsRequest,
    ) -> cms_20240330_models.ListIntegrationPolicyStorageRequirementsResponse:
        """
        @summary Get Storage Requirements Information for Access Center Policy
        
        @description During the effective period of the policy, all alarms within the application group will no longer send notifications.
        
        This article provides an example of creating a pause alarm notification policy `PauseNotify` for the application group `7301***`. This application group will pause alarms from `1622949300000` to `1623208500000` (Beijing Time `2021-06-06 11:15:00` to `2021-06-09 11:15:00`).
        
        @param request: ListIntegrationPolicyStorageRequirementsRequest
        @return: ListIntegrationPolicyStorageRequirementsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_integration_policy_storage_requirements_with_options_async(policy_id, request, headers, runtime)

    def list_maintain_windows_with_options(
        self,
        request: cms_20240330_models.ListMaintainWindowsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListMaintainWindowsResponse:
        """
        @summary 查询维护窗口列表
        
        @param request: ListMaintainWindowsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListMaintainWindowsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.direction):
            query['direction'] = request.direction
        if not UtilClient.is_unset(request.enable):
            query['enable'] = request.enable
        if not UtilClient.is_unset(request.maintain_window_id):
            query['maintainWindowId'] = request.maintain_window_id
        if not UtilClient.is_unset(request.maintain_window_name):
            query['maintainWindowName'] = request.maintain_window_name
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.order_by):
            query['orderBy'] = request.order_by
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListMaintainWindows',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/maintainWindows',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListMaintainWindowsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_maintain_windows_with_options_async(
        self,
        request: cms_20240330_models.ListMaintainWindowsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListMaintainWindowsResponse:
        """
        @summary 查询维护窗口列表
        
        @param request: ListMaintainWindowsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListMaintainWindowsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.direction):
            query['direction'] = request.direction
        if not UtilClient.is_unset(request.enable):
            query['enable'] = request.enable
        if not UtilClient.is_unset(request.maintain_window_id):
            query['maintainWindowId'] = request.maintain_window_id
        if not UtilClient.is_unset(request.maintain_window_name):
            query['maintainWindowName'] = request.maintain_window_name
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.order_by):
            query['orderBy'] = request.order_by
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListMaintainWindows',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/maintainWindows',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListMaintainWindowsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_maintain_windows(
        self,
        request: cms_20240330_models.ListMaintainWindowsRequest,
    ) -> cms_20240330_models.ListMaintainWindowsResponse:
        """
        @summary 查询维护窗口列表
        
        @param request: ListMaintainWindowsRequest
        @return: ListMaintainWindowsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_maintain_windows_with_options(request, headers, runtime)

    async def list_maintain_windows_async(
        self,
        request: cms_20240330_models.ListMaintainWindowsRequest,
    ) -> cms_20240330_models.ListMaintainWindowsResponse:
        """
        @summary 查询维护窗口列表
        
        @param request: ListMaintainWindowsRequest
        @return: ListMaintainWindowsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_maintain_windows_with_options_async(request, headers, runtime)

    def list_memory_stores_with_options(
        self,
        workspace: str,
        request: cms_20240330_models.ListMemoryStoresRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListMemoryStoresResponse:
        """
        @summary 查询记忆库列表
        
        @param request: ListMemoryStoresRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListMemoryStoresResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.memory_store_name):
            query['memoryStoreName'] = request.memory_store_name
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListMemoryStores',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListMemoryStoresResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_memory_stores_with_options_async(
        self,
        workspace: str,
        request: cms_20240330_models.ListMemoryStoresRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListMemoryStoresResponse:
        """
        @summary 查询记忆库列表
        
        @param request: ListMemoryStoresRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListMemoryStoresResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.memory_store_name):
            query['memoryStoreName'] = request.memory_store_name
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListMemoryStores',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListMemoryStoresResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_memory_stores(
        self,
        workspace: str,
        request: cms_20240330_models.ListMemoryStoresRequest,
    ) -> cms_20240330_models.ListMemoryStoresResponse:
        """
        @summary 查询记忆库列表
        
        @param request: ListMemoryStoresRequest
        @return: ListMemoryStoresResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_memory_stores_with_options(workspace, request, headers, runtime)

    async def list_memory_stores_async(
        self,
        workspace: str,
        request: cms_20240330_models.ListMemoryStoresRequest,
    ) -> cms_20240330_models.ListMemoryStoresResponse:
        """
        @summary 查询记忆库列表
        
        @param request: ListMemoryStoresRequest
        @return: ListMemoryStoresResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_memory_stores_with_options_async(workspace, request, headers, runtime)

    def list_notify_strategies_with_options(
        self,
        request: cms_20240330_models.ListNotifyStrategiesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListNotifyStrategiesResponse:
        """
        @summary 查询通知策略列表
        
        @param request: ListNotifyStrategiesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListNotifyStrategiesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.direction):
            query['direction'] = request.direction
        if not UtilClient.is_unset(request.enable):
            query['enable'] = request.enable
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.notify_strategy_id):
            query['notifyStrategyId'] = request.notify_strategy_id
        if not UtilClient.is_unset(request.notify_strategy_ids):
            query['notifyStrategyIds'] = request.notify_strategy_ids
        if not UtilClient.is_unset(request.notify_strategy_name):
            query['notifyStrategyName'] = request.notify_strategy_name
        if not UtilClient.is_unset(request.order_by):
            query['orderBy'] = request.order_by
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListNotifyStrategies',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/notifyStrategies',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListNotifyStrategiesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_notify_strategies_with_options_async(
        self,
        request: cms_20240330_models.ListNotifyStrategiesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListNotifyStrategiesResponse:
        """
        @summary 查询通知策略列表
        
        @param request: ListNotifyStrategiesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListNotifyStrategiesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.direction):
            query['direction'] = request.direction
        if not UtilClient.is_unset(request.enable):
            query['enable'] = request.enable
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.notify_strategy_id):
            query['notifyStrategyId'] = request.notify_strategy_id
        if not UtilClient.is_unset(request.notify_strategy_ids):
            query['notifyStrategyIds'] = request.notify_strategy_ids
        if not UtilClient.is_unset(request.notify_strategy_name):
            query['notifyStrategyName'] = request.notify_strategy_name
        if not UtilClient.is_unset(request.order_by):
            query['orderBy'] = request.order_by
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListNotifyStrategies',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/notifyStrategies',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListNotifyStrategiesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_notify_strategies(
        self,
        request: cms_20240330_models.ListNotifyStrategiesRequest,
    ) -> cms_20240330_models.ListNotifyStrategiesResponse:
        """
        @summary 查询通知策略列表
        
        @param request: ListNotifyStrategiesRequest
        @return: ListNotifyStrategiesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_notify_strategies_with_options(request, headers, runtime)

    async def list_notify_strategies_async(
        self,
        request: cms_20240330_models.ListNotifyStrategiesRequest,
    ) -> cms_20240330_models.ListNotifyStrategiesResponse:
        """
        @summary 查询通知策略列表
        
        @param request: ListNotifyStrategiesRequest
        @return: ListNotifyStrategiesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_notify_strategies_with_options_async(request, headers, runtime)

    def list_oncall_contacts_with_options(
        self,
        oncall_schedule_id: str,
        request: cms_20240330_models.ListOncallContactsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListOncallContactsResponse:
        """
        @summary 查询值班人
        
        @param request: ListOncallContactsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListOncallContactsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        if not UtilClient.is_unset(request.timestamp):
            query['timestamp'] = request.timestamp
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListOncallContacts',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/oncallSchedule/{OpenApiUtilClient.get_encode_param(oncall_schedule_id)}/contacts',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListOncallContactsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_oncall_contacts_with_options_async(
        self,
        oncall_schedule_id: str,
        request: cms_20240330_models.ListOncallContactsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListOncallContactsResponse:
        """
        @summary 查询值班人
        
        @param request: ListOncallContactsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListOncallContactsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        if not UtilClient.is_unset(request.timestamp):
            query['timestamp'] = request.timestamp
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListOncallContacts',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/oncallSchedule/{OpenApiUtilClient.get_encode_param(oncall_schedule_id)}/contacts',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListOncallContactsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_oncall_contacts(
        self,
        oncall_schedule_id: str,
        request: cms_20240330_models.ListOncallContactsRequest,
    ) -> cms_20240330_models.ListOncallContactsResponse:
        """
        @summary 查询值班人
        
        @param request: ListOncallContactsRequest
        @return: ListOncallContactsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_oncall_contacts_with_options(oncall_schedule_id, request, headers, runtime)

    async def list_oncall_contacts_async(
        self,
        oncall_schedule_id: str,
        request: cms_20240330_models.ListOncallContactsRequest,
    ) -> cms_20240330_models.ListOncallContactsResponse:
        """
        @summary 查询值班人
        
        @param request: ListOncallContactsRequest
        @return: ListOncallContactsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_oncall_contacts_with_options_async(oncall_schedule_id, request, headers, runtime)

    def list_oncall_schedules_with_options(
        self,
        tmp_req: cms_20240330_models.ListOncallSchedulesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListOncallSchedulesResponse:
        """
        @summary 查询当前账号下所有值班排班的配置信息
        
        @param tmp_req: ListOncallSchedulesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListOncallSchedulesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListOncallSchedulesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.oncall_schedule_ids):
            request.oncall_schedule_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.oncall_schedule_ids, 'oncallScheduleIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.oncall_schedule_ids_shrink):
            query['oncallScheduleIds'] = request.oncall_schedule_ids_shrink
        if not UtilClient.is_unset(request.oncall_schedule_name):
            query['oncallScheduleName'] = request.oncall_schedule_name
        if not UtilClient.is_unset(request.page_number):
            query['pageNumber'] = request.page_number
        if not UtilClient.is_unset(request.page_size):
            query['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListOncallSchedules',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/oncallSchedules',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListOncallSchedulesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_oncall_schedules_with_options_async(
        self,
        tmp_req: cms_20240330_models.ListOncallSchedulesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListOncallSchedulesResponse:
        """
        @summary 查询当前账号下所有值班排班的配置信息
        
        @param tmp_req: ListOncallSchedulesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListOncallSchedulesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListOncallSchedulesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.oncall_schedule_ids):
            request.oncall_schedule_ids_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.oncall_schedule_ids, 'oncallScheduleIds', 'json')
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.oncall_schedule_ids_shrink):
            query['oncallScheduleIds'] = request.oncall_schedule_ids_shrink
        if not UtilClient.is_unset(request.oncall_schedule_name):
            query['oncallScheduleName'] = request.oncall_schedule_name
        if not UtilClient.is_unset(request.page_number):
            query['pageNumber'] = request.page_number
        if not UtilClient.is_unset(request.page_size):
            query['pageSize'] = request.page_size
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListOncallSchedules',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/oncallSchedules',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListOncallSchedulesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_oncall_schedules(
        self,
        request: cms_20240330_models.ListOncallSchedulesRequest,
    ) -> cms_20240330_models.ListOncallSchedulesResponse:
        """
        @summary 查询当前账号下所有值班排班的配置信息
        
        @param request: ListOncallSchedulesRequest
        @return: ListOncallSchedulesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_oncall_schedules_with_options(request, headers, runtime)

    async def list_oncall_schedules_async(
        self,
        request: cms_20240330_models.ListOncallSchedulesRequest,
    ) -> cms_20240330_models.ListOncallSchedulesResponse:
        """
        @summary 查询当前账号下所有值班排班的配置信息
        
        @param request: ListOncallSchedulesRequest
        @return: ListOncallSchedulesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_oncall_schedules_with_options_async(request, headers, runtime)

    def list_pipelines_with_options(
        self,
        workspace: str,
        request: cms_20240330_models.ListPipelinesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListPipelinesResponse:
        """
        @summary 查询流水线列表
        
        @param request: ListPipelinesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListPipelinesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.pipeline_name):
            query['pipelineName'] = request.pipeline_name
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListPipelines',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/pipeline',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListPipelinesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_pipelines_with_options_async(
        self,
        workspace: str,
        request: cms_20240330_models.ListPipelinesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListPipelinesResponse:
        """
        @summary 查询流水线列表
        
        @param request: ListPipelinesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListPipelinesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.pipeline_name):
            query['pipelineName'] = request.pipeline_name
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListPipelines',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/pipeline',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListPipelinesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_pipelines(
        self,
        workspace: str,
        request: cms_20240330_models.ListPipelinesRequest,
    ) -> cms_20240330_models.ListPipelinesResponse:
        """
        @summary 查询流水线列表
        
        @param request: ListPipelinesRequest
        @return: ListPipelinesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_pipelines_with_options(workspace, request, headers, runtime)

    async def list_pipelines_async(
        self,
        workspace: str,
        request: cms_20240330_models.ListPipelinesRequest,
    ) -> cms_20240330_models.ListPipelinesResponse:
        """
        @summary 查询流水线列表
        
        @param request: ListPipelinesRequest
        @return: ListPipelinesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_pipelines_with_options_async(workspace, request, headers, runtime)

    def list_prometheus_clusters_with_options(
        self,
        tmp_req: cms_20240330_models.ListPrometheusClustersRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListPrometheusClustersResponse:
        """
        @summary 获取Prometheus集群信息列表
        
        @param tmp_req: ListPrometheusClustersRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListPrometheusClustersResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListPrometheusClustersShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.tag):
            request.tag_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tag, 'tag', 'json')
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.prometheus_cluster_name):
            query['prometheusClusterName'] = request.prometheus_cluster_name
        if not UtilClient.is_unset(request.region_id):
            query['regionId'] = request.region_id
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.tag_shrink):
            query['tag'] = request.tag_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListPrometheusClusters',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-clusters',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListPrometheusClustersResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_prometheus_clusters_with_options_async(
        self,
        tmp_req: cms_20240330_models.ListPrometheusClustersRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListPrometheusClustersResponse:
        """
        @summary 获取Prometheus集群信息列表
        
        @param tmp_req: ListPrometheusClustersRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListPrometheusClustersResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListPrometheusClustersShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.tag):
            request.tag_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tag, 'tag', 'json')
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.prometheus_cluster_name):
            query['prometheusClusterName'] = request.prometheus_cluster_name
        if not UtilClient.is_unset(request.region_id):
            query['regionId'] = request.region_id
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.tag_shrink):
            query['tag'] = request.tag_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListPrometheusClusters',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-clusters',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListPrometheusClustersResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_prometheus_clusters(
        self,
        request: cms_20240330_models.ListPrometheusClustersRequest,
    ) -> cms_20240330_models.ListPrometheusClustersResponse:
        """
        @summary 获取Prometheus集群信息列表
        
        @param request: ListPrometheusClustersRequest
        @return: ListPrometheusClustersResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_prometheus_clusters_with_options(request, headers, runtime)

    async def list_prometheus_clusters_async(
        self,
        request: cms_20240330_models.ListPrometheusClustersRequest,
    ) -> cms_20240330_models.ListPrometheusClustersResponse:
        """
        @summary 获取Prometheus集群信息列表
        
        @param request: ListPrometheusClustersRequest
        @return: ListPrometheusClustersResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_prometheus_clusters_with_options_async(request, headers, runtime)

    def list_prometheus_dashboards_with_options(
        self,
        prometheus_instance_id: str,
        request: cms_20240330_models.ListPrometheusDashboardsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListPrometheusDashboardsResponse:
        """
        @summary Get Prometheus Instance Dashboard List
        
        @description Get the list of Prometheus instance dashboards.
        
        @param request: ListPrometheusDashboardsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListPrometheusDashboardsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListPrometheusDashboards',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(prometheus_instance_id)}/dashboards',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListPrometheusDashboardsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_prometheus_dashboards_with_options_async(
        self,
        prometheus_instance_id: str,
        request: cms_20240330_models.ListPrometheusDashboardsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListPrometheusDashboardsResponse:
        """
        @summary Get Prometheus Instance Dashboard List
        
        @description Get the list of Prometheus instance dashboards.
        
        @param request: ListPrometheusDashboardsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListPrometheusDashboardsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListPrometheusDashboards',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(prometheus_instance_id)}/dashboards',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListPrometheusDashboardsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_prometheus_dashboards(
        self,
        prometheus_instance_id: str,
        request: cms_20240330_models.ListPrometheusDashboardsRequest,
    ) -> cms_20240330_models.ListPrometheusDashboardsResponse:
        """
        @summary Get Prometheus Instance Dashboard List
        
        @description Get the list of Prometheus instance dashboards.
        
        @param request: ListPrometheusDashboardsRequest
        @return: ListPrometheusDashboardsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_prometheus_dashboards_with_options(prometheus_instance_id, request, headers, runtime)

    async def list_prometheus_dashboards_async(
        self,
        prometheus_instance_id: str,
        request: cms_20240330_models.ListPrometheusDashboardsRequest,
    ) -> cms_20240330_models.ListPrometheusDashboardsResponse:
        """
        @summary Get Prometheus Instance Dashboard List
        
        @description Get the list of Prometheus instance dashboards.
        
        @param request: ListPrometheusDashboardsRequest
        @return: ListPrometheusDashboardsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_prometheus_dashboards_with_options_async(prometheus_instance_id, request, headers, runtime)

    def list_prometheus_instances_with_options(
        self,
        tmp_req: cms_20240330_models.ListPrometheusInstancesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListPrometheusInstancesResponse:
        """
        @summary Get the list of Prometheus instance information
        
        @description Get the list of Prometheus instances.
        
        @param tmp_req: ListPrometheusInstancesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListPrometheusInstancesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListPrometheusInstancesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.tag):
            request.tag_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tag, 'tag', 'json')
        query = {}
        if not UtilClient.is_unset(request.filter_region_ids):
            query['filterRegionIds'] = request.filter_region_ids
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.prometheus_instance_ids):
            query['prometheusInstanceIds'] = request.prometheus_instance_ids
        if not UtilClient.is_unset(request.prometheus_instance_name):
            query['prometheusInstanceName'] = request.prometheus_instance_name
        if not UtilClient.is_unset(request.query_scene):
            query['queryScene'] = request.query_scene
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.resource_type):
            query['resourceType'] = request.resource_type
        if not UtilClient.is_unset(request.sls_project):
            query['slsProject'] = request.sls_project
        if not UtilClient.is_unset(request.sls_store):
            query['slsStore'] = request.sls_store
        if not UtilClient.is_unset(request.tag_shrink):
            query['tag'] = request.tag_shrink
        if not UtilClient.is_unset(request.version):
            query['version'] = request.version
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListPrometheusInstances',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListPrometheusInstancesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_prometheus_instances_with_options_async(
        self,
        tmp_req: cms_20240330_models.ListPrometheusInstancesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListPrometheusInstancesResponse:
        """
        @summary Get the list of Prometheus instance information
        
        @description Get the list of Prometheus instances.
        
        @param tmp_req: ListPrometheusInstancesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListPrometheusInstancesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListPrometheusInstancesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.tag):
            request.tag_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tag, 'tag', 'json')
        query = {}
        if not UtilClient.is_unset(request.filter_region_ids):
            query['filterRegionIds'] = request.filter_region_ids
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.prometheus_instance_ids):
            query['prometheusInstanceIds'] = request.prometheus_instance_ids
        if not UtilClient.is_unset(request.prometheus_instance_name):
            query['prometheusInstanceName'] = request.prometheus_instance_name
        if not UtilClient.is_unset(request.query_scene):
            query['queryScene'] = request.query_scene
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.resource_type):
            query['resourceType'] = request.resource_type
        if not UtilClient.is_unset(request.sls_project):
            query['slsProject'] = request.sls_project
        if not UtilClient.is_unset(request.sls_store):
            query['slsStore'] = request.sls_store
        if not UtilClient.is_unset(request.tag_shrink):
            query['tag'] = request.tag_shrink
        if not UtilClient.is_unset(request.version):
            query['version'] = request.version
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListPrometheusInstances',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListPrometheusInstancesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_prometheus_instances(
        self,
        request: cms_20240330_models.ListPrometheusInstancesRequest,
    ) -> cms_20240330_models.ListPrometheusInstancesResponse:
        """
        @summary Get the list of Prometheus instance information
        
        @description Get the list of Prometheus instances.
        
        @param request: ListPrometheusInstancesRequest
        @return: ListPrometheusInstancesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_prometheus_instances_with_options(request, headers, runtime)

    async def list_prometheus_instances_async(
        self,
        request: cms_20240330_models.ListPrometheusInstancesRequest,
    ) -> cms_20240330_models.ListPrometheusInstancesResponse:
        """
        @summary Get the list of Prometheus instance information
        
        @description Get the list of Prometheus instances.
        
        @param request: ListPrometheusInstancesRequest
        @return: ListPrometheusInstancesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_prometheus_instances_with_options_async(request, headers, runtime)

    def list_prometheus_metrics_with_options(
        self,
        prometheus_instance_id: str,
        request: cms_20240330_models.ListPrometheusMetricsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListPrometheusMetricsResponse:
        """
        @summary 获取Prometheus实例topN指标列表
        
        @param request: ListPrometheusMetricsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListPrometheusMetricsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.end_time):
            query['endTime'] = request.end_time
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.start_time):
            query['startTime'] = request.start_time
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListPrometheusMetrics',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(prometheus_instance_id)}/metrics',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListPrometheusMetricsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_prometheus_metrics_with_options_async(
        self,
        prometheus_instance_id: str,
        request: cms_20240330_models.ListPrometheusMetricsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListPrometheusMetricsResponse:
        """
        @summary 获取Prometheus实例topN指标列表
        
        @param request: ListPrometheusMetricsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListPrometheusMetricsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.aliyun_lang):
            query['aliyunLang'] = request.aliyun_lang
        if not UtilClient.is_unset(request.end_time):
            query['endTime'] = request.end_time
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.start_time):
            query['startTime'] = request.start_time
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListPrometheusMetrics',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(prometheus_instance_id)}/metrics',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListPrometheusMetricsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_prometheus_metrics(
        self,
        prometheus_instance_id: str,
        request: cms_20240330_models.ListPrometheusMetricsRequest,
    ) -> cms_20240330_models.ListPrometheusMetricsResponse:
        """
        @summary 获取Prometheus实例topN指标列表
        
        @param request: ListPrometheusMetricsRequest
        @return: ListPrometheusMetricsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_prometheus_metrics_with_options(prometheus_instance_id, request, headers, runtime)

    async def list_prometheus_metrics_async(
        self,
        prometheus_instance_id: str,
        request: cms_20240330_models.ListPrometheusMetricsRequest,
    ) -> cms_20240330_models.ListPrometheusMetricsResponse:
        """
        @summary 获取Prometheus实例topN指标列表
        
        @param request: ListPrometheusMetricsRequest
        @return: ListPrometheusMetricsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_prometheus_metrics_with_options_async(prometheus_instance_id, request, headers, runtime)

    def list_prometheus_views_with_options(
        self,
        tmp_req: cms_20240330_models.ListPrometheusViewsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListPrometheusViewsResponse:
        """
        @summary Retrieve a list of Prometheus view instance information
        
        @description Retrieve a list of Prometheus view instance information.
        
        @param tmp_req: ListPrometheusViewsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListPrometheusViewsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListPrometheusViewsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.tag):
            request.tag_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tag, 'tag', 'json')
        query = {}
        if not UtilClient.is_unset(request.filter_region_ids):
            query['filterRegionIds'] = request.filter_region_ids
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.prometheus_view_ids):
            query['prometheusViewIds'] = request.prometheus_view_ids
        if not UtilClient.is_unset(request.prometheus_view_name):
            query['prometheusViewName'] = request.prometheus_view_name
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.resource_type):
            query['resourceType'] = request.resource_type
        if not UtilClient.is_unset(request.tag_shrink):
            query['tag'] = request.tag_shrink
        if not UtilClient.is_unset(request.version):
            query['version'] = request.version
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListPrometheusViews',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-views',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListPrometheusViewsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_prometheus_views_with_options_async(
        self,
        tmp_req: cms_20240330_models.ListPrometheusViewsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListPrometheusViewsResponse:
        """
        @summary Retrieve a list of Prometheus view instance information
        
        @description Retrieve a list of Prometheus view instance information.
        
        @param tmp_req: ListPrometheusViewsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListPrometheusViewsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListPrometheusViewsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.tag):
            request.tag_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tag, 'tag', 'json')
        query = {}
        if not UtilClient.is_unset(request.filter_region_ids):
            query['filterRegionIds'] = request.filter_region_ids
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.prometheus_view_ids):
            query['prometheusViewIds'] = request.prometheus_view_ids
        if not UtilClient.is_unset(request.prometheus_view_name):
            query['prometheusViewName'] = request.prometheus_view_name
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.resource_type):
            query['resourceType'] = request.resource_type
        if not UtilClient.is_unset(request.tag_shrink):
            query['tag'] = request.tag_shrink
        if not UtilClient.is_unset(request.version):
            query['version'] = request.version
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListPrometheusViews',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-views',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListPrometheusViewsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_prometheus_views(
        self,
        request: cms_20240330_models.ListPrometheusViewsRequest,
    ) -> cms_20240330_models.ListPrometheusViewsResponse:
        """
        @summary Retrieve a list of Prometheus view instance information
        
        @description Retrieve a list of Prometheus view instance information.
        
        @param request: ListPrometheusViewsRequest
        @return: ListPrometheusViewsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_prometheus_views_with_options(request, headers, runtime)

    async def list_prometheus_views_async(
        self,
        request: cms_20240330_models.ListPrometheusViewsRequest,
    ) -> cms_20240330_models.ListPrometheusViewsResponse:
        """
        @summary Retrieve a list of Prometheus view instance information
        
        @description Retrieve a list of Prometheus view instance information.
        
        @param request: ListPrometheusViewsRequest
        @return: ListPrometheusViewsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_prometheus_views_with_options_async(request, headers, runtime)

    def list_prometheus_virtual_instances_with_options(
        self,
        request: cms_20240330_models.ListPrometheusVirtualInstancesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListPrometheusVirtualInstancesResponse:
        """
        @summary Get Prometheus Virtual Instance
        
        @description Used for creating a site monitoring task
        
        @param request: ListPrometheusVirtualInstancesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListPrometheusVirtualInstancesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.namespace):
            query['namespace'] = request.namespace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListPrometheusVirtualInstances',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/virtual-instances',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListPrometheusVirtualInstancesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_prometheus_virtual_instances_with_options_async(
        self,
        request: cms_20240330_models.ListPrometheusVirtualInstancesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListPrometheusVirtualInstancesResponse:
        """
        @summary Get Prometheus Virtual Instance
        
        @description Used for creating a site monitoring task
        
        @param request: ListPrometheusVirtualInstancesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListPrometheusVirtualInstancesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.namespace):
            query['namespace'] = request.namespace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListPrometheusVirtualInstances',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/virtual-instances',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListPrometheusVirtualInstancesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_prometheus_virtual_instances(
        self,
        request: cms_20240330_models.ListPrometheusVirtualInstancesRequest,
    ) -> cms_20240330_models.ListPrometheusVirtualInstancesResponse:
        """
        @summary Get Prometheus Virtual Instance
        
        @description Used for creating a site monitoring task
        
        @param request: ListPrometheusVirtualInstancesRequest
        @return: ListPrometheusVirtualInstancesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_prometheus_virtual_instances_with_options(request, headers, runtime)

    async def list_prometheus_virtual_instances_async(
        self,
        request: cms_20240330_models.ListPrometheusVirtualInstancesRequest,
    ) -> cms_20240330_models.ListPrometheusVirtualInstancesResponse:
        """
        @summary Get Prometheus Virtual Instance
        
        @description Used for creating a site monitoring task
        
        @param request: ListPrometheusVirtualInstancesRequest
        @return: ListPrometheusVirtualInstancesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_prometheus_virtual_instances_with_options_async(request, headers, runtime)

    def list_rca_tasks_with_options(
        self,
        request: cms_20240330_models.ListRcaTasksRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListRcaTasksResponse:
        """
        @summary List History name
        
        @param request: ListRcaTasksRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListRcaTasksResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.alert_rule_id):
            query['alertRuleId'] = request.alert_rule_id
        if not UtilClient.is_unset(request.incident_uuid):
            query['incidentUuid'] = request.incident_uuid
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.task_id):
            query['taskId'] = request.task_id
        if not UtilClient.is_unset(request.trans_id):
            query['transId'] = request.trans_id
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListRcaTasks',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/rca/task/list',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListRcaTasksResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_rca_tasks_with_options_async(
        self,
        request: cms_20240330_models.ListRcaTasksRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListRcaTasksResponse:
        """
        @summary List History name
        
        @param request: ListRcaTasksRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListRcaTasksResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.alert_rule_id):
            query['alertRuleId'] = request.alert_rule_id
        if not UtilClient.is_unset(request.incident_uuid):
            query['incidentUuid'] = request.incident_uuid
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.task_id):
            query['taskId'] = request.task_id
        if not UtilClient.is_unset(request.trans_id):
            query['transId'] = request.trans_id
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListRcaTasks',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/rca/task/list',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListRcaTasksResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_rca_tasks(
        self,
        request: cms_20240330_models.ListRcaTasksRequest,
    ) -> cms_20240330_models.ListRcaTasksResponse:
        """
        @summary List History name
        
        @param request: ListRcaTasksRequest
        @return: ListRcaTasksResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_rca_tasks_with_options(request, headers, runtime)

    async def list_rca_tasks_async(
        self,
        request: cms_20240330_models.ListRcaTasksRequest,
    ) -> cms_20240330_models.ListRcaTasksResponse:
        """
        @summary List History name
        
        @param request: ListRcaTasksRequest
        @return: ListRcaTasksResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_rca_tasks_with_options_async(request, headers, runtime)

    def list_service_task_with_options(
        self,
        workspace: str,
        service_id: str,
        request: cms_20240330_models.ListServiceTaskRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListServiceTaskResponse:
        """
        @summary 列举ServiceTask
        
        @param request: ListServiceTaskRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListServiceTaskResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.search_condition):
            query['searchCondition'] = request.search_condition
        if not UtilClient.is_unset(request.type):
            query['type'] = request.type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListServiceTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/serviceTask/{OpenApiUtilClient.get_encode_param(workspace)}/{OpenApiUtilClient.get_encode_param(service_id)}/tasks',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListServiceTaskResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_service_task_with_options_async(
        self,
        workspace: str,
        service_id: str,
        request: cms_20240330_models.ListServiceTaskRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListServiceTaskResponse:
        """
        @summary 列举ServiceTask
        
        @param request: ListServiceTaskRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListServiceTaskResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.search_condition):
            query['searchCondition'] = request.search_condition
        if not UtilClient.is_unset(request.type):
            query['type'] = request.type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListServiceTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/serviceTask/{OpenApiUtilClient.get_encode_param(workspace)}/{OpenApiUtilClient.get_encode_param(service_id)}/tasks',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListServiceTaskResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_service_task(
        self,
        workspace: str,
        service_id: str,
        request: cms_20240330_models.ListServiceTaskRequest,
    ) -> cms_20240330_models.ListServiceTaskResponse:
        """
        @summary 列举ServiceTask
        
        @param request: ListServiceTaskRequest
        @return: ListServiceTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_service_task_with_options(workspace, service_id, request, headers, runtime)

    async def list_service_task_async(
        self,
        workspace: str,
        service_id: str,
        request: cms_20240330_models.ListServiceTaskRequest,
    ) -> cms_20240330_models.ListServiceTaskResponse:
        """
        @summary 列举ServiceTask
        
        @param request: ListServiceTaskRequest
        @return: ListServiceTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_service_task_with_options_async(workspace, service_id, request, headers, runtime)

    def list_services_with_options(
        self,
        workspace: str,
        tmp_req: cms_20240330_models.ListServicesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListServicesResponse:
        """
        @summary List Resource Services
        
        @param tmp_req: ListServicesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListServicesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListServicesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.tags):
            request.tags_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tags, 'tags', 'json')
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.service_name):
            query['serviceName'] = request.service_name
        if not UtilClient.is_unset(request.service_type):
            query['serviceType'] = request.service_type
        if not UtilClient.is_unset(request.tags_shrink):
            query['tags'] = request.tags_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListServices',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/services',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListServicesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_services_with_options_async(
        self,
        workspace: str,
        tmp_req: cms_20240330_models.ListServicesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListServicesResponse:
        """
        @summary List Resource Services
        
        @param tmp_req: ListServicesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListServicesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListServicesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.tags):
            request.tags_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tags, 'tags', 'json')
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.resource_group_id):
            query['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.service_name):
            query['serviceName'] = request.service_name
        if not UtilClient.is_unset(request.service_type):
            query['serviceType'] = request.service_type
        if not UtilClient.is_unset(request.tags_shrink):
            query['tags'] = request.tags_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListServices',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/services',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListServicesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_services(
        self,
        workspace: str,
        request: cms_20240330_models.ListServicesRequest,
    ) -> cms_20240330_models.ListServicesResponse:
        """
        @summary List Resource Services
        
        @param request: ListServicesRequest
        @return: ListServicesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_services_with_options(workspace, request, headers, runtime)

    async def list_services_async(
        self,
        workspace: str,
        request: cms_20240330_models.ListServicesRequest,
    ) -> cms_20240330_models.ListServicesResponse:
        """
        @summary List Resource Services
        
        @param request: ListServicesRequest
        @return: ListServicesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_services_with_options_async(workspace, request, headers, runtime)

    def list_site_monitors_with_options(
        self,
        request: cms_20240330_models.ListSiteMonitorsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListSiteMonitorsResponse:
        """
        @summary 列出资源SiteMonitor
        
        @param request: ListSiteMonitorsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListSiteMonitorsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.keyword):
            query['keyword'] = request.keyword
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.task_id):
            query['taskId'] = request.task_id
        if not UtilClient.is_unset(request.task_labels):
            query['taskLabels'] = request.task_labels
        if not UtilClient.is_unset(request.task_state):
            query['taskState'] = request.task_state
        if not UtilClient.is_unset(request.task_type):
            query['taskType'] = request.task_type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListSiteMonitors',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/siteMonitors',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListSiteMonitorsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_site_monitors_with_options_async(
        self,
        request: cms_20240330_models.ListSiteMonitorsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListSiteMonitorsResponse:
        """
        @summary 列出资源SiteMonitor
        
        @param request: ListSiteMonitorsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListSiteMonitorsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.keyword):
            query['keyword'] = request.keyword
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.task_id):
            query['taskId'] = request.task_id
        if not UtilClient.is_unset(request.task_labels):
            query['taskLabels'] = request.task_labels
        if not UtilClient.is_unset(request.task_state):
            query['taskState'] = request.task_state
        if not UtilClient.is_unset(request.task_type):
            query['taskType'] = request.task_type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListSiteMonitors',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/siteMonitors',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListSiteMonitorsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_site_monitors(
        self,
        request: cms_20240330_models.ListSiteMonitorsRequest,
    ) -> cms_20240330_models.ListSiteMonitorsResponse:
        """
        @summary 列出资源SiteMonitor
        
        @param request: ListSiteMonitorsRequest
        @return: ListSiteMonitorsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_site_monitors_with_options(request, headers, runtime)

    async def list_site_monitors_async(
        self,
        request: cms_20240330_models.ListSiteMonitorsRequest,
    ) -> cms_20240330_models.ListSiteMonitorsResponse:
        """
        @summary 列出资源SiteMonitor
        
        @param request: ListSiteMonitorsRequest
        @return: ListSiteMonitorsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_site_monitors_with_options_async(request, headers, runtime)

    def list_subscriptions_with_options(
        self,
        request: cms_20240330_models.ListSubscriptionsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListSubscriptionsResponse:
        """
        @summary 查询订阅规则列表
        
        @param request: ListSubscriptionsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListSubscriptionsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.direction):
            query['direction'] = request.direction
        if not UtilClient.is_unset(request.enable):
            query['enable'] = request.enable
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.order_by):
            query['orderBy'] = request.order_by
        if not UtilClient.is_unset(request.subscription_id):
            query['subscriptionId'] = request.subscription_id
        if not UtilClient.is_unset(request.subscription_name):
            query['subscriptionName'] = request.subscription_name
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListSubscriptions',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/subscriptions',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListSubscriptionsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_subscriptions_with_options_async(
        self,
        request: cms_20240330_models.ListSubscriptionsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListSubscriptionsResponse:
        """
        @summary 查询订阅规则列表
        
        @param request: ListSubscriptionsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListSubscriptionsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.direction):
            query['direction'] = request.direction
        if not UtilClient.is_unset(request.enable):
            query['enable'] = request.enable
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.order_by):
            query['orderBy'] = request.order_by
        if not UtilClient.is_unset(request.subscription_id):
            query['subscriptionId'] = request.subscription_id
        if not UtilClient.is_unset(request.subscription_name):
            query['subscriptionName'] = request.subscription_name
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListSubscriptions',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/subscriptions',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListSubscriptionsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_subscriptions(
        self,
        request: cms_20240330_models.ListSubscriptionsRequest,
    ) -> cms_20240330_models.ListSubscriptionsResponse:
        """
        @summary 查询订阅规则列表
        
        @param request: ListSubscriptionsRequest
        @return: ListSubscriptionsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_subscriptions_with_options(request, headers, runtime)

    async def list_subscriptions_async(
        self,
        request: cms_20240330_models.ListSubscriptionsRequest,
    ) -> cms_20240330_models.ListSubscriptionsResponse:
        """
        @summary 查询订阅规则列表
        
        @param request: ListSubscriptionsRequest
        @return: ListSubscriptionsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_subscriptions_with_options_async(request, headers, runtime)

    def list_tag_resources_with_options(
        self,
        tmp_req: cms_20240330_models.ListTagResourcesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListTagResourcesResponse:
        """
        @summary 查标签接口
        
        @param tmp_req: ListTagResourcesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListTagResourcesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListTagResourcesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.resource_id):
            request.resource_id_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.resource_id, 'resourceId', 'json')
        if not UtilClient.is_unset(tmp_req.tag):
            request.tag_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tag, 'tag', 'json')
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.resource_id_shrink):
            query['resourceId'] = request.resource_id_shrink
        if not UtilClient.is_unset(request.resource_type):
            query['resourceType'] = request.resource_type
        if not UtilClient.is_unset(request.tag_shrink):
            query['tag'] = request.tag_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListTagResources',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/tags',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListTagResourcesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_tag_resources_with_options_async(
        self,
        tmp_req: cms_20240330_models.ListTagResourcesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListTagResourcesResponse:
        """
        @summary 查标签接口
        
        @param tmp_req: ListTagResourcesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListTagResourcesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListTagResourcesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.resource_id):
            request.resource_id_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.resource_id, 'resourceId', 'json')
        if not UtilClient.is_unset(tmp_req.tag):
            request.tag_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tag, 'tag', 'json')
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.resource_id_shrink):
            query['resourceId'] = request.resource_id_shrink
        if not UtilClient.is_unset(request.resource_type):
            query['resourceType'] = request.resource_type
        if not UtilClient.is_unset(request.tag_shrink):
            query['tag'] = request.tag_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListTagResources',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/tags',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListTagResourcesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_tag_resources(
        self,
        request: cms_20240330_models.ListTagResourcesRequest,
    ) -> cms_20240330_models.ListTagResourcesResponse:
        """
        @summary 查标签接口
        
        @param request: ListTagResourcesRequest
        @return: ListTagResourcesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_tag_resources_with_options(request, headers, runtime)

    async def list_tag_resources_async(
        self,
        request: cms_20240330_models.ListTagResourcesRequest,
    ) -> cms_20240330_models.ListTagResourcesResponse:
        """
        @summary 查标签接口
        
        @param request: ListTagResourcesRequest
        @return: ListTagResourcesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_tag_resources_with_options_async(request, headers, runtime)

    def list_threads_with_options(
        self,
        name: str,
        tmp_req: cms_20240330_models.ListThreadsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListThreadsResponse:
        """
        @summary 列出会话
        
        @param tmp_req: ListThreadsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListThreadsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListThreadsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.filter):
            request.filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.filter, 'filter', 'json')
        query = {}
        if not UtilClient.is_unset(request.filter_shrink):
            query['filter'] = request.filter_shrink
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.status):
            query['status'] = request.status
        if not UtilClient.is_unset(request.thread_id):
            query['threadId'] = request.thread_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListThreads',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/threads',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListThreadsResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_threads_with_options_async(
        self,
        name: str,
        tmp_req: cms_20240330_models.ListThreadsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListThreadsResponse:
        """
        @summary 列出会话
        
        @param tmp_req: ListThreadsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListThreadsResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListThreadsShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.filter):
            request.filter_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.filter, 'filter', 'json')
        query = {}
        if not UtilClient.is_unset(request.filter_shrink):
            query['filter'] = request.filter_shrink
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.status):
            query['status'] = request.status
        if not UtilClient.is_unset(request.thread_id):
            query['threadId'] = request.thread_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListThreads',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/threads',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListThreadsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_threads(
        self,
        name: str,
        request: cms_20240330_models.ListThreadsRequest,
    ) -> cms_20240330_models.ListThreadsResponse:
        """
        @summary 列出会话
        
        @param request: ListThreadsRequest
        @return: ListThreadsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_threads_with_options(name, request, headers, runtime)

    async def list_threads_async(
        self,
        name: str,
        request: cms_20240330_models.ListThreadsRequest,
    ) -> cms_20240330_models.ListThreadsResponse:
        """
        @summary 列出会话
        
        @param request: ListThreadsRequest
        @return: ListThreadsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_threads_with_options_async(name, request, headers, runtime)

    def list_transformers_with_options(
        self,
        request: cms_20240330_models.ListTransformersRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListTransformersResponse:
        """
        @summary 查询数据转换器列表
        
        @param request: ListTransformersRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListTransformersResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.direction):
            query['direction'] = request.direction
        if not UtilClient.is_unset(request.enable):
            query['enable'] = request.enable
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.order_by):
            query['orderBy'] = request.order_by
        if not UtilClient.is_unset(request.transformer_id):
            query['transformerId'] = request.transformer_id
        if not UtilClient.is_unset(request.transformer_name):
            query['transformerName'] = request.transformer_name
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListTransformers',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/transformers',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListTransformersResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_transformers_with_options_async(
        self,
        request: cms_20240330_models.ListTransformersRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListTransformersResponse:
        """
        @summary 查询数据转换器列表
        
        @param request: ListTransformersRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListTransformersResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.direction):
            query['direction'] = request.direction
        if not UtilClient.is_unset(request.enable):
            query['enable'] = request.enable
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.order_by):
            query['orderBy'] = request.order_by
        if not UtilClient.is_unset(request.transformer_id):
            query['transformerId'] = request.transformer_id
        if not UtilClient.is_unset(request.transformer_name):
            query['transformerName'] = request.transformer_name
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListTransformers',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/transformers',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListTransformersResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_transformers(
        self,
        request: cms_20240330_models.ListTransformersRequest,
    ) -> cms_20240330_models.ListTransformersResponse:
        """
        @summary 查询数据转换器列表
        
        @param request: ListTransformersRequest
        @return: ListTransformersResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_transformers_with_options(request, headers, runtime)

    async def list_transformers_async(
        self,
        request: cms_20240330_models.ListTransformersRequest,
    ) -> cms_20240330_models.ListTransformersResponse:
        """
        @summary 查询数据转换器列表
        
        @param request: ListTransformersRequest
        @return: ListTransformersResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_transformers_with_options_async(request, headers, runtime)

    def list_user_notify_histories_with_options(
        self,
        request: cms_20240330_models.ListUserNotifyHistoriesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListUserNotifyHistoriesResponse:
        """
        @summary List History name
        
        @param request: ListUserNotifyHistoriesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListUserNotifyHistoriesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.batch_id):
            query['batchId'] = request.batch_id
        if not UtilClient.is_unset(request.channel):
            query['channel'] = request.channel
        if not UtilClient.is_unset(request.channel_category):
            query['channelCategory'] = request.channel_category
        if not UtilClient.is_unset(request.from_):
            query['from'] = request.from_
        if not UtilClient.is_unset(request.group):
            query['group'] = request.group
        if not UtilClient.is_unset(request.incident_id):
            query['incidentId'] = request.incident_id
        if not UtilClient.is_unset(request.include_no_channel):
            query['includeNoChannel'] = request.include_no_channel
        if not UtilClient.is_unset(request.is_desc):
            query['isDesc'] = request.is_desc
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.notify_strategy_id):
            query['notifyStrategyId'] = request.notify_strategy_id
        if not UtilClient.is_unset(request.notify_strategy_name):
            query['notifyStrategyName'] = request.notify_strategy_name
        if not UtilClient.is_unset(request.query_criteria_list):
            query['queryCriteriaList'] = request.query_criteria_list
        if not UtilClient.is_unset(request.receiver):
            query['receiver'] = request.receiver
        if not UtilClient.is_unset(request.rule_id):
            query['ruleId'] = request.rule_id
        if not UtilClient.is_unset(request.rule_name):
            query['ruleName'] = request.rule_name
        if not UtilClient.is_unset(request.send_type):
            query['sendType'] = request.send_type
        if not UtilClient.is_unset(request.severity):
            query['severity'] = request.severity
        if not UtilClient.is_unset(request.subscription_id):
            query['subscriptionId'] = request.subscription_id
        if not UtilClient.is_unset(request.subscription_name):
            query['subscriptionName'] = request.subscription_name
        if not UtilClient.is_unset(request.success):
            query['success'] = request.success
        if not UtilClient.is_unset(request.to):
            query['to'] = request.to
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListUserNotifyHistories',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/userHistories',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListUserNotifyHistoriesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_user_notify_histories_with_options_async(
        self,
        request: cms_20240330_models.ListUserNotifyHistoriesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListUserNotifyHistoriesResponse:
        """
        @summary List History name
        
        @param request: ListUserNotifyHistoriesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListUserNotifyHistoriesResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.batch_id):
            query['batchId'] = request.batch_id
        if not UtilClient.is_unset(request.channel):
            query['channel'] = request.channel
        if not UtilClient.is_unset(request.channel_category):
            query['channelCategory'] = request.channel_category
        if not UtilClient.is_unset(request.from_):
            query['from'] = request.from_
        if not UtilClient.is_unset(request.group):
            query['group'] = request.group
        if not UtilClient.is_unset(request.incident_id):
            query['incidentId'] = request.incident_id
        if not UtilClient.is_unset(request.include_no_channel):
            query['includeNoChannel'] = request.include_no_channel
        if not UtilClient.is_unset(request.is_desc):
            query['isDesc'] = request.is_desc
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.notify_strategy_id):
            query['notifyStrategyId'] = request.notify_strategy_id
        if not UtilClient.is_unset(request.notify_strategy_name):
            query['notifyStrategyName'] = request.notify_strategy_name
        if not UtilClient.is_unset(request.query_criteria_list):
            query['queryCriteriaList'] = request.query_criteria_list
        if not UtilClient.is_unset(request.receiver):
            query['receiver'] = request.receiver
        if not UtilClient.is_unset(request.rule_id):
            query['ruleId'] = request.rule_id
        if not UtilClient.is_unset(request.rule_name):
            query['ruleName'] = request.rule_name
        if not UtilClient.is_unset(request.send_type):
            query['sendType'] = request.send_type
        if not UtilClient.is_unset(request.severity):
            query['severity'] = request.severity
        if not UtilClient.is_unset(request.subscription_id):
            query['subscriptionId'] = request.subscription_id
        if not UtilClient.is_unset(request.subscription_name):
            query['subscriptionName'] = request.subscription_name
        if not UtilClient.is_unset(request.success):
            query['success'] = request.success
        if not UtilClient.is_unset(request.to):
            query['to'] = request.to
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListUserNotifyHistories',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/userHistories',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListUserNotifyHistoriesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_user_notify_histories(
        self,
        request: cms_20240330_models.ListUserNotifyHistoriesRequest,
    ) -> cms_20240330_models.ListUserNotifyHistoriesResponse:
        """
        @summary List History name
        
        @param request: ListUserNotifyHistoriesRequest
        @return: ListUserNotifyHistoriesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_user_notify_histories_with_options(request, headers, runtime)

    async def list_user_notify_histories_async(
        self,
        request: cms_20240330_models.ListUserNotifyHistoriesRequest,
    ) -> cms_20240330_models.ListUserNotifyHistoriesResponse:
        """
        @summary List History name
        
        @param request: ListUserNotifyHistoriesRequest
        @return: ListUserNotifyHistoriesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_user_notify_histories_with_options_async(request, headers, runtime)

    def list_workspaces_with_options(
        self,
        tmp_req: cms_20240330_models.ListWorkspacesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListWorkspacesResponse:
        """
        @summary Get Workspace List
        
        @param tmp_req: ListWorkspacesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListWorkspacesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListWorkspacesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.workspace_name_list):
            request.workspace_name_list_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.workspace_name_list, 'workspaceNameList', 'simple')
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.region):
            query['region'] = request.region
        if not UtilClient.is_unset(request.workspace_name):
            query['workspaceName'] = request.workspace_name
        if not UtilClient.is_unset(request.workspace_name_list_shrink):
            query['workspaceNameList'] = request.workspace_name_list_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListWorkspaces',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListWorkspacesResponse(),
            self.call_api(params, req, runtime)
        )

    async def list_workspaces_with_options_async(
        self,
        tmp_req: cms_20240330_models.ListWorkspacesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ListWorkspacesResponse:
        """
        @summary Get Workspace List
        
        @param tmp_req: ListWorkspacesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ListWorkspacesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ListWorkspacesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.workspace_name_list):
            request.workspace_name_list_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.workspace_name_list, 'workspaceNameList', 'simple')
        query = {}
        if not UtilClient.is_unset(request.max_results):
            query['maxResults'] = request.max_results
        if not UtilClient.is_unset(request.next_token):
            query['nextToken'] = request.next_token
        if not UtilClient.is_unset(request.region):
            query['region'] = request.region
        if not UtilClient.is_unset(request.workspace_name):
            query['workspaceName'] = request.workspace_name
        if not UtilClient.is_unset(request.workspace_name_list_shrink):
            query['workspaceNameList'] = request.workspace_name_list_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ListWorkspaces',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ListWorkspacesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def list_workspaces(
        self,
        request: cms_20240330_models.ListWorkspacesRequest,
    ) -> cms_20240330_models.ListWorkspacesResponse:
        """
        @summary Get Workspace List
        
        @param request: ListWorkspacesRequest
        @return: ListWorkspacesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.list_workspaces_with_options(request, headers, runtime)

    async def list_workspaces_async(
        self,
        request: cms_20240330_models.ListWorkspacesRequest,
    ) -> cms_20240330_models.ListWorkspacesResponse:
        """
        @summary Get Workspace List
        
        @param request: ListWorkspacesRequest
        @return: ListWorkspacesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.list_workspaces_with_options_async(request, headers, runtime)

    def mock_system_event_with_options(
        self,
        request: cms_20240330_models.MockSystemEventRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.MockSystemEventResponse:
        """
        @summary mock系统事件
        
        @param request: MockSystemEventRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: MockSystemEventResponse
        """
        UtilClient.validate_model(request)
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=request.body
        )
        params = open_api_models.Params(
            action='MockSystemEvent',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/v1/event/dryrun',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.MockSystemEventResponse(),
            self.call_api(params, req, runtime)
        )

    async def mock_system_event_with_options_async(
        self,
        request: cms_20240330_models.MockSystemEventRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.MockSystemEventResponse:
        """
        @summary mock系统事件
        
        @param request: MockSystemEventRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: MockSystemEventResponse
        """
        UtilClient.validate_model(request)
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=request.body
        )
        params = open_api_models.Params(
            action='MockSystemEvent',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/v1/event/dryrun',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.MockSystemEventResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def mock_system_event(
        self,
        request: cms_20240330_models.MockSystemEventRequest,
    ) -> cms_20240330_models.MockSystemEventResponse:
        """
        @summary mock系统事件
        
        @param request: MockSystemEventRequest
        @return: MockSystemEventResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.mock_system_event_with_options(request, headers, runtime)

    async def mock_system_event_async(
        self,
        request: cms_20240330_models.MockSystemEventRequest,
    ) -> cms_20240330_models.MockSystemEventResponse:
        """
        @summary mock系统事件
        
        @param request: MockSystemEventRequest
        @return: MockSystemEventResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.mock_system_event_with_options_async(request, headers, runtime)

    def open_cms_service_with_options(
        self,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.OpenCmsServiceResponse:
        """
        @summary 开通云监控
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: OpenCmsServiceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='OpenCmsService',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/cmsservice',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.OpenCmsServiceResponse(),
            self.call_api(params, req, runtime)
        )

    async def open_cms_service_with_options_async(
        self,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.OpenCmsServiceResponse:
        """
        @summary 开通云监控
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: OpenCmsServiceResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='OpenCmsService',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/cmsservice',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.OpenCmsServiceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def open_cms_service(self) -> cms_20240330_models.OpenCmsServiceResponse:
        """
        @summary 开通云监控
        
        @return: OpenCmsServiceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.open_cms_service_with_options(headers, runtime)

    async def open_cms_service_async(self) -> cms_20240330_models.OpenCmsServiceResponse:
        """
        @summary 开通云监控
        
        @return: OpenCmsServiceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.open_cms_service_with_options_async(headers, runtime)

    def patch_alert_rule_with_options(
        self,
        alert_rule_id: str,
        request: cms_20240330_models.PatchAlertRuleRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.PatchAlertRuleResponse:
        """
        @summary 修改一个已存在的告警规则
        
        @param request: PatchAlertRuleRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: PatchAlertRuleResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.call_source):
            query['callSource'] = request.call_source
        body = {}
        if not UtilClient.is_unset(request.alert_metric_input):
            body['alertMetricInput'] = request.alert_metric_input
        if not UtilClient.is_unset(request.annotations):
            body['annotations'] = request.annotations
        if not UtilClient.is_unset(request.condition):
            body['condition'] = request.condition
        if not UtilClient.is_unset(request.display_name):
            body['displayName'] = request.display_name
        if not UtilClient.is_unset(request.interval):
            body['interval'] = request.interval
        if not UtilClient.is_unset(request.labels):
            body['labels'] = request.labels
        if not UtilClient.is_unset(request.level):
            body['level'] = request.level
        if not UtilClient.is_unset(request.message):
            body['message'] = request.message
        if not UtilClient.is_unset(request.query):
            body['query'] = request.query
        if not UtilClient.is_unset(request.send):
            body['send'] = request.send
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='PatchAlertRule',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules/{OpenApiUtilClient.get_encode_param(alert_rule_id)}',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.PatchAlertRuleResponse(),
            self.call_api(params, req, runtime)
        )

    async def patch_alert_rule_with_options_async(
        self,
        alert_rule_id: str,
        request: cms_20240330_models.PatchAlertRuleRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.PatchAlertRuleResponse:
        """
        @summary 修改一个已存在的告警规则
        
        @param request: PatchAlertRuleRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: PatchAlertRuleResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.call_source):
            query['callSource'] = request.call_source
        body = {}
        if not UtilClient.is_unset(request.alert_metric_input):
            body['alertMetricInput'] = request.alert_metric_input
        if not UtilClient.is_unset(request.annotations):
            body['annotations'] = request.annotations
        if not UtilClient.is_unset(request.condition):
            body['condition'] = request.condition
        if not UtilClient.is_unset(request.display_name):
            body['displayName'] = request.display_name
        if not UtilClient.is_unset(request.interval):
            body['interval'] = request.interval
        if not UtilClient.is_unset(request.labels):
            body['labels'] = request.labels
        if not UtilClient.is_unset(request.level):
            body['level'] = request.level
        if not UtilClient.is_unset(request.message):
            body['message'] = request.message
        if not UtilClient.is_unset(request.query):
            body['query'] = request.query
        if not UtilClient.is_unset(request.send):
            body['send'] = request.send
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='PatchAlertRule',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules/{OpenApiUtilClient.get_encode_param(alert_rule_id)}',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.PatchAlertRuleResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def patch_alert_rule(
        self,
        alert_rule_id: str,
        request: cms_20240330_models.PatchAlertRuleRequest,
    ) -> cms_20240330_models.PatchAlertRuleResponse:
        """
        @summary 修改一个已存在的告警规则
        
        @param request: PatchAlertRuleRequest
        @return: PatchAlertRuleResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.patch_alert_rule_with_options(alert_rule_id, request, headers, runtime)

    async def patch_alert_rule_async(
        self,
        alert_rule_id: str,
        request: cms_20240330_models.PatchAlertRuleRequest,
    ) -> cms_20240330_models.PatchAlertRuleResponse:
        """
        @summary 修改一个已存在的告警规则
        
        @param request: PatchAlertRuleRequest
        @return: PatchAlertRuleResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.patch_alert_rule_with_options_async(alert_rule_id, request, headers, runtime)

    def proxy_api_for_member_account_with_options(
        self,
        proxy_api: str,
        member_account_id: str,
        request: cms_20240330_models.ProxyApiForMemberAccountRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ProxyApiForMemberAccountResponse:
        """
        @summary 代理成员账号api访问
        
        @param request: ProxyApiForMemberAccountRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ProxyApiForMemberAccountResponse
        """
        UtilClient.validate_model(request)
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=request.body
        )
        params = open_api_models.Params(
            action='ProxyApiForMemberAccount',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/member-account-proxy/{OpenApiUtilClient.get_encode_param(proxy_api)}/{OpenApiUtilClient.get_encode_param(member_account_id)}',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ProxyApiForMemberAccountResponse(),
            self.call_api(params, req, runtime)
        )

    async def proxy_api_for_member_account_with_options_async(
        self,
        proxy_api: str,
        member_account_id: str,
        request: cms_20240330_models.ProxyApiForMemberAccountRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ProxyApiForMemberAccountResponse:
        """
        @summary 代理成员账号api访问
        
        @param request: ProxyApiForMemberAccountRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ProxyApiForMemberAccountResponse
        """
        UtilClient.validate_model(request)
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=request.body
        )
        params = open_api_models.Params(
            action='ProxyApiForMemberAccount',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/member-account-proxy/{OpenApiUtilClient.get_encode_param(proxy_api)}/{OpenApiUtilClient.get_encode_param(member_account_id)}',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ProxyApiForMemberAccountResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def proxy_api_for_member_account(
        self,
        proxy_api: str,
        member_account_id: str,
        request: cms_20240330_models.ProxyApiForMemberAccountRequest,
    ) -> cms_20240330_models.ProxyApiForMemberAccountResponse:
        """
        @summary 代理成员账号api访问
        
        @param request: ProxyApiForMemberAccountRequest
        @return: ProxyApiForMemberAccountResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.proxy_api_for_member_account_with_options(proxy_api, member_account_id, request, headers, runtime)

    async def proxy_api_for_member_account_async(
        self,
        proxy_api: str,
        member_account_id: str,
        request: cms_20240330_models.ProxyApiForMemberAccountRequest,
    ) -> cms_20240330_models.ProxyApiForMemberAccountResponse:
        """
        @summary 代理成员账号api访问
        
        @param request: ProxyApiForMemberAccountRequest
        @return: ProxyApiForMemberAccountResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.proxy_api_for_member_account_with_options_async(proxy_api, member_account_id, request, headers, runtime)

    def put_incident_command_with_options(
        self,
        uuid: str,
        request: cms_20240330_models.PutIncidentCommandRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.PutIncidentCommandResponse:
        """
        @summary 执行Incident动作
        
        @param request: PutIncidentCommandRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: PutIncidentCommandResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.command_content):
            query['commandContent'] = request.command_content
        if not UtilClient.is_unset(request.session):
            query['session'] = request.session
        if not UtilClient.is_unset(request.token):
            query['token'] = request.token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='PutIncidentCommand',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/incident/{OpenApiUtilClient.get_encode_param(uuid)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.PutIncidentCommandResponse(),
            self.call_api(params, req, runtime)
        )

    async def put_incident_command_with_options_async(
        self,
        uuid: str,
        request: cms_20240330_models.PutIncidentCommandRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.PutIncidentCommandResponse:
        """
        @summary 执行Incident动作
        
        @param request: PutIncidentCommandRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: PutIncidentCommandResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.command_content):
            query['commandContent'] = request.command_content
        if not UtilClient.is_unset(request.session):
            query['session'] = request.session
        if not UtilClient.is_unset(request.token):
            query['token'] = request.token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='PutIncidentCommand',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/incident/{OpenApiUtilClient.get_encode_param(uuid)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.PutIncidentCommandResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def put_incident_command(
        self,
        uuid: str,
        request: cms_20240330_models.PutIncidentCommandRequest,
    ) -> cms_20240330_models.PutIncidentCommandResponse:
        """
        @summary 执行Incident动作
        
        @param request: PutIncidentCommandRequest
        @return: PutIncidentCommandResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.put_incident_command_with_options(uuid, request, headers, runtime)

    async def put_incident_command_async(
        self,
        uuid: str,
        request: cms_20240330_models.PutIncidentCommandRequest,
    ) -> cms_20240330_models.PutIncidentCommandResponse:
        """
        @summary 执行Incident动作
        
        @param request: PutIncidentCommandRequest
        @return: PutIncidentCommandResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.put_incident_command_with_options_async(uuid, request, headers, runtime)

    def put_resource_lifecycle_event_with_options(
        self,
        request: cms_20240330_models.PutResourceLifecycleEventRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.PutResourceLifecycleEventResponse:
        """
        @summary 提交资源生命周期事件
        
        @param request: PutResourceLifecycleEventRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: PutResourceLifecycleEventResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.resource_change_type):
            query['resourceChangeType'] = request.resource_change_type
        if not UtilClient.is_unset(request.resource_id):
            query['resourceId'] = request.resource_id
        if not UtilClient.is_unset(request.resource_properties):
            query['resourceProperties'] = request.resource_properties
        if not UtilClient.is_unset(request.resource_region):
            query['resourceRegion'] = request.resource_region
        if not UtilClient.is_unset(request.resource_type):
            query['resourceType'] = request.resource_type
        if not UtilClient.is_unset(request.resource_user_id):
            query['resourceUserId'] = request.resource_user_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='PutResourceLifecycleEvent',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/inner/v1/resource-lifecycle',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.PutResourceLifecycleEventResponse(),
            self.call_api(params, req, runtime)
        )

    async def put_resource_lifecycle_event_with_options_async(
        self,
        request: cms_20240330_models.PutResourceLifecycleEventRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.PutResourceLifecycleEventResponse:
        """
        @summary 提交资源生命周期事件
        
        @param request: PutResourceLifecycleEventRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: PutResourceLifecycleEventResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.resource_change_type):
            query['resourceChangeType'] = request.resource_change_type
        if not UtilClient.is_unset(request.resource_id):
            query['resourceId'] = request.resource_id
        if not UtilClient.is_unset(request.resource_properties):
            query['resourceProperties'] = request.resource_properties
        if not UtilClient.is_unset(request.resource_region):
            query['resourceRegion'] = request.resource_region
        if not UtilClient.is_unset(request.resource_type):
            query['resourceType'] = request.resource_type
        if not UtilClient.is_unset(request.resource_user_id):
            query['resourceUserId'] = request.resource_user_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='PutResourceLifecycleEvent',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/inner/v1/resource-lifecycle',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.PutResourceLifecycleEventResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def put_resource_lifecycle_event(
        self,
        request: cms_20240330_models.PutResourceLifecycleEventRequest,
    ) -> cms_20240330_models.PutResourceLifecycleEventResponse:
        """
        @summary 提交资源生命周期事件
        
        @param request: PutResourceLifecycleEventRequest
        @return: PutResourceLifecycleEventResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.put_resource_lifecycle_event_with_options(request, headers, runtime)

    async def put_resource_lifecycle_event_async(
        self,
        request: cms_20240330_models.PutResourceLifecycleEventRequest,
    ) -> cms_20240330_models.PutResourceLifecycleEventResponse:
        """
        @summary 提交资源生命周期事件
        
        @param request: PutResourceLifecycleEventRequest
        @return: PutResourceLifecycleEventResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.put_resource_lifecycle_event_with_options_async(request, headers, runtime)

    def put_workspace_with_options(
        self,
        workspace_name: str,
        request: cms_20240330_models.PutWorkspaceRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.PutWorkspaceResponse:
        """
        @summary Create Workspace
        
        @param request: PutWorkspaceRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: PutWorkspaceResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.display_name):
            body['displayName'] = request.display_name
        if not UtilClient.is_unset(request.sls_project):
            body['slsProject'] = request.sls_project
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='PutWorkspace',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace_name)}',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.PutWorkspaceResponse(),
            self.call_api(params, req, runtime)
        )

    async def put_workspace_with_options_async(
        self,
        workspace_name: str,
        request: cms_20240330_models.PutWorkspaceRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.PutWorkspaceResponse:
        """
        @summary Create Workspace
        
        @param request: PutWorkspaceRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: PutWorkspaceResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.display_name):
            body['displayName'] = request.display_name
        if not UtilClient.is_unset(request.sls_project):
            body['slsProject'] = request.sls_project
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='PutWorkspace',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace_name)}',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.PutWorkspaceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def put_workspace(
        self,
        workspace_name: str,
        request: cms_20240330_models.PutWorkspaceRequest,
    ) -> cms_20240330_models.PutWorkspaceResponse:
        """
        @summary Create Workspace
        
        @param request: PutWorkspaceRequest
        @return: PutWorkspaceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.put_workspace_with_options(workspace_name, request, headers, runtime)

    async def put_workspace_async(
        self,
        workspace_name: str,
        request: cms_20240330_models.PutWorkspaceRequest,
    ) -> cms_20240330_models.PutWorkspaceResponse:
        """
        @summary Create Workspace
        
        @param request: PutWorkspaceRequest
        @return: PutWorkspaceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.put_workspace_with_options_async(workspace_name, request, headers, runtime)

    def render_alert_metric_with_options(
        self,
        alert_metric_id: str,
        tmp_req: cms_20240330_models.RenderAlertMetricRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.RenderAlertMetricResponse:
        """
        @summary 渲染云监控2.0告警指标
        
        @param tmp_req: RenderAlertMetricRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: RenderAlertMetricResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.RenderAlertMetricShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.filter_values):
            request.filter_values_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.filter_values, 'filterValues', 'json')
        if not UtilClient.is_unset(tmp_req.param_values):
            request.param_values_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.param_values, 'paramValues', 'json')
        query = {}
        if not UtilClient.is_unset(request.filter_values_shrink):
            query['filterValues'] = request.filter_values_shrink
        if not UtilClient.is_unset(request.param_values_shrink):
            query['paramValues'] = request.param_values_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='RenderAlertMetric',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertMetrics/{OpenApiUtilClient.get_encode_param(alert_metric_id)}/render',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.RenderAlertMetricResponse(),
            self.call_api(params, req, runtime)
        )

    async def render_alert_metric_with_options_async(
        self,
        alert_metric_id: str,
        tmp_req: cms_20240330_models.RenderAlertMetricRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.RenderAlertMetricResponse:
        """
        @summary 渲染云监控2.0告警指标
        
        @param tmp_req: RenderAlertMetricRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: RenderAlertMetricResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.RenderAlertMetricShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.filter_values):
            request.filter_values_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.filter_values, 'filterValues', 'json')
        if not UtilClient.is_unset(tmp_req.param_values):
            request.param_values_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.param_values, 'paramValues', 'json')
        query = {}
        if not UtilClient.is_unset(request.filter_values_shrink):
            query['filterValues'] = request.filter_values_shrink
        if not UtilClient.is_unset(request.param_values_shrink):
            query['paramValues'] = request.param_values_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='RenderAlertMetric',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertMetrics/{OpenApiUtilClient.get_encode_param(alert_metric_id)}/render',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.RenderAlertMetricResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def render_alert_metric(
        self,
        alert_metric_id: str,
        request: cms_20240330_models.RenderAlertMetricRequest,
    ) -> cms_20240330_models.RenderAlertMetricResponse:
        """
        @summary 渲染云监控2.0告警指标
        
        @param request: RenderAlertMetricRequest
        @return: RenderAlertMetricResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.render_alert_metric_with_options(alert_metric_id, request, headers, runtime)

    async def render_alert_metric_async(
        self,
        alert_metric_id: str,
        request: cms_20240330_models.RenderAlertMetricRequest,
    ) -> cms_20240330_models.RenderAlertMetricResponse:
        """
        @summary 渲染云监控2.0告警指标
        
        @param request: RenderAlertMetricRequest
        @return: RenderAlertMetricResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.render_alert_metric_with_options_async(alert_metric_id, request, headers, runtime)

    def resend_verify_activate_with_options(
        self,
        contact_id: str,
        request: cms_20240330_models.ResendVerifyActivateRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ResendVerifyActivateResponse:
        """
        @summary 重新发送激活链接
        
        @param request: ResendVerifyActivateRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ResendVerifyActivateResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.channel_type):
            body['channelType'] = request.channel_type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='ResendVerifyActivate',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/contact/{OpenApiUtilClient.get_encode_param(contact_id)}/action/reSendVerifyActivate',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='formData',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ResendVerifyActivateResponse(),
            self.call_api(params, req, runtime)
        )

    async def resend_verify_activate_with_options_async(
        self,
        contact_id: str,
        request: cms_20240330_models.ResendVerifyActivateRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ResendVerifyActivateResponse:
        """
        @summary 重新发送激活链接
        
        @param request: ResendVerifyActivateRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ResendVerifyActivateResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.channel_type):
            body['channelType'] = request.channel_type
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='ResendVerifyActivate',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/contact/{OpenApiUtilClient.get_encode_param(contact_id)}/action/reSendVerifyActivate',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='formData',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ResendVerifyActivateResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def resend_verify_activate(
        self,
        contact_id: str,
        request: cms_20240330_models.ResendVerifyActivateRequest,
    ) -> cms_20240330_models.ResendVerifyActivateResponse:
        """
        @summary 重新发送激活链接
        
        @param request: ResendVerifyActivateRequest
        @return: ResendVerifyActivateResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.resend_verify_activate_with_options(contact_id, request, headers, runtime)

    async def resend_verify_activate_async(
        self,
        contact_id: str,
        request: cms_20240330_models.ResendVerifyActivateRequest,
    ) -> cms_20240330_models.ResendVerifyActivateResponse:
        """
        @summary 重新发送激活链接
        
        @param request: ResendVerifyActivateRequest
        @return: ResendVerifyActivateResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.resend_verify_activate_with_options_async(contact_id, request, headers, runtime)

    def search_memories_with_options(
        self,
        workspace: str,
        memory_store_name: str,
        request: cms_20240330_models.SearchMemoriesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.SearchMemoriesResponse:
        """
        @summary 搜索记忆
        
        @param request: SearchMemoriesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: SearchMemoriesResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.agent_id):
            body['agentId'] = request.agent_id
        if not UtilClient.is_unset(request.app_id):
            body['appId'] = request.app_id
        if not UtilClient.is_unset(request.metadata):
            body['metadata'] = request.metadata
        if not UtilClient.is_unset(request.query):
            body['query'] = request.query
        if not UtilClient.is_unset(request.rerank):
            body['rerank'] = request.rerank
        if not UtilClient.is_unset(request.run_id):
            body['runId'] = request.run_id
        if not UtilClient.is_unset(request.top_k):
            body['topK'] = request.top_k
        if not UtilClient.is_unset(request.user_id):
            body['userId'] = request.user_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='SearchMemories',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}/memory/search',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.SearchMemoriesResponse(),
            self.call_api(params, req, runtime)
        )

    async def search_memories_with_options_async(
        self,
        workspace: str,
        memory_store_name: str,
        request: cms_20240330_models.SearchMemoriesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.SearchMemoriesResponse:
        """
        @summary 搜索记忆
        
        @param request: SearchMemoriesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: SearchMemoriesResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.agent_id):
            body['agentId'] = request.agent_id
        if not UtilClient.is_unset(request.app_id):
            body['appId'] = request.app_id
        if not UtilClient.is_unset(request.metadata):
            body['metadata'] = request.metadata
        if not UtilClient.is_unset(request.query):
            body['query'] = request.query
        if not UtilClient.is_unset(request.rerank):
            body['rerank'] = request.rerank
        if not UtilClient.is_unset(request.run_id):
            body['runId'] = request.run_id
        if not UtilClient.is_unset(request.top_k):
            body['topK'] = request.top_k
        if not UtilClient.is_unset(request.user_id):
            body['userId'] = request.user_id
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='SearchMemories',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}/memory/search',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.SearchMemoriesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def search_memories(
        self,
        workspace: str,
        memory_store_name: str,
        request: cms_20240330_models.SearchMemoriesRequest,
    ) -> cms_20240330_models.SearchMemoriesResponse:
        """
        @summary 搜索记忆
        
        @param request: SearchMemoriesRequest
        @return: SearchMemoriesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.search_memories_with_options(workspace, memory_store_name, request, headers, runtime)

    async def search_memories_async(
        self,
        workspace: str,
        memory_store_name: str,
        request: cms_20240330_models.SearchMemoriesRequest,
    ) -> cms_20240330_models.SearchMemoriesResponse:
        """
        @summary 搜索记忆
        
        @param request: SearchMemoriesRequest
        @return: SearchMemoriesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.search_memories_with_options_async(workspace, memory_store_name, request, headers, runtime)

    def send_itsm_verify_code_with_options(
        self,
        request: cms_20240330_models.SendItsmVerifyCodeRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.SendItsmVerifyCodeResponse:
        """
        @summary 发送ITSM操作人验证码
        
        @param request: SendItsmVerifyCodeRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: SendItsmVerifyCodeResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.contact_id):
            query['contactId'] = request.contact_id
        if not UtilClient.is_unset(request.phone):
            query['phone'] = request.phone
        if not UtilClient.is_unset(request.session):
            query['session'] = request.session
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='SendItsmVerifyCode',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/auth/sendVerifyCode',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.SendItsmVerifyCodeResponse(),
            self.call_api(params, req, runtime)
        )

    async def send_itsm_verify_code_with_options_async(
        self,
        request: cms_20240330_models.SendItsmVerifyCodeRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.SendItsmVerifyCodeResponse:
        """
        @summary 发送ITSM操作人验证码
        
        @param request: SendItsmVerifyCodeRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: SendItsmVerifyCodeResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.contact_id):
            query['contactId'] = request.contact_id
        if not UtilClient.is_unset(request.phone):
            query['phone'] = request.phone
        if not UtilClient.is_unset(request.session):
            query['session'] = request.session
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='SendItsmVerifyCode',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/auth/sendVerifyCode',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.SendItsmVerifyCodeResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def send_itsm_verify_code(
        self,
        request: cms_20240330_models.SendItsmVerifyCodeRequest,
    ) -> cms_20240330_models.SendItsmVerifyCodeResponse:
        """
        @summary 发送ITSM操作人验证码
        
        @param request: SendItsmVerifyCodeRequest
        @return: SendItsmVerifyCodeResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.send_itsm_verify_code_with_options(request, headers, runtime)

    async def send_itsm_verify_code_async(
        self,
        request: cms_20240330_models.SendItsmVerifyCodeRequest,
    ) -> cms_20240330_models.SendItsmVerifyCodeResponse:
        """
        @summary 发送ITSM操作人验证码
        
        @param request: SendItsmVerifyCodeRequest
        @return: SendItsmVerifyCodeResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.send_itsm_verify_code_with_options_async(request, headers, runtime)

    def sync_alert_rules_by_group_with_options(
        self,
        request: cms_20240330_models.SyncAlertRulesByGroupRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.SyncAlertRulesByGroupResponse:
        """
        @summary 通过告警规则组批量同步告警规则
        
        @param request: SyncAlertRulesByGroupRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: SyncAlertRulesByGroupResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.biz_source):
            body['bizSource'] = request.biz_source
        if not UtilClient.is_unset(request.datasource):
            body['datasource'] = request.datasource
        if not UtilClient.is_unset(request.group):
            body['group'] = request.group
        if not UtilClient.is_unset(request.rules):
            body['rules'] = request.rules
        if not UtilClient.is_unset(request.workspace):
            body['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='SyncAlertRulesByGroup',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/syncAlertRulesByGroup',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.SyncAlertRulesByGroupResponse(),
            self.call_api(params, req, runtime)
        )

    async def sync_alert_rules_by_group_with_options_async(
        self,
        request: cms_20240330_models.SyncAlertRulesByGroupRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.SyncAlertRulesByGroupResponse:
        """
        @summary 通过告警规则组批量同步告警规则
        
        @param request: SyncAlertRulesByGroupRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: SyncAlertRulesByGroupResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.biz_source):
            body['bizSource'] = request.biz_source
        if not UtilClient.is_unset(request.datasource):
            body['datasource'] = request.datasource
        if not UtilClient.is_unset(request.group):
            body['group'] = request.group
        if not UtilClient.is_unset(request.rules):
            body['rules'] = request.rules
        if not UtilClient.is_unset(request.workspace):
            body['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='SyncAlertRulesByGroup',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/syncAlertRulesByGroup',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.SyncAlertRulesByGroupResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def sync_alert_rules_by_group(
        self,
        request: cms_20240330_models.SyncAlertRulesByGroupRequest,
    ) -> cms_20240330_models.SyncAlertRulesByGroupResponse:
        """
        @summary 通过告警规则组批量同步告警规则
        
        @param request: SyncAlertRulesByGroupRequest
        @return: SyncAlertRulesByGroupResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.sync_alert_rules_by_group_with_options(request, headers, runtime)

    async def sync_alert_rules_by_group_async(
        self,
        request: cms_20240330_models.SyncAlertRulesByGroupRequest,
    ) -> cms_20240330_models.SyncAlertRulesByGroupResponse:
        """
        @summary 通过告警规则组批量同步告警规则
        
        @param request: SyncAlertRulesByGroupRequest
        @return: SyncAlertRulesByGroupResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.sync_alert_rules_by_group_with_options_async(request, headers, runtime)

    def sync_notify_target_from_v1with_options(
        self,
        request: cms_20240330_models.SyncNotifyTargetFromV1Request,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.SyncNotifyTargetFromV1Response:
        """
        @summary 将CMS、ARMS、SLS通知对象同步到云监控2.0
        
        @param request: SyncNotifyTargetFromV1Request
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: SyncNotifyTargetFromV1Response
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.merge_strategy):
            query['mergeStrategy'] = request.merge_strategy
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='SyncNotifyTargetFromV1',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/notifyTarget',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.SyncNotifyTargetFromV1Response(),
            self.call_api(params, req, runtime)
        )

    async def sync_notify_target_from_v1with_options_async(
        self,
        request: cms_20240330_models.SyncNotifyTargetFromV1Request,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.SyncNotifyTargetFromV1Response:
        """
        @summary 将CMS、ARMS、SLS通知对象同步到云监控2.0
        
        @param request: SyncNotifyTargetFromV1Request
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: SyncNotifyTargetFromV1Response
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.merge_strategy):
            query['mergeStrategy'] = request.merge_strategy
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='SyncNotifyTargetFromV1',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/notifyTarget',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.SyncNotifyTargetFromV1Response(),
            await self.call_api_async(params, req, runtime)
        )

    def sync_notify_target_from_v1(
        self,
        request: cms_20240330_models.SyncNotifyTargetFromV1Request,
    ) -> cms_20240330_models.SyncNotifyTargetFromV1Response:
        """
        @summary 将CMS、ARMS、SLS通知对象同步到云监控2.0
        
        @param request: SyncNotifyTargetFromV1Request
        @return: SyncNotifyTargetFromV1Response
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.sync_notify_target_from_v1with_options(request, headers, runtime)

    async def sync_notify_target_from_v1_async(
        self,
        request: cms_20240330_models.SyncNotifyTargetFromV1Request,
    ) -> cms_20240330_models.SyncNotifyTargetFromV1Response:
        """
        @summary 将CMS、ARMS、SLS通知对象同步到云监控2.0
        
        @param request: SyncNotifyTargetFromV1Request
        @return: SyncNotifyTargetFromV1Response
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.sync_notify_target_from_v1with_options_async(request, headers, runtime)

    def sync_notify_target_from_v1manually_with_options(
        self,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.SyncNotifyTargetFromV1ManuallyResponse:
        """
        @summary 将CMS、ARMS、SLS通知对象同步到云监控2.0
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: SyncNotifyTargetFromV1ManuallyResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='SyncNotifyTargetFromV1Manually',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/compare/mergeByUserWithConflictInfo',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.SyncNotifyTargetFromV1ManuallyResponse(),
            self.call_api(params, req, runtime)
        )

    async def sync_notify_target_from_v1manually_with_options_async(
        self,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.SyncNotifyTargetFromV1ManuallyResponse:
        """
        @summary 将CMS、ARMS、SLS通知对象同步到云监控2.0
        
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: SyncNotifyTargetFromV1ManuallyResponse
        """
        req = open_api_models.OpenApiRequest(
            headers=headers
        )
        params = open_api_models.Params(
            action='SyncNotifyTargetFromV1Manually',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/compare/mergeByUserWithConflictInfo',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.SyncNotifyTargetFromV1ManuallyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def sync_notify_target_from_v1manually(self) -> cms_20240330_models.SyncNotifyTargetFromV1ManuallyResponse:
        """
        @summary 将CMS、ARMS、SLS通知对象同步到云监控2.0
        
        @return: SyncNotifyTargetFromV1ManuallyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.sync_notify_target_from_v1manually_with_options(headers, runtime)

    async def sync_notify_target_from_v1manually_async(self) -> cms_20240330_models.SyncNotifyTargetFromV1ManuallyResponse:
        """
        @summary 将CMS、ARMS、SLS通知对象同步到云监控2.0
        
        @return: SyncNotifyTargetFromV1ManuallyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.sync_notify_target_from_v1manually_with_options_async(headers, runtime)

    def tag_resources_with_options(
        self,
        request: cms_20240330_models.TagResourcesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.TagResourcesResponse:
        """
        @summary 打标签接口
        
        @param request: TagResourcesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: TagResourcesResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.resource_id):
            body['resourceId'] = request.resource_id
        if not UtilClient.is_unset(request.resource_type):
            body['resourceType'] = request.resource_type
        if not UtilClient.is_unset(request.tag):
            body['tag'] = request.tag
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='TagResources',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/tags',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.TagResourcesResponse(),
            self.call_api(params, req, runtime)
        )

    async def tag_resources_with_options_async(
        self,
        request: cms_20240330_models.TagResourcesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.TagResourcesResponse:
        """
        @summary 打标签接口
        
        @param request: TagResourcesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: TagResourcesResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.resource_id):
            body['resourceId'] = request.resource_id
        if not UtilClient.is_unset(request.resource_type):
            body['resourceType'] = request.resource_type
        if not UtilClient.is_unset(request.tag):
            body['tag'] = request.tag
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='TagResources',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/tags',
            method='POST',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.TagResourcesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def tag_resources(
        self,
        request: cms_20240330_models.TagResourcesRequest,
    ) -> cms_20240330_models.TagResourcesResponse:
        """
        @summary 打标签接口
        
        @param request: TagResourcesRequest
        @return: TagResourcesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.tag_resources_with_options(request, headers, runtime)

    async def tag_resources_async(
        self,
        request: cms_20240330_models.TagResourcesRequest,
    ) -> cms_20240330_models.TagResourcesResponse:
        """
        @summary 打标签接口
        
        @param request: TagResourcesRequest
        @return: TagResourcesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.tag_resources_with_options_async(request, headers, runtime)

    def untag_resources_with_options(
        self,
        tmp_req: cms_20240330_models.UntagResourcesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UntagResourcesResponse:
        """
        @summary 删标签接口
        
        @param tmp_req: UntagResourcesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UntagResourcesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.UntagResourcesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.resource_id):
            request.resource_id_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.resource_id, 'resourceId', 'json')
        if not UtilClient.is_unset(tmp_req.tag_key):
            request.tag_key_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tag_key, 'tagKey', 'json')
        query = {}
        if not UtilClient.is_unset(request.all):
            query['all'] = request.all
        if not UtilClient.is_unset(request.resource_id_shrink):
            query['resourceId'] = request.resource_id_shrink
        if not UtilClient.is_unset(request.resource_type):
            query['resourceType'] = request.resource_type
        if not UtilClient.is_unset(request.tag_key_shrink):
            query['tagKey'] = request.tag_key_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='UntagResources',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/tags',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UntagResourcesResponse(),
            self.call_api(params, req, runtime)
        )

    async def untag_resources_with_options_async(
        self,
        tmp_req: cms_20240330_models.UntagResourcesRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UntagResourcesResponse:
        """
        @summary 删标签接口
        
        @param tmp_req: UntagResourcesRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UntagResourcesResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.UntagResourcesShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.resource_id):
            request.resource_id_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.resource_id, 'resourceId', 'json')
        if not UtilClient.is_unset(tmp_req.tag_key):
            request.tag_key_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.tag_key, 'tagKey', 'json')
        query = {}
        if not UtilClient.is_unset(request.all):
            query['all'] = request.all
        if not UtilClient.is_unset(request.resource_id_shrink):
            query['resourceId'] = request.resource_id_shrink
        if not UtilClient.is_unset(request.resource_type):
            query['resourceType'] = request.resource_type
        if not UtilClient.is_unset(request.tag_key_shrink):
            query['tagKey'] = request.tag_key_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='UntagResources',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/tags',
            method='DELETE',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UntagResourcesResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def untag_resources(
        self,
        request: cms_20240330_models.UntagResourcesRequest,
    ) -> cms_20240330_models.UntagResourcesResponse:
        """
        @summary 删标签接口
        
        @param request: UntagResourcesRequest
        @return: UntagResourcesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.untag_resources_with_options(request, headers, runtime)

    async def untag_resources_async(
        self,
        request: cms_20240330_models.UntagResourcesRequest,
    ) -> cms_20240330_models.UntagResourcesResponse:
        """
        @summary 删标签接口
        
        @param request: UntagResourcesRequest
        @return: UntagResourcesResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.untag_resources_with_options_async(request, headers, runtime)

    def update_addon_release_with_options(
        self,
        release_name: str,
        policy_id: str,
        request: cms_20240330_models.UpdateAddonReleaseRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAddonReleaseResponse:
        """
        @summary Upgrade Access Component
        
        @param request: UpdateAddonReleaseRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAddonReleaseResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.addon_version):
            body['addonVersion'] = request.addon_version
        if not UtilClient.is_unset(request.dry_run):
            body['dryRun'] = request.dry_run
        if not UtilClient.is_unset(request.entity_rules):
            body['entityRules'] = request.entity_rules
        if not UtilClient.is_unset(request.values):
            body['values'] = request.values
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateAddonRelease',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/addon-releases/{OpenApiUtilClient.get_encode_param(release_name)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAddonReleaseResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_addon_release_with_options_async(
        self,
        release_name: str,
        policy_id: str,
        request: cms_20240330_models.UpdateAddonReleaseRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAddonReleaseResponse:
        """
        @summary Upgrade Access Component
        
        @param request: UpdateAddonReleaseRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAddonReleaseResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.addon_version):
            body['addonVersion'] = request.addon_version
        if not UtilClient.is_unset(request.dry_run):
            body['dryRun'] = request.dry_run
        if not UtilClient.is_unset(request.entity_rules):
            body['entityRules'] = request.entity_rules
        if not UtilClient.is_unset(request.values):
            body['values'] = request.values
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateAddonRelease',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(policy_id)}/addon-releases/{OpenApiUtilClient.get_encode_param(release_name)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAddonReleaseResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_addon_release(
        self,
        release_name: str,
        policy_id: str,
        request: cms_20240330_models.UpdateAddonReleaseRequest,
    ) -> cms_20240330_models.UpdateAddonReleaseResponse:
        """
        @summary Upgrade Access Component
        
        @param request: UpdateAddonReleaseRequest
        @return: UpdateAddonReleaseResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_addon_release_with_options(release_name, policy_id, request, headers, runtime)

    async def update_addon_release_async(
        self,
        release_name: str,
        policy_id: str,
        request: cms_20240330_models.UpdateAddonReleaseRequest,
    ) -> cms_20240330_models.UpdateAddonReleaseResponse:
        """
        @summary Upgrade Access Component
        
        @param request: UpdateAddonReleaseRequest
        @return: UpdateAddonReleaseResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_addon_release_with_options_async(release_name, policy_id, request, headers, runtime)

    def update_agg_task_group_with_options(
        self,
        instance_id: str,
        group_id: str,
        request: cms_20240330_models.UpdateAggTaskGroupRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAggTaskGroupResponse:
        """
        @summary Apply Aggregation Task Group
        
        @param request: UpdateAggTaskGroupRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAggTaskGroupResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.agg_task_group_config):
            body['aggTaskGroupConfig'] = request.agg_task_group_config
        if not UtilClient.is_unset(request.agg_task_group_config_type):
            body['aggTaskGroupConfigType'] = request.agg_task_group_config_type
        if not UtilClient.is_unset(request.agg_task_group_name):
            body['aggTaskGroupName'] = request.agg_task_group_name
        if not UtilClient.is_unset(request.cron_expr):
            body['cronExpr'] = request.cron_expr
        if not UtilClient.is_unset(request.delay):
            body['delay'] = request.delay
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.from_time):
            body['fromTime'] = request.from_time
        if not UtilClient.is_unset(request.max_retries):
            body['maxRetries'] = request.max_retries
        if not UtilClient.is_unset(request.max_run_time_in_seconds):
            body['maxRunTimeInSeconds'] = request.max_run_time_in_seconds
        if not UtilClient.is_unset(request.precheck_string):
            body['precheckString'] = request.precheck_string
        if not UtilClient.is_unset(request.schedule_mode):
            body['scheduleMode'] = request.schedule_mode
        if not UtilClient.is_unset(request.schedule_time_expr):
            body['scheduleTimeExpr'] = request.schedule_time_expr
        if not UtilClient.is_unset(request.status):
            body['status'] = request.status
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        if not UtilClient.is_unset(request.target_prometheus_id):
            body['targetPrometheusId'] = request.target_prometheus_id
        if not UtilClient.is_unset(request.to_time):
            body['toTime'] = request.to_time
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateAggTaskGroup',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(instance_id)}/agg-task-groups/{OpenApiUtilClient.get_encode_param(group_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAggTaskGroupResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_agg_task_group_with_options_async(
        self,
        instance_id: str,
        group_id: str,
        request: cms_20240330_models.UpdateAggTaskGroupRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAggTaskGroupResponse:
        """
        @summary Apply Aggregation Task Group
        
        @param request: UpdateAggTaskGroupRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAggTaskGroupResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.agg_task_group_config):
            body['aggTaskGroupConfig'] = request.agg_task_group_config
        if not UtilClient.is_unset(request.agg_task_group_config_type):
            body['aggTaskGroupConfigType'] = request.agg_task_group_config_type
        if not UtilClient.is_unset(request.agg_task_group_name):
            body['aggTaskGroupName'] = request.agg_task_group_name
        if not UtilClient.is_unset(request.cron_expr):
            body['cronExpr'] = request.cron_expr
        if not UtilClient.is_unset(request.delay):
            body['delay'] = request.delay
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.from_time):
            body['fromTime'] = request.from_time
        if not UtilClient.is_unset(request.max_retries):
            body['maxRetries'] = request.max_retries
        if not UtilClient.is_unset(request.max_run_time_in_seconds):
            body['maxRunTimeInSeconds'] = request.max_run_time_in_seconds
        if not UtilClient.is_unset(request.precheck_string):
            body['precheckString'] = request.precheck_string
        if not UtilClient.is_unset(request.schedule_mode):
            body['scheduleMode'] = request.schedule_mode
        if not UtilClient.is_unset(request.schedule_time_expr):
            body['scheduleTimeExpr'] = request.schedule_time_expr
        if not UtilClient.is_unset(request.status):
            body['status'] = request.status
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        if not UtilClient.is_unset(request.target_prometheus_id):
            body['targetPrometheusId'] = request.target_prometheus_id
        if not UtilClient.is_unset(request.to_time):
            body['toTime'] = request.to_time
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateAggTaskGroup',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(instance_id)}/agg-task-groups/{OpenApiUtilClient.get_encode_param(group_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAggTaskGroupResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_agg_task_group(
        self,
        instance_id: str,
        group_id: str,
        request: cms_20240330_models.UpdateAggTaskGroupRequest,
    ) -> cms_20240330_models.UpdateAggTaskGroupResponse:
        """
        @summary Apply Aggregation Task Group
        
        @param request: UpdateAggTaskGroupRequest
        @return: UpdateAggTaskGroupResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_agg_task_group_with_options(instance_id, group_id, request, headers, runtime)

    async def update_agg_task_group_async(
        self,
        instance_id: str,
        group_id: str,
        request: cms_20240330_models.UpdateAggTaskGroupRequest,
    ) -> cms_20240330_models.UpdateAggTaskGroupResponse:
        """
        @summary Apply Aggregation Task Group
        
        @param request: UpdateAggTaskGroupRequest
        @return: UpdateAggTaskGroupResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_agg_task_group_with_options_async(instance_id, group_id, request, headers, runtime)

    def update_agg_task_group_status_with_options(
        self,
        instance_id: str,
        group_id: str,
        request: cms_20240330_models.UpdateAggTaskGroupStatusRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAggTaskGroupStatusResponse:
        """
        @summary Update Aggregation Task Group Status
        
        @param request: UpdateAggTaskGroupStatusRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAggTaskGroupStatusResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.status):
            body['status'] = request.status
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateAggTaskGroupStatus',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(instance_id)}/agg-task-groups/{OpenApiUtilClient.get_encode_param(group_id)}/status',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAggTaskGroupStatusResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_agg_task_group_status_with_options_async(
        self,
        instance_id: str,
        group_id: str,
        request: cms_20240330_models.UpdateAggTaskGroupStatusRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAggTaskGroupStatusResponse:
        """
        @summary Update Aggregation Task Group Status
        
        @param request: UpdateAggTaskGroupStatusRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAggTaskGroupStatusResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.status):
            body['status'] = request.status
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateAggTaskGroupStatus',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(instance_id)}/agg-task-groups/{OpenApiUtilClient.get_encode_param(group_id)}/status',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAggTaskGroupStatusResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_agg_task_group_status(
        self,
        instance_id: str,
        group_id: str,
        request: cms_20240330_models.UpdateAggTaskGroupStatusRequest,
    ) -> cms_20240330_models.UpdateAggTaskGroupStatusResponse:
        """
        @summary Update Aggregation Task Group Status
        
        @param request: UpdateAggTaskGroupStatusRequest
        @return: UpdateAggTaskGroupStatusResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_agg_task_group_status_with_options(instance_id, group_id, request, headers, runtime)

    async def update_agg_task_group_status_async(
        self,
        instance_id: str,
        group_id: str,
        request: cms_20240330_models.UpdateAggTaskGroupStatusRequest,
    ) -> cms_20240330_models.UpdateAggTaskGroupStatusResponse:
        """
        @summary Update Aggregation Task Group Status
        
        @param request: UpdateAggTaskGroupStatusRequest
        @return: UpdateAggTaskGroupStatusResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_agg_task_group_status_with_options_async(instance_id, group_id, request, headers, runtime)

    def update_alert_action_with_options(
        self,
        alert_action_id: str,
        request: cms_20240330_models.UpdateAlertActionRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAlertActionResponse:
        """
        @summary 修改告警动作
        
        @param request: UpdateAlertActionRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAlertActionResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.alert_action_name):
            body['alertActionName'] = request.alert_action_name
        if not UtilClient.is_unset(request.eb_param):
            body['ebParam'] = request.eb_param
        if not UtilClient.is_unset(request.ess_param):
            body['essParam'] = request.ess_param
        if not UtilClient.is_unset(request.fc_3param):
            body['fc3Param'] = request.fc_3param
        if not UtilClient.is_unset(request.fc_param):
            body['fcParam'] = request.fc_param
        if not UtilClient.is_unset(request.mns_param):
            body['mnsParam'] = request.mns_param
        if not UtilClient.is_unset(request.pager_duty_param):
            body['pagerDutyParam'] = request.pager_duty_param
        if not UtilClient.is_unset(request.sls_param):
            body['slsParam'] = request.sls_param
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        if not UtilClient.is_unset(request.type):
            body['type'] = request.type
        if not UtilClient.is_unset(request.webhook_param):
            body['webhookParam'] = request.webhook_param
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateAlertAction',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertAction/{OpenApiUtilClient.get_encode_param(alert_action_id)}',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAlertActionResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_alert_action_with_options_async(
        self,
        alert_action_id: str,
        request: cms_20240330_models.UpdateAlertActionRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAlertActionResponse:
        """
        @summary 修改告警动作
        
        @param request: UpdateAlertActionRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAlertActionResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.alert_action_name):
            body['alertActionName'] = request.alert_action_name
        if not UtilClient.is_unset(request.eb_param):
            body['ebParam'] = request.eb_param
        if not UtilClient.is_unset(request.ess_param):
            body['essParam'] = request.ess_param
        if not UtilClient.is_unset(request.fc_3param):
            body['fc3Param'] = request.fc_3param
        if not UtilClient.is_unset(request.fc_param):
            body['fcParam'] = request.fc_param
        if not UtilClient.is_unset(request.mns_param):
            body['mnsParam'] = request.mns_param
        if not UtilClient.is_unset(request.pager_duty_param):
            body['pagerDutyParam'] = request.pager_duty_param
        if not UtilClient.is_unset(request.sls_param):
            body['slsParam'] = request.sls_param
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        if not UtilClient.is_unset(request.type):
            body['type'] = request.type
        if not UtilClient.is_unset(request.webhook_param):
            body['webhookParam'] = request.webhook_param
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateAlertAction',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertAction/{OpenApiUtilClient.get_encode_param(alert_action_id)}',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAlertActionResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_alert_action(
        self,
        alert_action_id: str,
        request: cms_20240330_models.UpdateAlertActionRequest,
    ) -> cms_20240330_models.UpdateAlertActionResponse:
        """
        @summary 修改告警动作
        
        @param request: UpdateAlertActionRequest
        @return: UpdateAlertActionResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_alert_action_with_options(alert_action_id, request, headers, runtime)

    async def update_alert_action_async(
        self,
        alert_action_id: str,
        request: cms_20240330_models.UpdateAlertActionRequest,
    ) -> cms_20240330_models.UpdateAlertActionResponse:
        """
        @summary 修改告警动作
        
        @param request: UpdateAlertActionRequest
        @return: UpdateAlertActionResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_alert_action_with_options_async(alert_action_id, request, headers, runtime)

    def update_alert_event_integration_policy_with_options(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.UpdateAlertEventIntegrationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAlertEventIntegrationPolicyResponse:
        """
        @summary 修改已存在的“告警事件集成策略”配置。
        
        @param request: UpdateAlertEventIntegrationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAlertEventIntegrationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='UpdateAlertEventIntegrationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertEventIntegrationPolicies/{OpenApiUtilClient.get_encode_param(alert_event_integration_policy_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAlertEventIntegrationPolicyResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_alert_event_integration_policy_with_options_async(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.UpdateAlertEventIntegrationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAlertEventIntegrationPolicyResponse:
        """
        @summary 修改已存在的“告警事件集成策略”配置。
        
        @param request: UpdateAlertEventIntegrationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAlertEventIntegrationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='UpdateAlertEventIntegrationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertEventIntegrationPolicies/{OpenApiUtilClient.get_encode_param(alert_event_integration_policy_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAlertEventIntegrationPolicyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_alert_event_integration_policy(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.UpdateAlertEventIntegrationPolicyRequest,
    ) -> cms_20240330_models.UpdateAlertEventIntegrationPolicyResponse:
        """
        @summary 修改已存在的“告警事件集成策略”配置。
        
        @param request: UpdateAlertEventIntegrationPolicyRequest
        @return: UpdateAlertEventIntegrationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_alert_event_integration_policy_with_options(alert_event_integration_policy_id, request, headers, runtime)

    async def update_alert_event_integration_policy_async(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.UpdateAlertEventIntegrationPolicyRequest,
    ) -> cms_20240330_models.UpdateAlertEventIntegrationPolicyResponse:
        """
        @summary 修改已存在的“告警事件集成策略”配置。
        
        @param request: UpdateAlertEventIntegrationPolicyRequest
        @return: UpdateAlertEventIntegrationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_alert_event_integration_policy_with_options_async(alert_event_integration_policy_id, request, headers, runtime)

    def update_alert_event_integration_policy_token_with_options(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.UpdateAlertEventIntegrationPolicyTokenRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAlertEventIntegrationPolicyTokenResponse:
        """
        @summary 更新集成token
        
        @param request: UpdateAlertEventIntegrationPolicyTokenRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAlertEventIntegrationPolicyTokenResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='UpdateAlertEventIntegrationPolicyToken',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertEventIntegrationPolicies/{OpenApiUtilClient.get_encode_param(alert_event_integration_policy_id)}/updateToken',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAlertEventIntegrationPolicyTokenResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_alert_event_integration_policy_token_with_options_async(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.UpdateAlertEventIntegrationPolicyTokenRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAlertEventIntegrationPolicyTokenResponse:
        """
        @summary 更新集成token
        
        @param request: UpdateAlertEventIntegrationPolicyTokenRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAlertEventIntegrationPolicyTokenResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='UpdateAlertEventIntegrationPolicyToken',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertEventIntegrationPolicies/{OpenApiUtilClient.get_encode_param(alert_event_integration_policy_id)}/updateToken',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAlertEventIntegrationPolicyTokenResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_alert_event_integration_policy_token(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.UpdateAlertEventIntegrationPolicyTokenRequest,
    ) -> cms_20240330_models.UpdateAlertEventIntegrationPolicyTokenResponse:
        """
        @summary 更新集成token
        
        @param request: UpdateAlertEventIntegrationPolicyTokenRequest
        @return: UpdateAlertEventIntegrationPolicyTokenResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_alert_event_integration_policy_token_with_options(alert_event_integration_policy_id, request, headers, runtime)

    async def update_alert_event_integration_policy_token_async(
        self,
        alert_event_integration_policy_id: str,
        request: cms_20240330_models.UpdateAlertEventIntegrationPolicyTokenRequest,
    ) -> cms_20240330_models.UpdateAlertEventIntegrationPolicyTokenResponse:
        """
        @summary 更新集成token
        
        @param request: UpdateAlertEventIntegrationPolicyTokenRequest
        @return: UpdateAlertEventIntegrationPolicyTokenResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_alert_event_integration_policy_token_with_options_async(alert_event_integration_policy_id, request, headers, runtime)

    def update_alert_notify_template_with_options(
        self,
        alert_notify_template_id: str,
        request: cms_20240330_models.UpdateAlertNotifyTemplateRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAlertNotifyTemplateResponse:
        """
        @summary 修改已存在的告警通知模板内容。
        
        @param request: UpdateAlertNotifyTemplateRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAlertNotifyTemplateResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.alert_notify_template_name):
            body['alertNotifyTemplateName'] = request.alert_notify_template_name
        if not UtilClient.is_unset(request.templates):
            body['templates'] = request.templates
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateAlertNotifyTemplate',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertNotifyTemplate/{OpenApiUtilClient.get_encode_param(alert_notify_template_id)}',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAlertNotifyTemplateResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_alert_notify_template_with_options_async(
        self,
        alert_notify_template_id: str,
        request: cms_20240330_models.UpdateAlertNotifyTemplateRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAlertNotifyTemplateResponse:
        """
        @summary 修改已存在的告警通知模板内容。
        
        @param request: UpdateAlertNotifyTemplateRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAlertNotifyTemplateResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.alert_notify_template_name):
            body['alertNotifyTemplateName'] = request.alert_notify_template_name
        if not UtilClient.is_unset(request.templates):
            body['templates'] = request.templates
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateAlertNotifyTemplate',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertNotifyTemplate/{OpenApiUtilClient.get_encode_param(alert_notify_template_id)}',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAlertNotifyTemplateResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_alert_notify_template(
        self,
        alert_notify_template_id: str,
        request: cms_20240330_models.UpdateAlertNotifyTemplateRequest,
    ) -> cms_20240330_models.UpdateAlertNotifyTemplateResponse:
        """
        @summary 修改已存在的告警通知模板内容。
        
        @param request: UpdateAlertNotifyTemplateRequest
        @return: UpdateAlertNotifyTemplateResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_alert_notify_template_with_options(alert_notify_template_id, request, headers, runtime)

    async def update_alert_notify_template_async(
        self,
        alert_notify_template_id: str,
        request: cms_20240330_models.UpdateAlertNotifyTemplateRequest,
    ) -> cms_20240330_models.UpdateAlertNotifyTemplateResponse:
        """
        @summary 修改已存在的告警通知模板内容。
        
        @param request: UpdateAlertNotifyTemplateRequest
        @return: UpdateAlertNotifyTemplateResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_alert_notify_template_with_options_async(alert_notify_template_id, request, headers, runtime)

    def update_alert_robot_with_options(
        self,
        robot_id: str,
        request: cms_20240330_models.UpdateAlertRobotRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAlertRobotResponse:
        """
        @summary 修改已存在的告警机器人（Alert Robot）的配置信息。
        
        @param request: UpdateAlertRobotRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAlertRobotResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.is_custom):
            body['isCustom'] = request.is_custom
        if not UtilClient.is_unset(request.lang):
            body['lang'] = request.lang
        if not UtilClient.is_unset(request.name):
            body['name'] = request.name
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        if not UtilClient.is_unset(request.type):
            body['type'] = request.type
        if not UtilClient.is_unset(request.url):
            body['url'] = request.url
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateAlertRobot',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/robot/{OpenApiUtilClient.get_encode_param(robot_id)}',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAlertRobotResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_alert_robot_with_options_async(
        self,
        robot_id: str,
        request: cms_20240330_models.UpdateAlertRobotRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAlertRobotResponse:
        """
        @summary 修改已存在的告警机器人（Alert Robot）的配置信息。
        
        @param request: UpdateAlertRobotRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAlertRobotResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.is_custom):
            body['isCustom'] = request.is_custom
        if not UtilClient.is_unset(request.lang):
            body['lang'] = request.lang
        if not UtilClient.is_unset(request.name):
            body['name'] = request.name
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        if not UtilClient.is_unset(request.type):
            body['type'] = request.type
        if not UtilClient.is_unset(request.url):
            body['url'] = request.url
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateAlertRobot',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/robot/{OpenApiUtilClient.get_encode_param(robot_id)}',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAlertRobotResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_alert_robot(
        self,
        robot_id: str,
        request: cms_20240330_models.UpdateAlertRobotRequest,
    ) -> cms_20240330_models.UpdateAlertRobotResponse:
        """
        @summary 修改已存在的告警机器人（Alert Robot）的配置信息。
        
        @param request: UpdateAlertRobotRequest
        @return: UpdateAlertRobotResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_alert_robot_with_options(robot_id, request, headers, runtime)

    async def update_alert_robot_async(
        self,
        robot_id: str,
        request: cms_20240330_models.UpdateAlertRobotRequest,
    ) -> cms_20240330_models.UpdateAlertRobotResponse:
        """
        @summary 修改已存在的告警机器人（Alert Robot）的配置信息。
        
        @param request: UpdateAlertRobotRequest
        @return: UpdateAlertRobotResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_alert_robot_with_options_async(robot_id, request, headers, runtime)

    def update_alert_rule_with_options(
        self,
        alert_rule_id: str,
        request: cms_20240330_models.UpdateAlertRuleRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAlertRuleResponse:
        """
        @summary 修改已存在的告警规则配置。
        
        @param request: UpdateAlertRuleRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAlertRuleResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.call_source):
            query['callSource'] = request.call_source
        body = {}
        if not UtilClient.is_unset(request.alert_metric_input):
            body['alertMetricInput'] = request.alert_metric_input
        if not UtilClient.is_unset(request.annotations):
            body['annotations'] = request.annotations
        if not UtilClient.is_unset(request.condition):
            body['condition'] = request.condition
        if not UtilClient.is_unset(request.display_name):
            body['displayName'] = request.display_name
        if not UtilClient.is_unset(request.interval):
            body['interval'] = request.interval
        if not UtilClient.is_unset(request.labels):
            body['labels'] = request.labels
        if not UtilClient.is_unset(request.level):
            body['level'] = request.level
        if not UtilClient.is_unset(request.message):
            body['message'] = request.message
        if not UtilClient.is_unset(request.query):
            body['query'] = request.query
        if not UtilClient.is_unset(request.send):
            body['send'] = request.send
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateAlertRule',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules/{OpenApiUtilClient.get_encode_param(alert_rule_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAlertRuleResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_alert_rule_with_options_async(
        self,
        alert_rule_id: str,
        request: cms_20240330_models.UpdateAlertRuleRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAlertRuleResponse:
        """
        @summary 修改已存在的告警规则配置。
        
        @param request: UpdateAlertRuleRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAlertRuleResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.call_source):
            query['callSource'] = request.call_source
        body = {}
        if not UtilClient.is_unset(request.alert_metric_input):
            body['alertMetricInput'] = request.alert_metric_input
        if not UtilClient.is_unset(request.annotations):
            body['annotations'] = request.annotations
        if not UtilClient.is_unset(request.condition):
            body['condition'] = request.condition
        if not UtilClient.is_unset(request.display_name):
            body['displayName'] = request.display_name
        if not UtilClient.is_unset(request.interval):
            body['interval'] = request.interval
        if not UtilClient.is_unset(request.labels):
            body['labels'] = request.labels
        if not UtilClient.is_unset(request.level):
            body['level'] = request.level
        if not UtilClient.is_unset(request.message):
            body['message'] = request.message
        if not UtilClient.is_unset(request.query):
            body['query'] = request.query
        if not UtilClient.is_unset(request.send):
            body['send'] = request.send
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateAlertRule',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules/{OpenApiUtilClient.get_encode_param(alert_rule_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAlertRuleResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_alert_rule(
        self,
        alert_rule_id: str,
        request: cms_20240330_models.UpdateAlertRuleRequest,
    ) -> cms_20240330_models.UpdateAlertRuleResponse:
        """
        @summary 修改已存在的告警规则配置。
        
        @param request: UpdateAlertRuleRequest
        @return: UpdateAlertRuleResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_alert_rule_with_options(alert_rule_id, request, headers, runtime)

    async def update_alert_rule_async(
        self,
        alert_rule_id: str,
        request: cms_20240330_models.UpdateAlertRuleRequest,
    ) -> cms_20240330_models.UpdateAlertRuleResponse:
        """
        @summary 修改已存在的告警规则配置。
        
        @param request: UpdateAlertRuleRequest
        @return: UpdateAlertRuleResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_alert_rule_with_options_async(alert_rule_id, request, headers, runtime)

    def update_alert_rule_kvs_with_options(
        self,
        request: cms_20240330_models.UpdateAlertRuleKvsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAlertRuleKvsResponse:
        """
        @summary 更新告警规则的键值对字段(label和annotation)
        
        @param request: UpdateAlertRuleKvsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAlertRuleKvsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.call_source):
            query['callSource'] = request.call_source
        body = {}
        if not UtilClient.is_unset(request.alert_rule_ids):
            body['alertRuleIds'] = request.alert_rule_ids
        if not UtilClient.is_unset(request.put_annotations):
            body['putAnnotations'] = request.put_annotations
        if not UtilClient.is_unset(request.put_labels):
            body['putLabels'] = request.put_labels
        if not UtilClient.is_unset(request.remove_annotations):
            body['removeAnnotations'] = request.remove_annotations
        if not UtilClient.is_unset(request.remove_labels):
            body['removeLabels'] = request.remove_labels
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateAlertRuleKvs',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules/action/updateKvs',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAlertRuleKvsResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_alert_rule_kvs_with_options_async(
        self,
        request: cms_20240330_models.UpdateAlertRuleKvsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAlertRuleKvsResponse:
        """
        @summary 更新告警规则的键值对字段(label和annotation)
        
        @param request: UpdateAlertRuleKvsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAlertRuleKvsResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.call_source):
            query['callSource'] = request.call_source
        body = {}
        if not UtilClient.is_unset(request.alert_rule_ids):
            body['alertRuleIds'] = request.alert_rule_ids
        if not UtilClient.is_unset(request.put_annotations):
            body['putAnnotations'] = request.put_annotations
        if not UtilClient.is_unset(request.put_labels):
            body['putLabels'] = request.put_labels
        if not UtilClient.is_unset(request.remove_annotations):
            body['removeAnnotations'] = request.remove_annotations
        if not UtilClient.is_unset(request.remove_labels):
            body['removeLabels'] = request.remove_labels
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateAlertRuleKvs',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/alertRules/action/updateKvs',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAlertRuleKvsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_alert_rule_kvs(
        self,
        request: cms_20240330_models.UpdateAlertRuleKvsRequest,
    ) -> cms_20240330_models.UpdateAlertRuleKvsResponse:
        """
        @summary 更新告警规则的键值对字段(label和annotation)
        
        @param request: UpdateAlertRuleKvsRequest
        @return: UpdateAlertRuleKvsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_alert_rule_kvs_with_options(request, headers, runtime)

    async def update_alert_rule_kvs_async(
        self,
        request: cms_20240330_models.UpdateAlertRuleKvsRequest,
    ) -> cms_20240330_models.UpdateAlertRuleKvsResponse:
        """
        @summary 更新告警规则的键值对字段(label和annotation)
        
        @param request: UpdateAlertRuleKvsRequest
        @return: UpdateAlertRuleKvsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_alert_rule_kvs_with_options_async(request, headers, runtime)

    def update_alert_webhook_with_options(
        self,
        webhook_id: str,
        request: cms_20240330_models.UpdateAlertWebhookRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAlertWebhookResponse:
        """
        @summary 修改已存在的告警 Webhook 通知配置。
        
        @param request: UpdateAlertWebhookRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAlertWebhookResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.content_type):
            body['contentType'] = request.content_type
        if not UtilClient.is_unset(request.headers):
            body['headers'] = request.headers
        if not UtilClient.is_unset(request.is_custom):
            body['isCustom'] = request.is_custom
        if not UtilClient.is_unset(request.lang):
            body['lang'] = request.lang
        if not UtilClient.is_unset(request.method):
            body['method'] = request.method
        if not UtilClient.is_unset(request.name):
            body['name'] = request.name
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        if not UtilClient.is_unset(request.url):
            body['url'] = request.url
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateAlertWebhook',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/webhook/{OpenApiUtilClient.get_encode_param(webhook_id)}',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAlertWebhookResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_alert_webhook_with_options_async(
        self,
        webhook_id: str,
        request: cms_20240330_models.UpdateAlertWebhookRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateAlertWebhookResponse:
        """
        @summary 修改已存在的告警 Webhook 通知配置。
        
        @param request: UpdateAlertWebhookRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateAlertWebhookResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.content_type):
            body['contentType'] = request.content_type
        if not UtilClient.is_unset(request.headers):
            body['headers'] = request.headers
        if not UtilClient.is_unset(request.is_custom):
            body['isCustom'] = request.is_custom
        if not UtilClient.is_unset(request.lang):
            body['lang'] = request.lang
        if not UtilClient.is_unset(request.method):
            body['method'] = request.method
        if not UtilClient.is_unset(request.name):
            body['name'] = request.name
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        if not UtilClient.is_unset(request.url):
            body['url'] = request.url
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateAlertWebhook',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/webhook/{OpenApiUtilClient.get_encode_param(webhook_id)}',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateAlertWebhookResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_alert_webhook(
        self,
        webhook_id: str,
        request: cms_20240330_models.UpdateAlertWebhookRequest,
    ) -> cms_20240330_models.UpdateAlertWebhookResponse:
        """
        @summary 修改已存在的告警 Webhook 通知配置。
        
        @param request: UpdateAlertWebhookRequest
        @return: UpdateAlertWebhookResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_alert_webhook_with_options(webhook_id, request, headers, runtime)

    async def update_alert_webhook_async(
        self,
        webhook_id: str,
        request: cms_20240330_models.UpdateAlertWebhookRequest,
    ) -> cms_20240330_models.UpdateAlertWebhookResponse:
        """
        @summary 修改已存在的告警 Webhook 通知配置。
        
        @param request: UpdateAlertWebhookRequest
        @return: UpdateAlertWebhookResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_alert_webhook_with_options_async(webhook_id, request, headers, runtime)

    def update_biz_trace_with_options(
        self,
        biz_trace_id: str,
        request: cms_20240330_models.UpdateBizTraceRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateBizTraceResponse:
        """
        @summary 修改业务链路
        
        @param request: UpdateBizTraceRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateBizTraceResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.advanced_config):
            body['advancedConfig'] = request.advanced_config
        if not UtilClient.is_unset(request.biz_trace_name):
            body['bizTraceName'] = request.biz_trace_name
        if not UtilClient.is_unset(request.rule_config):
            body['ruleConfig'] = request.rule_config
        if not UtilClient.is_unset(request.workspace):
            body['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateBizTrace',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/bizTrace/{OpenApiUtilClient.get_encode_param(biz_trace_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateBizTraceResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_biz_trace_with_options_async(
        self,
        biz_trace_id: str,
        request: cms_20240330_models.UpdateBizTraceRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateBizTraceResponse:
        """
        @summary 修改业务链路
        
        @param request: UpdateBizTraceRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateBizTraceResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.advanced_config):
            body['advancedConfig'] = request.advanced_config
        if not UtilClient.is_unset(request.biz_trace_name):
            body['bizTraceName'] = request.biz_trace_name
        if not UtilClient.is_unset(request.rule_config):
            body['ruleConfig'] = request.rule_config
        if not UtilClient.is_unset(request.workspace):
            body['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateBizTrace',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/bizTrace/{OpenApiUtilClient.get_encode_param(biz_trace_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateBizTraceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_biz_trace(
        self,
        biz_trace_id: str,
        request: cms_20240330_models.UpdateBizTraceRequest,
    ) -> cms_20240330_models.UpdateBizTraceResponse:
        """
        @summary 修改业务链路
        
        @param request: UpdateBizTraceRequest
        @return: UpdateBizTraceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_biz_trace_with_options(biz_trace_id, request, headers, runtime)

    async def update_biz_trace_async(
        self,
        biz_trace_id: str,
        request: cms_20240330_models.UpdateBizTraceRequest,
    ) -> cms_20240330_models.UpdateBizTraceResponse:
        """
        @summary 修改业务链路
        
        @param request: UpdateBizTraceRequest
        @return: UpdateBizTraceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_biz_trace_with_options_async(biz_trace_id, request, headers, runtime)

    def update_contact_with_options(
        self,
        contact_id: str,
        request: cms_20240330_models.UpdateContactRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateContactResponse:
        """
        @summary 修改已存在的联系人的详细信息
        
        @param request: UpdateContactRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateContactResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.email):
            body['email'] = request.email
        if not UtilClient.is_unset(request.im_user_ids):
            body['imUserIds'] = request.im_user_ids
        if not UtilClient.is_unset(request.is_inner_call):
            body['isInnerCall'] = request.is_inner_call
        if not UtilClient.is_unset(request.lang):
            body['lang'] = request.lang
        if not UtilClient.is_unset(request.name):
            body['name'] = request.name
        if not UtilClient.is_unset(request.phone):
            body['phone'] = request.phone
        if not UtilClient.is_unset(request.phone_code):
            body['phoneCode'] = request.phone_code
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateContact',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/contact/{OpenApiUtilClient.get_encode_param(contact_id)}',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateContactResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_contact_with_options_async(
        self,
        contact_id: str,
        request: cms_20240330_models.UpdateContactRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateContactResponse:
        """
        @summary 修改已存在的联系人的详细信息
        
        @param request: UpdateContactRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateContactResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.email):
            body['email'] = request.email
        if not UtilClient.is_unset(request.im_user_ids):
            body['imUserIds'] = request.im_user_ids
        if not UtilClient.is_unset(request.is_inner_call):
            body['isInnerCall'] = request.is_inner_call
        if not UtilClient.is_unset(request.lang):
            body['lang'] = request.lang
        if not UtilClient.is_unset(request.name):
            body['name'] = request.name
        if not UtilClient.is_unset(request.phone):
            body['phone'] = request.phone
        if not UtilClient.is_unset(request.phone_code):
            body['phoneCode'] = request.phone_code
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateContact',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/contact/{OpenApiUtilClient.get_encode_param(contact_id)}',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateContactResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_contact(
        self,
        contact_id: str,
        request: cms_20240330_models.UpdateContactRequest,
    ) -> cms_20240330_models.UpdateContactResponse:
        """
        @summary 修改已存在的联系人的详细信息
        
        @param request: UpdateContactRequest
        @return: UpdateContactResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_contact_with_options(contact_id, request, headers, runtime)

    async def update_contact_async(
        self,
        contact_id: str,
        request: cms_20240330_models.UpdateContactRequest,
    ) -> cms_20240330_models.UpdateContactResponse:
        """
        @summary 修改已存在的联系人的详细信息
        
        @param request: UpdateContactRequest
        @return: UpdateContactResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_contact_with_options_async(contact_id, request, headers, runtime)

    def update_contact_group_with_options(
        self,
        contact_group_id: str,
        request: cms_20240330_models.UpdateContactGroupRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateContactGroupResponse:
        """
        @summary 修改已存在的联系人组信息。
        
        @param request: UpdateContactGroupRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateContactGroupResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.contacts):
            body['contacts'] = request.contacts
        if not UtilClient.is_unset(request.name):
            body['name'] = request.name
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateContactGroup',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/contactGroup/{OpenApiUtilClient.get_encode_param(contact_group_id)}',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateContactGroupResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_contact_group_with_options_async(
        self,
        contact_group_id: str,
        request: cms_20240330_models.UpdateContactGroupRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateContactGroupResponse:
        """
        @summary 修改已存在的联系人组信息。
        
        @param request: UpdateContactGroupRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateContactGroupResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.contacts):
            body['contacts'] = request.contacts
        if not UtilClient.is_unset(request.name):
            body['name'] = request.name
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateContactGroup',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/contactGroup/{OpenApiUtilClient.get_encode_param(contact_group_id)}',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateContactGroupResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_contact_group(
        self,
        contact_group_id: str,
        request: cms_20240330_models.UpdateContactGroupRequest,
    ) -> cms_20240330_models.UpdateContactGroupResponse:
        """
        @summary 修改已存在的联系人组信息。
        
        @param request: UpdateContactGroupRequest
        @return: UpdateContactGroupResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_contact_group_with_options(contact_group_id, request, headers, runtime)

    async def update_contact_group_async(
        self,
        contact_group_id: str,
        request: cms_20240330_models.UpdateContactGroupRequest,
    ) -> cms_20240330_models.UpdateContactGroupResponse:
        """
        @summary 修改已存在的联系人组信息。
        
        @param request: UpdateContactGroupRequest
        @return: UpdateContactGroupResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_contact_group_with_options_async(contact_group_id, request, headers, runtime)

    def update_dataset_with_options(
        self,
        workspace: str,
        dataset_name: str,
        request: cms_20240330_models.UpdateDatasetRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateDatasetResponse:
        """
        @summary 更新数据集
        
        @param request: UpdateDatasetRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateDatasetResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateDataset',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/dataset/{OpenApiUtilClient.get_encode_param(dataset_name)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateDatasetResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_dataset_with_options_async(
        self,
        workspace: str,
        dataset_name: str,
        request: cms_20240330_models.UpdateDatasetRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateDatasetResponse:
        """
        @summary 更新数据集
        
        @param request: UpdateDatasetRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateDatasetResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateDataset',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/dataset/{OpenApiUtilClient.get_encode_param(dataset_name)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateDatasetResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_dataset(
        self,
        workspace: str,
        dataset_name: str,
        request: cms_20240330_models.UpdateDatasetRequest,
    ) -> cms_20240330_models.UpdateDatasetResponse:
        """
        @summary 更新数据集
        
        @param request: UpdateDatasetRequest
        @return: UpdateDatasetResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_dataset_with_options(workspace, dataset_name, request, headers, runtime)

    async def update_dataset_async(
        self,
        workspace: str,
        dataset_name: str,
        request: cms_20240330_models.UpdateDatasetRequest,
    ) -> cms_20240330_models.UpdateDatasetResponse:
        """
        @summary 更新数据集
        
        @param request: UpdateDatasetRequest
        @return: UpdateDatasetResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_dataset_with_options_async(workspace, dataset_name, request, headers, runtime)

    def update_delivery_task_with_options(
        self,
        task_id: str,
        request: cms_20240330_models.UpdateDeliveryTaskRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateDeliveryTaskResponse:
        """
        @summary 更新数据投递任务
        
        @param request: UpdateDeliveryTaskRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateDeliveryTaskResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.data_source_id):
            body['dataSourceId'] = request.data_source_id
        if not UtilClient.is_unset(request.external_labels):
            body['externalLabels'] = request.external_labels
        if not UtilClient.is_unset(request.label_filters):
            body['labelFilters'] = request.label_filters
        if not UtilClient.is_unset(request.label_filters_type):
            body['labelFiltersType'] = request.label_filters_type
        if not UtilClient.is_unset(request.resource_group_id):
            body['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.sink_list):
            body['sinkList'] = request.sink_list
        if not UtilClient.is_unset(request.status):
            body['status'] = request.status
        if not UtilClient.is_unset(request.task_description):
            body['taskDescription'] = request.task_description
        if not UtilClient.is_unset(request.task_name):
            body['taskName'] = request.task_name
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateDeliveryTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/delivery-task/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateDeliveryTaskResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_delivery_task_with_options_async(
        self,
        task_id: str,
        request: cms_20240330_models.UpdateDeliveryTaskRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateDeliveryTaskResponse:
        """
        @summary 更新数据投递任务
        
        @param request: UpdateDeliveryTaskRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateDeliveryTaskResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.data_source_id):
            body['dataSourceId'] = request.data_source_id
        if not UtilClient.is_unset(request.external_labels):
            body['externalLabels'] = request.external_labels
        if not UtilClient.is_unset(request.label_filters):
            body['labelFilters'] = request.label_filters
        if not UtilClient.is_unset(request.label_filters_type):
            body['labelFiltersType'] = request.label_filters_type
        if not UtilClient.is_unset(request.resource_group_id):
            body['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.sink_list):
            body['sinkList'] = request.sink_list
        if not UtilClient.is_unset(request.status):
            body['status'] = request.status
        if not UtilClient.is_unset(request.task_description):
            body['taskDescription'] = request.task_description
        if not UtilClient.is_unset(request.task_name):
            body['taskName'] = request.task_name
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateDeliveryTask',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/delivery-task/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateDeliveryTaskResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_delivery_task(
        self,
        task_id: str,
        request: cms_20240330_models.UpdateDeliveryTaskRequest,
    ) -> cms_20240330_models.UpdateDeliveryTaskResponse:
        """
        @summary 更新数据投递任务
        
        @param request: UpdateDeliveryTaskRequest
        @return: UpdateDeliveryTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_delivery_task_with_options(task_id, request, headers, runtime)

    async def update_delivery_task_async(
        self,
        task_id: str,
        request: cms_20240330_models.UpdateDeliveryTaskRequest,
    ) -> cms_20240330_models.UpdateDeliveryTaskResponse:
        """
        @summary 更新数据投递任务
        
        @param request: UpdateDeliveryTaskRequest
        @return: UpdateDeliveryTaskResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_delivery_task_with_options_async(task_id, request, headers, runtime)

    def update_digital_employee_with_options(
        self,
        name: str,
        request: cms_20240330_models.UpdateDigitalEmployeeRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateDigitalEmployeeResponse:
        """
        @summary 更新UpdateDigitalEmployee
        
        @param request: UpdateDigitalEmployeeRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateDigitalEmployeeResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.default_rule):
            body['defaultRule'] = request.default_rule
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.display_name):
            body['displayName'] = request.display_name
        if not UtilClient.is_unset(request.knowledges):
            body['knowledges'] = request.knowledges
        if not UtilClient.is_unset(request.role_arn):
            body['roleArn'] = request.role_arn
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateDigitalEmployee',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digital-employee/{OpenApiUtilClient.get_encode_param(name)}',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateDigitalEmployeeResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_digital_employee_with_options_async(
        self,
        name: str,
        request: cms_20240330_models.UpdateDigitalEmployeeRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateDigitalEmployeeResponse:
        """
        @summary 更新UpdateDigitalEmployee
        
        @param request: UpdateDigitalEmployeeRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateDigitalEmployeeResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.default_rule):
            body['defaultRule'] = request.default_rule
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.display_name):
            body['displayName'] = request.display_name
        if not UtilClient.is_unset(request.knowledges):
            body['knowledges'] = request.knowledges
        if not UtilClient.is_unset(request.role_arn):
            body['roleArn'] = request.role_arn
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateDigitalEmployee',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digital-employee/{OpenApiUtilClient.get_encode_param(name)}',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateDigitalEmployeeResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_digital_employee(
        self,
        name: str,
        request: cms_20240330_models.UpdateDigitalEmployeeRequest,
    ) -> cms_20240330_models.UpdateDigitalEmployeeResponse:
        """
        @summary 更新UpdateDigitalEmployee
        
        @param request: UpdateDigitalEmployeeRequest
        @return: UpdateDigitalEmployeeResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_digital_employee_with_options(name, request, headers, runtime)

    async def update_digital_employee_async(
        self,
        name: str,
        request: cms_20240330_models.UpdateDigitalEmployeeRequest,
    ) -> cms_20240330_models.UpdateDigitalEmployeeResponse:
        """
        @summary 更新UpdateDigitalEmployee
        
        @param request: UpdateDigitalEmployeeRequest
        @return: UpdateDigitalEmployeeResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_digital_employee_with_options_async(name, request, headers, runtime)

    def update_digital_employee_skill_with_options(
        self,
        name: str,
        skill_name: str,
        request: cms_20240330_models.UpdateDigitalEmployeeSkillRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateDigitalEmployeeSkillResponse:
        """
        @summary 更新技能
        
        @param request: UpdateDigitalEmployeeSkillRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateDigitalEmployeeSkillResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.display_name):
            body['displayName'] = request.display_name
        if not UtilClient.is_unset(request.enable):
            body['enable'] = request.enable
        if not UtilClient.is_unset(request.files):
            body['files'] = request.files
        if not UtilClient.is_unset(request.remark):
            body['remark'] = request.remark
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateDigitalEmployeeSkill',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/skill/{OpenApiUtilClient.get_encode_param(skill_name)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateDigitalEmployeeSkillResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_digital_employee_skill_with_options_async(
        self,
        name: str,
        skill_name: str,
        request: cms_20240330_models.UpdateDigitalEmployeeSkillRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateDigitalEmployeeSkillResponse:
        """
        @summary 更新技能
        
        @param request: UpdateDigitalEmployeeSkillRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateDigitalEmployeeSkillResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.display_name):
            body['displayName'] = request.display_name
        if not UtilClient.is_unset(request.enable):
            body['enable'] = request.enable
        if not UtilClient.is_unset(request.files):
            body['files'] = request.files
        if not UtilClient.is_unset(request.remark):
            body['remark'] = request.remark
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateDigitalEmployeeSkill',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/skill/{OpenApiUtilClient.get_encode_param(skill_name)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateDigitalEmployeeSkillResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_digital_employee_skill(
        self,
        name: str,
        skill_name: str,
        request: cms_20240330_models.UpdateDigitalEmployeeSkillRequest,
    ) -> cms_20240330_models.UpdateDigitalEmployeeSkillResponse:
        """
        @summary 更新技能
        
        @param request: UpdateDigitalEmployeeSkillRequest
        @return: UpdateDigitalEmployeeSkillResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_digital_employee_skill_with_options(name, skill_name, request, headers, runtime)

    async def update_digital_employee_skill_async(
        self,
        name: str,
        skill_name: str,
        request: cms_20240330_models.UpdateDigitalEmployeeSkillRequest,
    ) -> cms_20240330_models.UpdateDigitalEmployeeSkillResponse:
        """
        @summary 更新技能
        
        @param request: UpdateDigitalEmployeeSkillRequest
        @return: UpdateDigitalEmployeeSkillResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_digital_employee_skill_with_options_async(name, skill_name, request, headers, runtime)

    def update_digital_employee_tools_with_options(
        self,
        name: str,
        request: cms_20240330_models.UpdateDigitalEmployeeToolsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateDigitalEmployeeToolsResponse:
        """
        @summary 更新数据员工的工具
        
        @param request: UpdateDigitalEmployeeToolsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateDigitalEmployeeToolsResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.mcp_services):
            body['mcpServices'] = request.mcp_services
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateDigitalEmployeeTools',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/tools',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateDigitalEmployeeToolsResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_digital_employee_tools_with_options_async(
        self,
        name: str,
        request: cms_20240330_models.UpdateDigitalEmployeeToolsRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateDigitalEmployeeToolsResponse:
        """
        @summary 更新数据员工的工具
        
        @param request: UpdateDigitalEmployeeToolsRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateDigitalEmployeeToolsResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.mcp_services):
            body['mcpServices'] = request.mcp_services
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateDigitalEmployeeTools',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/tools',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateDigitalEmployeeToolsResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_digital_employee_tools(
        self,
        name: str,
        request: cms_20240330_models.UpdateDigitalEmployeeToolsRequest,
    ) -> cms_20240330_models.UpdateDigitalEmployeeToolsResponse:
        """
        @summary 更新数据员工的工具
        
        @param request: UpdateDigitalEmployeeToolsRequest
        @return: UpdateDigitalEmployeeToolsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_digital_employee_tools_with_options(name, request, headers, runtime)

    async def update_digital_employee_tools_async(
        self,
        name: str,
        request: cms_20240330_models.UpdateDigitalEmployeeToolsRequest,
    ) -> cms_20240330_models.UpdateDigitalEmployeeToolsResponse:
        """
        @summary 更新数据员工的工具
        
        @param request: UpdateDigitalEmployeeToolsRequest
        @return: UpdateDigitalEmployeeToolsResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_digital_employee_tools_with_options_async(name, request, headers, runtime)

    def update_escalation_policy_with_options(
        self,
        uuid: str,
        request: cms_20240330_models.UpdateEscalationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateEscalationPolicyResponse:
        """
        @summary 更新升级策略
        
        @param request: UpdateEscalationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateEscalationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='UpdateEscalationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/escalationPolicies/{OpenApiUtilClient.get_encode_param(uuid)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateEscalationPolicyResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_escalation_policy_with_options_async(
        self,
        uuid: str,
        request: cms_20240330_models.UpdateEscalationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateEscalationPolicyResponse:
        """
        @summary 更新升级策略
        
        @param request: UpdateEscalationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateEscalationPolicyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='UpdateEscalationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/escalationPolicies/{OpenApiUtilClient.get_encode_param(uuid)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateEscalationPolicyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_escalation_policy(
        self,
        uuid: str,
        request: cms_20240330_models.UpdateEscalationPolicyRequest,
    ) -> cms_20240330_models.UpdateEscalationPolicyResponse:
        """
        @summary 更新升级策略
        
        @param request: UpdateEscalationPolicyRequest
        @return: UpdateEscalationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_escalation_policy_with_options(uuid, request, headers, runtime)

    async def update_escalation_policy_async(
        self,
        uuid: str,
        request: cms_20240330_models.UpdateEscalationPolicyRequest,
    ) -> cms_20240330_models.UpdateEscalationPolicyResponse:
        """
        @summary 更新升级策略
        
        @param request: UpdateEscalationPolicyRequest
        @return: UpdateEscalationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_escalation_policy_with_options_async(uuid, request, headers, runtime)

    def update_experiment_plan_with_options(
        self,
        workspace: str,
        plan_id: str,
        request: cms_20240330_models.UpdateExperimentPlanRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateExperimentPlanResponse:
        """
        @summary 修改实验计划
        
        @param request: UpdateExperimentPlanRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateExperimentPlanResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.dataset_id):
            body['datasetId'] = request.dataset_id
        if not UtilClient.is_unset(request.dataset_project):
            body['datasetProject'] = request.dataset_project
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.experiments):
            body['experiments'] = request.experiments
        if not UtilClient.is_unset(request.plan_name):
            body['planName'] = request.plan_name
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateExperimentPlan',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/experiments/{OpenApiUtilClient.get_encode_param(workspace)}/plans/{OpenApiUtilClient.get_encode_param(plan_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateExperimentPlanResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_experiment_plan_with_options_async(
        self,
        workspace: str,
        plan_id: str,
        request: cms_20240330_models.UpdateExperimentPlanRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateExperimentPlanResponse:
        """
        @summary 修改实验计划
        
        @param request: UpdateExperimentPlanRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateExperimentPlanResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.dataset_id):
            body['datasetId'] = request.dataset_id
        if not UtilClient.is_unset(request.dataset_project):
            body['datasetProject'] = request.dataset_project
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.experiments):
            body['experiments'] = request.experiments
        if not UtilClient.is_unset(request.plan_name):
            body['planName'] = request.plan_name
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateExperimentPlan',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/api/v1/experiments/{OpenApiUtilClient.get_encode_param(workspace)}/plans/{OpenApiUtilClient.get_encode_param(plan_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateExperimentPlanResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_experiment_plan(
        self,
        workspace: str,
        plan_id: str,
        request: cms_20240330_models.UpdateExperimentPlanRequest,
    ) -> cms_20240330_models.UpdateExperimentPlanResponse:
        """
        @summary 修改实验计划
        
        @param request: UpdateExperimentPlanRequest
        @return: UpdateExperimentPlanResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_experiment_plan_with_options(workspace, plan_id, request, headers, runtime)

    async def update_experiment_plan_async(
        self,
        workspace: str,
        plan_id: str,
        request: cms_20240330_models.UpdateExperimentPlanRequest,
    ) -> cms_20240330_models.UpdateExperimentPlanResponse:
        """
        @summary 修改实验计划
        
        @param request: UpdateExperimentPlanRequest
        @return: UpdateExperimentPlanResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_experiment_plan_with_options_async(workspace, plan_id, request, headers, runtime)

    def update_integration_policy_with_options(
        self,
        integration_policy_id: str,
        request: cms_20240330_models.UpdateIntegrationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateIntegrationPolicyResponse:
        """
        @summary Update the specified policy
        
        @param request: UpdateIntegrationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateIntegrationPolicyResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.fee_package):
            body['feePackage'] = request.fee_package
        if not UtilClient.is_unset(request.policy_name):
            body['policyName'] = request.policy_name
        if not UtilClient.is_unset(request.resource_group_id):
            body['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateIntegrationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(integration_policy_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateIntegrationPolicyResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_integration_policy_with_options_async(
        self,
        integration_policy_id: str,
        request: cms_20240330_models.UpdateIntegrationPolicyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateIntegrationPolicyResponse:
        """
        @summary Update the specified policy
        
        @param request: UpdateIntegrationPolicyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateIntegrationPolicyResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.fee_package):
            body['feePackage'] = request.fee_package
        if not UtilClient.is_unset(request.policy_name):
            body['policyName'] = request.policy_name
        if not UtilClient.is_unset(request.resource_group_id):
            body['resourceGroupId'] = request.resource_group_id
        if not UtilClient.is_unset(request.tags):
            body['tags'] = request.tags
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateIntegrationPolicy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/integration-policies/{OpenApiUtilClient.get_encode_param(integration_policy_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateIntegrationPolicyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_integration_policy(
        self,
        integration_policy_id: str,
        request: cms_20240330_models.UpdateIntegrationPolicyRequest,
    ) -> cms_20240330_models.UpdateIntegrationPolicyResponse:
        """
        @summary Update the specified policy
        
        @param request: UpdateIntegrationPolicyRequest
        @return: UpdateIntegrationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_integration_policy_with_options(integration_policy_id, request, headers, runtime)

    async def update_integration_policy_async(
        self,
        integration_policy_id: str,
        request: cms_20240330_models.UpdateIntegrationPolicyRequest,
    ) -> cms_20240330_models.UpdateIntegrationPolicyResponse:
        """
        @summary Update the specified policy
        
        @param request: UpdateIntegrationPolicyRequest
        @return: UpdateIntegrationPolicyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_integration_policy_with_options_async(integration_policy_id, request, headers, runtime)

    def update_maintain_window_with_options(
        self,
        maintain_window_id: str,
        request: cms_20240330_models.UpdateMaintainWindowRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateMaintainWindowResponse:
        """
        @summary 修改已存在的维护窗口配置。
        
        @param request: UpdateMaintainWindowRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateMaintainWindowResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='UpdateMaintainWindow',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/maintainWindows/{OpenApiUtilClient.get_encode_param(maintain_window_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateMaintainWindowResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_maintain_window_with_options_async(
        self,
        maintain_window_id: str,
        request: cms_20240330_models.UpdateMaintainWindowRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateMaintainWindowResponse:
        """
        @summary 修改已存在的维护窗口配置。
        
        @param request: UpdateMaintainWindowRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateMaintainWindowResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='UpdateMaintainWindow',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/maintainWindows/{OpenApiUtilClient.get_encode_param(maintain_window_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateMaintainWindowResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_maintain_window(
        self,
        maintain_window_id: str,
        request: cms_20240330_models.UpdateMaintainWindowRequest,
    ) -> cms_20240330_models.UpdateMaintainWindowResponse:
        """
        @summary 修改已存在的维护窗口配置。
        
        @param request: UpdateMaintainWindowRequest
        @return: UpdateMaintainWindowResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_maintain_window_with_options(maintain_window_id, request, headers, runtime)

    async def update_maintain_window_async(
        self,
        maintain_window_id: str,
        request: cms_20240330_models.UpdateMaintainWindowRequest,
    ) -> cms_20240330_models.UpdateMaintainWindowResponse:
        """
        @summary 修改已存在的维护窗口配置。
        
        @param request: UpdateMaintainWindowRequest
        @return: UpdateMaintainWindowResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_maintain_window_with_options_async(maintain_window_id, request, headers, runtime)

    def update_memory_with_options(
        self,
        workspace: str,
        memory_store_name: str,
        memory_id: str,
        request: cms_20240330_models.UpdateMemoryRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateMemoryResponse:
        """
        @summary 修改记忆
        
        @param request: UpdateMemoryRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateMemoryResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.metadata):
            body['metadata'] = request.metadata
        if not UtilClient.is_unset(request.text):
            body['text'] = request.text
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateMemory',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}/memory/{OpenApiUtilClient.get_encode_param(memory_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateMemoryResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_memory_with_options_async(
        self,
        workspace: str,
        memory_store_name: str,
        memory_id: str,
        request: cms_20240330_models.UpdateMemoryRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateMemoryResponse:
        """
        @summary 修改记忆
        
        @param request: UpdateMemoryRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateMemoryResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.metadata):
            body['metadata'] = request.metadata
        if not UtilClient.is_unset(request.text):
            body['text'] = request.text
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateMemory',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}/memory/{OpenApiUtilClient.get_encode_param(memory_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateMemoryResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_memory(
        self,
        workspace: str,
        memory_store_name: str,
        memory_id: str,
        request: cms_20240330_models.UpdateMemoryRequest,
    ) -> cms_20240330_models.UpdateMemoryResponse:
        """
        @summary 修改记忆
        
        @param request: UpdateMemoryRequest
        @return: UpdateMemoryResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_memory_with_options(workspace, memory_store_name, memory_id, request, headers, runtime)

    async def update_memory_async(
        self,
        workspace: str,
        memory_store_name: str,
        memory_id: str,
        request: cms_20240330_models.UpdateMemoryRequest,
    ) -> cms_20240330_models.UpdateMemoryResponse:
        """
        @summary 修改记忆
        
        @param request: UpdateMemoryRequest
        @return: UpdateMemoryResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_memory_with_options_async(workspace, memory_store_name, memory_id, request, headers, runtime)

    def update_memory_store_with_options(
        self,
        workspace: str,
        memory_store_name: str,
        request: cms_20240330_models.UpdateMemoryStoreRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateMemoryStoreResponse:
        """
        @summary 修改记忆库配置
        
        @param request: UpdateMemoryStoreRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateMemoryStoreResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.custom_extraction_strategies):
            body['customExtractionStrategies'] = request.custom_extraction_strategies
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.enable_graph):
            body['enableGraph'] = request.enable_graph
        if not UtilClient.is_unset(request.extraction_strategies):
            body['extractionStrategies'] = request.extraction_strategies
        if not UtilClient.is_unset(request.short_term_ttl):
            body['shortTermTtl'] = request.short_term_ttl
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateMemoryStore',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateMemoryStoreResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_memory_store_with_options_async(
        self,
        workspace: str,
        memory_store_name: str,
        request: cms_20240330_models.UpdateMemoryStoreRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateMemoryStoreResponse:
        """
        @summary 修改记忆库配置
        
        @param request: UpdateMemoryStoreRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateMemoryStoreResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.custom_extraction_strategies):
            body['customExtractionStrategies'] = request.custom_extraction_strategies
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.enable_graph):
            body['enableGraph'] = request.enable_graph
        if not UtilClient.is_unset(request.extraction_strategies):
            body['extractionStrategies'] = request.extraction_strategies
        if not UtilClient.is_unset(request.short_term_ttl):
            body['shortTermTtl'] = request.short_term_ttl
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateMemoryStore',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/memorystore/{OpenApiUtilClient.get_encode_param(memory_store_name)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateMemoryStoreResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_memory_store(
        self,
        workspace: str,
        memory_store_name: str,
        request: cms_20240330_models.UpdateMemoryStoreRequest,
    ) -> cms_20240330_models.UpdateMemoryStoreResponse:
        """
        @summary 修改记忆库配置
        
        @param request: UpdateMemoryStoreRequest
        @return: UpdateMemoryStoreResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_memory_store_with_options(workspace, memory_store_name, request, headers, runtime)

    async def update_memory_store_async(
        self,
        workspace: str,
        memory_store_name: str,
        request: cms_20240330_models.UpdateMemoryStoreRequest,
    ) -> cms_20240330_models.UpdateMemoryStoreResponse:
        """
        @summary 修改记忆库配置
        
        @param request: UpdateMemoryStoreRequest
        @return: UpdateMemoryStoreResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_memory_store_with_options_async(workspace, memory_store_name, request, headers, runtime)

    def update_notify_strategy_with_options(
        self,
        notify_strategy_id: str,
        request: cms_20240330_models.UpdateNotifyStrategyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateNotifyStrategyResponse:
        """
        @summary 修改已存在的告警通知策略
        
        @param request: UpdateNotifyStrategyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateNotifyStrategyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='UpdateNotifyStrategy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/notifyStrategies/{OpenApiUtilClient.get_encode_param(notify_strategy_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateNotifyStrategyResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_notify_strategy_with_options_async(
        self,
        notify_strategy_id: str,
        request: cms_20240330_models.UpdateNotifyStrategyRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateNotifyStrategyResponse:
        """
        @summary 修改已存在的告警通知策略
        
        @param request: UpdateNotifyStrategyRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateNotifyStrategyResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='UpdateNotifyStrategy',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/notifyStrategies/{OpenApiUtilClient.get_encode_param(notify_strategy_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateNotifyStrategyResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_notify_strategy(
        self,
        notify_strategy_id: str,
        request: cms_20240330_models.UpdateNotifyStrategyRequest,
    ) -> cms_20240330_models.UpdateNotifyStrategyResponse:
        """
        @summary 修改已存在的告警通知策略
        
        @param request: UpdateNotifyStrategyRequest
        @return: UpdateNotifyStrategyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_notify_strategy_with_options(notify_strategy_id, request, headers, runtime)

    async def update_notify_strategy_async(
        self,
        notify_strategy_id: str,
        request: cms_20240330_models.UpdateNotifyStrategyRequest,
    ) -> cms_20240330_models.UpdateNotifyStrategyResponse:
        """
        @summary 修改已存在的告警通知策略
        
        @param request: UpdateNotifyStrategyRequest
        @return: UpdateNotifyStrategyResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_notify_strategy_with_options_async(notify_strategy_id, request, headers, runtime)

    def update_oncall_schedule_with_options(
        self,
        oncall_schedule_id: str,
        request: cms_20240330_models.UpdateOncallScheduleRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateOncallScheduleResponse:
        """
        @summary 更新UpdateOncallSchedule
        
        @param request: UpdateOncallScheduleRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateOncallScheduleResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.oncall_schedule_name):
            body['oncallScheduleName'] = request.oncall_schedule_name
        if not UtilClient.is_unset(request.rotations):
            body['rotations'] = request.rotations
        if not UtilClient.is_unset(request.shift_robot_id):
            body['shiftRobotId'] = request.shift_robot_id
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateOncallSchedule',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/oncallSchedule/{OpenApiUtilClient.get_encode_param(oncall_schedule_id)}',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateOncallScheduleResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_oncall_schedule_with_options_async(
        self,
        oncall_schedule_id: str,
        request: cms_20240330_models.UpdateOncallScheduleRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateOncallScheduleResponse:
        """
        @summary 更新UpdateOncallSchedule
        
        @param request: UpdateOncallScheduleRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateOncallScheduleResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.oncall_schedule_name):
            body['oncallScheduleName'] = request.oncall_schedule_name
        if not UtilClient.is_unset(request.rotations):
            body['rotations'] = request.rotations
        if not UtilClient.is_unset(request.shift_robot_id):
            body['shiftRobotId'] = request.shift_robot_id
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateOncallSchedule',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/oncallSchedule/{OpenApiUtilClient.get_encode_param(oncall_schedule_id)}',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateOncallScheduleResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_oncall_schedule(
        self,
        oncall_schedule_id: str,
        request: cms_20240330_models.UpdateOncallScheduleRequest,
    ) -> cms_20240330_models.UpdateOncallScheduleResponse:
        """
        @summary 更新UpdateOncallSchedule
        
        @param request: UpdateOncallScheduleRequest
        @return: UpdateOncallScheduleResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_oncall_schedule_with_options(oncall_schedule_id, request, headers, runtime)

    async def update_oncall_schedule_async(
        self,
        oncall_schedule_id: str,
        request: cms_20240330_models.UpdateOncallScheduleRequest,
    ) -> cms_20240330_models.UpdateOncallScheduleResponse:
        """
        @summary 更新UpdateOncallSchedule
        
        @param request: UpdateOncallScheduleRequest
        @return: UpdateOncallScheduleResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_oncall_schedule_with_options_async(oncall_schedule_id, request, headers, runtime)

    def update_pipeline_with_options(
        self,
        workspace: str,
        pipeline_name: str,
        request: cms_20240330_models.UpdatePipelineRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdatePipelineResponse:
        """
        @summary 更新流水线
        
        @param request: UpdatePipelineRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdatePipelineResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.execute_policy):
            body['executePolicy'] = request.execute_policy
        if not UtilClient.is_unset(request.pipeline):
            body['pipeline'] = request.pipeline
        if not UtilClient.is_unset(request.sink):
            body['sink'] = request.sink
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdatePipeline',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/pipeline/{OpenApiUtilClient.get_encode_param(pipeline_name)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdatePipelineResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_pipeline_with_options_async(
        self,
        workspace: str,
        pipeline_name: str,
        request: cms_20240330_models.UpdatePipelineRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdatePipelineResponse:
        """
        @summary 更新流水线
        
        @param request: UpdatePipelineRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdatePipelineResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.execute_policy):
            body['executePolicy'] = request.execute_policy
        if not UtilClient.is_unset(request.pipeline):
            body['pipeline'] = request.pipeline
        if not UtilClient.is_unset(request.sink):
            body['sink'] = request.sink
        if not UtilClient.is_unset(request.source):
            body['source'] = request.source
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdatePipeline',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/pipeline/{OpenApiUtilClient.get_encode_param(pipeline_name)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdatePipelineResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_pipeline(
        self,
        workspace: str,
        pipeline_name: str,
        request: cms_20240330_models.UpdatePipelineRequest,
    ) -> cms_20240330_models.UpdatePipelineResponse:
        """
        @summary 更新流水线
        
        @param request: UpdatePipelineRequest
        @return: UpdatePipelineResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_pipeline_with_options(workspace, pipeline_name, request, headers, runtime)

    async def update_pipeline_async(
        self,
        workspace: str,
        pipeline_name: str,
        request: cms_20240330_models.UpdatePipelineRequest,
    ) -> cms_20240330_models.UpdatePipelineResponse:
        """
        @summary 更新流水线
        
        @param request: UpdatePipelineRequest
        @return: UpdatePipelineResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_pipeline_with_options_async(workspace, pipeline_name, request, headers, runtime)

    def update_prometheus_cluster_with_options(
        self,
        prometheus_cluster_name: str,
        request: cms_20240330_models.UpdatePrometheusClusterRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdatePrometheusClusterResponse:
        """
        @summary 更新Prometheus集群信息
        
        @param request: UpdatePrometheusClusterRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdatePrometheusClusterResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.auth_free_write_policy):
            body['authFreeWritePolicy'] = request.auth_free_write_policy
        if not UtilClient.is_unset(request.enable_auth_free_write):
            body['enableAuthFreeWrite'] = request.enable_auth_free_write
        if not UtilClient.is_unset(request.payment_type):
            body['paymentType'] = request.payment_type
        if not UtilClient.is_unset(request.storage_duration):
            body['storageDuration'] = request.storage_duration
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdatePrometheusCluster',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-clusters/{OpenApiUtilClient.get_encode_param(prometheus_cluster_name)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdatePrometheusClusterResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_prometheus_cluster_with_options_async(
        self,
        prometheus_cluster_name: str,
        request: cms_20240330_models.UpdatePrometheusClusterRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdatePrometheusClusterResponse:
        """
        @summary 更新Prometheus集群信息
        
        @param request: UpdatePrometheusClusterRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdatePrometheusClusterResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.auth_free_write_policy):
            body['authFreeWritePolicy'] = request.auth_free_write_policy
        if not UtilClient.is_unset(request.enable_auth_free_write):
            body['enableAuthFreeWrite'] = request.enable_auth_free_write
        if not UtilClient.is_unset(request.payment_type):
            body['paymentType'] = request.payment_type
        if not UtilClient.is_unset(request.storage_duration):
            body['storageDuration'] = request.storage_duration
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdatePrometheusCluster',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-clusters/{OpenApiUtilClient.get_encode_param(prometheus_cluster_name)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdatePrometheusClusterResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_prometheus_cluster(
        self,
        prometheus_cluster_name: str,
        request: cms_20240330_models.UpdatePrometheusClusterRequest,
    ) -> cms_20240330_models.UpdatePrometheusClusterResponse:
        """
        @summary 更新Prometheus集群信息
        
        @param request: UpdatePrometheusClusterRequest
        @return: UpdatePrometheusClusterResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_prometheus_cluster_with_options(prometheus_cluster_name, request, headers, runtime)

    async def update_prometheus_cluster_async(
        self,
        prometheus_cluster_name: str,
        request: cms_20240330_models.UpdatePrometheusClusterRequest,
    ) -> cms_20240330_models.UpdatePrometheusClusterResponse:
        """
        @summary 更新Prometheus集群信息
        
        @param request: UpdatePrometheusClusterRequest
        @return: UpdatePrometheusClusterResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_prometheus_cluster_with_options_async(prometheus_cluster_name, request, headers, runtime)

    def update_prometheus_instance_with_options(
        self,
        prometheus_instance_id: str,
        request: cms_20240330_models.UpdatePrometheusInstanceRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdatePrometheusInstanceResponse:
        """
        @summary Update Prometheus instance information
        
        @description Update Prometheus instance information.
        
        @param request: UpdatePrometheusInstanceRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdatePrometheusInstanceResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.archive_duration):
            body['archiveDuration'] = request.archive_duration
        if not UtilClient.is_unset(request.auth_free_read_policy):
            body['authFreeReadPolicy'] = request.auth_free_read_policy
        if not UtilClient.is_unset(request.auth_free_write_policy):
            body['authFreeWritePolicy'] = request.auth_free_write_policy
        if not UtilClient.is_unset(request.basic_metric_query_limit):
            body['basicMetricQueryLimit'] = request.basic_metric_query_limit
        if not UtilClient.is_unset(request.enable_auth_free_read):
            body['enableAuthFreeRead'] = request.enable_auth_free_read
        if not UtilClient.is_unset(request.enable_auth_free_write):
            body['enableAuthFreeWrite'] = request.enable_auth_free_write
        if not UtilClient.is_unset(request.enable_auth_token):
            body['enableAuthToken'] = request.enable_auth_token
        if not UtilClient.is_unset(request.payment_type):
            body['paymentType'] = request.payment_type
        if not UtilClient.is_unset(request.prometheus_instance_name):
            body['prometheusInstanceName'] = request.prometheus_instance_name
        if not UtilClient.is_unset(request.status):
            body['status'] = request.status
        if not UtilClient.is_unset(request.storage_duration):
            body['storageDuration'] = request.storage_duration
        if not UtilClient.is_unset(request.version):
            body['version'] = request.version
        if not UtilClient.is_unset(request.workspace):
            body['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdatePrometheusInstance',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(prometheus_instance_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdatePrometheusInstanceResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_prometheus_instance_with_options_async(
        self,
        prometheus_instance_id: str,
        request: cms_20240330_models.UpdatePrometheusInstanceRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdatePrometheusInstanceResponse:
        """
        @summary Update Prometheus instance information
        
        @description Update Prometheus instance information.
        
        @param request: UpdatePrometheusInstanceRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdatePrometheusInstanceResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.archive_duration):
            body['archiveDuration'] = request.archive_duration
        if not UtilClient.is_unset(request.auth_free_read_policy):
            body['authFreeReadPolicy'] = request.auth_free_read_policy
        if not UtilClient.is_unset(request.auth_free_write_policy):
            body['authFreeWritePolicy'] = request.auth_free_write_policy
        if not UtilClient.is_unset(request.basic_metric_query_limit):
            body['basicMetricQueryLimit'] = request.basic_metric_query_limit
        if not UtilClient.is_unset(request.enable_auth_free_read):
            body['enableAuthFreeRead'] = request.enable_auth_free_read
        if not UtilClient.is_unset(request.enable_auth_free_write):
            body['enableAuthFreeWrite'] = request.enable_auth_free_write
        if not UtilClient.is_unset(request.enable_auth_token):
            body['enableAuthToken'] = request.enable_auth_token
        if not UtilClient.is_unset(request.payment_type):
            body['paymentType'] = request.payment_type
        if not UtilClient.is_unset(request.prometheus_instance_name):
            body['prometheusInstanceName'] = request.prometheus_instance_name
        if not UtilClient.is_unset(request.status):
            body['status'] = request.status
        if not UtilClient.is_unset(request.storage_duration):
            body['storageDuration'] = request.storage_duration
        if not UtilClient.is_unset(request.version):
            body['version'] = request.version
        if not UtilClient.is_unset(request.workspace):
            body['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdatePrometheusInstance',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-instances/{OpenApiUtilClient.get_encode_param(prometheus_instance_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdatePrometheusInstanceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_prometheus_instance(
        self,
        prometheus_instance_id: str,
        request: cms_20240330_models.UpdatePrometheusInstanceRequest,
    ) -> cms_20240330_models.UpdatePrometheusInstanceResponse:
        """
        @summary Update Prometheus instance information
        
        @description Update Prometheus instance information.
        
        @param request: UpdatePrometheusInstanceRequest
        @return: UpdatePrometheusInstanceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_prometheus_instance_with_options(prometheus_instance_id, request, headers, runtime)

    async def update_prometheus_instance_async(
        self,
        prometheus_instance_id: str,
        request: cms_20240330_models.UpdatePrometheusInstanceRequest,
    ) -> cms_20240330_models.UpdatePrometheusInstanceResponse:
        """
        @summary Update Prometheus instance information
        
        @description Update Prometheus instance information.
        
        @param request: UpdatePrometheusInstanceRequest
        @return: UpdatePrometheusInstanceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_prometheus_instance_with_options_async(prometheus_instance_id, request, headers, runtime)

    def update_prometheus_user_setting_with_options(
        self,
        setting_key: str,
        request: cms_20240330_models.UpdatePrometheusUserSettingRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdatePrometheusUserSettingResponse:
        """
        @summary 更新Prom实例信息
        
        @param request: UpdatePrometheusUserSettingRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdatePrometheusUserSettingResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.setting_value):
            query['settingValue'] = request.setting_value
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='UpdatePrometheusUserSetting',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-user-setting/{OpenApiUtilClient.get_encode_param(setting_key)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdatePrometheusUserSettingResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_prometheus_user_setting_with_options_async(
        self,
        setting_key: str,
        request: cms_20240330_models.UpdatePrometheusUserSettingRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdatePrometheusUserSettingResponse:
        """
        @summary 更新Prom实例信息
        
        @param request: UpdatePrometheusUserSettingRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdatePrometheusUserSettingResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.setting_value):
            query['settingValue'] = request.setting_value
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='UpdatePrometheusUserSetting',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-user-setting/{OpenApiUtilClient.get_encode_param(setting_key)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdatePrometheusUserSettingResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_prometheus_user_setting(
        self,
        setting_key: str,
        request: cms_20240330_models.UpdatePrometheusUserSettingRequest,
    ) -> cms_20240330_models.UpdatePrometheusUserSettingResponse:
        """
        @summary 更新Prom实例信息
        
        @param request: UpdatePrometheusUserSettingRequest
        @return: UpdatePrometheusUserSettingResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_prometheus_user_setting_with_options(setting_key, request, headers, runtime)

    async def update_prometheus_user_setting_async(
        self,
        setting_key: str,
        request: cms_20240330_models.UpdatePrometheusUserSettingRequest,
    ) -> cms_20240330_models.UpdatePrometheusUserSettingResponse:
        """
        @summary 更新Prom实例信息
        
        @param request: UpdatePrometheusUserSettingRequest
        @return: UpdatePrometheusUserSettingResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_prometheus_user_setting_with_options_async(setting_key, request, headers, runtime)

    def update_prometheus_view_with_options(
        self,
        prometheus_view_id: str,
        request: cms_20240330_models.UpdatePrometheusViewRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdatePrometheusViewResponse:
        """
        @summary Update Prometheus view instance information
        
        @description Update Prometheus view instance information.
        
        @param request: UpdatePrometheusViewRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdatePrometheusViewResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.auth_free_read_policy):
            body['authFreeReadPolicy'] = request.auth_free_read_policy
        if not UtilClient.is_unset(request.enable_auth_free_read):
            body['enableAuthFreeRead'] = request.enable_auth_free_read
        if not UtilClient.is_unset(request.enable_auth_token):
            body['enableAuthToken'] = request.enable_auth_token
        if not UtilClient.is_unset(request.prometheus_instances):
            body['prometheusInstances'] = request.prometheus_instances
        if not UtilClient.is_unset(request.prometheus_view_name):
            body['prometheusViewName'] = request.prometheus_view_name
        if not UtilClient.is_unset(request.status):
            body['status'] = request.status
        if not UtilClient.is_unset(request.workspace):
            body['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdatePrometheusView',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-views/{OpenApiUtilClient.get_encode_param(prometheus_view_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdatePrometheusViewResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_prometheus_view_with_options_async(
        self,
        prometheus_view_id: str,
        request: cms_20240330_models.UpdatePrometheusViewRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdatePrometheusViewResponse:
        """
        @summary Update Prometheus view instance information
        
        @description Update Prometheus view instance information.
        
        @param request: UpdatePrometheusViewRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdatePrometheusViewResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.auth_free_read_policy):
            body['authFreeReadPolicy'] = request.auth_free_read_policy
        if not UtilClient.is_unset(request.enable_auth_free_read):
            body['enableAuthFreeRead'] = request.enable_auth_free_read
        if not UtilClient.is_unset(request.enable_auth_token):
            body['enableAuthToken'] = request.enable_auth_token
        if not UtilClient.is_unset(request.prometheus_instances):
            body['prometheusInstances'] = request.prometheus_instances
        if not UtilClient.is_unset(request.prometheus_view_name):
            body['prometheusViewName'] = request.prometheus_view_name
        if not UtilClient.is_unset(request.status):
            body['status'] = request.status
        if not UtilClient.is_unset(request.workspace):
            body['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdatePrometheusView',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/prometheus-views/{OpenApiUtilClient.get_encode_param(prometheus_view_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdatePrometheusViewResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_prometheus_view(
        self,
        prometheus_view_id: str,
        request: cms_20240330_models.UpdatePrometheusViewRequest,
    ) -> cms_20240330_models.UpdatePrometheusViewResponse:
        """
        @summary Update Prometheus view instance information
        
        @description Update Prometheus view instance information.
        
        @param request: UpdatePrometheusViewRequest
        @return: UpdatePrometheusViewResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_prometheus_view_with_options(prometheus_view_id, request, headers, runtime)

    async def update_prometheus_view_async(
        self,
        prometheus_view_id: str,
        request: cms_20240330_models.UpdatePrometheusViewRequest,
    ) -> cms_20240330_models.UpdatePrometheusViewResponse:
        """
        @summary Update Prometheus view instance information
        
        @description Update Prometheus view instance information.
        
        @param request: UpdatePrometheusViewRequest
        @return: UpdatePrometheusViewResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_prometheus_view_with_options_async(prometheus_view_id, request, headers, runtime)

    def update_service_with_options(
        self,
        workspace: str,
        service_id: str,
        request: cms_20240330_models.UpdateServiceRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateServiceResponse:
        """
        @summary Update Service
        
        @param request: UpdateServiceRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateServiceResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.attributes):
            body['attributes'] = request.attributes
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.display_name):
            body['displayName'] = request.display_name
        if not UtilClient.is_unset(request.service_status):
            body['serviceStatus'] = request.service_status
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateService',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/service/{OpenApiUtilClient.get_encode_param(service_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateServiceResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_service_with_options_async(
        self,
        workspace: str,
        service_id: str,
        request: cms_20240330_models.UpdateServiceRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateServiceResponse:
        """
        @summary Update Service
        
        @param request: UpdateServiceRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateServiceResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.attributes):
            body['attributes'] = request.attributes
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        if not UtilClient.is_unset(request.display_name):
            body['displayName'] = request.display_name
        if not UtilClient.is_unset(request.service_status):
            body['serviceStatus'] = request.service_status
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateService',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/service/{OpenApiUtilClient.get_encode_param(service_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateServiceResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_service(
        self,
        workspace: str,
        service_id: str,
        request: cms_20240330_models.UpdateServiceRequest,
    ) -> cms_20240330_models.UpdateServiceResponse:
        """
        @summary Update Service
        
        @param request: UpdateServiceRequest
        @return: UpdateServiceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_service_with_options(workspace, service_id, request, headers, runtime)

    async def update_service_async(
        self,
        workspace: str,
        service_id: str,
        request: cms_20240330_models.UpdateServiceRequest,
    ) -> cms_20240330_models.UpdateServiceResponse:
        """
        @summary Update Service
        
        @param request: UpdateServiceRequest
        @return: UpdateServiceResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_service_with_options_async(workspace, service_id, request, headers, runtime)

    def update_service_observability_with_options(
        self,
        workspace: str,
        type: str,
        request: cms_20240330_models.UpdateServiceObservabilityRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateServiceObservabilityResponse:
        """
        @summary 更新应用可观测实例
        
        @param request: UpdateServiceObservabilityRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateServiceObservabilityResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.fee_type):
            body['feeType'] = request.fee_type
        if not UtilClient.is_unset(request.quotas):
            body['quotas'] = request.quotas
        if not UtilClient.is_unset(request.settings):
            body['settings'] = request.settings
        if not UtilClient.is_unset(request.status):
            body['status'] = request.status
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateServiceObservability',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/service-observability/{OpenApiUtilClient.get_encode_param(type)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateServiceObservabilityResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_service_observability_with_options_async(
        self,
        workspace: str,
        type: str,
        request: cms_20240330_models.UpdateServiceObservabilityRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateServiceObservabilityResponse:
        """
        @summary 更新应用可观测实例
        
        @param request: UpdateServiceObservabilityRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateServiceObservabilityResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.fee_type):
            body['feeType'] = request.fee_type
        if not UtilClient.is_unset(request.quotas):
            body['quotas'] = request.quotas
        if not UtilClient.is_unset(request.settings):
            body['settings'] = request.settings
        if not UtilClient.is_unset(request.status):
            body['status'] = request.status
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateServiceObservability',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/service-observability/{OpenApiUtilClient.get_encode_param(type)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateServiceObservabilityResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_service_observability(
        self,
        workspace: str,
        type: str,
        request: cms_20240330_models.UpdateServiceObservabilityRequest,
    ) -> cms_20240330_models.UpdateServiceObservabilityResponse:
        """
        @summary 更新应用可观测实例
        
        @param request: UpdateServiceObservabilityRequest
        @return: UpdateServiceObservabilityResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_service_observability_with_options(workspace, type, request, headers, runtime)

    async def update_service_observability_async(
        self,
        workspace: str,
        type: str,
        request: cms_20240330_models.UpdateServiceObservabilityRequest,
    ) -> cms_20240330_models.UpdateServiceObservabilityResponse:
        """
        @summary 更新应用可观测实例
        
        @param request: UpdateServiceObservabilityRequest
        @return: UpdateServiceObservabilityResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_service_observability_with_options_async(workspace, type, request, headers, runtime)

    def update_site_monitor_with_options(
        self,
        task_id: str,
        request: cms_20240330_models.UpdateSiteMonitorRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateSiteMonitorResponse:
        """
        @summary 更新UpdateSiteMonitor
        
        @param request: UpdateSiteMonitorRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateSiteMonitorResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        body = {}
        if not UtilClient.is_unset(request.address):
            body['address'] = request.address
        if not UtilClient.is_unset(request.custom_schedule):
            body['customSchedule'] = request.custom_schedule
        if not UtilClient.is_unset(request.interval):
            body['interval'] = request.interval
        if not UtilClient.is_unset(request.interval_unit):
            body['intervalUnit'] = request.interval_unit
        if not UtilClient.is_unset(request.isp_cities):
            body['ispCities'] = request.isp_cities
        if not UtilClient.is_unset(request.option):
            body['option'] = request.option
        if not UtilClient.is_unset(request.task_labels):
            body['taskLabels'] = request.task_labels
        if not UtilClient.is_unset(request.task_name):
            body['taskName'] = request.task_name
        if not UtilClient.is_unset(request.update_label):
            body['updateLabel'] = request.update_label
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateSiteMonitor',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/sitemonitor/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateSiteMonitorResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_site_monitor_with_options_async(
        self,
        task_id: str,
        request: cms_20240330_models.UpdateSiteMonitorRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateSiteMonitorResponse:
        """
        @summary 更新UpdateSiteMonitor
        
        @param request: UpdateSiteMonitorRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateSiteMonitorResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        body = {}
        if not UtilClient.is_unset(request.address):
            body['address'] = request.address
        if not UtilClient.is_unset(request.custom_schedule):
            body['customSchedule'] = request.custom_schedule
        if not UtilClient.is_unset(request.interval):
            body['interval'] = request.interval
        if not UtilClient.is_unset(request.interval_unit):
            body['intervalUnit'] = request.interval_unit
        if not UtilClient.is_unset(request.isp_cities):
            body['ispCities'] = request.isp_cities
        if not UtilClient.is_unset(request.option):
            body['option'] = request.option
        if not UtilClient.is_unset(request.task_labels):
            body['taskLabels'] = request.task_labels
        if not UtilClient.is_unset(request.task_name):
            body['taskName'] = request.task_name
        if not UtilClient.is_unset(request.update_label):
            body['updateLabel'] = request.update_label
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateSiteMonitor',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/sitemonitor/{OpenApiUtilClient.get_encode_param(task_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateSiteMonitorResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_site_monitor(
        self,
        task_id: str,
        request: cms_20240330_models.UpdateSiteMonitorRequest,
    ) -> cms_20240330_models.UpdateSiteMonitorResponse:
        """
        @summary 更新UpdateSiteMonitor
        
        @param request: UpdateSiteMonitorRequest
        @return: UpdateSiteMonitorResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_site_monitor_with_options(task_id, request, headers, runtime)

    async def update_site_monitor_async(
        self,
        task_id: str,
        request: cms_20240330_models.UpdateSiteMonitorRequest,
    ) -> cms_20240330_models.UpdateSiteMonitorResponse:
        """
        @summary 更新UpdateSiteMonitor
        
        @param request: UpdateSiteMonitorRequest
        @return: UpdateSiteMonitorResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_site_monitor_with_options_async(task_id, request, headers, runtime)

    def update_subscription_with_options(
        self,
        subscription_id: str,
        request: cms_20240330_models.UpdateSubscriptionRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateSubscriptionResponse:
        """
        @summary 更新一个已存在的订阅配置
        
        @param request: UpdateSubscriptionRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateSubscriptionResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='UpdateSubscription',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/subscriptions/{OpenApiUtilClient.get_encode_param(subscription_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateSubscriptionResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_subscription_with_options_async(
        self,
        subscription_id: str,
        request: cms_20240330_models.UpdateSubscriptionRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateSubscriptionResponse:
        """
        @summary 更新一个已存在的订阅配置
        
        @param request: UpdateSubscriptionRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateSubscriptionResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='UpdateSubscription',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/subscriptions/{OpenApiUtilClient.get_encode_param(subscription_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateSubscriptionResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_subscription(
        self,
        subscription_id: str,
        request: cms_20240330_models.UpdateSubscriptionRequest,
    ) -> cms_20240330_models.UpdateSubscriptionResponse:
        """
        @summary 更新一个已存在的订阅配置
        
        @param request: UpdateSubscriptionRequest
        @return: UpdateSubscriptionResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_subscription_with_options(subscription_id, request, headers, runtime)

    async def update_subscription_async(
        self,
        subscription_id: str,
        request: cms_20240330_models.UpdateSubscriptionRequest,
    ) -> cms_20240330_models.UpdateSubscriptionResponse:
        """
        @summary 更新一个已存在的订阅配置
        
        @param request: UpdateSubscriptionRequest
        @return: UpdateSubscriptionResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_subscription_with_options_async(subscription_id, request, headers, runtime)

    def update_thread_with_options(
        self,
        name: str,
        thread_id: str,
        request: cms_20240330_models.UpdateThreadRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateThreadResponse:
        """
        @summary 更新会话
        
        @param request: UpdateThreadRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateThreadResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.status):
            body['status'] = request.status
        if not UtilClient.is_unset(request.title):
            body['title'] = request.title
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateThread',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/thread/{OpenApiUtilClient.get_encode_param(thread_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateThreadResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_thread_with_options_async(
        self,
        name: str,
        thread_id: str,
        request: cms_20240330_models.UpdateThreadRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateThreadResponse:
        """
        @summary 更新会话
        
        @param request: UpdateThreadRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateThreadResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.status):
            body['status'] = request.status
        if not UtilClient.is_unset(request.title):
            body['title'] = request.title
        req = open_api_models.OpenApiRequest(
            headers=headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateThread',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/digitalEmployee/{OpenApiUtilClient.get_encode_param(name)}/thread/{OpenApiUtilClient.get_encode_param(thread_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateThreadResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_thread(
        self,
        name: str,
        thread_id: str,
        request: cms_20240330_models.UpdateThreadRequest,
    ) -> cms_20240330_models.UpdateThreadResponse:
        """
        @summary 更新会话
        
        @param request: UpdateThreadRequest
        @return: UpdateThreadResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_thread_with_options(name, thread_id, request, headers, runtime)

    async def update_thread_async(
        self,
        name: str,
        thread_id: str,
        request: cms_20240330_models.UpdateThreadRequest,
    ) -> cms_20240330_models.UpdateThreadResponse:
        """
        @summary 更新会话
        
        @param request: UpdateThreadRequest
        @return: UpdateThreadResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_thread_with_options_async(name, thread_id, request, headers, runtime)

    def update_transformer_with_options(
        self,
        transformer_id: str,
        request: cms_20240330_models.UpdateTransformerRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateTransformerResponse:
        """
        @summary 更新转化器
        
        @param request: UpdateTransformerRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateTransformerResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='UpdateTransformer',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/transformers/{OpenApiUtilClient.get_encode_param(transformer_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateTransformerResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_transformer_with_options_async(
        self,
        transformer_id: str,
        request: cms_20240330_models.UpdateTransformerRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateTransformerResponse:
        """
        @summary 更新转化器
        
        @param request: UpdateTransformerRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateTransformerResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(request.body)
        )
        params = open_api_models.Params(
            action='UpdateTransformer',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/transformers/{OpenApiUtilClient.get_encode_param(transformer_id)}',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateTransformerResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_transformer(
        self,
        transformer_id: str,
        request: cms_20240330_models.UpdateTransformerRequest,
    ) -> cms_20240330_models.UpdateTransformerResponse:
        """
        @summary 更新转化器
        
        @param request: UpdateTransformerRequest
        @return: UpdateTransformerResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_transformer_with_options(transformer_id, request, headers, runtime)

    async def update_transformer_async(
        self,
        transformer_id: str,
        request: cms_20240330_models.UpdateTransformerRequest,
    ) -> cms_20240330_models.UpdateTransformerResponse:
        """
        @summary 更新转化器
        
        @param request: UpdateTransformerRequest
        @return: UpdateTransformerResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_transformer_with_options_async(transformer_id, request, headers, runtime)

    def update_transformer_sort_id_with_options(
        self,
        transformer_id: str,
        request: cms_20240330_models.UpdateTransformerSortIdRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateTransformerSortIdResponse:
        """
        @summary 更新转化器
        
        @param request: UpdateTransformerSortIdRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateTransformerSortIdResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.sort_id):
            query['sortId'] = request.sort_id
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='UpdateTransformerSortId',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/transformers/{OpenApiUtilClient.get_encode_param(transformer_id)}/updateSortId',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateTransformerSortIdResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_transformer_sort_id_with_options_async(
        self,
        transformer_id: str,
        request: cms_20240330_models.UpdateTransformerSortIdRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateTransformerSortIdResponse:
        """
        @summary 更新转化器
        
        @param request: UpdateTransformerSortIdRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateTransformerSortIdResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.client_token):
            query['clientToken'] = request.client_token
        if not UtilClient.is_unset(request.sort_id):
            query['sortId'] = request.sort_id
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='UpdateTransformerSortId',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/transformers/{OpenApiUtilClient.get_encode_param(transformer_id)}/updateSortId',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateTransformerSortIdResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_transformer_sort_id(
        self,
        transformer_id: str,
        request: cms_20240330_models.UpdateTransformerSortIdRequest,
    ) -> cms_20240330_models.UpdateTransformerSortIdResponse:
        """
        @summary 更新转化器
        
        @param request: UpdateTransformerSortIdRequest
        @return: UpdateTransformerSortIdResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.update_transformer_sort_id_with_options(transformer_id, request, headers, runtime)

    async def update_transformer_sort_id_async(
        self,
        transformer_id: str,
        request: cms_20240330_models.UpdateTransformerSortIdRequest,
    ) -> cms_20240330_models.UpdateTransformerSortIdResponse:
        """
        @summary 更新转化器
        
        @param request: UpdateTransformerSortIdRequest
        @return: UpdateTransformerSortIdResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.update_transformer_sort_id_with_options_async(transformer_id, request, headers, runtime)

    def update_umodel_with_options(
        self,
        workspace: str,
        request: cms_20240330_models.UpdateUmodelRequest,
        headers: cms_20240330_models.UpdateUmodelHeaders,
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateUmodelResponse:
        """
        @summary Update Umodel configuration information
        
        @description Update Umodel configuration information
        
        @param request: UpdateUmodelRequest
        @param headers: UpdateUmodelHeaders
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateUmodelResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        real_headers = {}
        if not UtilClient.is_unset(headers.common_headers):
            real_headers = headers.common_headers
        if not UtilClient.is_unset(headers.log_version):
            real_headers['logVersion'] = UtilClient.to_jsonstring(headers.log_version)
        req = open_api_models.OpenApiRequest(
            headers=real_headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateUmodel',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/umodel',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateUmodelResponse(),
            self.call_api(params, req, runtime)
        )

    async def update_umodel_with_options_async(
        self,
        workspace: str,
        request: cms_20240330_models.UpdateUmodelRequest,
        headers: cms_20240330_models.UpdateUmodelHeaders,
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpdateUmodelResponse:
        """
        @summary Update Umodel configuration information
        
        @description Update Umodel configuration information
        
        @param request: UpdateUmodelRequest
        @param headers: UpdateUmodelHeaders
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpdateUmodelResponse
        """
        UtilClient.validate_model(request)
        body = {}
        if not UtilClient.is_unset(request.description):
            body['description'] = request.description
        real_headers = {}
        if not UtilClient.is_unset(headers.common_headers):
            real_headers = headers.common_headers
        if not UtilClient.is_unset(headers.log_version):
            real_headers['logVersion'] = UtilClient.to_jsonstring(headers.log_version)
        req = open_api_models.OpenApiRequest(
            headers=real_headers,
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpdateUmodel',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/umodel',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpdateUmodelResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def update_umodel(
        self,
        workspace: str,
        request: cms_20240330_models.UpdateUmodelRequest,
    ) -> cms_20240330_models.UpdateUmodelResponse:
        """
        @summary Update Umodel configuration information
        
        @description Update Umodel configuration information
        
        @param request: UpdateUmodelRequest
        @return: UpdateUmodelResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = cms_20240330_models.UpdateUmodelHeaders()
        return self.update_umodel_with_options(workspace, request, headers, runtime)

    async def update_umodel_async(
        self,
        workspace: str,
        request: cms_20240330_models.UpdateUmodelRequest,
    ) -> cms_20240330_models.UpdateUmodelResponse:
        """
        @summary Update Umodel configuration information
        
        @description Update Umodel configuration information
        
        @param request: UpdateUmodelRequest
        @return: UpdateUmodelResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = cms_20240330_models.UpdateUmodelHeaders()
        return await self.update_umodel_with_options_async(workspace, request, headers, runtime)

    def upsert_umodel_common_schema_ref_with_options(
        self,
        workspace: str,
        request: cms_20240330_models.UpsertUmodelCommonSchemaRefRequest,
        headers: cms_20240330_models.UpsertUmodelCommonSchemaRefHeaders,
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpsertUmodelCommonSchemaRefResponse:
        """
        @summary 更新Umodel配置信息
        
        @param request: UpsertUmodelCommonSchemaRefRequest
        @param headers: UpsertUmodelCommonSchemaRefHeaders
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpsertUmodelCommonSchemaRefResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.group):
            query['group'] = request.group
        if not UtilClient.is_unset(request.version):
            query['version'] = request.version
        real_headers = {}
        if not UtilClient.is_unset(headers.common_headers):
            real_headers = headers.common_headers
        if not UtilClient.is_unset(headers.log_version):
            real_headers['logVersion'] = UtilClient.to_jsonstring(headers.log_version)
        req = open_api_models.OpenApiRequest(
            headers=real_headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='UpsertUmodelCommonSchemaRef',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/umodel/common-schema-ref',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpsertUmodelCommonSchemaRefResponse(),
            self.call_api(params, req, runtime)
        )

    async def upsert_umodel_common_schema_ref_with_options_async(
        self,
        workspace: str,
        request: cms_20240330_models.UpsertUmodelCommonSchemaRefRequest,
        headers: cms_20240330_models.UpsertUmodelCommonSchemaRefHeaders,
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpsertUmodelCommonSchemaRefResponse:
        """
        @summary 更新Umodel配置信息
        
        @param request: UpsertUmodelCommonSchemaRefRequest
        @param headers: UpsertUmodelCommonSchemaRefHeaders
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpsertUmodelCommonSchemaRefResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.group):
            query['group'] = request.group
        if not UtilClient.is_unset(request.version):
            query['version'] = request.version
        real_headers = {}
        if not UtilClient.is_unset(headers.common_headers):
            real_headers = headers.common_headers
        if not UtilClient.is_unset(headers.log_version):
            real_headers['logVersion'] = UtilClient.to_jsonstring(headers.log_version)
        req = open_api_models.OpenApiRequest(
            headers=real_headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='UpsertUmodelCommonSchemaRef',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/umodel/common-schema-ref',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpsertUmodelCommonSchemaRefResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def upsert_umodel_common_schema_ref(
        self,
        workspace: str,
        request: cms_20240330_models.UpsertUmodelCommonSchemaRefRequest,
    ) -> cms_20240330_models.UpsertUmodelCommonSchemaRefResponse:
        """
        @summary 更新Umodel配置信息
        
        @param request: UpsertUmodelCommonSchemaRefRequest
        @return: UpsertUmodelCommonSchemaRefResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = cms_20240330_models.UpsertUmodelCommonSchemaRefHeaders()
        return self.upsert_umodel_common_schema_ref_with_options(workspace, request, headers, runtime)

    async def upsert_umodel_common_schema_ref_async(
        self,
        workspace: str,
        request: cms_20240330_models.UpsertUmodelCommonSchemaRefRequest,
    ) -> cms_20240330_models.UpsertUmodelCommonSchemaRefResponse:
        """
        @summary 更新Umodel配置信息
        
        @param request: UpsertUmodelCommonSchemaRefRequest
        @return: UpsertUmodelCommonSchemaRefResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = cms_20240330_models.UpsertUmodelCommonSchemaRefHeaders()
        return await self.upsert_umodel_common_schema_ref_with_options_async(workspace, request, headers, runtime)

    def upsert_umodel_data_with_options(
        self,
        workspace: str,
        request: cms_20240330_models.UpsertUmodelDataRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpsertUmodelDataResponse:
        """
        @summary Write Umodel Elements
        
        @param request: UpsertUmodelDataRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpsertUmodelDataResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.method):
            query['method'] = request.method
        body = {}
        if not UtilClient.is_unset(request.elements):
            body['elements'] = request.elements
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpsertUmodelData',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/umodel/data',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpsertUmodelDataResponse(),
            self.call_api(params, req, runtime)
        )

    async def upsert_umodel_data_with_options_async(
        self,
        workspace: str,
        request: cms_20240330_models.UpsertUmodelDataRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.UpsertUmodelDataResponse:
        """
        @summary Write Umodel Elements
        
        @param request: UpsertUmodelDataRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: UpsertUmodelDataResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.method):
            query['method'] = request.method
        body = {}
        if not UtilClient.is_unset(request.elements):
            body['elements'] = request.elements
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query),
            body=OpenApiUtilClient.parse_to_map(body)
        )
        params = open_api_models.Params(
            action='UpsertUmodelData',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/workspace/{OpenApiUtilClient.get_encode_param(workspace)}/umodel/data',
            method='PATCH',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.UpsertUmodelDataResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def upsert_umodel_data(
        self,
        workspace: str,
        request: cms_20240330_models.UpsertUmodelDataRequest,
    ) -> cms_20240330_models.UpsertUmodelDataResponse:
        """
        @summary Write Umodel Elements
        
        @param request: UpsertUmodelDataRequest
        @return: UpsertUmodelDataResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.upsert_umodel_data_with_options(workspace, request, headers, runtime)

    async def upsert_umodel_data_async(
        self,
        workspace: str,
        request: cms_20240330_models.UpsertUmodelDataRequest,
    ) -> cms_20240330_models.UpsertUmodelDataResponse:
        """
        @summary Write Umodel Elements
        
        @param request: UpsertUmodelDataRequest
        @return: UpsertUmodelDataResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.upsert_umodel_data_with_options_async(workspace, request, headers, runtime)

    def verify_itsm_operator_with_options(
        self,
        request: cms_20240330_models.VerifyItsmOperatorRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.VerifyItsmOperatorResponse:
        """
        @summary 验证手机号码验证码
        
        @param request: VerifyItsmOperatorRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: VerifyItsmOperatorResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.code):
            query['code'] = request.code
        if not UtilClient.is_unset(request.contact_id):
            query['contactId'] = request.contact_id
        if not UtilClient.is_unset(request.phone):
            query['phone'] = request.phone
        if not UtilClient.is_unset(request.session):
            query['session'] = request.session
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='VerifyItsmOperator',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/auth/verify',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.VerifyItsmOperatorResponse(),
            self.call_api(params, req, runtime)
        )

    async def verify_itsm_operator_with_options_async(
        self,
        request: cms_20240330_models.VerifyItsmOperatorRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.VerifyItsmOperatorResponse:
        """
        @summary 验证手机号码验证码
        
        @param request: VerifyItsmOperatorRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: VerifyItsmOperatorResponse
        """
        UtilClient.validate_model(request)
        query = {}
        if not UtilClient.is_unset(request.code):
            query['code'] = request.code
        if not UtilClient.is_unset(request.contact_id):
            query['contactId'] = request.contact_id
        if not UtilClient.is_unset(request.phone):
            query['phone'] = request.phone
        if not UtilClient.is_unset(request.session):
            query['session'] = request.session
        if not UtilClient.is_unset(request.workspace):
            query['workspace'] = request.workspace
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='VerifyItsmOperator',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/auth/verify',
            method='PUT',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.VerifyItsmOperatorResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def verify_itsm_operator(
        self,
        request: cms_20240330_models.VerifyItsmOperatorRequest,
    ) -> cms_20240330_models.VerifyItsmOperatorResponse:
        """
        @summary 验证手机号码验证码
        
        @param request: VerifyItsmOperatorRequest
        @return: VerifyItsmOperatorResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.verify_itsm_operator_with_options(request, headers, runtime)

    async def verify_itsm_operator_async(
        self,
        request: cms_20240330_models.VerifyItsmOperatorRequest,
    ) -> cms_20240330_models.VerifyItsmOperatorResponse:
        """
        @summary 验证手机号码验证码
        
        @param request: VerifyItsmOperatorRequest
        @return: VerifyItsmOperatorResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.verify_itsm_operator_with_options_async(request, headers, runtime)

    def view_oncall_schedule_with_options(
        self,
        oncall_schedule_id: str,
        tmp_req: cms_20240330_models.ViewOncallScheduleRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ViewOncallScheduleResponse:
        """
        @summary 查看值班日历
        
        @param tmp_req: ViewOncallScheduleRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ViewOncallScheduleResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ViewOncallScheduleShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.un_saved_schedule):
            request.un_saved_schedule_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.un_saved_schedule, 'unSavedSchedule', 'json')
        query = {}
        if not UtilClient.is_unset(request.end_date):
            query['endDate'] = request.end_date
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        if not UtilClient.is_unset(request.start_date):
            query['startDate'] = request.start_date
        if not UtilClient.is_unset(request.un_saved_schedule_shrink):
            query['unSavedSchedule'] = request.un_saved_schedule_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ViewOncallSchedule',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/oncallSchedule/{OpenApiUtilClient.get_encode_param(oncall_schedule_id)}/calendar',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ViewOncallScheduleResponse(),
            self.call_api(params, req, runtime)
        )

    async def view_oncall_schedule_with_options_async(
        self,
        oncall_schedule_id: str,
        tmp_req: cms_20240330_models.ViewOncallScheduleRequest,
        headers: Dict[str, str],
        runtime: util_models.RuntimeOptions,
    ) -> cms_20240330_models.ViewOncallScheduleResponse:
        """
        @summary 查看值班日历
        
        @param tmp_req: ViewOncallScheduleRequest
        @param headers: map
        @param runtime: runtime options for this request RuntimeOptions
        @return: ViewOncallScheduleResponse
        """
        UtilClient.validate_model(tmp_req)
        request = cms_20240330_models.ViewOncallScheduleShrinkRequest()
        OpenApiUtilClient.convert(tmp_req, request)
        if not UtilClient.is_unset(tmp_req.un_saved_schedule):
            request.un_saved_schedule_shrink = OpenApiUtilClient.array_to_string_with_specified_style(tmp_req.un_saved_schedule, 'unSavedSchedule', 'json')
        query = {}
        if not UtilClient.is_unset(request.end_date):
            query['endDate'] = request.end_date
        if not UtilClient.is_unset(request.source):
            query['source'] = request.source
        if not UtilClient.is_unset(request.start_date):
            query['startDate'] = request.start_date
        if not UtilClient.is_unset(request.un_saved_schedule_shrink):
            query['unSavedSchedule'] = request.un_saved_schedule_shrink
        req = open_api_models.OpenApiRequest(
            headers=headers,
            query=OpenApiUtilClient.query(query)
        )
        params = open_api_models.Params(
            action='ViewOncallSchedule',
            version='2024-03-30',
            protocol='HTTPS',
            pathname=f'/oncallSchedule/{OpenApiUtilClient.get_encode_param(oncall_schedule_id)}/calendar',
            method='GET',
            auth_type='AK',
            style='ROA',
            req_body_type='json',
            body_type='json'
        )
        return TeaCore.from_map(
            cms_20240330_models.ViewOncallScheduleResponse(),
            await self.call_api_async(params, req, runtime)
        )

    def view_oncall_schedule(
        self,
        oncall_schedule_id: str,
        request: cms_20240330_models.ViewOncallScheduleRequest,
    ) -> cms_20240330_models.ViewOncallScheduleResponse:
        """
        @summary 查看值班日历
        
        @param request: ViewOncallScheduleRequest
        @return: ViewOncallScheduleResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return self.view_oncall_schedule_with_options(oncall_schedule_id, request, headers, runtime)

    async def view_oncall_schedule_async(
        self,
        oncall_schedule_id: str,
        request: cms_20240330_models.ViewOncallScheduleRequest,
    ) -> cms_20240330_models.ViewOncallScheduleResponse:
        """
        @summary 查看值班日历
        
        @param request: ViewOncallScheduleRequest
        @return: ViewOncallScheduleResponse
        """
        runtime = util_models.RuntimeOptions()
        headers = {}
        return await self.view_oncall_schedule_with_options_async(oncall_schedule_id, request, headers, runtime)
