# -*- coding: utf8 -*-
# Copyright (c) 2017-2025 Tencent. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import warnings

from tencentcloud.common.abstract_model import AbstractModel


class AddModelKeyRequest(AbstractModel):
    r"""AddModelKey请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ServiceProviderId: <p>服务提供商ID</p>
        :type ServiceProviderId: str
        :param _Keys: <p>Key 列表，至少 1 个，最多 10 个</p>
        :type Keys: list of KeyItem
        """
        self._ServiceProviderId = None
        self._Keys = None

    @property
    def ServiceProviderId(self):
        r"""<p>服务提供商ID</p>
        :rtype: str
        """
        return self._ServiceProviderId

    @ServiceProviderId.setter
    def ServiceProviderId(self, ServiceProviderId):
        self._ServiceProviderId = ServiceProviderId

    @property
    def Keys(self):
        r"""<p>Key 列表，至少 1 个，最多 10 个</p>
        :rtype: list of KeyItem
        """
        return self._Keys

    @Keys.setter
    def Keys(self, Keys):
        self._Keys = Keys


    def _deserialize(self, params):
        self._ServiceProviderId = params.get("ServiceProviderId")
        if params.get("Keys") is not None:
            self._Keys = []
            for item in params.get("Keys"):
                obj = KeyItem()
                obj._deserialize(item)
                self._Keys.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class AddModelKeyResponse(AbstractModel):
    r"""AddModelKey返回参数结构体

    """

    def __init__(self):
        r"""
        :param _KeyIds: <p>生成的 Key ID 列表</p>
        :type KeyIds: list of str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._KeyIds = None
        self._RequestId = None

    @property
    def KeyIds(self):
        r"""<p>生成的 Key ID 列表</p>
        :rtype: list of str
        """
        return self._KeyIds

    @KeyIds.setter
    def KeyIds(self, KeyIds):
        self._KeyIds = KeyIds

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._KeyIds = params.get("KeyIds")
        self._RequestId = params.get("RequestId")


class AddModelRewriteRequest(AbstractModel):
    r"""AddModelRewrite请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例 ID。</p>
        :type ModelRouterId: str
        :param _SourceModel: <p>源模型名（重写规则的 key）。</p><p>长度 1-255 字符；支持特殊值 <code>default</code> 表示兜底规则（命中所有未显式列出的源模型）。</p><p>不允许使用 <code>IntentRouter/</code> 前缀（大小写不敏感），即 IntentRouter 不能作为 source。</p>
        :type SourceModel: str
        :param _TargetModel: <p>目标模型名（重写规则的 value）。</p><p>长度 1-255 字符；必须是已关联到该模型路由实例的模型（含 IntentRouter/* 也需先通过 AssociateModels 关联）。</p><p>不允许使用 <code>default</code>；不允许与 SourceModel 相同（大小写不敏感）。</p>
        :type TargetModel: str
        """
        self._ModelRouterId = None
        self._SourceModel = None
        self._TargetModel = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例 ID。</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def SourceModel(self):
        r"""<p>源模型名（重写规则的 key）。</p><p>长度 1-255 字符；支持特殊值 <code>default</code> 表示兜底规则（命中所有未显式列出的源模型）。</p><p>不允许使用 <code>IntentRouter/</code> 前缀（大小写不敏感），即 IntentRouter 不能作为 source。</p>
        :rtype: str
        """
        return self._SourceModel

    @SourceModel.setter
    def SourceModel(self, SourceModel):
        self._SourceModel = SourceModel

    @property
    def TargetModel(self):
        r"""<p>目标模型名（重写规则的 value）。</p><p>长度 1-255 字符；必须是已关联到该模型路由实例的模型（含 IntentRouter/* 也需先通过 AssociateModels 关联）。</p><p>不允许使用 <code>default</code>；不允许与 SourceModel 相同（大小写不敏感）。</p>
        :rtype: str
        """
        return self._TargetModel

    @TargetModel.setter
    def TargetModel(self, TargetModel):
        self._TargetModel = TargetModel


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._SourceModel = params.get("SourceModel")
        self._TargetModel = params.get("TargetModel")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class AddModelRewriteResponse(AbstractModel):
    r"""AddModelRewrite返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class AssociateBudgetRequest(AbstractModel):
    r"""AssociateBudget请求参数结构体

    """

    def __init__(self):
        r"""
        :param _BudgetId: <p>Budget ID。</p>
        :type BudgetId: str
        :param _Resources: <p>要关联的资源列表。</p><p>仅支持企业型模型路由实例和企业型实例下的Key。同一请求内不允许重复资源；资源已关联其他Budget时将替换为新的Budget。</p>
        :type Resources: list of BudgetResource
        """
        self._BudgetId = None
        self._Resources = None

    @property
    def BudgetId(self):
        r"""<p>Budget ID。</p>
        :rtype: str
        """
        return self._BudgetId

    @BudgetId.setter
    def BudgetId(self, BudgetId):
        self._BudgetId = BudgetId

    @property
    def Resources(self):
        r"""<p>要关联的资源列表。</p><p>仅支持企业型模型路由实例和企业型实例下的Key。同一请求内不允许重复资源；资源已关联其他Budget时将替换为新的Budget。</p>
        :rtype: list of BudgetResource
        """
        return self._Resources

    @Resources.setter
    def Resources(self, Resources):
        self._Resources = Resources


    def _deserialize(self, params):
        self._BudgetId = params.get("BudgetId")
        if params.get("Resources") is not None:
            self._Resources = []
            for item in params.get("Resources"):
                obj = BudgetResource()
                obj._deserialize(item)
                self._Resources.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class AssociateBudgetResponse(AbstractModel):
    r"""AssociateBudget返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class AssociateCustomizedConfigRequest(AbstractModel):
    r"""AssociateCustomizedConfig请求参数结构体

    """

    def __init__(self):
        r"""
        :param _UconfigId: 配置ID
        :type UconfigId: str
        :param _BindList: 关联的server或location
        :type BindList: list of BindItem
        """
        self._UconfigId = None
        self._BindList = None

    @property
    def UconfigId(self):
        r"""配置ID
        :rtype: str
        """
        return self._UconfigId

    @UconfigId.setter
    def UconfigId(self, UconfigId):
        self._UconfigId = UconfigId

    @property
    def BindList(self):
        r"""关联的server或location
        :rtype: list of BindItem
        """
        return self._BindList

    @BindList.setter
    def BindList(self, BindList):
        self._BindList = BindList


    def _deserialize(self, params):
        self._UconfigId = params.get("UconfigId")
        if params.get("BindList") is not None:
            self._BindList = []
            for item in params.get("BindList"):
                obj = BindItem()
                obj._deserialize(item)
                self._BindList.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class AssociateCustomizedConfigResponse(AbstractModel):
    r"""AssociateCustomizedConfig返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class AssociateGuardrailConfig(AbstractModel):
    r"""模型路由待关联 Guardrail 防护配置

    """

    def __init__(self):
        r"""
        :param _Type: <p>Guardrail 防护类型。</p><p>枚举值：</p><ul><li>WAF：使用腾讯云 WAF LLM SDK 接入配置对模型路由请求进行安全防护。</li></ul><p>当前仅支持 WAF；不传时默认为 WAF。</p>
        :type Type: str
        :param _InstanceId: <p>关联的腾讯云 WAF 实例 ID。</p><p>当 Type 为 WAF 时必填。接口会校验该 WAF 实例存在且属于当前账号。</p>
        :type InstanceId: str
        :param _ServiceId: <p>WAF LLM SDK 接入服务 ID。</p><p>该字段对应 WAF LLM SDK 接入配置中的服务标识，用于指定模型路由请求要绑定的 WAF 防护配置。当 Type 为 WAF 时必填。接口会校验该服务配置存在于指定的 WAF 实例下。</p>
        :type ServiceId: str
        :param _InputCheckDepth: <p>最大检测对话轮数。</p><p>当 Type 为 WAF 时选填；未传时默认取值为 5。若传入，取值必须为正整数。</p>
        :type InputCheckDepth: int
        """
        self._Type = None
        self._InstanceId = None
        self._ServiceId = None
        self._InputCheckDepth = None

    @property
    def Type(self):
        r"""<p>Guardrail 防护类型。</p><p>枚举值：</p><ul><li>WAF：使用腾讯云 WAF LLM SDK 接入配置对模型路由请求进行安全防护。</li></ul><p>当前仅支持 WAF；不传时默认为 WAF。</p>
        :rtype: str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type

    @property
    def InstanceId(self):
        r"""<p>关联的腾讯云 WAF 实例 ID。</p><p>当 Type 为 WAF 时必填。接口会校验该 WAF 实例存在且属于当前账号。</p>
        :rtype: str
        """
        return self._InstanceId

    @InstanceId.setter
    def InstanceId(self, InstanceId):
        self._InstanceId = InstanceId

    @property
    def ServiceId(self):
        r"""<p>WAF LLM SDK 接入服务 ID。</p><p>该字段对应 WAF LLM SDK 接入配置中的服务标识，用于指定模型路由请求要绑定的 WAF 防护配置。当 Type 为 WAF 时必填。接口会校验该服务配置存在于指定的 WAF 实例下。</p>
        :rtype: str
        """
        return self._ServiceId

    @ServiceId.setter
    def ServiceId(self, ServiceId):
        self._ServiceId = ServiceId

    @property
    def InputCheckDepth(self):
        r"""<p>最大检测对话轮数。</p><p>当 Type 为 WAF 时选填；未传时默认取值为 5。若传入，取值必须为正整数。</p>
        :rtype: int
        """
        return self._InputCheckDepth

    @InputCheckDepth.setter
    def InputCheckDepth(self, InputCheckDepth):
        self._InputCheckDepth = InputCheckDepth


    def _deserialize(self, params):
        self._Type = params.get("Type")
        self._InstanceId = params.get("InstanceId")
        self._ServiceId = params.get("ServiceId")
        self._InputCheckDepth = params.get("InputCheckDepth")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class AssociateModelRouterGuardrailsRequest(AbstractModel):
    r"""AssociateModelRouterGuardrails请求参数结构体

    """

    def __init__(self):
        r"""
        :param _Guardrails: <p>待关联的 Guardrail 防护配置列表。</p><p>当前最多支持 1 个元素。每个元素必须填写 InstanceId、ServiceId；Type 和 InputCheckDepth 为选填，不传时分别使用默认值 WAF 和 5。本结构不包含 GuardrailId，关联成功后由系统生成。</p>
        :type Guardrails: list of AssociateGuardrailConfig
        :param _ModelRouterId: <p>模型路由实例 ID。</p>
        :type ModelRouterId: str
        """
        self._Guardrails = None
        self._ModelRouterId = None

    @property
    def Guardrails(self):
        r"""<p>待关联的 Guardrail 防护配置列表。</p><p>当前最多支持 1 个元素。每个元素必须填写 InstanceId、ServiceId；Type 和 InputCheckDepth 为选填，不传时分别使用默认值 WAF 和 5。本结构不包含 GuardrailId，关联成功后由系统生成。</p>
        :rtype: list of AssociateGuardrailConfig
        """
        return self._Guardrails

    @Guardrails.setter
    def Guardrails(self, Guardrails):
        self._Guardrails = Guardrails

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例 ID。</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId


    def _deserialize(self, params):
        if params.get("Guardrails") is not None:
            self._Guardrails = []
            for item in params.get("Guardrails"):
                obj = AssociateGuardrailConfig()
                obj._deserialize(item)
                self._Guardrails.append(obj)
        self._ModelRouterId = params.get("ModelRouterId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class AssociateModelRouterGuardrailsResponse(AbstractModel):
    r"""AssociateModelRouterGuardrails返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class AssociateModelsToModelRouterRequest(AbstractModel):
    r"""AssociateModelsToModelRouter请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID</p>
        :type ModelRouterId: str
        :param _Models: <p>需要关联的模型信息</p>
        :type Models: list of ModelRouterModel
        """
        self._ModelRouterId = None
        self._Models = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def Models(self):
        r"""<p>需要关联的模型信息</p>
        :rtype: list of ModelRouterModel
        """
        return self._Models

    @Models.setter
    def Models(self, Models):
        self._Models = Models


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        if params.get("Models") is not None:
            self._Models = []
            for item in params.get("Models"):
                obj = ModelRouterModel()
                obj._deserialize(item)
                self._Models.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class AssociateModelsToModelRouterResponse(AbstractModel):
    r"""AssociateModelsToModelRouter返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class AssociateTargetGroupsRequest(AbstractModel):
    r"""AssociateTargetGroups请求参数结构体

    """

    def __init__(self):
        r"""
        :param _Associations: 绑定的关系数组，目标组类型需要一致。
一次请求最多支持20个。

        :type Associations: list of TargetGroupAssociation
        """
        self._Associations = None

    @property
    def Associations(self):
        r"""绑定的关系数组，目标组类型需要一致。
一次请求最多支持20个。

        :rtype: list of TargetGroupAssociation
        """
        return self._Associations

    @Associations.setter
    def Associations(self, Associations):
        self._Associations = Associations


    def _deserialize(self, params):
        if params.get("Associations") is not None:
            self._Associations = []
            for item in params.get("Associations"):
                obj = TargetGroupAssociation()
                obj._deserialize(item)
                self._Associations.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class AssociateTargetGroupsResponse(AbstractModel):
    r"""AssociateTargetGroups返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class AssociatedModelRouterItem(AbstractModel):
    r"""关联的模型路由实例

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID</p>
        :type ModelRouterId: str
        """
        self._ModelRouterId = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class AssociationItem(AbstractModel):
    r"""目标组关联到的规则

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 关联到的负载均衡ID
        :type LoadBalancerId: str
        :param _ListenerId: 关联到的监听器ID
        :type ListenerId: str
        :param _LocationId: 关联到的转发规则ID
注意：此字段可能返回 null，表示取不到有效值。
        :type LocationId: str
        :param _Protocol: 关联到的监听器协议类型，如HTTP,TCP,
        :type Protocol: str
        :param _Port: 关联到的监听器端口
        :type Port: int
        :param _Domain: 关联到的转发规则域名
注意：此字段可能返回 null，表示取不到有效值。
        :type Domain: str
        :param _Url: 关联到的转发规则URL
注意：此字段可能返回 null，表示取不到有效值。
        :type Url: str
        :param _LoadBalancerName: 负载均衡名称
        :type LoadBalancerName: str
        :param _ListenerName: 监听器名称
        :type ListenerName: str
        :param _Weight: 关联目标组的权重， 该参数只有v2新版目标组生效。
        :type Weight: int
        :param _RuleId: 高级路由规则ID
        :type RuleId: str
        """
        self._LoadBalancerId = None
        self._ListenerId = None
        self._LocationId = None
        self._Protocol = None
        self._Port = None
        self._Domain = None
        self._Url = None
        self._LoadBalancerName = None
        self._ListenerName = None
        self._Weight = None
        self._RuleId = None

    @property
    def LoadBalancerId(self):
        r"""关联到的负载均衡ID
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerId(self):
        r"""关联到的监听器ID
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def LocationId(self):
        r"""关联到的转发规则ID
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._LocationId

    @LocationId.setter
    def LocationId(self, LocationId):
        self._LocationId = LocationId

    @property
    def Protocol(self):
        r"""关联到的监听器协议类型，如HTTP,TCP,
        :rtype: str
        """
        return self._Protocol

    @Protocol.setter
    def Protocol(self, Protocol):
        self._Protocol = Protocol

    @property
    def Port(self):
        r"""关联到的监听器端口
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def Domain(self):
        r"""关联到的转发规则域名
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def Url(self):
        r"""关联到的转发规则URL
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Url

    @Url.setter
    def Url(self, Url):
        self._Url = Url

    @property
    def LoadBalancerName(self):
        r"""负载均衡名称
        :rtype: str
        """
        return self._LoadBalancerName

    @LoadBalancerName.setter
    def LoadBalancerName(self, LoadBalancerName):
        self._LoadBalancerName = LoadBalancerName

    @property
    def ListenerName(self):
        r"""监听器名称
        :rtype: str
        """
        return self._ListenerName

    @ListenerName.setter
    def ListenerName(self, ListenerName):
        self._ListenerName = ListenerName

    @property
    def Weight(self):
        r"""关联目标组的权重， 该参数只有v2新版目标组生效。
        :rtype: int
        """
        return self._Weight

    @Weight.setter
    def Weight(self, Weight):
        self._Weight = Weight

    @property
    def RuleId(self):
        r"""高级路由规则ID
        :rtype: str
        """
        return self._RuleId

    @RuleId.setter
    def RuleId(self, RuleId):
        self._RuleId = RuleId


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerId = params.get("ListenerId")
        self._LocationId = params.get("LocationId")
        self._Protocol = params.get("Protocol")
        self._Port = params.get("Port")
        self._Domain = params.get("Domain")
        self._Url = params.get("Url")
        self._LoadBalancerName = params.get("LoadBalancerName")
        self._ListenerName = params.get("ListenerName")
        self._Weight = params.get("Weight")
        self._RuleId = params.get("RuleId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class AutoRewriteRequest(AbstractModel):
    r"""AutoRewrite请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例ID。
        :type LoadBalancerId: str
        :param _ListenerId: HTTPS:443监听器的ID。
        :type ListenerId: str
        :param _Domains: HTTPS:443监听器下需要重定向的域名，若不填，则对HTTPS:443监听器下的所有域名都设置重定向。
        :type Domains: list of str
        :param _RewriteCodes: 重定向状态码，可取值301,302,307。
        :type RewriteCodes: list of int
        :param _TakeUrls: 重定向是否携带匹配的URL。
        :type TakeUrls: list of bool
        """
        self._LoadBalancerId = None
        self._ListenerId = None
        self._Domains = None
        self._RewriteCodes = None
        self._TakeUrls = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerId(self):
        r"""HTTPS:443监听器的ID。
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def Domains(self):
        r"""HTTPS:443监听器下需要重定向的域名，若不填，则对HTTPS:443监听器下的所有域名都设置重定向。
        :rtype: list of str
        """
        return self._Domains

    @Domains.setter
    def Domains(self, Domains):
        self._Domains = Domains

    @property
    def RewriteCodes(self):
        r"""重定向状态码，可取值301,302,307。
        :rtype: list of int
        """
        return self._RewriteCodes

    @RewriteCodes.setter
    def RewriteCodes(self, RewriteCodes):
        self._RewriteCodes = RewriteCodes

    @property
    def TakeUrls(self):
        r"""重定向是否携带匹配的URL。
        :rtype: list of bool
        """
        return self._TakeUrls

    @TakeUrls.setter
    def TakeUrls(self, TakeUrls):
        self._TakeUrls = TakeUrls


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerId = params.get("ListenerId")
        self._Domains = params.get("Domains")
        self._RewriteCodes = params.get("RewriteCodes")
        self._TakeUrls = params.get("TakeUrls")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class AutoRewriteResponse(AbstractModel):
    r"""AutoRewrite返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class AvailableZoneAffinityInfo(AbstractModel):
    r"""可用区转发亲和信息

    """

    def __init__(self):
        r"""
        :param _Enable: 是否开启可用区转发亲和。true：开启可用区转发亲和；false：开启可用区转发亲和。
        :type Enable: bool
        :param _ExitRatio: 可用区转发亲和失效阈值，当可用区内后端服务健康比例小于该阈值时，负载均衡会退出可用区转发亲和，转为全可用区转发。
注意：此字段可能返回 null，表示取不到有效值。
        :type ExitRatio: int
        :param _ReentryRatio: 可用区转发亲和的重新生效阈值，当处于全可用区转发，且负载均衡可用区内的后端服务健康比例大于等于该阈值时，负载均衡会重新进入可用区转发亲和。
注意：此字段可能返回 null，表示取不到有效值。
        :type ReentryRatio: int
        """
        self._Enable = None
        self._ExitRatio = None
        self._ReentryRatio = None

    @property
    def Enable(self):
        r"""是否开启可用区转发亲和。true：开启可用区转发亲和；false：开启可用区转发亲和。
        :rtype: bool
        """
        return self._Enable

    @Enable.setter
    def Enable(self, Enable):
        self._Enable = Enable

    @property
    def ExitRatio(self):
        r"""可用区转发亲和失效阈值，当可用区内后端服务健康比例小于该阈值时，负载均衡会退出可用区转发亲和，转为全可用区转发。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._ExitRatio

    @ExitRatio.setter
    def ExitRatio(self, ExitRatio):
        self._ExitRatio = ExitRatio

    @property
    def ReentryRatio(self):
        r"""可用区转发亲和的重新生效阈值，当处于全可用区转发，且负载均衡可用区内的后端服务健康比例大于等于该阈值时，负载均衡会重新进入可用区转发亲和。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._ReentryRatio

    @ReentryRatio.setter
    def ReentryRatio(self, ReentryRatio):
        self._ReentryRatio = ReentryRatio


    def _deserialize(self, params):
        self._Enable = params.get("Enable")
        self._ExitRatio = params.get("ExitRatio")
        self._ReentryRatio = params.get("ReentryRatio")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class Backend(AbstractModel):
    r"""监听器绑定的后端服务的详细信息

    """

    def __init__(self):
        r"""
        :param _Type: 后端服务的类型，可取：CVM、ENI、CCN、EVM、GLOBALROUTE、NAT、SRV等
        :type Type: str
        :param _InstanceId: 后端服务的唯一 ID，如 ins-abcd1234
        :type InstanceId: str
        :param _Port: 后端服务的监听端口，如果是全端口段监听器绑定的全监听目标组场景，此端口返回0，表示无效端口，绑定的后端服务的端口随监听器端口。
        :type Port: int
        :param _Weight: 后端服务的转发权重，取值范围：[0, 100]，默认为 10。
        :type Weight: int
        :param _PublicIpAddresses: 后端服务的外网 IP
注意：此字段可能返回 null，表示取不到有效值。
        :type PublicIpAddresses: list of str
        :param _PrivateIpAddresses: 后端服务的内网 IP
        :type PrivateIpAddresses: list of str
        :param _InstanceName: 后端服务的实例名称
注意：此字段可能返回 null，表示取不到有效值。
        :type InstanceName: str
        :param _RegisteredTime: 后端服务被绑定的时间
        :type RegisteredTime: str
        :param _EniId: 弹性网卡唯一ID，如 eni-1234abcd
注意：此字段可能返回 null，表示取不到有效值。
        :type EniId: str
        :param _Tag: 标签。
        :type Tag: str
        :param _Zone: 后端服务所在的可用区，如ap-guangzhou-1
注意：此字段可能返回 null，表示取不到有效值。
        :type Zone: str
        """
        self._Type = None
        self._InstanceId = None
        self._Port = None
        self._Weight = None
        self._PublicIpAddresses = None
        self._PrivateIpAddresses = None
        self._InstanceName = None
        self._RegisteredTime = None
        self._EniId = None
        self._Tag = None
        self._Zone = None

    @property
    def Type(self):
        r"""后端服务的类型，可取：CVM、ENI、CCN、EVM、GLOBALROUTE、NAT、SRV等
        :rtype: str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type

    @property
    def InstanceId(self):
        r"""后端服务的唯一 ID，如 ins-abcd1234
        :rtype: str
        """
        return self._InstanceId

    @InstanceId.setter
    def InstanceId(self, InstanceId):
        self._InstanceId = InstanceId

    @property
    def Port(self):
        r"""后端服务的监听端口，如果是全端口段监听器绑定的全监听目标组场景，此端口返回0，表示无效端口，绑定的后端服务的端口随监听器端口。
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def Weight(self):
        r"""后端服务的转发权重，取值范围：[0, 100]，默认为 10。
        :rtype: int
        """
        return self._Weight

    @Weight.setter
    def Weight(self, Weight):
        self._Weight = Weight

    @property
    def PublicIpAddresses(self):
        r"""后端服务的外网 IP
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: list of str
        """
        return self._PublicIpAddresses

    @PublicIpAddresses.setter
    def PublicIpAddresses(self, PublicIpAddresses):
        self._PublicIpAddresses = PublicIpAddresses

    @property
    def PrivateIpAddresses(self):
        r"""后端服务的内网 IP
        :rtype: list of str
        """
        return self._PrivateIpAddresses

    @PrivateIpAddresses.setter
    def PrivateIpAddresses(self, PrivateIpAddresses):
        self._PrivateIpAddresses = PrivateIpAddresses

    @property
    def InstanceName(self):
        r"""后端服务的实例名称
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._InstanceName

    @InstanceName.setter
    def InstanceName(self, InstanceName):
        self._InstanceName = InstanceName

    @property
    def RegisteredTime(self):
        r"""后端服务被绑定的时间
        :rtype: str
        """
        return self._RegisteredTime

    @RegisteredTime.setter
    def RegisteredTime(self, RegisteredTime):
        self._RegisteredTime = RegisteredTime

    @property
    def EniId(self):
        r"""弹性网卡唯一ID，如 eni-1234abcd
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._EniId

    @EniId.setter
    def EniId(self, EniId):
        self._EniId = EniId

    @property
    def Tag(self):
        r"""标签。
        :rtype: str
        """
        return self._Tag

    @Tag.setter
    def Tag(self, Tag):
        self._Tag = Tag

    @property
    def Zone(self):
        r"""后端服务所在的可用区，如ap-guangzhou-1
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Zone

    @Zone.setter
    def Zone(self, Zone):
        self._Zone = Zone


    def _deserialize(self, params):
        self._Type = params.get("Type")
        self._InstanceId = params.get("InstanceId")
        self._Port = params.get("Port")
        self._Weight = params.get("Weight")
        self._PublicIpAddresses = params.get("PublicIpAddresses")
        self._PrivateIpAddresses = params.get("PrivateIpAddresses")
        self._InstanceName = params.get("InstanceName")
        self._RegisteredTime = params.get("RegisteredTime")
        self._EniId = params.get("EniId")
        self._Tag = params.get("Tag")
        self._Zone = params.get("Zone")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class BasicTargetGroupInfo(AbstractModel):
    r"""监听器或者转发规则绑定的目标组基本信息

    """

    def __init__(self):
        r"""
        :param _TargetGroupId: 目标组ID
        :type TargetGroupId: str
        :param _TargetGroupName: 目标组名称
        :type TargetGroupName: str
        :param _Weight: 目标组权重
        :type Weight: int
        """
        self._TargetGroupId = None
        self._TargetGroupName = None
        self._Weight = None

    @property
    def TargetGroupId(self):
        r"""目标组ID
        :rtype: str
        """
        return self._TargetGroupId

    @TargetGroupId.setter
    def TargetGroupId(self, TargetGroupId):
        self._TargetGroupId = TargetGroupId

    @property
    def TargetGroupName(self):
        r"""目标组名称
        :rtype: str
        """
        return self._TargetGroupName

    @TargetGroupName.setter
    def TargetGroupName(self, TargetGroupName):
        self._TargetGroupName = TargetGroupName

    @property
    def Weight(self):
        r"""目标组权重
        :rtype: int
        """
        return self._Weight

    @Weight.setter
    def Weight(self, Weight):
        self._Weight = Weight


    def _deserialize(self, params):
        self._TargetGroupId = params.get("TargetGroupId")
        self._TargetGroupName = params.get("TargetGroupName")
        self._Weight = params.get("Weight")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class BatchDeregisterTargetsRequest(AbstractModel):
    r"""BatchDeregisterTargets请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡ID。
        :type LoadBalancerId: str
        :param _Targets: 解绑目标。
        :type Targets: list of BatchTarget
        """
        self._LoadBalancerId = None
        self._Targets = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def Targets(self):
        r"""解绑目标。
        :rtype: list of BatchTarget
        """
        return self._Targets

    @Targets.setter
    def Targets(self, Targets):
        self._Targets = Targets


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        if params.get("Targets") is not None:
            self._Targets = []
            for item in params.get("Targets"):
                obj = BatchTarget()
                obj._deserialize(item)
                self._Targets.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class BatchDeregisterTargetsResponse(AbstractModel):
    r"""BatchDeregisterTargets返回参数结构体

    """

    def __init__(self):
        r"""
        :param _FailListenerIdSet: 解绑失败的监听器ID。
        :type FailListenerIdSet: list of str
        :param _Message: 解绑失败错误原因信息。
        :type Message: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._FailListenerIdSet = None
        self._Message = None
        self._RequestId = None

    @property
    def FailListenerIdSet(self):
        r"""解绑失败的监听器ID。
        :rtype: list of str
        """
        return self._FailListenerIdSet

    @FailListenerIdSet.setter
    def FailListenerIdSet(self, FailListenerIdSet):
        self._FailListenerIdSet = FailListenerIdSet

    @property
    def Message(self):
        r"""解绑失败错误原因信息。
        :rtype: str
        """
        return self._Message

    @Message.setter
    def Message(self, Message):
        self._Message = Message

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._FailListenerIdSet = params.get("FailListenerIdSet")
        self._Message = params.get("Message")
        self._RequestId = params.get("RequestId")


class BatchModifyTargetTagRequest(AbstractModel):
    r"""BatchModifyTargetTag请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例 ID。
        :type LoadBalancerId: str
        :param _ModifyList: 要批量修改标签的列表。
        :type ModifyList: list of RsTagRule
        """
        self._LoadBalancerId = None
        self._ModifyList = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例 ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ModifyList(self):
        r"""要批量修改标签的列表。
        :rtype: list of RsTagRule
        """
        return self._ModifyList

    @ModifyList.setter
    def ModifyList(self, ModifyList):
        self._ModifyList = ModifyList


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        if params.get("ModifyList") is not None:
            self._ModifyList = []
            for item in params.get("ModifyList"):
                obj = RsTagRule()
                obj._deserialize(item)
                self._ModifyList.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class BatchModifyTargetTagResponse(AbstractModel):
    r"""BatchModifyTargetTag返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class BatchModifyTargetWeightRequest(AbstractModel):
    r"""BatchModifyTargetWeight请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: <p>负载均衡实例 ID。</p>
        :type LoadBalancerId: str
        :param _ModifyList: <p>要批量修改权重的列表。ModifyList数组最多100个元素，ModifyList[i].Targets最多50个，全部Targets累加不超过500。</p>
        :type ModifyList: list of RsWeightRule
        """
        self._LoadBalancerId = None
        self._ModifyList = None

    @property
    def LoadBalancerId(self):
        r"""<p>负载均衡实例 ID。</p>
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ModifyList(self):
        r"""<p>要批量修改权重的列表。ModifyList数组最多100个元素，ModifyList[i].Targets最多50个，全部Targets累加不超过500。</p>
        :rtype: list of RsWeightRule
        """
        return self._ModifyList

    @ModifyList.setter
    def ModifyList(self, ModifyList):
        self._ModifyList = ModifyList


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        if params.get("ModifyList") is not None:
            self._ModifyList = []
            for item in params.get("ModifyList"):
                obj = RsWeightRule()
                obj._deserialize(item)
                self._ModifyList.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class BatchModifyTargetWeightResponse(AbstractModel):
    r"""BatchModifyTargetWeight返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class BatchRegisterTargetsRequest(AbstractModel):
    r"""BatchRegisterTargets请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡ID。
        :type LoadBalancerId: str
        :param _Targets: 绑定目标。
        :type Targets: list of BatchTarget
        """
        self._LoadBalancerId = None
        self._Targets = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def Targets(self):
        r"""绑定目标。
        :rtype: list of BatchTarget
        """
        return self._Targets

    @Targets.setter
    def Targets(self, Targets):
        self._Targets = Targets


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        if params.get("Targets") is not None:
            self._Targets = []
            for item in params.get("Targets"):
                obj = BatchTarget()
                obj._deserialize(item)
                self._Targets.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class BatchRegisterTargetsResponse(AbstractModel):
    r"""BatchRegisterTargets返回参数结构体

    """

    def __init__(self):
        r"""
        :param _FailListenerIdSet: 绑定失败的监听器ID，如为空表示全部绑定成功。
        :type FailListenerIdSet: list of str
        :param _Message: 绑定失败错误原因信息。
        :type Message: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._FailListenerIdSet = None
        self._Message = None
        self._RequestId = None

    @property
    def FailListenerIdSet(self):
        r"""绑定失败的监听器ID，如为空表示全部绑定成功。
        :rtype: list of str
        """
        return self._FailListenerIdSet

    @FailListenerIdSet.setter
    def FailListenerIdSet(self, FailListenerIdSet):
        self._FailListenerIdSet = FailListenerIdSet

    @property
    def Message(self):
        r"""绑定失败错误原因信息。
        :rtype: str
        """
        return self._Message

    @Message.setter
    def Message(self, Message):
        self._Message = Message

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._FailListenerIdSet = params.get("FailListenerIdSet")
        self._Message = params.get("Message")
        self._RequestId = params.get("RequestId")


class BatchTarget(AbstractModel):
    r"""批量绑定类型

    """

    def __init__(self):
        r"""
        :param _ListenerId: <p>监听器 ID。</p>
        :type ListenerId: str
        :param _Port: <p>绑定端口。</p>
        :type Port: int
        :param _InstanceId: <p>子机 ID。表示绑定主网卡主 IP。</p>
        :type InstanceId: str
        :param _EniIp: <p>绑定 IP 时需要传入此参数，支持弹性网卡的 IP 和其他内网 IP，如果是弹性网卡则必须先绑定至CVM，然后才能绑定到负载均衡实例。注意：参数 InstanceId、EniIp 只能传入一个且必须传入一个。如果绑定双栈IPV6子机，必须传该参数。如果是跨地域绑定，则必须传该参数，不支持传InstanceId参数。</p>
        :type EniIp: str
        :param _Weight: <p>子机权重，范围[0, 100]。绑定时如果不存在，则默认为10。</p>
        :type Weight: int
        :param _LocationId: <p>七层规则 ID。7层负载均衡该参数必填</p>
        :type LocationId: str
        :param _Tag: <p>标签。</p>
        :type Tag: str
        """
        self._ListenerId = None
        self._Port = None
        self._InstanceId = None
        self._EniIp = None
        self._Weight = None
        self._LocationId = None
        self._Tag = None

    @property
    def ListenerId(self):
        r"""<p>监听器 ID。</p>
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def Port(self):
        r"""<p>绑定端口。</p>
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def InstanceId(self):
        r"""<p>子机 ID。表示绑定主网卡主 IP。</p>
        :rtype: str
        """
        return self._InstanceId

    @InstanceId.setter
    def InstanceId(self, InstanceId):
        self._InstanceId = InstanceId

    @property
    def EniIp(self):
        r"""<p>绑定 IP 时需要传入此参数，支持弹性网卡的 IP 和其他内网 IP，如果是弹性网卡则必须先绑定至CVM，然后才能绑定到负载均衡实例。注意：参数 InstanceId、EniIp 只能传入一个且必须传入一个。如果绑定双栈IPV6子机，必须传该参数。如果是跨地域绑定，则必须传该参数，不支持传InstanceId参数。</p>
        :rtype: str
        """
        return self._EniIp

    @EniIp.setter
    def EniIp(self, EniIp):
        self._EniIp = EniIp

    @property
    def Weight(self):
        r"""<p>子机权重，范围[0, 100]。绑定时如果不存在，则默认为10。</p>
        :rtype: int
        """
        return self._Weight

    @Weight.setter
    def Weight(self, Weight):
        self._Weight = Weight

    @property
    def LocationId(self):
        r"""<p>七层规则 ID。7层负载均衡该参数必填</p>
        :rtype: str
        """
        return self._LocationId

    @LocationId.setter
    def LocationId(self, LocationId):
        self._LocationId = LocationId

    @property
    def Tag(self):
        r"""<p>标签。</p>
        :rtype: str
        """
        return self._Tag

    @Tag.setter
    def Tag(self, Tag):
        self._Tag = Tag


    def _deserialize(self, params):
        self._ListenerId = params.get("ListenerId")
        self._Port = params.get("Port")
        self._InstanceId = params.get("InstanceId")
        self._EniIp = params.get("EniIp")
        self._Weight = params.get("Weight")
        self._LocationId = params.get("LocationId")
        self._Tag = params.get("Tag")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class BindDetailItem(AbstractModel):
    r"""绑定关系，包含监听器名字、协议、url、vport。

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 配置绑定的CLB ID
        :type LoadBalancerId: str
        :param _ListenerId: 配置绑定的监听器ID
        :type ListenerId: str
        :param _Domain: 配置绑定的域名
        :type Domain: str
        :param _LocationId: 配置绑定的规则
        :type LocationId: str
        :param _ListenerName: 监听器名字
        :type ListenerName: str
        :param _Protocol: 监听器协议
        :type Protocol: str
        :param _Vport: 监听器端口
        :type Vport: int
        :param _Url: location的url
注意：此字段可能返回 null，表示取不到有效值。
        :type Url: str
        :param _UconfigId: 配置ID
        :type UconfigId: str
        """
        self._LoadBalancerId = None
        self._ListenerId = None
        self._Domain = None
        self._LocationId = None
        self._ListenerName = None
        self._Protocol = None
        self._Vport = None
        self._Url = None
        self._UconfigId = None

    @property
    def LoadBalancerId(self):
        r"""配置绑定的CLB ID
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerId(self):
        r"""配置绑定的监听器ID
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def Domain(self):
        r"""配置绑定的域名
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def LocationId(self):
        r"""配置绑定的规则
        :rtype: str
        """
        return self._LocationId

    @LocationId.setter
    def LocationId(self, LocationId):
        self._LocationId = LocationId

    @property
    def ListenerName(self):
        r"""监听器名字
        :rtype: str
        """
        return self._ListenerName

    @ListenerName.setter
    def ListenerName(self, ListenerName):
        self._ListenerName = ListenerName

    @property
    def Protocol(self):
        r"""监听器协议
        :rtype: str
        """
        return self._Protocol

    @Protocol.setter
    def Protocol(self, Protocol):
        self._Protocol = Protocol

    @property
    def Vport(self):
        r"""监听器端口
        :rtype: int
        """
        return self._Vport

    @Vport.setter
    def Vport(self, Vport):
        self._Vport = Vport

    @property
    def Url(self):
        r"""location的url
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Url

    @Url.setter
    def Url(self, Url):
        self._Url = Url

    @property
    def UconfigId(self):
        r"""配置ID
        :rtype: str
        """
        return self._UconfigId

    @UconfigId.setter
    def UconfigId(self, UconfigId):
        self._UconfigId = UconfigId


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerId = params.get("ListenerId")
        self._Domain = params.get("Domain")
        self._LocationId = params.get("LocationId")
        self._ListenerName = params.get("ListenerName")
        self._Protocol = params.get("Protocol")
        self._Vport = params.get("Vport")
        self._Url = params.get("Url")
        self._UconfigId = params.get("UconfigId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class BindItem(AbstractModel):
    r"""配置绑定关系

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 配置绑定的CLB ID
        :type LoadBalancerId: str
        :param _ListenerId: 配置绑定的监听器ID
        :type ListenerId: str
        :param _Domain: 配置绑定的域名
        :type Domain: str
        :param _LocationId: 配置绑定的规则
        :type LocationId: str
        """
        self._LoadBalancerId = None
        self._ListenerId = None
        self._Domain = None
        self._LocationId = None

    @property
    def LoadBalancerId(self):
        r"""配置绑定的CLB ID
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerId(self):
        r"""配置绑定的监听器ID
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def Domain(self):
        r"""配置绑定的域名
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def LocationId(self):
        r"""配置绑定的规则
        :rtype: str
        """
        return self._LocationId

    @LocationId.setter
    def LocationId(self, LocationId):
        self._LocationId = LocationId


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerId = params.get("ListenerId")
        self._Domain = params.get("Domain")
        self._LocationId = params.get("LocationId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class BlockedIP(AbstractModel):
    r"""加入了12306黑名单的IP

    """

    def __init__(self):
        r"""
        :param _IP: 黑名单IP
        :type IP: str
        :param _CreateTime: 加入黑名单的时间
        :type CreateTime: str
        :param _ExpireTime: 过期时间
        :type ExpireTime: str
        """
        self._IP = None
        self._CreateTime = None
        self._ExpireTime = None

    @property
    def IP(self):
        r"""黑名单IP
        :rtype: str
        """
        return self._IP

    @IP.setter
    def IP(self, IP):
        self._IP = IP

    @property
    def CreateTime(self):
        r"""加入黑名单的时间
        :rtype: str
        """
        return self._CreateTime

    @CreateTime.setter
    def CreateTime(self, CreateTime):
        self._CreateTime = CreateTime

    @property
    def ExpireTime(self):
        r"""过期时间
        :rtype: str
        """
        return self._ExpireTime

    @ExpireTime.setter
    def ExpireTime(self, ExpireTime):
        self._ExpireTime = ExpireTime


    def _deserialize(self, params):
        self._IP = params.get("IP")
        self._CreateTime = params.get("CreateTime")
        self._ExpireTime = params.get("ExpireTime")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class BudgetAssociation(AbstractModel):
    r"""Budget关联资源信息

    """

    def __init__(self):
        r"""
        :param _BudgetId: <p>Budget ID。</p>
        :type BudgetId: str
        :param _CreatedTime: <p>关联创建时间。</p>
        :type CreatedTime: str
        :param _KeyId: <p>Key ID。仅当Type为Key时返回。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type KeyId: str
        :param _ModelRouterId: <p>模型路由实例ID。</p><p>当Type为ModelRouter时表示关联资源本身；当Type为Key时表示Key所属实例。</p>
        :type ModelRouterId: str
        :param _ResourceName: <p>资源对象的名称。</p>
        :type ResourceName: str
        :param _Status: <p>关联关系的状态</p><p>枚举值：</p><ul><li>Active： 已生效</li><li>Configuring： 配置中</li><li>ConfigureFailed： 配置失败</li></ul>
        :type Status: str
        :param _Type: <p>关联资源类型。</p><p>枚举值：</p><ul><li>ModelRouter：模型路由实例</li><li>Key：模型路由Key</li><li>UserGroup：用户组</li></ul>
        :type Type: str
        :param _UserGroupId: <p>关联的用户组id</p>
        :type UserGroupId: str
        """
        self._BudgetId = None
        self._CreatedTime = None
        self._KeyId = None
        self._ModelRouterId = None
        self._ResourceName = None
        self._Status = None
        self._Type = None
        self._UserGroupId = None

    @property
    def BudgetId(self):
        r"""<p>Budget ID。</p>
        :rtype: str
        """
        return self._BudgetId

    @BudgetId.setter
    def BudgetId(self, BudgetId):
        self._BudgetId = BudgetId

    @property
    def CreatedTime(self):
        r"""<p>关联创建时间。</p>
        :rtype: str
        """
        return self._CreatedTime

    @CreatedTime.setter
    def CreatedTime(self, CreatedTime):
        self._CreatedTime = CreatedTime

    @property
    def KeyId(self):
        r"""<p>Key ID。仅当Type为Key时返回。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._KeyId

    @KeyId.setter
    def KeyId(self, KeyId):
        self._KeyId = KeyId

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID。</p><p>当Type为ModelRouter时表示关联资源本身；当Type为Key时表示Key所属实例。</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def ResourceName(self):
        r"""<p>资源对象的名称。</p>
        :rtype: str
        """
        return self._ResourceName

    @ResourceName.setter
    def ResourceName(self, ResourceName):
        self._ResourceName = ResourceName

    @property
    def Status(self):
        r"""<p>关联关系的状态</p><p>枚举值：</p><ul><li>Active： 已生效</li><li>Configuring： 配置中</li><li>ConfigureFailed： 配置失败</li></ul>
        :rtype: str
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status

    @property
    def Type(self):
        r"""<p>关联资源类型。</p><p>枚举值：</p><ul><li>ModelRouter：模型路由实例</li><li>Key：模型路由Key</li><li>UserGroup：用户组</li></ul>
        :rtype: str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type

    @property
    def UserGroupId(self):
        r"""<p>关联的用户组id</p>
        :rtype: str
        """
        return self._UserGroupId

    @UserGroupId.setter
    def UserGroupId(self, UserGroupId):
        self._UserGroupId = UserGroupId


    def _deserialize(self, params):
        self._BudgetId = params.get("BudgetId")
        self._CreatedTime = params.get("CreatedTime")
        self._KeyId = params.get("KeyId")
        self._ModelRouterId = params.get("ModelRouterId")
        self._ResourceName = params.get("ResourceName")
        self._Status = params.get("Status")
        self._Type = params.get("Type")
        self._UserGroupId = params.get("UserGroupId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class BudgetConfig(AbstractModel):
    r"""Budget预算配置

    """

    def __init__(self):
        r"""
        :param _BudgetDuration: <p>预算刷新周期。</p><p>枚举值：</p><ul><li>1d：按天刷新</li><li>7d：按周刷新</li><li>30d：按月刷新</li></ul><p>不传时默认30d。同一个Budget下每种刷新周期最多配置一次。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type BudgetDuration: str
        :param _BudgetResetAt: <p>下一次刷新的时间</p>
        :type BudgetResetAt: str
        :param _MaxBudget: <p>最大预算。</p><p>单位：credit。取值需大于0且不超过10000000000；不传时默认100000。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type MaxBudget: float
        """
        self._BudgetDuration = None
        self._BudgetResetAt = None
        self._MaxBudget = None

    @property
    def BudgetDuration(self):
        r"""<p>预算刷新周期。</p><p>枚举值：</p><ul><li>1d：按天刷新</li><li>7d：按周刷新</li><li>30d：按月刷新</li></ul><p>不传时默认30d。同一个Budget下每种刷新周期最多配置一次。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._BudgetDuration

    @BudgetDuration.setter
    def BudgetDuration(self, BudgetDuration):
        self._BudgetDuration = BudgetDuration

    @property
    def BudgetResetAt(self):
        r"""<p>下一次刷新的时间</p>
        :rtype: str
        """
        return self._BudgetResetAt

    @BudgetResetAt.setter
    def BudgetResetAt(self, BudgetResetAt):
        self._BudgetResetAt = BudgetResetAt

    @property
    def MaxBudget(self):
        r"""<p>最大预算。</p><p>单位：credit。取值需大于0且不超过10000000000；不传时默认100000。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: float
        """
        return self._MaxBudget

    @MaxBudget.setter
    def MaxBudget(self, MaxBudget):
        self._MaxBudget = MaxBudget


    def _deserialize(self, params):
        self._BudgetDuration = params.get("BudgetDuration")
        self._BudgetResetAt = params.get("BudgetResetAt")
        self._MaxBudget = params.get("MaxBudget")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class BudgetConfigInput(AbstractModel):
    r"""Budget预算配置入参

    """

    def __init__(self):
        r"""
        :param _BudgetDuration: <p>预算刷新周期。</p><p>支持取值：</p><ul><li>1d：按天刷新</li><li>7d：按周刷新</li><li>30d：按月刷新</li></ul><p>不传时默认使用30d。同一个Budget下每种刷新周期最多配置一次。</p>
        :type BudgetDuration: str
        :param _MaxBudget: <p>最大预算。</p><p>单位：credit。取值需大于0且不超过10000000000；不传时默认100000。</p>
        :type MaxBudget: float
        """
        self._BudgetDuration = None
        self._MaxBudget = None

    @property
    def BudgetDuration(self):
        r"""<p>预算刷新周期。</p><p>支持取值：</p><ul><li>1d：按天刷新</li><li>7d：按周刷新</li><li>30d：按月刷新</li></ul><p>不传时默认使用30d。同一个Budget下每种刷新周期最多配置一次。</p>
        :rtype: str
        """
        return self._BudgetDuration

    @BudgetDuration.setter
    def BudgetDuration(self, BudgetDuration):
        self._BudgetDuration = BudgetDuration

    @property
    def MaxBudget(self):
        r"""<p>最大预算。</p><p>单位：credit。取值需大于0且不超过10000000000；不传时默认100000。</p>
        :rtype: float
        """
        return self._MaxBudget

    @MaxBudget.setter
    def MaxBudget(self, MaxBudget):
        self._MaxBudget = MaxBudget


    def _deserialize(self, params):
        self._BudgetDuration = params.get("BudgetDuration")
        self._MaxBudget = params.get("MaxBudget")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class BudgetInfo(AbstractModel):
    r"""Budget信息

    """

    def __init__(self):
        r"""
        :param _AssociationKeyCount: <p>关联的key数量</p>
        :type AssociationKeyCount: int
        :param _AssociationModelRouterCount: <p>关联的模型路由数量</p>
        :type AssociationModelRouterCount: int
        :param _AssociationUserGroupCount: <p>关联的用户组数量</p>
        :type AssociationUserGroupCount: int
        :param _BudgetConfigs: <p>Budget预算配置数组。</p><p>最多返回3个元素，每种刷新周期（1d/7d/30d）各一个。</p>
        :type BudgetConfigs: list of BudgetConfig
        :param _BudgetId: <p>Budget ID。</p>
        :type BudgetId: str
        :param _BudgetName: <p>Budget名称。</p>
        :type BudgetName: str
        :param _CreatedTime: <p>创建时间。</p>
        :type CreatedTime: str
        :param _ModifiedTime: <p>修改时间。</p>
        :type ModifiedTime: str
        :param _RateLimitConfig: <p>Budget限速信息。</p>
        :type RateLimitConfig: :class:`tencentcloud.clb.v20180317.models.RateLimitConfigForBudget`
        :param _Status: <p>Budget状态。</p><p>枚举值：</p><ul><li>Provisioning：创建中</li><li>Active：运行中</li><li>Configuring：变配中</li><li>Deleting：删除中</li><li>ProvisionFailed：创建失败</li><li>ConfigureFailed：变配失败</li><li>DeletionFailed：删除失败</li></ul>
        :type Status: str
        """
        self._AssociationKeyCount = None
        self._AssociationModelRouterCount = None
        self._AssociationUserGroupCount = None
        self._BudgetConfigs = None
        self._BudgetId = None
        self._BudgetName = None
        self._CreatedTime = None
        self._ModifiedTime = None
        self._RateLimitConfig = None
        self._Status = None

    @property
    def AssociationKeyCount(self):
        r"""<p>关联的key数量</p>
        :rtype: int
        """
        return self._AssociationKeyCount

    @AssociationKeyCount.setter
    def AssociationKeyCount(self, AssociationKeyCount):
        self._AssociationKeyCount = AssociationKeyCount

    @property
    def AssociationModelRouterCount(self):
        r"""<p>关联的模型路由数量</p>
        :rtype: int
        """
        return self._AssociationModelRouterCount

    @AssociationModelRouterCount.setter
    def AssociationModelRouterCount(self, AssociationModelRouterCount):
        self._AssociationModelRouterCount = AssociationModelRouterCount

    @property
    def AssociationUserGroupCount(self):
        r"""<p>关联的用户组数量</p>
        :rtype: int
        """
        return self._AssociationUserGroupCount

    @AssociationUserGroupCount.setter
    def AssociationUserGroupCount(self, AssociationUserGroupCount):
        self._AssociationUserGroupCount = AssociationUserGroupCount

    @property
    def BudgetConfigs(self):
        r"""<p>Budget预算配置数组。</p><p>最多返回3个元素，每种刷新周期（1d/7d/30d）各一个。</p>
        :rtype: list of BudgetConfig
        """
        return self._BudgetConfigs

    @BudgetConfigs.setter
    def BudgetConfigs(self, BudgetConfigs):
        self._BudgetConfigs = BudgetConfigs

    @property
    def BudgetId(self):
        r"""<p>Budget ID。</p>
        :rtype: str
        """
        return self._BudgetId

    @BudgetId.setter
    def BudgetId(self, BudgetId):
        self._BudgetId = BudgetId

    @property
    def BudgetName(self):
        r"""<p>Budget名称。</p>
        :rtype: str
        """
        return self._BudgetName

    @BudgetName.setter
    def BudgetName(self, BudgetName):
        self._BudgetName = BudgetName

    @property
    def CreatedTime(self):
        r"""<p>创建时间。</p>
        :rtype: str
        """
        return self._CreatedTime

    @CreatedTime.setter
    def CreatedTime(self, CreatedTime):
        self._CreatedTime = CreatedTime

    @property
    def ModifiedTime(self):
        r"""<p>修改时间。</p>
        :rtype: str
        """
        return self._ModifiedTime

    @ModifiedTime.setter
    def ModifiedTime(self, ModifiedTime):
        self._ModifiedTime = ModifiedTime

    @property
    def RateLimitConfig(self):
        r"""<p>Budget限速信息。</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.RateLimitConfigForBudget`
        """
        return self._RateLimitConfig

    @RateLimitConfig.setter
    def RateLimitConfig(self, RateLimitConfig):
        self._RateLimitConfig = RateLimitConfig

    @property
    def Status(self):
        r"""<p>Budget状态。</p><p>枚举值：</p><ul><li>Provisioning：创建中</li><li>Active：运行中</li><li>Configuring：变配中</li><li>Deleting：删除中</li><li>ProvisionFailed：创建失败</li><li>ConfigureFailed：变配失败</li><li>DeletionFailed：删除失败</li></ul>
        :rtype: str
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status


    def _deserialize(self, params):
        self._AssociationKeyCount = params.get("AssociationKeyCount")
        self._AssociationModelRouterCount = params.get("AssociationModelRouterCount")
        self._AssociationUserGroupCount = params.get("AssociationUserGroupCount")
        if params.get("BudgetConfigs") is not None:
            self._BudgetConfigs = []
            for item in params.get("BudgetConfigs"):
                obj = BudgetConfig()
                obj._deserialize(item)
                self._BudgetConfigs.append(obj)
        self._BudgetId = params.get("BudgetId")
        self._BudgetName = params.get("BudgetName")
        self._CreatedTime = params.get("CreatedTime")
        self._ModifiedTime = params.get("ModifiedTime")
        if params.get("RateLimitConfig") is not None:
            self._RateLimitConfig = RateLimitConfigForBudget()
            self._RateLimitConfig._deserialize(params.get("RateLimitConfig"))
        self._Status = params.get("Status")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class BudgetResource(AbstractModel):
    r"""Budget关联资源对象。仅支持企业型模型路由实例和企业型实例下的Key。

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID。</p><p>当Type为ModelRouter时表示要关联的实例；当Type为Key时表示Key所属实例。</p>
        :type ModelRouterId: str
        :param _Type: <p>资源类型。</p><p>枚举值：</p><ul><li>ModelRouter：模型路由实例</li><li>Key：模型路由Key</li><li>UserGroup：用户组（Type 为 UserGroup 时需传 UserGroupId）</li></ul>
        :type Type: str
        :param _KeyId: <p>Key ID。</p><p>字段本身选填；当Type为Key时必填，当Type为ModelRouter时不传。</p>
        :type KeyId: str
        :param _UserGroupId: <p>用户组ID</p>
        :type UserGroupId: str
        """
        self._ModelRouterId = None
        self._Type = None
        self._KeyId = None
        self._UserGroupId = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID。</p><p>当Type为ModelRouter时表示要关联的实例；当Type为Key时表示Key所属实例。</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def Type(self):
        r"""<p>资源类型。</p><p>枚举值：</p><ul><li>ModelRouter：模型路由实例</li><li>Key：模型路由Key</li><li>UserGroup：用户组（Type 为 UserGroup 时需传 UserGroupId）</li></ul>
        :rtype: str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type

    @property
    def KeyId(self):
        r"""<p>Key ID。</p><p>字段本身选填；当Type为Key时必填，当Type为ModelRouter时不传。</p>
        :rtype: str
        """
        return self._KeyId

    @KeyId.setter
    def KeyId(self, KeyId):
        self._KeyId = KeyId

    @property
    def UserGroupId(self):
        r"""<p>用户组ID</p>
        :rtype: str
        """
        return self._UserGroupId

    @UserGroupId.setter
    def UserGroupId(self, UserGroupId):
        self._UserGroupId = UserGroupId


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._Type = params.get("Type")
        self._KeyId = params.get("KeyId")
        self._UserGroupId = params.get("UserGroupId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CertIdRelatedWithLoadBalancers(AbstractModel):
    r"""证书ID，以及与该证书ID关联的负载均衡实例列表

    """

    def __init__(self):
        r"""
        :param _CertId: 证书ID
        :type CertId: str
        :param _LoadBalancers: 与证书关联的负载均衡实例列表
        :type LoadBalancers: list of LoadBalancer
        """
        self._CertId = None
        self._LoadBalancers = None

    @property
    def CertId(self):
        r"""证书ID
        :rtype: str
        """
        return self._CertId

    @CertId.setter
    def CertId(self, CertId):
        self._CertId = CertId

    @property
    def LoadBalancers(self):
        r"""与证书关联的负载均衡实例列表
        :rtype: list of LoadBalancer
        """
        return self._LoadBalancers

    @LoadBalancers.setter
    def LoadBalancers(self, LoadBalancers):
        self._LoadBalancers = LoadBalancers


    def _deserialize(self, params):
        self._CertId = params.get("CertId")
        if params.get("LoadBalancers") is not None:
            self._LoadBalancers = []
            for item in params.get("LoadBalancers"):
                obj = LoadBalancer()
                obj._deserialize(item)
                self._LoadBalancers.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CertInfo(AbstractModel):
    r"""证书信息

    """

    def __init__(self):
        r"""
        :param _CertId: 证书 ID，如果不填写此项则必须上传证书内容，包括CertName, CertContent，若为服务端证书必须包含CertKey。
        :type CertId: str
        :param _CertName: 上传证书的名称，如果没有 CertId，则此项必传。
        :type CertName: str
        :param _CertContent: 上传证书的公钥；如果没有 CertId，则此项必传。
        :type CertContent: str
        :param _CertKey: 上传服务端证书的私钥；如果没有 CertId，则此项必传。
        :type CertKey: str
        """
        self._CertId = None
        self._CertName = None
        self._CertContent = None
        self._CertKey = None

    @property
    def CertId(self):
        r"""证书 ID，如果不填写此项则必须上传证书内容，包括CertName, CertContent，若为服务端证书必须包含CertKey。
        :rtype: str
        """
        return self._CertId

    @CertId.setter
    def CertId(self, CertId):
        self._CertId = CertId

    @property
    def CertName(self):
        r"""上传证书的名称，如果没有 CertId，则此项必传。
        :rtype: str
        """
        return self._CertName

    @CertName.setter
    def CertName(self, CertName):
        self._CertName = CertName

    @property
    def CertContent(self):
        r"""上传证书的公钥；如果没有 CertId，则此项必传。
        :rtype: str
        """
        return self._CertContent

    @CertContent.setter
    def CertContent(self, CertContent):
        self._CertContent = CertContent

    @property
    def CertKey(self):
        r"""上传服务端证书的私钥；如果没有 CertId，则此项必传。
        :rtype: str
        """
        return self._CertKey

    @CertKey.setter
    def CertKey(self, CertKey):
        self._CertKey = CertKey


    def _deserialize(self, params):
        self._CertId = params.get("CertId")
        self._CertName = params.get("CertName")
        self._CertContent = params.get("CertContent")
        self._CertKey = params.get("CertKey")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CertificateInput(AbstractModel):
    r"""证书信息

    """

    def __init__(self):
        r"""
        :param _SSLMode: 认证类型，UNIDIRECTIONAL：单向认证，MUTUAL：双向认证。
默认为 UNIDIRECTIONAL。
        :type SSLMode: str
        :param _SSLVerifyClient: 双向认证时，是否开启客户端认证，ON:开启，OPTIONAL:自适应，默认ON。
        :type SSLVerifyClient: str
        :param _CertId: 服务端证书的 ID，如果不填写此项则必须上传证书，包括 CertContent（服务端证书内容），CertKey（服务端证书密钥），CertName（服务端证书名称）。
        :type CertId: str
        :param _CertCaId: 客户端证书的 ID，当监听器采用双向认证，即 SSLMode=MUTUAL 时，如果不填写此项则必须上传客户端证书，包括 CertCaContent，CertCaName。
        :type CertCaId: str
        :param _CertName: 上传服务端证书的名称，如果没有 CertId，则此项必传。
        :type CertName: str
        :param _CertKey: 上传服务端证书的 key，如果没有 CertId，则此项必传。
        :type CertKey: str
        :param _CertContent: 上传服务端证书的内容，如果没有 CertId，则此项必传。
        :type CertContent: str
        :param _CertCaName: 上传客户端 CA 证书的名称，如果 SSLMode=MUTUAL，如果没有 CertCaId，则此项必传。
        :type CertCaName: str
        :param _CertCaContent: 上传客户端证书的内容，如果 SSLMode=MUTUAL，如果没有 CertCaId，则此项必传。
        :type CertCaContent: str
        """
        self._SSLMode = None
        self._SSLVerifyClient = None
        self._CertId = None
        self._CertCaId = None
        self._CertName = None
        self._CertKey = None
        self._CertContent = None
        self._CertCaName = None
        self._CertCaContent = None

    @property
    def SSLMode(self):
        r"""认证类型，UNIDIRECTIONAL：单向认证，MUTUAL：双向认证。
默认为 UNIDIRECTIONAL。
        :rtype: str
        """
        return self._SSLMode

    @SSLMode.setter
    def SSLMode(self, SSLMode):
        self._SSLMode = SSLMode

    @property
    def SSLVerifyClient(self):
        r"""双向认证时，是否开启客户端认证，ON:开启，OPTIONAL:自适应，默认ON。
        :rtype: str
        """
        return self._SSLVerifyClient

    @SSLVerifyClient.setter
    def SSLVerifyClient(self, SSLVerifyClient):
        self._SSLVerifyClient = SSLVerifyClient

    @property
    def CertId(self):
        r"""服务端证书的 ID，如果不填写此项则必须上传证书，包括 CertContent（服务端证书内容），CertKey（服务端证书密钥），CertName（服务端证书名称）。
        :rtype: str
        """
        return self._CertId

    @CertId.setter
    def CertId(self, CertId):
        self._CertId = CertId

    @property
    def CertCaId(self):
        r"""客户端证书的 ID，当监听器采用双向认证，即 SSLMode=MUTUAL 时，如果不填写此项则必须上传客户端证书，包括 CertCaContent，CertCaName。
        :rtype: str
        """
        return self._CertCaId

    @CertCaId.setter
    def CertCaId(self, CertCaId):
        self._CertCaId = CertCaId

    @property
    def CertName(self):
        r"""上传服务端证书的名称，如果没有 CertId，则此项必传。
        :rtype: str
        """
        return self._CertName

    @CertName.setter
    def CertName(self, CertName):
        self._CertName = CertName

    @property
    def CertKey(self):
        r"""上传服务端证书的 key，如果没有 CertId，则此项必传。
        :rtype: str
        """
        return self._CertKey

    @CertKey.setter
    def CertKey(self, CertKey):
        self._CertKey = CertKey

    @property
    def CertContent(self):
        r"""上传服务端证书的内容，如果没有 CertId，则此项必传。
        :rtype: str
        """
        return self._CertContent

    @CertContent.setter
    def CertContent(self, CertContent):
        self._CertContent = CertContent

    @property
    def CertCaName(self):
        r"""上传客户端 CA 证书的名称，如果 SSLMode=MUTUAL，如果没有 CertCaId，则此项必传。
        :rtype: str
        """
        return self._CertCaName

    @CertCaName.setter
    def CertCaName(self, CertCaName):
        self._CertCaName = CertCaName

    @property
    def CertCaContent(self):
        r"""上传客户端证书的内容，如果 SSLMode=MUTUAL，如果没有 CertCaId，则此项必传。
        :rtype: str
        """
        return self._CertCaContent

    @CertCaContent.setter
    def CertCaContent(self, CertCaContent):
        self._CertCaContent = CertCaContent


    def _deserialize(self, params):
        self._SSLMode = params.get("SSLMode")
        self._SSLVerifyClient = params.get("SSLVerifyClient")
        self._CertId = params.get("CertId")
        self._CertCaId = params.get("CertCaId")
        self._CertName = params.get("CertName")
        self._CertKey = params.get("CertKey")
        self._CertContent = params.get("CertContent")
        self._CertCaName = params.get("CertCaName")
        self._CertCaContent = params.get("CertCaContent")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CertificateOutput(AbstractModel):
    r"""证书相关信息

    """

    def __init__(self):
        r"""
        :param _SSLMode: 认证类型，UNIDIRECTIONAL：单向认证，MUTUAL：双向认证
        :type SSLMode: str
        :param _SSLVerifyClient: 是否开启客户端证书验证，只在双向认证时生效。
        :type SSLVerifyClient: str
        :param _CertId: 服务端证书的ID。
        :type CertId: str
        :param _CertCaId: 客户端证书的 ID。
        :type CertCaId: str
        :param _ExtCertIds: 多本服务器证书场景扩展的服务器证书ID。
        :type ExtCertIds: list of str
        """
        self._SSLMode = None
        self._SSLVerifyClient = None
        self._CertId = None
        self._CertCaId = None
        self._ExtCertIds = None

    @property
    def SSLMode(self):
        r"""认证类型，UNIDIRECTIONAL：单向认证，MUTUAL：双向认证
        :rtype: str
        """
        return self._SSLMode

    @SSLMode.setter
    def SSLMode(self, SSLMode):
        self._SSLMode = SSLMode

    @property
    def SSLVerifyClient(self):
        r"""是否开启客户端证书验证，只在双向认证时生效。
        :rtype: str
        """
        return self._SSLVerifyClient

    @SSLVerifyClient.setter
    def SSLVerifyClient(self, SSLVerifyClient):
        self._SSLVerifyClient = SSLVerifyClient

    @property
    def CertId(self):
        r"""服务端证书的ID。
        :rtype: str
        """
        return self._CertId

    @CertId.setter
    def CertId(self, CertId):
        self._CertId = CertId

    @property
    def CertCaId(self):
        r"""客户端证书的 ID。
        :rtype: str
        """
        return self._CertCaId

    @CertCaId.setter
    def CertCaId(self, CertCaId):
        self._CertCaId = CertCaId

    @property
    def ExtCertIds(self):
        r"""多本服务器证书场景扩展的服务器证书ID。
        :rtype: list of str
        """
        return self._ExtCertIds

    @ExtCertIds.setter
    def ExtCertIds(self, ExtCertIds):
        self._ExtCertIds = ExtCertIds


    def _deserialize(self, params):
        self._SSLMode = params.get("SSLMode")
        self._SSLVerifyClient = params.get("SSLVerifyClient")
        self._CertId = params.get("CertId")
        self._CertCaId = params.get("CertCaId")
        self._ExtCertIds = params.get("ExtCertIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ChatCompletionsRequest(AbstractModel):
    r"""ChatCompletions请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ApiKey: <p>virtual key，用于向代理网关鉴权</p>
        :type ApiKey: str
        :param _Attachments: <p>多模态附件列表</p>
        :type Attachments: list of MultiModalityAttachments
        :param _ChatContent: <p>聊天内容</p>
        :type ChatContent: str
        :param _Model: <p>模型名称，配置的模型标识</p><p>示例：gpt-4o、deepseek-chat</p>
        :type Model: str
        :param _ModelRouterId: <p>模型路由实例ID</p>
        :type ModelRouterId: str
        :param _RequestPath: <p>请求路径</p><p>默认值：/v1/chat/completions</p>
        :type RequestPath: str
        """
        self._ApiKey = None
        self._Attachments = None
        self._ChatContent = None
        self._Model = None
        self._ModelRouterId = None
        self._RequestPath = None

    @property
    def ApiKey(self):
        r"""<p>virtual key，用于向代理网关鉴权</p>
        :rtype: str
        """
        return self._ApiKey

    @ApiKey.setter
    def ApiKey(self, ApiKey):
        self._ApiKey = ApiKey

    @property
    def Attachments(self):
        r"""<p>多模态附件列表</p>
        :rtype: list of MultiModalityAttachments
        """
        return self._Attachments

    @Attachments.setter
    def Attachments(self, Attachments):
        self._Attachments = Attachments

    @property
    def ChatContent(self):
        r"""<p>聊天内容</p>
        :rtype: str
        """
        return self._ChatContent

    @ChatContent.setter
    def ChatContent(self, ChatContent):
        self._ChatContent = ChatContent

    @property
    def Model(self):
        r"""<p>模型名称，配置的模型标识</p><p>示例：gpt-4o、deepseek-chat</p>
        :rtype: str
        """
        return self._Model

    @Model.setter
    def Model(self, Model):
        self._Model = Model

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def RequestPath(self):
        r"""<p>请求路径</p><p>默认值：/v1/chat/completions</p>
        :rtype: str
        """
        return self._RequestPath

    @RequestPath.setter
    def RequestPath(self, RequestPath):
        self._RequestPath = RequestPath


    def _deserialize(self, params):
        self._ApiKey = params.get("ApiKey")
        if params.get("Attachments") is not None:
            self._Attachments = []
            for item in params.get("Attachments"):
                obj = MultiModalityAttachments()
                obj._deserialize(item)
                self._Attachments.append(obj)
        self._ChatContent = params.get("ChatContent")
        self._Model = params.get("Model")
        self._ModelRouterId = params.get("ModelRouterId")
        self._RequestPath = params.get("RequestPath")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ChatCompletionsResponse(AbstractModel):
    r"""ChatCompletions返回参数结构体

    """

    def __init__(self):
        r"""
        :param _ChatResponseMessage: <p>聊天的返回信息</p>
        :type ChatResponseMessage: str
        :param _ErrorInChat: <p>聊天请求发送过程中的失败信息</p>
        :type ErrorInChat: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._ChatResponseMessage = None
        self._ErrorInChat = None
        self._RequestId = None

    @property
    def ChatResponseMessage(self):
        r"""<p>聊天的返回信息</p>
        :rtype: str
        """
        return self._ChatResponseMessage

    @ChatResponseMessage.setter
    def ChatResponseMessage(self, ChatResponseMessage):
        self._ChatResponseMessage = ChatResponseMessage

    @property
    def ErrorInChat(self):
        r"""<p>聊天请求发送过程中的失败信息</p>
        :rtype: str
        """
        return self._ErrorInChat

    @ErrorInChat.setter
    def ErrorInChat(self, ErrorInChat):
        self._ErrorInChat = ErrorInChat

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._ChatResponseMessage = params.get("ChatResponseMessage")
        self._ErrorInChat = params.get("ErrorInChat")
        self._RequestId = params.get("RequestId")


class ClassicalHealth(AbstractModel):
    r"""传统型负载均衡后端服务的健康状态

    """

    def __init__(self):
        r"""
        :param _IP: 后端服务的内网 IP
        :type IP: str
        :param _Port: 后端服务的端口
        :type Port: int
        :param _ListenerPort: 负载均衡的监听端口
        :type ListenerPort: int
        :param _Protocol: 转发协议
        :type Protocol: str
        :param _HealthStatus: 健康检查结果，1 表示健康，0 表示不健康
        :type HealthStatus: int
        """
        self._IP = None
        self._Port = None
        self._ListenerPort = None
        self._Protocol = None
        self._HealthStatus = None

    @property
    def IP(self):
        r"""后端服务的内网 IP
        :rtype: str
        """
        return self._IP

    @IP.setter
    def IP(self, IP):
        self._IP = IP

    @property
    def Port(self):
        r"""后端服务的端口
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def ListenerPort(self):
        r"""负载均衡的监听端口
        :rtype: int
        """
        return self._ListenerPort

    @ListenerPort.setter
    def ListenerPort(self, ListenerPort):
        self._ListenerPort = ListenerPort

    @property
    def Protocol(self):
        r"""转发协议
        :rtype: str
        """
        return self._Protocol

    @Protocol.setter
    def Protocol(self, Protocol):
        self._Protocol = Protocol

    @property
    def HealthStatus(self):
        r"""健康检查结果，1 表示健康，0 表示不健康
        :rtype: int
        """
        return self._HealthStatus

    @HealthStatus.setter
    def HealthStatus(self, HealthStatus):
        self._HealthStatus = HealthStatus


    def _deserialize(self, params):
        self._IP = params.get("IP")
        self._Port = params.get("Port")
        self._ListenerPort = params.get("ListenerPort")
        self._Protocol = params.get("Protocol")
        self._HealthStatus = params.get("HealthStatus")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ClassicalListener(AbstractModel):
    r"""传统型负载均衡监听器信息

    """

    def __init__(self):
        r"""
        :param _ListenerId: <p>负载均衡监听器ID</p>
        :type ListenerId: str
        :param _ListenerPort: <p>负载均衡监听器端口</p>
        :type ListenerPort: int
        :param _InstancePort: <p>监听器后端转发端口</p>
        :type InstancePort: int
        :param _ListenerName: <p>监听器名称</p>
        :type ListenerName: str
        :param _Protocol: <p>监听器协议类型</p>
        :type Protocol: str
        :param _SessionExpire: <p>会话保持时间</p>
        :type SessionExpire: int
        :param _HealthSwitch: <p>是否开启了健康检查：1（开启）、0（关闭）</p>
        :type HealthSwitch: int
        :param _TimeOut: <p>响应超时时间</p><p>单位：秒</p>
        :type TimeOut: int
        :param _IntervalTime: <p>检查间隔</p><p>单位：秒</p>
        :type IntervalTime: int
        :param _HealthNum: <p>健康阈值</p>
        :type HealthNum: int
        :param _UnhealthNum: <p>不健康阈值</p>
        :type UnhealthNum: int
        :param _HttpHash: <p>传统型公网负载均衡 监听器的请求均衡方法。空字符串或wrr 表示按权重轮询，ip_hash 表示根据访问的源 IP 进行一致性哈希方式来分发，least_conn表示按最小连接数。</p>
        :type HttpHash: str
        :param _HttpCode: <p>传统型公网负载均衡的 HTTP、HTTPS 监听器的健康检查返回码。具体可参考创建监听器中对该字段的解释</p>
        :type HttpCode: int
        :param _HttpCheckPath: <p>传统型公网负载均衡的 HTTP、HTTPS 监听器的健康检查路径</p>
        :type HttpCheckPath: str
        :param _SSLMode: <p>传统型公网负载均衡的 HTTPS 监听器的认证方式</p>
        :type SSLMode: str
        :param _CertId: <p>传统型公网负载均衡的 HTTPS 监听器的服务端证书 ID</p>
        :type CertId: str
        :param _CertCaId: <p>传统型公网负载均衡的 HTTPS 监听器的客户端证书 ID</p>
        :type CertCaId: str
        :param _Status: <p>监听器的状态，0 表示创建中，1 表示运行中</p>
        :type Status: int
        """
        self._ListenerId = None
        self._ListenerPort = None
        self._InstancePort = None
        self._ListenerName = None
        self._Protocol = None
        self._SessionExpire = None
        self._HealthSwitch = None
        self._TimeOut = None
        self._IntervalTime = None
        self._HealthNum = None
        self._UnhealthNum = None
        self._HttpHash = None
        self._HttpCode = None
        self._HttpCheckPath = None
        self._SSLMode = None
        self._CertId = None
        self._CertCaId = None
        self._Status = None

    @property
    def ListenerId(self):
        r"""<p>负载均衡监听器ID</p>
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def ListenerPort(self):
        r"""<p>负载均衡监听器端口</p>
        :rtype: int
        """
        return self._ListenerPort

    @ListenerPort.setter
    def ListenerPort(self, ListenerPort):
        self._ListenerPort = ListenerPort

    @property
    def InstancePort(self):
        r"""<p>监听器后端转发端口</p>
        :rtype: int
        """
        return self._InstancePort

    @InstancePort.setter
    def InstancePort(self, InstancePort):
        self._InstancePort = InstancePort

    @property
    def ListenerName(self):
        r"""<p>监听器名称</p>
        :rtype: str
        """
        return self._ListenerName

    @ListenerName.setter
    def ListenerName(self, ListenerName):
        self._ListenerName = ListenerName

    @property
    def Protocol(self):
        r"""<p>监听器协议类型</p>
        :rtype: str
        """
        return self._Protocol

    @Protocol.setter
    def Protocol(self, Protocol):
        self._Protocol = Protocol

    @property
    def SessionExpire(self):
        r"""<p>会话保持时间</p>
        :rtype: int
        """
        return self._SessionExpire

    @SessionExpire.setter
    def SessionExpire(self, SessionExpire):
        self._SessionExpire = SessionExpire

    @property
    def HealthSwitch(self):
        r"""<p>是否开启了健康检查：1（开启）、0（关闭）</p>
        :rtype: int
        """
        return self._HealthSwitch

    @HealthSwitch.setter
    def HealthSwitch(self, HealthSwitch):
        self._HealthSwitch = HealthSwitch

    @property
    def TimeOut(self):
        r"""<p>响应超时时间</p><p>单位：秒</p>
        :rtype: int
        """
        return self._TimeOut

    @TimeOut.setter
    def TimeOut(self, TimeOut):
        self._TimeOut = TimeOut

    @property
    def IntervalTime(self):
        r"""<p>检查间隔</p><p>单位：秒</p>
        :rtype: int
        """
        return self._IntervalTime

    @IntervalTime.setter
    def IntervalTime(self, IntervalTime):
        self._IntervalTime = IntervalTime

    @property
    def HealthNum(self):
        r"""<p>健康阈值</p>
        :rtype: int
        """
        return self._HealthNum

    @HealthNum.setter
    def HealthNum(self, HealthNum):
        self._HealthNum = HealthNum

    @property
    def UnhealthNum(self):
        r"""<p>不健康阈值</p>
        :rtype: int
        """
        return self._UnhealthNum

    @UnhealthNum.setter
    def UnhealthNum(self, UnhealthNum):
        self._UnhealthNum = UnhealthNum

    @property
    def HttpHash(self):
        r"""<p>传统型公网负载均衡 监听器的请求均衡方法。空字符串或wrr 表示按权重轮询，ip_hash 表示根据访问的源 IP 进行一致性哈希方式来分发，least_conn表示按最小连接数。</p>
        :rtype: str
        """
        return self._HttpHash

    @HttpHash.setter
    def HttpHash(self, HttpHash):
        self._HttpHash = HttpHash

    @property
    def HttpCode(self):
        r"""<p>传统型公网负载均衡的 HTTP、HTTPS 监听器的健康检查返回码。具体可参考创建监听器中对该字段的解释</p>
        :rtype: int
        """
        return self._HttpCode

    @HttpCode.setter
    def HttpCode(self, HttpCode):
        self._HttpCode = HttpCode

    @property
    def HttpCheckPath(self):
        r"""<p>传统型公网负载均衡的 HTTP、HTTPS 监听器的健康检查路径</p>
        :rtype: str
        """
        return self._HttpCheckPath

    @HttpCheckPath.setter
    def HttpCheckPath(self, HttpCheckPath):
        self._HttpCheckPath = HttpCheckPath

    @property
    def SSLMode(self):
        r"""<p>传统型公网负载均衡的 HTTPS 监听器的认证方式</p>
        :rtype: str
        """
        return self._SSLMode

    @SSLMode.setter
    def SSLMode(self, SSLMode):
        self._SSLMode = SSLMode

    @property
    def CertId(self):
        r"""<p>传统型公网负载均衡的 HTTPS 监听器的服务端证书 ID</p>
        :rtype: str
        """
        return self._CertId

    @CertId.setter
    def CertId(self, CertId):
        self._CertId = CertId

    @property
    def CertCaId(self):
        r"""<p>传统型公网负载均衡的 HTTPS 监听器的客户端证书 ID</p>
        :rtype: str
        """
        return self._CertCaId

    @CertCaId.setter
    def CertCaId(self, CertCaId):
        self._CertCaId = CertCaId

    @property
    def Status(self):
        r"""<p>监听器的状态，0 表示创建中，1 表示运行中</p>
        :rtype: int
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status


    def _deserialize(self, params):
        self._ListenerId = params.get("ListenerId")
        self._ListenerPort = params.get("ListenerPort")
        self._InstancePort = params.get("InstancePort")
        self._ListenerName = params.get("ListenerName")
        self._Protocol = params.get("Protocol")
        self._SessionExpire = params.get("SessionExpire")
        self._HealthSwitch = params.get("HealthSwitch")
        self._TimeOut = params.get("TimeOut")
        self._IntervalTime = params.get("IntervalTime")
        self._HealthNum = params.get("HealthNum")
        self._UnhealthNum = params.get("UnhealthNum")
        self._HttpHash = params.get("HttpHash")
        self._HttpCode = params.get("HttpCode")
        self._HttpCheckPath = params.get("HttpCheckPath")
        self._SSLMode = params.get("SSLMode")
        self._CertId = params.get("CertId")
        self._CertCaId = params.get("CertCaId")
        self._Status = params.get("Status")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ClassicalLoadBalancerInfo(AbstractModel):
    r"""负载均衡信息

    """

    def __init__(self):
        r"""
        :param _InstanceId: 后端实例ID
        :type InstanceId: str
        :param _LoadBalancerIds: 负载均衡实例ID列表
        :type LoadBalancerIds: list of str
        """
        self._InstanceId = None
        self._LoadBalancerIds = None

    @property
    def InstanceId(self):
        r"""后端实例ID
        :rtype: str
        """
        return self._InstanceId

    @InstanceId.setter
    def InstanceId(self, InstanceId):
        self._InstanceId = InstanceId

    @property
    def LoadBalancerIds(self):
        r"""负载均衡实例ID列表
        :rtype: list of str
        """
        return self._LoadBalancerIds

    @LoadBalancerIds.setter
    def LoadBalancerIds(self, LoadBalancerIds):
        self._LoadBalancerIds = LoadBalancerIds


    def _deserialize(self, params):
        self._InstanceId = params.get("InstanceId")
        self._LoadBalancerIds = params.get("LoadBalancerIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ClassicalTarget(AbstractModel):
    r"""传统型负载均衡的后端服务相关信息

    """

    def __init__(self):
        r"""
        :param _Type: 后端服务的类型，可取值：CVM、ENI（即将支持）
        :type Type: str
        :param _InstanceId: 后端服务的唯一 ID，可通过 DescribeInstances 接口返回字段中的 unInstanceId 字段获取
        :type InstanceId: str
        :param _Weight: 后端服务的转发权重，取值范围：[0, 100]，默认为 10。
        :type Weight: int
        :param _PublicIpAddresses: 后端服务的外网 IP
        :type PublicIpAddresses: list of str
        :param _PrivateIpAddresses: 后端服务的内网 IP
        :type PrivateIpAddresses: list of str
        :param _InstanceName: 后端服务的实例名称
        :type InstanceName: str
        :param _RunFlag: 后端服务的状态
1：故障，2：运行中，3：创建中，4：已关机，5：已退还，6：退还中， 7：重启中，8：开机中，9：关机中，10：密码重置中，11：格式化中，12：镜像制作中，13：带宽设置中，14：重装系统中，19：升级中，21：热迁移中
        :type RunFlag: int
        """
        self._Type = None
        self._InstanceId = None
        self._Weight = None
        self._PublicIpAddresses = None
        self._PrivateIpAddresses = None
        self._InstanceName = None
        self._RunFlag = None

    @property
    def Type(self):
        r"""后端服务的类型，可取值：CVM、ENI（即将支持）
        :rtype: str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type

    @property
    def InstanceId(self):
        r"""后端服务的唯一 ID，可通过 DescribeInstances 接口返回字段中的 unInstanceId 字段获取
        :rtype: str
        """
        return self._InstanceId

    @InstanceId.setter
    def InstanceId(self, InstanceId):
        self._InstanceId = InstanceId

    @property
    def Weight(self):
        r"""后端服务的转发权重，取值范围：[0, 100]，默认为 10。
        :rtype: int
        """
        return self._Weight

    @Weight.setter
    def Weight(self, Weight):
        self._Weight = Weight

    @property
    def PublicIpAddresses(self):
        r"""后端服务的外网 IP
        :rtype: list of str
        """
        return self._PublicIpAddresses

    @PublicIpAddresses.setter
    def PublicIpAddresses(self, PublicIpAddresses):
        self._PublicIpAddresses = PublicIpAddresses

    @property
    def PrivateIpAddresses(self):
        r"""后端服务的内网 IP
        :rtype: list of str
        """
        return self._PrivateIpAddresses

    @PrivateIpAddresses.setter
    def PrivateIpAddresses(self, PrivateIpAddresses):
        self._PrivateIpAddresses = PrivateIpAddresses

    @property
    def InstanceName(self):
        r"""后端服务的实例名称
        :rtype: str
        """
        return self._InstanceName

    @InstanceName.setter
    def InstanceName(self, InstanceName):
        self._InstanceName = InstanceName

    @property
    def RunFlag(self):
        r"""后端服务的状态
1：故障，2：运行中，3：创建中，4：已关机，5：已退还，6：退还中， 7：重启中，8：开机中，9：关机中，10：密码重置中，11：格式化中，12：镜像制作中，13：带宽设置中，14：重装系统中，19：升级中，21：热迁移中
        :rtype: int
        """
        return self._RunFlag

    @RunFlag.setter
    def RunFlag(self, RunFlag):
        self._RunFlag = RunFlag


    def _deserialize(self, params):
        self._Type = params.get("Type")
        self._InstanceId = params.get("InstanceId")
        self._Weight = params.get("Weight")
        self._PublicIpAddresses = params.get("PublicIpAddresses")
        self._PrivateIpAddresses = params.get("PrivateIpAddresses")
        self._InstanceName = params.get("InstanceName")
        self._RunFlag = params.get("RunFlag")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ClassicalTargetInfo(AbstractModel):
    r"""传统型负载均衡的后端信息

    """

    def __init__(self):
        r"""
        :param _InstanceId: 后端实例ID
        :type InstanceId: str
        :param _Weight: 权重，取值范围 [0, 100]
        :type Weight: int
        """
        self._InstanceId = None
        self._Weight = None

    @property
    def InstanceId(self):
        r"""后端实例ID
        :rtype: str
        """
        return self._InstanceId

    @InstanceId.setter
    def InstanceId(self, InstanceId):
        self._InstanceId = InstanceId

    @property
    def Weight(self):
        r"""权重，取值范围 [0, 100]
        :rtype: int
        """
        return self._Weight

    @Weight.setter
    def Weight(self, Weight):
        self._Weight = Weight


    def _deserialize(self, params):
        self._InstanceId = params.get("InstanceId")
        self._Weight = params.get("Weight")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CloneLoadBalancerRequest(AbstractModel):
    r"""CloneLoadBalancer请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口获取。
        :type LoadBalancerId: str
        :param _LoadBalancerName: 克隆出负载均衡实例的名称，规则：1-60 个英文、汉字、数字、连接线“-”或下划线“_”。
注意：如果名称与系统中已有负载均衡实例的名称相同，则系统将会自动生成此次创建的负载均衡实例的名称。
        :type LoadBalancerName: str
        :param _ProjectId: 负载均衡实例所属的项目 ID，默认项目 ID 为0，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口获取。不传此参数则视为默认项目。
        :type ProjectId: int
        :param _MasterZoneId: 仅适用于公网负载均衡。设置跨可用区容灾时的主可用区ID，可用区 ID 和名称均支持，例如 100001 或 ap-guangzhou-1。
注：主可用区是需要承载流量的可用区，备可用区默认不承载流量，主可用区不可用时才使用备可用区，平台将为您自动选择最佳备可用区。可通过 [DescribeResources](https://cloud.tencent.com/document/api/214/70213) 接口查询一个地域的主可用区的列表。
        :type MasterZoneId: str
        :param _SlaveZoneId: 仅适用于公网负载均衡。设置跨可用区容灾时的备可用区ID，可用区 ID 和名称均支持，例如 100001 或 ap-guangzhou-1。
注：备可用区是主可用区故障后，需要承载流量的可用区。可通过 [DescribeResources](https://cloud.tencent.com/document/api/214/70213) 接口查询一个地域的主/备可用区的列表。
        :type SlaveZoneId: str
        :param _ZoneId: 仅适用于公网负载均衡。可用区ID，可用区 ID 和名称均支持，指定可用区以创建负载均衡实例。如：100001 或 ap-guangzhou-1。不传则查询所有可用区的 CVM 实例。如需指定可用区，可调用查询可用区列表 [DescribeZones](https://cloud.tencent.com/document/product/213/15707) 接口查询。
        :type ZoneId: str
        :param _InternetAccessible: 仅适用于公网负载均衡。负载均衡的网络计费模式。
        :type InternetAccessible: :class:`tencentcloud.clb.v20180317.models.InternetAccessible`
        :param _VipIsp: 仅适用于公网负载均衡。目前仅广州、上海、南京、济南、杭州、福州、北京、石家庄、武汉、长沙、成都、重庆地域支持静态单线 IP 线路类型，如需体验，请联系商务经理申请。申请通过后，即可选择中国移动（CMCC）、中国联通（CUCC）或中国电信（CTCC）的运营商类型，网络计费模式只能使用按带宽包计费(BANDWIDTH_PACKAGE)。 如果不指定本参数，则默认使用BGP。可通过 DescribeResources 接口查询一个地域所支持的Isp。
        :type VipIsp: str
        :param _Vip: 指定Vip申请负载均衡。
        :type Vip: str
        :param _Tags: 购买负载均衡同时，给负载均衡打上标签。
        :type Tags: list of TagInfo
        :param _ExclusiveCluster: 独占集群信息。
        :type ExclusiveCluster: :class:`tencentcloud.clb.v20180317.models.ExclusiveCluster`
        :param _BandwidthPackageId: 带宽包ID，可以通过 [DescribeBandwidthPackages](https://cloud.tencent.com/document/api/215/19209) 接口获取。指定此参数时，网络计费方式（InternetAccessible.InternetChargeType）只支持按带宽包计费（BANDWIDTH_PACKAGE）。
        :type BandwidthPackageId: str
        :param _SnatPro: 是否支持绑定跨地域/跨Vpc绑定IP的功能。
        :type SnatPro: bool
        :param _SnatIps: 开启绑定跨地域/跨Vpc绑定IP的功能后，创建SnatIp。
        :type SnatIps: list of SnatIp
        :param _ClusterIds: 公网独占集群ID或者CDCId，可以通过 [DescribeExclusiveClusters](https://cloud.tencent.com/document/product/214/49278) 接口获取。
        :type ClusterIds: list of str
        :param _SlaType: 性能容量型规格。<li>clb.c2.medium（标准型）</li><li>clb.c3.small（高阶型1）</li><li>clb.c3.medium（高阶型2）</li><li>clb.c4.small（超强型1）</li><li>clb.c4.medium（超强型2）</li><li>clb.c4.large（超强型3）</li><li>clb.c4.xlarge（超强型4）</li>
        :type SlaType: str
        :param _ClusterTag: Stgw独占集群的标签。
        :type ClusterTag: str
        :param _Zones: 仅适用于私有网络内网负载均衡。内网就近接入时，选择可用区下发。可调用[DescribeZones](https://cloud.tencent.com/document/product/213/15707)接口查询可用区列表。
        :type Zones: list of str
        :param _EipAddressId: EIP 的唯一 ID，形如：eip-qhx8udkc，仅适用于内网负载均衡绑定EIP，可以通过 [DescribeAddresses](https://cloud.tencent.com/document/product/215/16702) 接口查询。
        :type EipAddressId: str
        """
        self._LoadBalancerId = None
        self._LoadBalancerName = None
        self._ProjectId = None
        self._MasterZoneId = None
        self._SlaveZoneId = None
        self._ZoneId = None
        self._InternetAccessible = None
        self._VipIsp = None
        self._Vip = None
        self._Tags = None
        self._ExclusiveCluster = None
        self._BandwidthPackageId = None
        self._SnatPro = None
        self._SnatIps = None
        self._ClusterIds = None
        self._SlaType = None
        self._ClusterTag = None
        self._Zones = None
        self._EipAddressId = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口获取。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def LoadBalancerName(self):
        r"""克隆出负载均衡实例的名称，规则：1-60 个英文、汉字、数字、连接线“-”或下划线“_”。
注意：如果名称与系统中已有负载均衡实例的名称相同，则系统将会自动生成此次创建的负载均衡实例的名称。
        :rtype: str
        """
        return self._LoadBalancerName

    @LoadBalancerName.setter
    def LoadBalancerName(self, LoadBalancerName):
        self._LoadBalancerName = LoadBalancerName

    @property
    def ProjectId(self):
        r"""负载均衡实例所属的项目 ID，默认项目 ID 为0，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口获取。不传此参数则视为默认项目。
        :rtype: int
        """
        return self._ProjectId

    @ProjectId.setter
    def ProjectId(self, ProjectId):
        self._ProjectId = ProjectId

    @property
    def MasterZoneId(self):
        r"""仅适用于公网负载均衡。设置跨可用区容灾时的主可用区ID，可用区 ID 和名称均支持，例如 100001 或 ap-guangzhou-1。
注：主可用区是需要承载流量的可用区，备可用区默认不承载流量，主可用区不可用时才使用备可用区，平台将为您自动选择最佳备可用区。可通过 [DescribeResources](https://cloud.tencent.com/document/api/214/70213) 接口查询一个地域的主可用区的列表。
        :rtype: str
        """
        return self._MasterZoneId

    @MasterZoneId.setter
    def MasterZoneId(self, MasterZoneId):
        self._MasterZoneId = MasterZoneId

    @property
    def SlaveZoneId(self):
        r"""仅适用于公网负载均衡。设置跨可用区容灾时的备可用区ID，可用区 ID 和名称均支持，例如 100001 或 ap-guangzhou-1。
注：备可用区是主可用区故障后，需要承载流量的可用区。可通过 [DescribeResources](https://cloud.tencent.com/document/api/214/70213) 接口查询一个地域的主/备可用区的列表。
        :rtype: str
        """
        return self._SlaveZoneId

    @SlaveZoneId.setter
    def SlaveZoneId(self, SlaveZoneId):
        self._SlaveZoneId = SlaveZoneId

    @property
    def ZoneId(self):
        r"""仅适用于公网负载均衡。可用区ID，可用区 ID 和名称均支持，指定可用区以创建负载均衡实例。如：100001 或 ap-guangzhou-1。不传则查询所有可用区的 CVM 实例。如需指定可用区，可调用查询可用区列表 [DescribeZones](https://cloud.tencent.com/document/product/213/15707) 接口查询。
        :rtype: str
        """
        return self._ZoneId

    @ZoneId.setter
    def ZoneId(self, ZoneId):
        self._ZoneId = ZoneId

    @property
    def InternetAccessible(self):
        r"""仅适用于公网负载均衡。负载均衡的网络计费模式。
        :rtype: :class:`tencentcloud.clb.v20180317.models.InternetAccessible`
        """
        return self._InternetAccessible

    @InternetAccessible.setter
    def InternetAccessible(self, InternetAccessible):
        self._InternetAccessible = InternetAccessible

    @property
    def VipIsp(self):
        r"""仅适用于公网负载均衡。目前仅广州、上海、南京、济南、杭州、福州、北京、石家庄、武汉、长沙、成都、重庆地域支持静态单线 IP 线路类型，如需体验，请联系商务经理申请。申请通过后，即可选择中国移动（CMCC）、中国联通（CUCC）或中国电信（CTCC）的运营商类型，网络计费模式只能使用按带宽包计费(BANDWIDTH_PACKAGE)。 如果不指定本参数，则默认使用BGP。可通过 DescribeResources 接口查询一个地域所支持的Isp。
        :rtype: str
        """
        return self._VipIsp

    @VipIsp.setter
    def VipIsp(self, VipIsp):
        self._VipIsp = VipIsp

    @property
    def Vip(self):
        r"""指定Vip申请负载均衡。
        :rtype: str
        """
        return self._Vip

    @Vip.setter
    def Vip(self, Vip):
        self._Vip = Vip

    @property
    def Tags(self):
        r"""购买负载均衡同时，给负载均衡打上标签。
        :rtype: list of TagInfo
        """
        return self._Tags

    @Tags.setter
    def Tags(self, Tags):
        self._Tags = Tags

    @property
    def ExclusiveCluster(self):
        r"""独占集群信息。
        :rtype: :class:`tencentcloud.clb.v20180317.models.ExclusiveCluster`
        """
        return self._ExclusiveCluster

    @ExclusiveCluster.setter
    def ExclusiveCluster(self, ExclusiveCluster):
        self._ExclusiveCluster = ExclusiveCluster

    @property
    def BandwidthPackageId(self):
        r"""带宽包ID，可以通过 [DescribeBandwidthPackages](https://cloud.tencent.com/document/api/215/19209) 接口获取。指定此参数时，网络计费方式（InternetAccessible.InternetChargeType）只支持按带宽包计费（BANDWIDTH_PACKAGE）。
        :rtype: str
        """
        return self._BandwidthPackageId

    @BandwidthPackageId.setter
    def BandwidthPackageId(self, BandwidthPackageId):
        self._BandwidthPackageId = BandwidthPackageId

    @property
    def SnatPro(self):
        r"""是否支持绑定跨地域/跨Vpc绑定IP的功能。
        :rtype: bool
        """
        return self._SnatPro

    @SnatPro.setter
    def SnatPro(self, SnatPro):
        self._SnatPro = SnatPro

    @property
    def SnatIps(self):
        r"""开启绑定跨地域/跨Vpc绑定IP的功能后，创建SnatIp。
        :rtype: list of SnatIp
        """
        return self._SnatIps

    @SnatIps.setter
    def SnatIps(self, SnatIps):
        self._SnatIps = SnatIps

    @property
    def ClusterIds(self):
        r"""公网独占集群ID或者CDCId，可以通过 [DescribeExclusiveClusters](https://cloud.tencent.com/document/product/214/49278) 接口获取。
        :rtype: list of str
        """
        return self._ClusterIds

    @ClusterIds.setter
    def ClusterIds(self, ClusterIds):
        self._ClusterIds = ClusterIds

    @property
    def SlaType(self):
        r"""性能容量型规格。<li>clb.c2.medium（标准型）</li><li>clb.c3.small（高阶型1）</li><li>clb.c3.medium（高阶型2）</li><li>clb.c4.small（超强型1）</li><li>clb.c4.medium（超强型2）</li><li>clb.c4.large（超强型3）</li><li>clb.c4.xlarge（超强型4）</li>
        :rtype: str
        """
        return self._SlaType

    @SlaType.setter
    def SlaType(self, SlaType):
        self._SlaType = SlaType

    @property
    def ClusterTag(self):
        r"""Stgw独占集群的标签。
        :rtype: str
        """
        return self._ClusterTag

    @ClusterTag.setter
    def ClusterTag(self, ClusterTag):
        self._ClusterTag = ClusterTag

    @property
    def Zones(self):
        r"""仅适用于私有网络内网负载均衡。内网就近接入时，选择可用区下发。可调用[DescribeZones](https://cloud.tencent.com/document/product/213/15707)接口查询可用区列表。
        :rtype: list of str
        """
        return self._Zones

    @Zones.setter
    def Zones(self, Zones):
        self._Zones = Zones

    @property
    def EipAddressId(self):
        r"""EIP 的唯一 ID，形如：eip-qhx8udkc，仅适用于内网负载均衡绑定EIP，可以通过 [DescribeAddresses](https://cloud.tencent.com/document/product/215/16702) 接口查询。
        :rtype: str
        """
        return self._EipAddressId

    @EipAddressId.setter
    def EipAddressId(self, EipAddressId):
        self._EipAddressId = EipAddressId


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._LoadBalancerName = params.get("LoadBalancerName")
        self._ProjectId = params.get("ProjectId")
        self._MasterZoneId = params.get("MasterZoneId")
        self._SlaveZoneId = params.get("SlaveZoneId")
        self._ZoneId = params.get("ZoneId")
        if params.get("InternetAccessible") is not None:
            self._InternetAccessible = InternetAccessible()
            self._InternetAccessible._deserialize(params.get("InternetAccessible"))
        self._VipIsp = params.get("VipIsp")
        self._Vip = params.get("Vip")
        if params.get("Tags") is not None:
            self._Tags = []
            for item in params.get("Tags"):
                obj = TagInfo()
                obj._deserialize(item)
                self._Tags.append(obj)
        if params.get("ExclusiveCluster") is not None:
            self._ExclusiveCluster = ExclusiveCluster()
            self._ExclusiveCluster._deserialize(params.get("ExclusiveCluster"))
        self._BandwidthPackageId = params.get("BandwidthPackageId")
        self._SnatPro = params.get("SnatPro")
        if params.get("SnatIps") is not None:
            self._SnatIps = []
            for item in params.get("SnatIps"):
                obj = SnatIp()
                obj._deserialize(item)
                self._SnatIps.append(obj)
        self._ClusterIds = params.get("ClusterIds")
        self._SlaType = params.get("SlaType")
        self._ClusterTag = params.get("ClusterTag")
        self._Zones = params.get("Zones")
        self._EipAddressId = params.get("EipAddressId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CloneLoadBalancerResponse(AbstractModel):
    r"""CloneLoadBalancer返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class Cluster(AbstractModel):
    r"""集群的详细信息，如集群ID，名称，类型，可用区，标签等

    """

    def __init__(self):
        r"""
        :param _ClusterId: 集群唯一ID
        :type ClusterId: str
        :param _ClusterName: 集群名称
        :type ClusterName: str
        :param _ClusterType: 集群类型，如TGW，STGW，VPCGW
        :type ClusterType: str
        :param _ClusterTag: 集群标签，只有TGW/STGW集群有标签
注意：此字段可能返回 null，表示取不到有效值。
        :type ClusterTag: str
        :param _Zone: 集群所在可用区，如ap-guangzhou-1
        :type Zone: str
        :param _Network: 集群网络类型，如Public，Private
        :type Network: str
        :param _MaxConn: 最大连接数（个/秒）
注意：此字段可能返回 null，表示取不到有效值。
        :type MaxConn: int
        :param _MaxInFlow: 最大入带宽Mbps
注意：此字段可能返回 null，表示取不到有效值。
        :type MaxInFlow: int
        :param _MaxInPkg: 最大入包量（个/秒）
注意：此字段可能返回 null，表示取不到有效值。
        :type MaxInPkg: int
        :param _MaxOutFlow: 最大出带宽Mbps
注意：此字段可能返回 null，表示取不到有效值。
        :type MaxOutFlow: int
        :param _MaxOutPkg: 最大出包量（个/秒）
注意：此字段可能返回 null，表示取不到有效值。
        :type MaxOutPkg: int
        :param _MaxNewConn: 最大新建连接数（个/秒）
注意：此字段可能返回 null，表示取不到有效值。
        :type MaxNewConn: int
        :param _HTTPMaxNewConn: http最大新建连接数（个/秒）
注意：此字段可能返回 null，表示取不到有效值。
        :type HTTPMaxNewConn: int
        :param _HTTPSMaxNewConn: https最大新建连接数（个/秒）
注意：此字段可能返回 null，表示取不到有效值。
        :type HTTPSMaxNewConn: int
        :param _HTTPQps: http QPS
注意：此字段可能返回 null，表示取不到有效值。
        :type HTTPQps: int
        :param _HTTPSQps: https QPS
注意：此字段可能返回 null，表示取不到有效值。
        :type HTTPSQps: int
        :param _ResourceCount: 集群内资源总数目
        :type ResourceCount: int
        :param _IdleResourceCount: 集群内空闲资源数目
注意：此字段可能返回 null，表示取不到有效值。
        :type IdleResourceCount: int
        :param _LoadBalanceDirectorCount: 集群内转发机的数目
注意：此字段可能返回 null，表示取不到有效值。
        :type LoadBalanceDirectorCount: int
        :param _Isp: 集群的Isp属性，如："BGP","CMCC","CUCC","CTCC","INTERNAL"。
注意：此字段可能返回 null，表示取不到有效值。
        :type Isp: str
        :param _ClustersZone: 集群所在的可用区
注意：此字段可能返回 null，表示取不到有效值。
        :type ClustersZone: :class:`tencentcloud.clb.v20180317.models.ClustersZone`
        :param _ClustersVersion: 集群版本
注意：此字段可能返回 null，表示取不到有效值。
        :type ClustersVersion: str
        :param _DisasterRecoveryType: 集群容灾类型，如SINGLE-ZONE，DISASTER-RECOVERY，MUTUAL-DISASTER-RECOVERY
        :type DisasterRecoveryType: str
        :param _Egress: 网络出口
        :type Egress: str
        :param _IPVersion: IP版本
        :type IPVersion: str
        :param _Tag: 标签信息
        :type Tag: list of TagInfo
        """
        self._ClusterId = None
        self._ClusterName = None
        self._ClusterType = None
        self._ClusterTag = None
        self._Zone = None
        self._Network = None
        self._MaxConn = None
        self._MaxInFlow = None
        self._MaxInPkg = None
        self._MaxOutFlow = None
        self._MaxOutPkg = None
        self._MaxNewConn = None
        self._HTTPMaxNewConn = None
        self._HTTPSMaxNewConn = None
        self._HTTPQps = None
        self._HTTPSQps = None
        self._ResourceCount = None
        self._IdleResourceCount = None
        self._LoadBalanceDirectorCount = None
        self._Isp = None
        self._ClustersZone = None
        self._ClustersVersion = None
        self._DisasterRecoveryType = None
        self._Egress = None
        self._IPVersion = None
        self._Tag = None

    @property
    def ClusterId(self):
        r"""集群唯一ID
        :rtype: str
        """
        return self._ClusterId

    @ClusterId.setter
    def ClusterId(self, ClusterId):
        self._ClusterId = ClusterId

    @property
    def ClusterName(self):
        r"""集群名称
        :rtype: str
        """
        return self._ClusterName

    @ClusterName.setter
    def ClusterName(self, ClusterName):
        self._ClusterName = ClusterName

    @property
    def ClusterType(self):
        r"""集群类型，如TGW，STGW，VPCGW
        :rtype: str
        """
        return self._ClusterType

    @ClusterType.setter
    def ClusterType(self, ClusterType):
        self._ClusterType = ClusterType

    @property
    def ClusterTag(self):
        r"""集群标签，只有TGW/STGW集群有标签
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ClusterTag

    @ClusterTag.setter
    def ClusterTag(self, ClusterTag):
        self._ClusterTag = ClusterTag

    @property
    def Zone(self):
        r"""集群所在可用区，如ap-guangzhou-1
        :rtype: str
        """
        return self._Zone

    @Zone.setter
    def Zone(self, Zone):
        self._Zone = Zone

    @property
    def Network(self):
        r"""集群网络类型，如Public，Private
        :rtype: str
        """
        return self._Network

    @Network.setter
    def Network(self, Network):
        self._Network = Network

    @property
    def MaxConn(self):
        r"""最大连接数（个/秒）
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._MaxConn

    @MaxConn.setter
    def MaxConn(self, MaxConn):
        self._MaxConn = MaxConn

    @property
    def MaxInFlow(self):
        r"""最大入带宽Mbps
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._MaxInFlow

    @MaxInFlow.setter
    def MaxInFlow(self, MaxInFlow):
        self._MaxInFlow = MaxInFlow

    @property
    def MaxInPkg(self):
        r"""最大入包量（个/秒）
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._MaxInPkg

    @MaxInPkg.setter
    def MaxInPkg(self, MaxInPkg):
        self._MaxInPkg = MaxInPkg

    @property
    def MaxOutFlow(self):
        r"""最大出带宽Mbps
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._MaxOutFlow

    @MaxOutFlow.setter
    def MaxOutFlow(self, MaxOutFlow):
        self._MaxOutFlow = MaxOutFlow

    @property
    def MaxOutPkg(self):
        r"""最大出包量（个/秒）
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._MaxOutPkg

    @MaxOutPkg.setter
    def MaxOutPkg(self, MaxOutPkg):
        self._MaxOutPkg = MaxOutPkg

    @property
    def MaxNewConn(self):
        r"""最大新建连接数（个/秒）
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._MaxNewConn

    @MaxNewConn.setter
    def MaxNewConn(self, MaxNewConn):
        self._MaxNewConn = MaxNewConn

    @property
    def HTTPMaxNewConn(self):
        r"""http最大新建连接数（个/秒）
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._HTTPMaxNewConn

    @HTTPMaxNewConn.setter
    def HTTPMaxNewConn(self, HTTPMaxNewConn):
        self._HTTPMaxNewConn = HTTPMaxNewConn

    @property
    def HTTPSMaxNewConn(self):
        r"""https最大新建连接数（个/秒）
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._HTTPSMaxNewConn

    @HTTPSMaxNewConn.setter
    def HTTPSMaxNewConn(self, HTTPSMaxNewConn):
        self._HTTPSMaxNewConn = HTTPSMaxNewConn

    @property
    def HTTPQps(self):
        r"""http QPS
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._HTTPQps

    @HTTPQps.setter
    def HTTPQps(self, HTTPQps):
        self._HTTPQps = HTTPQps

    @property
    def HTTPSQps(self):
        r"""https QPS
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._HTTPSQps

    @HTTPSQps.setter
    def HTTPSQps(self, HTTPSQps):
        self._HTTPSQps = HTTPSQps

    @property
    def ResourceCount(self):
        r"""集群内资源总数目
        :rtype: int
        """
        return self._ResourceCount

    @ResourceCount.setter
    def ResourceCount(self, ResourceCount):
        self._ResourceCount = ResourceCount

    @property
    def IdleResourceCount(self):
        r"""集群内空闲资源数目
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._IdleResourceCount

    @IdleResourceCount.setter
    def IdleResourceCount(self, IdleResourceCount):
        self._IdleResourceCount = IdleResourceCount

    @property
    def LoadBalanceDirectorCount(self):
        r"""集群内转发机的数目
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._LoadBalanceDirectorCount

    @LoadBalanceDirectorCount.setter
    def LoadBalanceDirectorCount(self, LoadBalanceDirectorCount):
        self._LoadBalanceDirectorCount = LoadBalanceDirectorCount

    @property
    def Isp(self):
        r"""集群的Isp属性，如："BGP","CMCC","CUCC","CTCC","INTERNAL"。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Isp

    @Isp.setter
    def Isp(self, Isp):
        self._Isp = Isp

    @property
    def ClustersZone(self):
        r"""集群所在的可用区
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.ClustersZone`
        """
        return self._ClustersZone

    @ClustersZone.setter
    def ClustersZone(self, ClustersZone):
        self._ClustersZone = ClustersZone

    @property
    def ClustersVersion(self):
        r"""集群版本
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ClustersVersion

    @ClustersVersion.setter
    def ClustersVersion(self, ClustersVersion):
        self._ClustersVersion = ClustersVersion

    @property
    def DisasterRecoveryType(self):
        r"""集群容灾类型，如SINGLE-ZONE，DISASTER-RECOVERY，MUTUAL-DISASTER-RECOVERY
        :rtype: str
        """
        return self._DisasterRecoveryType

    @DisasterRecoveryType.setter
    def DisasterRecoveryType(self, DisasterRecoveryType):
        self._DisasterRecoveryType = DisasterRecoveryType

    @property
    def Egress(self):
        r"""网络出口
        :rtype: str
        """
        return self._Egress

    @Egress.setter
    def Egress(self, Egress):
        self._Egress = Egress

    @property
    def IPVersion(self):
        r"""IP版本
        :rtype: str
        """
        return self._IPVersion

    @IPVersion.setter
    def IPVersion(self, IPVersion):
        self._IPVersion = IPVersion

    @property
    def Tag(self):
        r"""标签信息
        :rtype: list of TagInfo
        """
        return self._Tag

    @Tag.setter
    def Tag(self, Tag):
        self._Tag = Tag


    def _deserialize(self, params):
        self._ClusterId = params.get("ClusterId")
        self._ClusterName = params.get("ClusterName")
        self._ClusterType = params.get("ClusterType")
        self._ClusterTag = params.get("ClusterTag")
        self._Zone = params.get("Zone")
        self._Network = params.get("Network")
        self._MaxConn = params.get("MaxConn")
        self._MaxInFlow = params.get("MaxInFlow")
        self._MaxInPkg = params.get("MaxInPkg")
        self._MaxOutFlow = params.get("MaxOutFlow")
        self._MaxOutPkg = params.get("MaxOutPkg")
        self._MaxNewConn = params.get("MaxNewConn")
        self._HTTPMaxNewConn = params.get("HTTPMaxNewConn")
        self._HTTPSMaxNewConn = params.get("HTTPSMaxNewConn")
        self._HTTPQps = params.get("HTTPQps")
        self._HTTPSQps = params.get("HTTPSQps")
        self._ResourceCount = params.get("ResourceCount")
        self._IdleResourceCount = params.get("IdleResourceCount")
        self._LoadBalanceDirectorCount = params.get("LoadBalanceDirectorCount")
        self._Isp = params.get("Isp")
        if params.get("ClustersZone") is not None:
            self._ClustersZone = ClustersZone()
            self._ClustersZone._deserialize(params.get("ClustersZone"))
        self._ClustersVersion = params.get("ClustersVersion")
        self._DisasterRecoveryType = params.get("DisasterRecoveryType")
        self._Egress = params.get("Egress")
        self._IPVersion = params.get("IPVersion")
        if params.get("Tag") is not None:
            self._Tag = []
            for item in params.get("Tag"):
                obj = TagInfo()
                obj._deserialize(item)
                self._Tag.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ClusterInfo(AbstractModel):
    r"""模型路由集群信息

    """

    def __init__(self):
        r"""
        :param _ClusterId: <p>独占集群ID</p>
        :type ClusterId: str
        :param _Type: <p>集群类型</p><p>枚举值：</p><ul><li>Public： 公有云集群</li><li>Exclusive： 独占集群</li></ul><p>默认值：Public</p>
        :type Type: str
        :param _ClusterName: <p>集群名称</p>
        :type ClusterName: str
        """
        self._ClusterId = None
        self._Type = None
        self._ClusterName = None

    @property
    def ClusterId(self):
        r"""<p>独占集群ID</p>
        :rtype: str
        """
        return self._ClusterId

    @ClusterId.setter
    def ClusterId(self, ClusterId):
        self._ClusterId = ClusterId

    @property
    def Type(self):
        r"""<p>集群类型</p><p>枚举值：</p><ul><li>Public： 公有云集群</li><li>Exclusive： 独占集群</li></ul><p>默认值：Public</p>
        :rtype: str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type

    @property
    def ClusterName(self):
        r"""<p>集群名称</p>
        :rtype: str
        """
        return self._ClusterName

    @ClusterName.setter
    def ClusterName(self, ClusterName):
        self._ClusterName = ClusterName


    def _deserialize(self, params):
        self._ClusterId = params.get("ClusterId")
        self._Type = params.get("Type")
        self._ClusterName = params.get("ClusterName")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ClusterInfoInput(AbstractModel):
    r"""创建模型路由时的集群信息

    """

    def __init__(self):
        r"""
        :param _ClusterId: <p>集群ID</p>
        :type ClusterId: str
        :param _Type: <p>集群类型</p><p>枚举值：</p><ul><li>Exclusive： 独占集群</li><li>Public： 公有云共享集群</li></ul>
        :type Type: str
        """
        self._ClusterId = None
        self._Type = None

    @property
    def ClusterId(self):
        r"""<p>集群ID</p>
        :rtype: str
        """
        return self._ClusterId

    @ClusterId.setter
    def ClusterId(self, ClusterId):
        self._ClusterId = ClusterId

    @property
    def Type(self):
        r"""<p>集群类型</p><p>枚举值：</p><ul><li>Exclusive： 独占集群</li><li>Public： 公有云共享集群</li></ul>
        :rtype: str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type


    def _deserialize(self, params):
        self._ClusterId = params.get("ClusterId")
        self._Type = params.get("Type")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ClusterItem(AbstractModel):
    r"""独占集群信息

    """

    def __init__(self):
        r"""
        :param _ClusterId: 集群唯一ID
        :type ClusterId: str
        :param _ClusterName: 集群名称
        :type ClusterName: str
        :param _Zone: 集群所在可用区，如ap-guangzhou-1
注意：此字段可能返回 null，表示取不到有效值。
        :type Zone: str
        """
        self._ClusterId = None
        self._ClusterName = None
        self._Zone = None

    @property
    def ClusterId(self):
        r"""集群唯一ID
        :rtype: str
        """
        return self._ClusterId

    @ClusterId.setter
    def ClusterId(self, ClusterId):
        self._ClusterId = ClusterId

    @property
    def ClusterName(self):
        r"""集群名称
        :rtype: str
        """
        return self._ClusterName

    @ClusterName.setter
    def ClusterName(self, ClusterName):
        self._ClusterName = ClusterName

    @property
    def Zone(self):
        r"""集群所在可用区，如ap-guangzhou-1
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Zone

    @Zone.setter
    def Zone(self, Zone):
        self._Zone = Zone


    def _deserialize(self, params):
        self._ClusterId = params.get("ClusterId")
        self._ClusterName = params.get("ClusterName")
        self._Zone = params.get("Zone")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ClusterResource(AbstractModel):
    r"""集群内资源类型

    """

    def __init__(self):
        r"""
        :param _ClusterId: 集群唯一ID，如tgw-12345678。
        :type ClusterId: str
        :param _Vip: ip地址。
        :type Vip: str
        :param _LoadBalancerId: 负载均衡唯一ID，如lb-12345678。
注意：此字段可能返回 null，表示取不到有效值。
        :type LoadBalancerId: str
        :param _Idle: 资源是否闲置。
        :type Idle: str
        :param _ClusterName: 集群名称。
        :type ClusterName: str
        :param _Isp: 集群的Isp属性，如："BGP","CMCC","CUCC","CTCC","INTERNAL"。
        :type Isp: str
        :param _ClustersZone: 集群所在的可用区
注意：此字段可能返回 null，表示取不到有效值。
        :type ClustersZone: :class:`tencentcloud.clb.v20180317.models.ClustersZone`
        """
        self._ClusterId = None
        self._Vip = None
        self._LoadBalancerId = None
        self._Idle = None
        self._ClusterName = None
        self._Isp = None
        self._ClustersZone = None

    @property
    def ClusterId(self):
        r"""集群唯一ID，如tgw-12345678。
        :rtype: str
        """
        return self._ClusterId

    @ClusterId.setter
    def ClusterId(self, ClusterId):
        self._ClusterId = ClusterId

    @property
    def Vip(self):
        r"""ip地址。
        :rtype: str
        """
        return self._Vip

    @Vip.setter
    def Vip(self, Vip):
        self._Vip = Vip

    @property
    def LoadBalancerId(self):
        r"""负载均衡唯一ID，如lb-12345678。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def Idle(self):
        r"""资源是否闲置。
        :rtype: str
        """
        return self._Idle

    @Idle.setter
    def Idle(self, Idle):
        self._Idle = Idle

    @property
    def ClusterName(self):
        r"""集群名称。
        :rtype: str
        """
        return self._ClusterName

    @ClusterName.setter
    def ClusterName(self, ClusterName):
        self._ClusterName = ClusterName

    @property
    def Isp(self):
        r"""集群的Isp属性，如："BGP","CMCC","CUCC","CTCC","INTERNAL"。
        :rtype: str
        """
        return self._Isp

    @Isp.setter
    def Isp(self, Isp):
        self._Isp = Isp

    @property
    def ClustersZone(self):
        r"""集群所在的可用区
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.ClustersZone`
        """
        return self._ClustersZone

    @ClustersZone.setter
    def ClustersZone(self, ClustersZone):
        self._ClustersZone = ClustersZone


    def _deserialize(self, params):
        self._ClusterId = params.get("ClusterId")
        self._Vip = params.get("Vip")
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._Idle = params.get("Idle")
        self._ClusterName = params.get("ClusterName")
        self._Isp = params.get("Isp")
        if params.get("ClustersZone") is not None:
            self._ClustersZone = ClustersZone()
            self._ClustersZone._deserialize(params.get("ClustersZone"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ClustersZone(AbstractModel):
    r"""集群所在的可用区。

    """

    def __init__(self):
        r"""
        :param _MasterZone: 集群所在的主可用区。
        :type MasterZone: list of str
        :param _SlaveZone: 集群所在的备可用区。
        :type SlaveZone: list of str
        """
        self._MasterZone = None
        self._SlaveZone = None

    @property
    def MasterZone(self):
        r"""集群所在的主可用区。
        :rtype: list of str
        """
        return self._MasterZone

    @MasterZone.setter
    def MasterZone(self, MasterZone):
        self._MasterZone = MasterZone

    @property
    def SlaveZone(self):
        r"""集群所在的备可用区。
        :rtype: list of str
        """
        return self._SlaveZone

    @SlaveZone.setter
    def SlaveZone(self, SlaveZone):
        self._SlaveZone = SlaveZone


    def _deserialize(self, params):
        self._MasterZone = params.get("MasterZone")
        self._SlaveZone = params.get("SlaveZone")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class Coefficient(AbstractModel):
    r"""ModelAlias 积分系数配置

    """

    def __init__(self):
        r"""
        :param _InputCachedCoefficient: <p>缓存命中输入积分系数。</p><p>用于 provider prompt cache 命中的输入 token。</p><p>取值范围：[0, 5000]</p><p>默认值：3</p>
        :type InputCachedCoefficient: float
        :param _InputCacheCreationCoefficient: <p>缓存创建积分系数</p>
        :type InputCacheCreationCoefficient: float
        :param _InputCoefficient: <p>输入积分系数。</p><p>取值范围：[1, 5000]</p><p>默认值：25</p>
        :type InputCoefficient: float
        :param _OutputCoefficient: <p>输出积分系数。</p><p>取值范围：[1, 5000]</p><p>默认值：100</p>
        :type OutputCoefficient: float
        """
        self._InputCachedCoefficient = None
        self._InputCacheCreationCoefficient = None
        self._InputCoefficient = None
        self._OutputCoefficient = None

    @property
    def InputCachedCoefficient(self):
        r"""<p>缓存命中输入积分系数。</p><p>用于 provider prompt cache 命中的输入 token。</p><p>取值范围：[0, 5000]</p><p>默认值：3</p>
        :rtype: float
        """
        return self._InputCachedCoefficient

    @InputCachedCoefficient.setter
    def InputCachedCoefficient(self, InputCachedCoefficient):
        self._InputCachedCoefficient = InputCachedCoefficient

    @property
    def InputCacheCreationCoefficient(self):
        r"""<p>缓存创建积分系数</p>
        :rtype: float
        """
        return self._InputCacheCreationCoefficient

    @InputCacheCreationCoefficient.setter
    def InputCacheCreationCoefficient(self, InputCacheCreationCoefficient):
        self._InputCacheCreationCoefficient = InputCacheCreationCoefficient

    @property
    def InputCoefficient(self):
        r"""<p>输入积分系数。</p><p>取值范围：[1, 5000]</p><p>默认值：25</p>
        :rtype: float
        """
        return self._InputCoefficient

    @InputCoefficient.setter
    def InputCoefficient(self, InputCoefficient):
        self._InputCoefficient = InputCoefficient

    @property
    def OutputCoefficient(self):
        r"""<p>输出积分系数。</p><p>取值范围：[1, 5000]</p><p>默认值：100</p>
        :rtype: float
        """
        return self._OutputCoefficient

    @OutputCoefficient.setter
    def OutputCoefficient(self, OutputCoefficient):
        self._OutputCoefficient = OutputCoefficient


    def _deserialize(self, params):
        self._InputCachedCoefficient = params.get("InputCachedCoefficient")
        self._InputCacheCreationCoefficient = params.get("InputCacheCreationCoefficient")
        self._InputCoefficient = params.get("InputCoefficient")
        self._OutputCoefficient = params.get("OutputCoefficient")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ConfigListItem(AbstractModel):
    r"""配置内容

    """

    def __init__(self):
        r"""
        :param _UconfigId: 配置ID
        :type UconfigId: str
        :param _ConfigType: 配置类型， 可选值：CLB（实例维度配置）， SERVER（服务维度配置），LOCATION（规则维度配置）
        :type ConfigType: str
        :param _ConfigName: 配置名字
        :type ConfigName: str
        :param _ConfigContent: 配置内容
        :type ConfigContent: str
        :param _CreateTimestamp: 配置的创建时间。
格式：YYYY-MM-DD HH:mm:ss
        :type CreateTimestamp: str
        :param _UpdateTimestamp: 配置的修改时间。
格式：YYYY-MM-DD HH:mm:ss
        :type UpdateTimestamp: str
        """
        self._UconfigId = None
        self._ConfigType = None
        self._ConfigName = None
        self._ConfigContent = None
        self._CreateTimestamp = None
        self._UpdateTimestamp = None

    @property
    def UconfigId(self):
        r"""配置ID
        :rtype: str
        """
        return self._UconfigId

    @UconfigId.setter
    def UconfigId(self, UconfigId):
        self._UconfigId = UconfigId

    @property
    def ConfigType(self):
        r"""配置类型， 可选值：CLB（实例维度配置）， SERVER（服务维度配置），LOCATION（规则维度配置）
        :rtype: str
        """
        return self._ConfigType

    @ConfigType.setter
    def ConfigType(self, ConfigType):
        self._ConfigType = ConfigType

    @property
    def ConfigName(self):
        r"""配置名字
        :rtype: str
        """
        return self._ConfigName

    @ConfigName.setter
    def ConfigName(self, ConfigName):
        self._ConfigName = ConfigName

    @property
    def ConfigContent(self):
        r"""配置内容
        :rtype: str
        """
        return self._ConfigContent

    @ConfigContent.setter
    def ConfigContent(self, ConfigContent):
        self._ConfigContent = ConfigContent

    @property
    def CreateTimestamp(self):
        r"""配置的创建时间。
格式：YYYY-MM-DD HH:mm:ss
        :rtype: str
        """
        return self._CreateTimestamp

    @CreateTimestamp.setter
    def CreateTimestamp(self, CreateTimestamp):
        self._CreateTimestamp = CreateTimestamp

    @property
    def UpdateTimestamp(self):
        r"""配置的修改时间。
格式：YYYY-MM-DD HH:mm:ss
        :rtype: str
        """
        return self._UpdateTimestamp

    @UpdateTimestamp.setter
    def UpdateTimestamp(self, UpdateTimestamp):
        self._UpdateTimestamp = UpdateTimestamp


    def _deserialize(self, params):
        self._UconfigId = params.get("UconfigId")
        self._ConfigType = params.get("ConfigType")
        self._ConfigName = params.get("ConfigName")
        self._ConfigContent = params.get("ConfigContent")
        self._CreateTimestamp = params.get("CreateTimestamp")
        self._UpdateTimestamp = params.get("UpdateTimestamp")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CreateBYOKNetworkRequest(AbstractModel):
    r"""CreateBYOKNetwork请求参数结构体

    """

    def __init__(self):
        r"""
        :param _SubnetId: <p>子网 ID</p><p>参数格式：subnet-xxxxxxxx</p>
        :type SubnetId: str
        :param _VpcId: <p>VPC 实例 ID</p><p>参数格式：vpc-xxxxxxxx</p>
        :type VpcId: str
        :param _ServiceProviderName: <p>BYOK 的自定义名字</p><p>入参限制：1～256个字符，可选</p>
        :type ServiceProviderName: str
        :param _Tags: <p>标签</p>
        :type Tags: list of TagInfo
        """
        self._SubnetId = None
        self._VpcId = None
        self._ServiceProviderName = None
        self._Tags = None

    @property
    def SubnetId(self):
        r"""<p>子网 ID</p><p>参数格式：subnet-xxxxxxxx</p>
        :rtype: str
        """
        return self._SubnetId

    @SubnetId.setter
    def SubnetId(self, SubnetId):
        self._SubnetId = SubnetId

    @property
    def VpcId(self):
        r"""<p>VPC 实例 ID</p><p>参数格式：vpc-xxxxxxxx</p>
        :rtype: str
        """
        return self._VpcId

    @VpcId.setter
    def VpcId(self, VpcId):
        self._VpcId = VpcId

    @property
    def ServiceProviderName(self):
        r"""<p>BYOK 的自定义名字</p><p>入参限制：1～256个字符，可选</p>
        :rtype: str
        """
        return self._ServiceProviderName

    @ServiceProviderName.setter
    def ServiceProviderName(self, ServiceProviderName):
        self._ServiceProviderName = ServiceProviderName

    @property
    def Tags(self):
        r"""<p>标签</p>
        :rtype: list of TagInfo
        """
        return self._Tags

    @Tags.setter
    def Tags(self, Tags):
        self._Tags = Tags


    def _deserialize(self, params):
        self._SubnetId = params.get("SubnetId")
        self._VpcId = params.get("VpcId")
        self._ServiceProviderName = params.get("ServiceProviderName")
        if params.get("Tags") is not None:
            self._Tags = []
            for item in params.get("Tags"):
                obj = TagInfo()
                obj._deserialize(item)
                self._Tags.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CreateBYOKNetworkResponse(AbstractModel):
    r"""CreateBYOKNetwork返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class CreateBudgetRequest(AbstractModel):
    r"""CreateBudget请求参数结构体

    """

    def __init__(self):
        r"""
        :param _BudgetConfigs: <p>预算配置数组。</p><p>数组长度最大为3，最多可同时配置1d、7d、30d三个刷新周期，且每种刷新周期只能出现一次。BudgetResetAt不支持作为入参设置，系统会按配置的刷新周期自动维护刷新时间。</p>
        :type BudgetConfigs: list of BudgetConfigInput
        :param _BudgetName: <p>Budget名称。</p><p>不传默认为 '-'。</p>
        :type BudgetName: str
        :param _RateLimitConfig: <p>Budget限速配置。</p>
        :type RateLimitConfig: :class:`tencentcloud.clb.v20180317.models.RateLimitConfigForBudget`
        :param _Resources: <p>创建Budget时同时关联的资源列表。</p><p>仅支持企业型模型路由实例和企业型实例下的Key。如果资源不存在或不可关联，创建请求失败；资源已关联其他Budget时将替换为新创建的Budget。</p>
        :type Resources: list of BudgetResource
        """
        self._BudgetConfigs = None
        self._BudgetName = None
        self._RateLimitConfig = None
        self._Resources = None

    @property
    def BudgetConfigs(self):
        r"""<p>预算配置数组。</p><p>数组长度最大为3，最多可同时配置1d、7d、30d三个刷新周期，且每种刷新周期只能出现一次。BudgetResetAt不支持作为入参设置，系统会按配置的刷新周期自动维护刷新时间。</p>
        :rtype: list of BudgetConfigInput
        """
        return self._BudgetConfigs

    @BudgetConfigs.setter
    def BudgetConfigs(self, BudgetConfigs):
        self._BudgetConfigs = BudgetConfigs

    @property
    def BudgetName(self):
        r"""<p>Budget名称。</p><p>不传默认为 '-'。</p>
        :rtype: str
        """
        return self._BudgetName

    @BudgetName.setter
    def BudgetName(self, BudgetName):
        self._BudgetName = BudgetName

    @property
    def RateLimitConfig(self):
        r"""<p>Budget限速配置。</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.RateLimitConfigForBudget`
        """
        return self._RateLimitConfig

    @RateLimitConfig.setter
    def RateLimitConfig(self, RateLimitConfig):
        self._RateLimitConfig = RateLimitConfig

    @property
    def Resources(self):
        r"""<p>创建Budget时同时关联的资源列表。</p><p>仅支持企业型模型路由实例和企业型实例下的Key。如果资源不存在或不可关联，创建请求失败；资源已关联其他Budget时将替换为新创建的Budget。</p>
        :rtype: list of BudgetResource
        """
        return self._Resources

    @Resources.setter
    def Resources(self, Resources):
        self._Resources = Resources


    def _deserialize(self, params):
        if params.get("BudgetConfigs") is not None:
            self._BudgetConfigs = []
            for item in params.get("BudgetConfigs"):
                obj = BudgetConfigInput()
                obj._deserialize(item)
                self._BudgetConfigs.append(obj)
        self._BudgetName = params.get("BudgetName")
        if params.get("RateLimitConfig") is not None:
            self._RateLimitConfig = RateLimitConfigForBudget()
            self._RateLimitConfig._deserialize(params.get("RateLimitConfig"))
        if params.get("Resources") is not None:
            self._Resources = []
            for item in params.get("Resources"):
                obj = BudgetResource()
                obj._deserialize(item)
                self._Resources.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CreateBudgetResponse(AbstractModel):
    r"""CreateBudget返回参数结构体

    """

    def __init__(self):
        r"""
        :param _BudgetId: <p>Budget ID。</p><p>创建请求提交后返回，可通过DescribeBudgets查询状态。</p>
        :type BudgetId: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._BudgetId = None
        self._RequestId = None

    @property
    def BudgetId(self):
        r"""<p>Budget ID。</p><p>创建请求提交后返回，可通过DescribeBudgets查询状态。</p>
        :rtype: str
        """
        return self._BudgetId

    @BudgetId.setter
    def BudgetId(self, BudgetId):
        self._BudgetId = BudgetId

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._BudgetId = params.get("BudgetId")
        self._RequestId = params.get("RequestId")


class CreateClsLogSetRequest(AbstractModel):
    r"""CreateClsLogSet请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LogsetName: 日志集的名字，不能和cls其他日志集重名。不填默认为clb_logset。
        :type LogsetName: str
        :param _Period: 日志集的保存周期，单位：天。
        :type Period: int
        :param _LogsetType: 日志集类型，ACCESS：访问日志，HEALTH：健康检查日志，默认ACCESS。
        :type LogsetType: str
        """
        self._LogsetName = None
        self._Period = None
        self._LogsetType = None

    @property
    def LogsetName(self):
        r"""日志集的名字，不能和cls其他日志集重名。不填默认为clb_logset。
        :rtype: str
        """
        return self._LogsetName

    @LogsetName.setter
    def LogsetName(self, LogsetName):
        self._LogsetName = LogsetName

    @property
    def Period(self):
        warnings.warn("parameter `Period` is deprecated", DeprecationWarning) 

        r"""日志集的保存周期，单位：天。
        :rtype: int
        """
        return self._Period

    @Period.setter
    def Period(self, Period):
        warnings.warn("parameter `Period` is deprecated", DeprecationWarning) 

        self._Period = Period

    @property
    def LogsetType(self):
        r"""日志集类型，ACCESS：访问日志，HEALTH：健康检查日志，默认ACCESS。
        :rtype: str
        """
        return self._LogsetType

    @LogsetType.setter
    def LogsetType(self, LogsetType):
        self._LogsetType = LogsetType


    def _deserialize(self, params):
        self._LogsetName = params.get("LogsetName")
        self._Period = params.get("Period")
        self._LogsetType = params.get("LogsetType")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CreateClsLogSetResponse(AbstractModel):
    r"""CreateClsLogSet返回参数结构体

    """

    def __init__(self):
        r"""
        :param _LogsetId: 日志集的 ID。
        :type LogsetId: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._LogsetId = None
        self._RequestId = None

    @property
    def LogsetId(self):
        r"""日志集的 ID。
        :rtype: str
        """
        return self._LogsetId

    @LogsetId.setter
    def LogsetId(self, LogsetId):
        self._LogsetId = LogsetId

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._LogsetId = params.get("LogsetId")
        self._RequestId = params.get("RequestId")


class CreateIntentRouterRequest(AbstractModel):
    r"""CreateIntentRouter请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID。</p>
        :type ModelRouterId: str
        :param _RouteName: <p>路由名称，用作LiteLLM的model_name。</p><p>必须以"IntentRouter/"为前缀，后缀仅支持字母、数字、连字符和下划线，后缀长度1-128个字符。</p>
        :type RouteName: str
        :param _Tiers: <p>Tier配置列表。</p><p>每个Tier至少包含一个模型，模型名称必须是已关联到该实例的模型。</p>
        :type Tiers: list of TierItem
        :param _RouterDescribe: <p>意图路由描述。</p>
        :type RouterDescribe: str
        """
        self._ModelRouterId = None
        self._RouteName = None
        self._Tiers = None
        self._RouterDescribe = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID。</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def RouteName(self):
        r"""<p>路由名称，用作LiteLLM的model_name。</p><p>必须以"IntentRouter/"为前缀，后缀仅支持字母、数字、连字符和下划线，后缀长度1-128个字符。</p>
        :rtype: str
        """
        return self._RouteName

    @RouteName.setter
    def RouteName(self, RouteName):
        self._RouteName = RouteName

    @property
    def Tiers(self):
        r"""<p>Tier配置列表。</p><p>每个Tier至少包含一个模型，模型名称必须是已关联到该实例的模型。</p>
        :rtype: list of TierItem
        """
        return self._Tiers

    @Tiers.setter
    def Tiers(self, Tiers):
        self._Tiers = Tiers

    @property
    def RouterDescribe(self):
        r"""<p>意图路由描述。</p>
        :rtype: str
        """
        return self._RouterDescribe

    @RouterDescribe.setter
    def RouterDescribe(self, RouterDescribe):
        self._RouterDescribe = RouterDescribe


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._RouteName = params.get("RouteName")
        if params.get("Tiers") is not None:
            self._Tiers = []
            for item in params.get("Tiers"):
                obj = TierItem()
                obj._deserialize(item)
                self._Tiers.append(obj)
        self._RouterDescribe = params.get("RouterDescribe")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CreateIntentRouterResponse(AbstractModel):
    r"""CreateIntentRouter返回参数结构体

    """

    def __init__(self):
        r"""
        :param _IntentRouterId: <p>创建的意图路由ID（ir-xxx格式）。</p>
        :type IntentRouterId: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._IntentRouterId = None
        self._RequestId = None

    @property
    def IntentRouterId(self):
        r"""<p>创建的意图路由ID（ir-xxx格式）。</p>
        :rtype: str
        """
        return self._IntentRouterId

    @IntentRouterId.setter
    def IntentRouterId(self, IntentRouterId):
        self._IntentRouterId = IntentRouterId

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._IntentRouterId = params.get("IntentRouterId")
        self._RequestId = params.get("RequestId")


class CreateKeyRequest(AbstractModel):
    r"""CreateKey请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID</p>
        :type ModelRouterId: str
        :param _KeyName: <p>Key名称</p>
        :type KeyName: str
        :param _RateLimitConfig: <p>限速配置</p>
        :type RateLimitConfig: :class:`tencentcloud.clb.v20180317.models.RateLimitConfigForKey`
        :param _BudgetId: <p>关联的积分预算ID</p>
        :type BudgetId: str
        :param _UserGroupId: <p>需要关联的用户组ID</p>
        :type UserGroupId: str
        :param _Tags: <p>标签</p>
        :type Tags: list of TagInfo
        """
        self._ModelRouterId = None
        self._KeyName = None
        self._RateLimitConfig = None
        self._BudgetId = None
        self._UserGroupId = None
        self._Tags = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def KeyName(self):
        r"""<p>Key名称</p>
        :rtype: str
        """
        return self._KeyName

    @KeyName.setter
    def KeyName(self, KeyName):
        self._KeyName = KeyName

    @property
    def RateLimitConfig(self):
        r"""<p>限速配置</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.RateLimitConfigForKey`
        """
        return self._RateLimitConfig

    @RateLimitConfig.setter
    def RateLimitConfig(self, RateLimitConfig):
        self._RateLimitConfig = RateLimitConfig

    @property
    def BudgetId(self):
        r"""<p>关联的积分预算ID</p>
        :rtype: str
        """
        return self._BudgetId

    @BudgetId.setter
    def BudgetId(self, BudgetId):
        self._BudgetId = BudgetId

    @property
    def UserGroupId(self):
        r"""<p>需要关联的用户组ID</p>
        :rtype: str
        """
        return self._UserGroupId

    @UserGroupId.setter
    def UserGroupId(self, UserGroupId):
        self._UserGroupId = UserGroupId

    @property
    def Tags(self):
        r"""<p>标签</p>
        :rtype: list of TagInfo
        """
        return self._Tags

    @Tags.setter
    def Tags(self, Tags):
        self._Tags = Tags


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._KeyName = params.get("KeyName")
        if params.get("RateLimitConfig") is not None:
            self._RateLimitConfig = RateLimitConfigForKey()
            self._RateLimitConfig._deserialize(params.get("RateLimitConfig"))
        self._BudgetId = params.get("BudgetId")
        self._UserGroupId = params.get("UserGroupId")
        if params.get("Tags") is not None:
            self._Tags = []
            for item in params.get("Tags"):
                obj = TagInfo()
                obj._deserialize(item)
                self._Tags.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CreateKeyResponse(AbstractModel):
    r"""CreateKey返回参数结构体

    """

    def __init__(self):
        r"""
        :param _KeyId: <p>Key的ID</p>
        :type KeyId: str
        :param _Key: <p>返回的真实Key</p>
        :type Key: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._KeyId = None
        self._Key = None
        self._RequestId = None

    @property
    def KeyId(self):
        r"""<p>Key的ID</p>
        :rtype: str
        """
        return self._KeyId

    @KeyId.setter
    def KeyId(self, KeyId):
        self._KeyId = KeyId

    @property
    def Key(self):
        r"""<p>返回的真实Key</p>
        :rtype: str
        """
        return self._Key

    @Key.setter
    def Key(self, Key):
        self._Key = Key

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._KeyId = params.get("KeyId")
        self._Key = params.get("Key")
        self._RequestId = params.get("RequestId")


class CreateKeysRequest(AbstractModel):
    r"""CreateKeys请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由ID</p>
        :type ModelRouterId: str
        :param _BudgetId: <p>需要绑定的预算信息，所有Key共用</p>
        :type BudgetId: str
        :param _Keys: <p>Key列表</p>
        :type Keys: list of InputKeyInfo
        :param _Mode: <p>批量创建Key的模式</p><p>枚举值：</p><ul><li>Generate： 平台生成Key</li><li>Import： 导入自带Key</li></ul><p>默认值：Generate</p>
        :type Mode: str
        :param _RateLimitConfig: <p>限速信息，所有Key共用</p>
        :type RateLimitConfig: :class:`tencentcloud.clb.v20180317.models.RateLimitConfigForKey`
        :param _Tags: <p>标签。所有Key都会绑定该标签。</p>
        :type Tags: list of TagInfo
        :param _UserGroupId: <p>需要关联的用户组ID</p>
        :type UserGroupId: str
        """
        self._ModelRouterId = None
        self._BudgetId = None
        self._Keys = None
        self._Mode = None
        self._RateLimitConfig = None
        self._Tags = None
        self._UserGroupId = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def BudgetId(self):
        r"""<p>需要绑定的预算信息，所有Key共用</p>
        :rtype: str
        """
        return self._BudgetId

    @BudgetId.setter
    def BudgetId(self, BudgetId):
        self._BudgetId = BudgetId

    @property
    def Keys(self):
        r"""<p>Key列表</p>
        :rtype: list of InputKeyInfo
        """
        return self._Keys

    @Keys.setter
    def Keys(self, Keys):
        self._Keys = Keys

    @property
    def Mode(self):
        r"""<p>批量创建Key的模式</p><p>枚举值：</p><ul><li>Generate： 平台生成Key</li><li>Import： 导入自带Key</li></ul><p>默认值：Generate</p>
        :rtype: str
        """
        return self._Mode

    @Mode.setter
    def Mode(self, Mode):
        self._Mode = Mode

    @property
    def RateLimitConfig(self):
        r"""<p>限速信息，所有Key共用</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.RateLimitConfigForKey`
        """
        return self._RateLimitConfig

    @RateLimitConfig.setter
    def RateLimitConfig(self, RateLimitConfig):
        self._RateLimitConfig = RateLimitConfig

    @property
    def Tags(self):
        r"""<p>标签。所有Key都会绑定该标签。</p>
        :rtype: list of TagInfo
        """
        return self._Tags

    @Tags.setter
    def Tags(self, Tags):
        self._Tags = Tags

    @property
    def UserGroupId(self):
        r"""<p>需要关联的用户组ID</p>
        :rtype: str
        """
        return self._UserGroupId

    @UserGroupId.setter
    def UserGroupId(self, UserGroupId):
        self._UserGroupId = UserGroupId


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._BudgetId = params.get("BudgetId")
        if params.get("Keys") is not None:
            self._Keys = []
            for item in params.get("Keys"):
                obj = InputKeyInfo()
                obj._deserialize(item)
                self._Keys.append(obj)
        self._Mode = params.get("Mode")
        if params.get("RateLimitConfig") is not None:
            self._RateLimitConfig = RateLimitConfigForKey()
            self._RateLimitConfig._deserialize(params.get("RateLimitConfig"))
        if params.get("Tags") is not None:
            self._Tags = []
            for item in params.get("Tags"):
                obj = TagInfo()
                obj._deserialize(item)
                self._Tags.append(obj)
        self._UserGroupId = params.get("UserGroupId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CreateKeysResponse(AbstractModel):
    r"""CreateKeys返回参数结构体

    """

    def __init__(self):
        r"""
        :param _CreatedKeys: <p>创建的Key的信息</p>
        :type CreatedKeys: list of CreatedKey
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._CreatedKeys = None
        self._RequestId = None

    @property
    def CreatedKeys(self):
        r"""<p>创建的Key的信息</p>
        :rtype: list of CreatedKey
        """
        return self._CreatedKeys

    @CreatedKeys.setter
    def CreatedKeys(self, CreatedKeys):
        self._CreatedKeys = CreatedKeys

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("CreatedKeys") is not None:
            self._CreatedKeys = []
            for item in params.get("CreatedKeys"):
                obj = CreatedKey()
                obj._deserialize(item)
                self._CreatedKeys.append(obj)
        self._RequestId = params.get("RequestId")


class CreateListenerRequest(AbstractModel):
    r"""CreateListener请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: <p>负载均衡实例 ID，可以通过 <a href="https://cloud.tencent.com/document/product/214/30685">DescribeLoadBalancers</a> 接口获取。</p>
        :type LoadBalancerId: str
        :param _Ports: <p>要将监听器创建到哪些端口，每个端口对应一个新的监听器。<br>端口范围：1~65535</p>
        :type Ports: list of int
        :param _Protocol: <p>监听器协议： TCP | UDP | HTTP | HTTPS | TCP_SSL | QUIC。</p>
        :type Protocol: str
        :param _ListenerNames: <p>要创建的监听器名称列表，名称与Ports数组按序一一对应，如不需立即命名，则无需提供此参数。命名规则：1-80 个英文字母、汉字等国际通用语言字符，数字，连接线“-”、下划线“_”等常见字符（禁止Unicode补充字符，如emoji表情、生僻汉字等）。</p>
        :type ListenerNames: list of str
        :param _HealthCheck: <p>健康检查相关参数，此参数仅适用于TCP/UDP/TCP_SSL/QUIC监听器。</p>
        :type HealthCheck: :class:`tencentcloud.clb.v20180317.models.HealthCheck`
        :param _Certificate: <p>证书相关信息。参数限制如下：</p><li>此参数仅适用于TCP_SSL监听器和未开启SNI特性的HTTPS监听器。</li><li>创建TCP_SSL监听器和未开启SNI特性的HTTPS监听器时，此参数和参数MultiCertInfo至少需要传一个， 但不能同时传入。</li>
        :type Certificate: :class:`tencentcloud.clb.v20180317.models.CertificateInput`
        :param _SessionExpireTime: <p>会话保持时间，单位：秒。可选值：30~3600，默认为0，默认不开启。此参数仅适用于TCP/UDP监听器。</p>
        :type SessionExpireTime: int
        :param _Scheduler: <p>监听器转发的方式。可选值：WRR（按权重轮询）、LEAST_CONN（按最小连接数）<br>默认为 WRR。此参数仅适用于TCP/UDP/TCP_SSL/QUIC监听器。</p>
        :type Scheduler: str
        :param _SniSwitch: <p>是否开启SNI特性，此参数仅适用于HTTPS监听器。0表示未开启，1表示开启。</p>
        :type SniSwitch: int
        :param _TargetType: <p>后端目标类型，NODE表示绑定普通节点，TARGETGROUP表示绑定目标组。此参数仅适用于TCP/UDP监听器。七层监听器应在转发规则中设置。</p>
        :type TargetType: str
        :param _SessionType: <p>会话保持类型。不传或传NORMAL表示默认会话保持类型。QUIC_CID 表示根据Quic Connection ID做会话保持。QUIC_CID只支持UDP协议。此参数仅适用于TCP/UDP监听器。七层监听器应在转发规则中设置。（若选择QUIC_CID，则Protocol必须为UDP，Scheduler必须为WRR，同时只支持ipv4）</p>
        :type SessionType: str
        :param _KeepaliveEnable: <p>是否开启长连接，此参数仅适用于HTTP/HTTPS监听器，0:关闭；1:开启， 默认关闭。<br>若后端服务对连接数上限有限制，则建议谨慎开启。此功能目前处于内测中，如需使用，请提交 <a href="https://cloud.tencent.com/apply/p/tsodp6qm21">内测申请</a>。</p>
        :type KeepaliveEnable: int
        :param _EndPort: <p>创建端口段监听器时必须传入此参数，用以标识结束端口。同时，入参Ports只允许传入一个成员，用以标识开始端口。【如果您需要体验端口段功能，请通过 <a href="https://console.cloud.tencent.com/workorder/category">工单申请</a>】。</p>
        :type EndPort: int
        :param _DeregisterTargetRst: <p>重新调度功能，解绑后端服务开关，打开此开关，当解绑后端服务时触发重新调度。仅TCP/UDP监听器支持。</p>
        :type DeregisterTargetRst: bool
        :param _MultiCertInfo: <p>证书信息，支持同时传入不同算法类型的多本服务端证书，参数限制如下：</p><li>此参数仅适用于TCP_SSL监听器和未开启SNI特性的HTTPS监听器。</li><li>创建TCP_SSL监听器和未开启SNI特性的HTTPS监听器时，此参数和参数Certificate至少需要传一个， 但不能同时传入。</li>
        :type MultiCertInfo: :class:`tencentcloud.clb.v20180317.models.MultiCertInfo`
        :param _MaxConn: <p>监听器最大连接数，当前仅性能容量型实例且仅TCP/UDP/TCP_SSL/QUIC监听器支持，不传或者传-1表示监听器维度不限速。基础网络实例不支持该参数。</p>
        :type MaxConn: int
        :param _MaxCps: <p>监听器最大新增连接数，当前仅性能容量型实例且仅TCP/UDP/TCP_SSL/QUIC监听器支持，不传或者传-1表示监听器维度不限速。基础网络实例不支持该参数。</p>
        :type MaxCps: int
        :param _IdleConnectTimeout: <p>空闲连接超时时间，此参数仅适用于TCP/UDP监听器，单位：秒。默认值：TCP监听器默认值为900s，UDP监听器默认值为300s。取值范围：共享型实例和独占型实例支持：10-900，性能容量型实例支持：10-1980。如需设置超过取值范围的值请通过 <a href="https://console.cloud.tencent.com/workorder/category">工单申请</a>。</p><p>取值范围：[10, 1980]</p><p>单位：秒</p><p>默认值：900</p><p>TCP监听器默认值为900s，UDP监听器默认值为300s。取值范围：共享型实例和独占型实例支持：10-900，性能容量型实例支持：10-1980。</p>
        :type IdleConnectTimeout: int
        :param _ProxyProtocol: <p>TCP_SSL和QUIC是否支持PP</p>
        :type ProxyProtocol: bool
        :param _SnatEnable: <p>是否开启SNAT（源IP替换），True（开启）、False（关闭）。默认为关闭。注意：SnatEnable开启时会替换客户端源IP，此时<code>透传客户端源IP</code>选项关闭，反之亦然。</p>
        :type SnatEnable: bool
        :param _FullEndPorts: <p>全端口段监听器的结束端口，端口范围：2 - 65535</p>
        :type FullEndPorts: list of int
        :param _H2cSwitch: <p>内网 HTTP 监听器开启 h2c 开关。<br>True（开启）、False（关闭）。默认为关闭。<br>开启后，监听器仅支持创建后端转发类型为 GRPC 或 GRPCS 的七层规则；创建规则时需在 Rules.N.ForwardType 中显式传入 GRPC 或 GRPCS。</p>
        :type H2cSwitch: bool
        :param _SslCloseSwitch: <p>控制 TCP_SSL 类型的监听器是否移除 SSL 加密层。开启后，监听器将作为普通 TCP 协议运行。 可选值：</p><ul><li>True： 关闭 SSL 功能（协议降级为纯文本 TCP）。</li><li>False（默认）： 保持 SSL 功能开启。</li></ul>
        :type SslCloseSwitch: bool
        :param _DataCompressMode: <p>数据压缩模式。可选值：transparent（透传模式）、compatibility（兼容模式）</p>
        :type DataCompressMode: str
        :param _RescheduleTargetZeroWeight: <p>重新调度功能，权重调为0开关，打开此开关，后端服务器权重调为0时触发重新调度。仅TCP/UDP监听器支持。</p>
        :type RescheduleTargetZeroWeight: bool
        :param _RescheduleUnhealthy: <p>重新调度功能，健康检查异常开关，打开此开关，后端服务器健康检查异常时触发重新调度。仅TCP/UDP监听器支持。</p>
        :type RescheduleUnhealthy: bool
        :param _RescheduleExpandTarget: <p>重新调度功能，扩容后端服务开关，打开此开关，后端服务器增加或者减少时触发重新调度。仅TCP/UDP监听器支持。</p>
        :type RescheduleExpandTarget: bool
        :param _RescheduleStartTime: <p>重新调度触发开始时间，取值0~3600s。仅TCP/UDP监听器支持。</p>
        :type RescheduleStartTime: int
        :param _RescheduleInterval: <p>重新调度触发持续时间，取值0~3600s。仅TCP/UDP监听器支持。</p>
        :type RescheduleInterval: int
        """
        self._LoadBalancerId = None
        self._Ports = None
        self._Protocol = None
        self._ListenerNames = None
        self._HealthCheck = None
        self._Certificate = None
        self._SessionExpireTime = None
        self._Scheduler = None
        self._SniSwitch = None
        self._TargetType = None
        self._SessionType = None
        self._KeepaliveEnable = None
        self._EndPort = None
        self._DeregisterTargetRst = None
        self._MultiCertInfo = None
        self._MaxConn = None
        self._MaxCps = None
        self._IdleConnectTimeout = None
        self._ProxyProtocol = None
        self._SnatEnable = None
        self._FullEndPorts = None
        self._H2cSwitch = None
        self._SslCloseSwitch = None
        self._DataCompressMode = None
        self._RescheduleTargetZeroWeight = None
        self._RescheduleUnhealthy = None
        self._RescheduleExpandTarget = None
        self._RescheduleStartTime = None
        self._RescheduleInterval = None

    @property
    def LoadBalancerId(self):
        r"""<p>负载均衡实例 ID，可以通过 <a href="https://cloud.tencent.com/document/product/214/30685">DescribeLoadBalancers</a> 接口获取。</p>
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def Ports(self):
        r"""<p>要将监听器创建到哪些端口，每个端口对应一个新的监听器。<br>端口范围：1~65535</p>
        :rtype: list of int
        """
        return self._Ports

    @Ports.setter
    def Ports(self, Ports):
        self._Ports = Ports

    @property
    def Protocol(self):
        r"""<p>监听器协议： TCP | UDP | HTTP | HTTPS | TCP_SSL | QUIC。</p>
        :rtype: str
        """
        return self._Protocol

    @Protocol.setter
    def Protocol(self, Protocol):
        self._Protocol = Protocol

    @property
    def ListenerNames(self):
        r"""<p>要创建的监听器名称列表，名称与Ports数组按序一一对应，如不需立即命名，则无需提供此参数。命名规则：1-80 个英文字母、汉字等国际通用语言字符，数字，连接线“-”、下划线“_”等常见字符（禁止Unicode补充字符，如emoji表情、生僻汉字等）。</p>
        :rtype: list of str
        """
        return self._ListenerNames

    @ListenerNames.setter
    def ListenerNames(self, ListenerNames):
        self._ListenerNames = ListenerNames

    @property
    def HealthCheck(self):
        r"""<p>健康检查相关参数，此参数仅适用于TCP/UDP/TCP_SSL/QUIC监听器。</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.HealthCheck`
        """
        return self._HealthCheck

    @HealthCheck.setter
    def HealthCheck(self, HealthCheck):
        self._HealthCheck = HealthCheck

    @property
    def Certificate(self):
        r"""<p>证书相关信息。参数限制如下：</p><li>此参数仅适用于TCP_SSL监听器和未开启SNI特性的HTTPS监听器。</li><li>创建TCP_SSL监听器和未开启SNI特性的HTTPS监听器时，此参数和参数MultiCertInfo至少需要传一个， 但不能同时传入。</li>
        :rtype: :class:`tencentcloud.clb.v20180317.models.CertificateInput`
        """
        return self._Certificate

    @Certificate.setter
    def Certificate(self, Certificate):
        self._Certificate = Certificate

    @property
    def SessionExpireTime(self):
        r"""<p>会话保持时间，单位：秒。可选值：30~3600，默认为0，默认不开启。此参数仅适用于TCP/UDP监听器。</p>
        :rtype: int
        """
        return self._SessionExpireTime

    @SessionExpireTime.setter
    def SessionExpireTime(self, SessionExpireTime):
        self._SessionExpireTime = SessionExpireTime

    @property
    def Scheduler(self):
        r"""<p>监听器转发的方式。可选值：WRR（按权重轮询）、LEAST_CONN（按最小连接数）<br>默认为 WRR。此参数仅适用于TCP/UDP/TCP_SSL/QUIC监听器。</p>
        :rtype: str
        """
        return self._Scheduler

    @Scheduler.setter
    def Scheduler(self, Scheduler):
        self._Scheduler = Scheduler

    @property
    def SniSwitch(self):
        r"""<p>是否开启SNI特性，此参数仅适用于HTTPS监听器。0表示未开启，1表示开启。</p>
        :rtype: int
        """
        return self._SniSwitch

    @SniSwitch.setter
    def SniSwitch(self, SniSwitch):
        self._SniSwitch = SniSwitch

    @property
    def TargetType(self):
        r"""<p>后端目标类型，NODE表示绑定普通节点，TARGETGROUP表示绑定目标组。此参数仅适用于TCP/UDP监听器。七层监听器应在转发规则中设置。</p>
        :rtype: str
        """
        return self._TargetType

    @TargetType.setter
    def TargetType(self, TargetType):
        self._TargetType = TargetType

    @property
    def SessionType(self):
        r"""<p>会话保持类型。不传或传NORMAL表示默认会话保持类型。QUIC_CID 表示根据Quic Connection ID做会话保持。QUIC_CID只支持UDP协议。此参数仅适用于TCP/UDP监听器。七层监听器应在转发规则中设置。（若选择QUIC_CID，则Protocol必须为UDP，Scheduler必须为WRR，同时只支持ipv4）</p>
        :rtype: str
        """
        return self._SessionType

    @SessionType.setter
    def SessionType(self, SessionType):
        self._SessionType = SessionType

    @property
    def KeepaliveEnable(self):
        r"""<p>是否开启长连接，此参数仅适用于HTTP/HTTPS监听器，0:关闭；1:开启， 默认关闭。<br>若后端服务对连接数上限有限制，则建议谨慎开启。此功能目前处于内测中，如需使用，请提交 <a href="https://cloud.tencent.com/apply/p/tsodp6qm21">内测申请</a>。</p>
        :rtype: int
        """
        return self._KeepaliveEnable

    @KeepaliveEnable.setter
    def KeepaliveEnable(self, KeepaliveEnable):
        self._KeepaliveEnable = KeepaliveEnable

    @property
    def EndPort(self):
        r"""<p>创建端口段监听器时必须传入此参数，用以标识结束端口。同时，入参Ports只允许传入一个成员，用以标识开始端口。【如果您需要体验端口段功能，请通过 <a href="https://console.cloud.tencent.com/workorder/category">工单申请</a>】。</p>
        :rtype: int
        """
        return self._EndPort

    @EndPort.setter
    def EndPort(self, EndPort):
        self._EndPort = EndPort

    @property
    def DeregisterTargetRst(self):
        r"""<p>重新调度功能，解绑后端服务开关，打开此开关，当解绑后端服务时触发重新调度。仅TCP/UDP监听器支持。</p>
        :rtype: bool
        """
        return self._DeregisterTargetRst

    @DeregisterTargetRst.setter
    def DeregisterTargetRst(self, DeregisterTargetRst):
        self._DeregisterTargetRst = DeregisterTargetRst

    @property
    def MultiCertInfo(self):
        r"""<p>证书信息，支持同时传入不同算法类型的多本服务端证书，参数限制如下：</p><li>此参数仅适用于TCP_SSL监听器和未开启SNI特性的HTTPS监听器。</li><li>创建TCP_SSL监听器和未开启SNI特性的HTTPS监听器时，此参数和参数Certificate至少需要传一个， 但不能同时传入。</li>
        :rtype: :class:`tencentcloud.clb.v20180317.models.MultiCertInfo`
        """
        return self._MultiCertInfo

    @MultiCertInfo.setter
    def MultiCertInfo(self, MultiCertInfo):
        self._MultiCertInfo = MultiCertInfo

    @property
    def MaxConn(self):
        r"""<p>监听器最大连接数，当前仅性能容量型实例且仅TCP/UDP/TCP_SSL/QUIC监听器支持，不传或者传-1表示监听器维度不限速。基础网络实例不支持该参数。</p>
        :rtype: int
        """
        return self._MaxConn

    @MaxConn.setter
    def MaxConn(self, MaxConn):
        self._MaxConn = MaxConn

    @property
    def MaxCps(self):
        r"""<p>监听器最大新增连接数，当前仅性能容量型实例且仅TCP/UDP/TCP_SSL/QUIC监听器支持，不传或者传-1表示监听器维度不限速。基础网络实例不支持该参数。</p>
        :rtype: int
        """
        return self._MaxCps

    @MaxCps.setter
    def MaxCps(self, MaxCps):
        self._MaxCps = MaxCps

    @property
    def IdleConnectTimeout(self):
        r"""<p>空闲连接超时时间，此参数仅适用于TCP/UDP监听器，单位：秒。默认值：TCP监听器默认值为900s，UDP监听器默认值为300s。取值范围：共享型实例和独占型实例支持：10-900，性能容量型实例支持：10-1980。如需设置超过取值范围的值请通过 <a href="https://console.cloud.tencent.com/workorder/category">工单申请</a>。</p><p>取值范围：[10, 1980]</p><p>单位：秒</p><p>默认值：900</p><p>TCP监听器默认值为900s，UDP监听器默认值为300s。取值范围：共享型实例和独占型实例支持：10-900，性能容量型实例支持：10-1980。</p>
        :rtype: int
        """
        return self._IdleConnectTimeout

    @IdleConnectTimeout.setter
    def IdleConnectTimeout(self, IdleConnectTimeout):
        self._IdleConnectTimeout = IdleConnectTimeout

    @property
    def ProxyProtocol(self):
        r"""<p>TCP_SSL和QUIC是否支持PP</p>
        :rtype: bool
        """
        return self._ProxyProtocol

    @ProxyProtocol.setter
    def ProxyProtocol(self, ProxyProtocol):
        self._ProxyProtocol = ProxyProtocol

    @property
    def SnatEnable(self):
        r"""<p>是否开启SNAT（源IP替换），True（开启）、False（关闭）。默认为关闭。注意：SnatEnable开启时会替换客户端源IP，此时<code>透传客户端源IP</code>选项关闭，反之亦然。</p>
        :rtype: bool
        """
        return self._SnatEnable

    @SnatEnable.setter
    def SnatEnable(self, SnatEnable):
        self._SnatEnable = SnatEnable

    @property
    def FullEndPorts(self):
        r"""<p>全端口段监听器的结束端口，端口范围：2 - 65535</p>
        :rtype: list of int
        """
        return self._FullEndPorts

    @FullEndPorts.setter
    def FullEndPorts(self, FullEndPorts):
        self._FullEndPorts = FullEndPorts

    @property
    def H2cSwitch(self):
        r"""<p>内网 HTTP 监听器开启 h2c 开关。<br>True（开启）、False（关闭）。默认为关闭。<br>开启后，监听器仅支持创建后端转发类型为 GRPC 或 GRPCS 的七层规则；创建规则时需在 Rules.N.ForwardType 中显式传入 GRPC 或 GRPCS。</p>
        :rtype: bool
        """
        return self._H2cSwitch

    @H2cSwitch.setter
    def H2cSwitch(self, H2cSwitch):
        self._H2cSwitch = H2cSwitch

    @property
    def SslCloseSwitch(self):
        r"""<p>控制 TCP_SSL 类型的监听器是否移除 SSL 加密层。开启后，监听器将作为普通 TCP 协议运行。 可选值：</p><ul><li>True： 关闭 SSL 功能（协议降级为纯文本 TCP）。</li><li>False（默认）： 保持 SSL 功能开启。</li></ul>
        :rtype: bool
        """
        return self._SslCloseSwitch

    @SslCloseSwitch.setter
    def SslCloseSwitch(self, SslCloseSwitch):
        self._SslCloseSwitch = SslCloseSwitch

    @property
    def DataCompressMode(self):
        r"""<p>数据压缩模式。可选值：transparent（透传模式）、compatibility（兼容模式）</p>
        :rtype: str
        """
        return self._DataCompressMode

    @DataCompressMode.setter
    def DataCompressMode(self, DataCompressMode):
        self._DataCompressMode = DataCompressMode

    @property
    def RescheduleTargetZeroWeight(self):
        r"""<p>重新调度功能，权重调为0开关，打开此开关，后端服务器权重调为0时触发重新调度。仅TCP/UDP监听器支持。</p>
        :rtype: bool
        """
        return self._RescheduleTargetZeroWeight

    @RescheduleTargetZeroWeight.setter
    def RescheduleTargetZeroWeight(self, RescheduleTargetZeroWeight):
        self._RescheduleTargetZeroWeight = RescheduleTargetZeroWeight

    @property
    def RescheduleUnhealthy(self):
        r"""<p>重新调度功能，健康检查异常开关，打开此开关，后端服务器健康检查异常时触发重新调度。仅TCP/UDP监听器支持。</p>
        :rtype: bool
        """
        return self._RescheduleUnhealthy

    @RescheduleUnhealthy.setter
    def RescheduleUnhealthy(self, RescheduleUnhealthy):
        self._RescheduleUnhealthy = RescheduleUnhealthy

    @property
    def RescheduleExpandTarget(self):
        r"""<p>重新调度功能，扩容后端服务开关，打开此开关，后端服务器增加或者减少时触发重新调度。仅TCP/UDP监听器支持。</p>
        :rtype: bool
        """
        return self._RescheduleExpandTarget

    @RescheduleExpandTarget.setter
    def RescheduleExpandTarget(self, RescheduleExpandTarget):
        self._RescheduleExpandTarget = RescheduleExpandTarget

    @property
    def RescheduleStartTime(self):
        r"""<p>重新调度触发开始时间，取值0~3600s。仅TCP/UDP监听器支持。</p>
        :rtype: int
        """
        return self._RescheduleStartTime

    @RescheduleStartTime.setter
    def RescheduleStartTime(self, RescheduleStartTime):
        self._RescheduleStartTime = RescheduleStartTime

    @property
    def RescheduleInterval(self):
        r"""<p>重新调度触发持续时间，取值0~3600s。仅TCP/UDP监听器支持。</p>
        :rtype: int
        """
        return self._RescheduleInterval

    @RescheduleInterval.setter
    def RescheduleInterval(self, RescheduleInterval):
        self._RescheduleInterval = RescheduleInterval


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._Ports = params.get("Ports")
        self._Protocol = params.get("Protocol")
        self._ListenerNames = params.get("ListenerNames")
        if params.get("HealthCheck") is not None:
            self._HealthCheck = HealthCheck()
            self._HealthCheck._deserialize(params.get("HealthCheck"))
        if params.get("Certificate") is not None:
            self._Certificate = CertificateInput()
            self._Certificate._deserialize(params.get("Certificate"))
        self._SessionExpireTime = params.get("SessionExpireTime")
        self._Scheduler = params.get("Scheduler")
        self._SniSwitch = params.get("SniSwitch")
        self._TargetType = params.get("TargetType")
        self._SessionType = params.get("SessionType")
        self._KeepaliveEnable = params.get("KeepaliveEnable")
        self._EndPort = params.get("EndPort")
        self._DeregisterTargetRst = params.get("DeregisterTargetRst")
        if params.get("MultiCertInfo") is not None:
            self._MultiCertInfo = MultiCertInfo()
            self._MultiCertInfo._deserialize(params.get("MultiCertInfo"))
        self._MaxConn = params.get("MaxConn")
        self._MaxCps = params.get("MaxCps")
        self._IdleConnectTimeout = params.get("IdleConnectTimeout")
        self._ProxyProtocol = params.get("ProxyProtocol")
        self._SnatEnable = params.get("SnatEnable")
        self._FullEndPorts = params.get("FullEndPorts")
        self._H2cSwitch = params.get("H2cSwitch")
        self._SslCloseSwitch = params.get("SslCloseSwitch")
        self._DataCompressMode = params.get("DataCompressMode")
        self._RescheduleTargetZeroWeight = params.get("RescheduleTargetZeroWeight")
        self._RescheduleUnhealthy = params.get("RescheduleUnhealthy")
        self._RescheduleExpandTarget = params.get("RescheduleExpandTarget")
        self._RescheduleStartTime = params.get("RescheduleStartTime")
        self._RescheduleInterval = params.get("RescheduleInterval")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CreateListenerResponse(AbstractModel):
    r"""CreateListener返回参数结构体

    """

    def __init__(self):
        r"""
        :param _ListenerIds: <p>创建的监听器的唯一标识数组。</p>
        :type ListenerIds: list of str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._ListenerIds = None
        self._RequestId = None

    @property
    def ListenerIds(self):
        r"""<p>创建的监听器的唯一标识数组。</p>
        :rtype: list of str
        """
        return self._ListenerIds

    @ListenerIds.setter
    def ListenerIds(self, ListenerIds):
        self._ListenerIds = ListenerIds

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._ListenerIds = params.get("ListenerIds")
        self._RequestId = params.get("RequestId")


class CreateLoadBalancerRequest(AbstractModel):
    r"""CreateLoadBalancer请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerType: <p>负载均衡实例的网络类型：<br>OPEN：公网属性， INTERNAL：内网属性。</p>
        :type LoadBalancerType: str
        :param _Forward: <p>负载均衡实例的类型。1：通用的负载均衡实例，目前只支持传入1。</p>
        :type Forward: int
        :param _LoadBalancerName: <p>负载均衡实例的名称，只在创建一个实例的时候才会生效。规则：1-80 个英文字母、汉字等国际通用语言字符，数字，连接线“-”、下划线“_”等常见字符（禁止Unicode补充字符，如emoji表情、生僻汉字等）。注意：如果名称与系统中已有负载均衡实例的名称相同，则系统将会自动生成此次创建的负载均衡实例的名称。</p>
        :type LoadBalancerName: str
        :param _VpcId: <p>负载均衡后端目标设备所属的网络 ID，如vpc-12345678，可以通过 <a href="https://cloud.tencent.com/document/product/215/15778">DescribeVpcs</a> 接口获取。 不填此参数则默认为DefaultVPC。创建内网负载均衡实例时，此参数必填。</p>
        :type VpcId: str
        :param _SubnetId: <p>在私有网络内购买内网负载均衡实例的情况下，必须指定子网 ID，内网负载均衡实例的 VIP 将从这个子网中产生。<br>创建内网负载均衡实例，或者创建 IPv6FullChain 版本的负载均衡实例，此参数必填。<br>创建公网IPv4负载均衡实例时，不支持指定该参数。</p>
        :type SubnetId: str
        :param _ProjectId: <p>负载均衡实例所属的项目 ID，默认项目 ID 为0。可以通过 <a href="https://cloud.tencent.com/document/api/651/78725">DescribeProject</a> 接口获取。不填此参数则视为默认项目。</p>
        :type ProjectId: int
        :param _AddressIPVersion: <p>仅适用于公网负载均衡。IP版本，可取值：IPV4、IPV6、IPv6FullChain，不区分大小写，默认值 IPV4。说明：取值为IPV6表示为IPV6 NAT64版本；取值为IPv6FullChain，表示为IPv6版本。</p>
        :type AddressIPVersion: str
        :param _Number: <p>创建负载均衡的个数，默认值 1。创建个数不能超过账号所能创建的最大值，默认创建最大值为20。</p>
        :type Number: int
        :param _MasterZoneId: <p>仅适用于公网且IP版本为IPv4的负载均衡。设置跨可用区容灾时的主可用区ID， 可用区 ID 和名称均支持，例如 100001 或 ap-guangzhou-1<br>注：主可用区是需要承载流量的可用区，备可用区默认不承载流量，主可用区不可用时才使用备可用区。</p>
        :type MasterZoneId: str
        :param _ZoneId: <p>仅适用于公网且IP版本为IPv4的负载均衡。可用区ID，可用区 ID 和名称均支持，指定可用区以创建负载均衡实例。如：100001 或 ap-guangzhou-1。</p>
        :type ZoneId: str
        :param _InternetAccessible: <p>网络计费模式，其中的最大出带宽，仅对内网属性的性能容量型实例和公网属性的所有实例生效。</p>
        :type InternetAccessible: :class:`tencentcloud.clb.v20180317.models.InternetAccessible`
        :param _VipIsp: <p>仅适用于公网负载均衡。目前仅广州、上海、南京、济南、杭州、福州、北京、石家庄、武汉、长沙、成都、重庆地域支持静态单线 IP 线路类型，如需体验，请联系商务经理申请。申请通过后，即可选择中国移动（CMCC）、中国联通（CUCC）或中国电信（CTCC）的运营商类型，网络计费模式只能使用按带宽包计费(BANDWIDTH_PACKAGE)。 如果不指定本参数，则默认使用BGP。可通过 <a href="https://cloud.tencent.com/document/api/214/70213">DescribeResources</a>  接口查询一个地域所支持的Isp。</p>
        :type VipIsp: str
        :param _Tags: <p>购买负载均衡的同时，给负载均衡打上标签，最大支持20个标签键值对。</p>
        :type Tags: list of TagInfo
        :param _Vip: <p>指定VIP申请负载均衡。此参数选填，不填写此参数时自动分配VIP。IPv4和IPv6类型支持此参数，IPv6 NAT64类型不支持。<br>注意：当指定VIP创建内网实例、或公网IPv6 BGP实例时，若VIP不属于指定VPC子网的网段内时，会创建失败；若VIP已被占用，也会创建失败。</p>
        :type Vip: str
        :param _BandwidthPackageId: <p>带宽包ID，可以通过 <a href="https://cloud.tencent.com/document/api/215/19209">DescribeBandwidthPackages</a> 接口获取。指定此参数时，网络计费方式（InternetAccessible.InternetChargeType）只支持按带宽包计费（BANDWIDTH_PACKAGE），带宽包的属性即为其结算方式。非上移用户购买的 IPv6 负载均衡实例，且运营商类型非 BGP 时 ，不支持指定具体带宽包id。</p>
        :type BandwidthPackageId: str
        :param _ExclusiveCluster: <p>独占型实例信息。若创建独占型的内网负载均衡实例，则此参数必填。</p>
        :type ExclusiveCluster: :class:`tencentcloud.clb.v20180317.models.ExclusiveCluster`
        :param _SlaType: <p>性能容量型规格。</p><ul><li>若需要创建性能容量型实例，则此参数必填，取值范围：<ul><li> clb.c2.medium：标准型规格 </li><li> clb.c3.small：高阶型1规格 </li><li> clb.c3.medium：高阶型2规格 </li><li> clb.c4.small：超强型1规格 </li><li> clb.c4.medium：超强型2规格 </li><li> clb.c4.large：超强型3规格 </li><li> clb.c4.xlarge：超强型4规格 </li></ul></li><li>中国站用户若需要创建共享型实例，则无需填写此参数。国际站用户不传该参数默认购买的是标准型实例。</li></ul>如需了解规格详情，请参见[实例规格对比](https://cloud.tencent.com/document/product/214/84689)。
        :type SlaType: str
        :param _ClusterIds: <p>集群ID，集群标识，在需要配置公有云独占集群或本地专有集群时使用。公有云独占集群申请请<a href="https://console.cloud.tencent.com/workorder/category">提交工单</a>，本地专有集群请参考<a href="https://cloud.tencent.com/document/product/1346">本地专有集群</a>描述。</p>
        :type ClusterIds: list of str
        :param _ClientToken: <p>用于保证请求幂等性的字符串。该字符串由客户生成，需保证不同请求之间唯一，最大值不超过64个ASCII字符。若不指定该参数，则无法保证请求的幂等性。</p>
        :type ClientToken: str
        :param _SnatPro: <p>是否支持绑定跨地域/跨Vpc绑定IP的功能。</p>
        :type SnatPro: bool
        :param _SnatIps: <p>开启绑定跨地域/跨Vpc绑定IP的功能后，创建SnatIp。</p>
        :type SnatIps: list of SnatIp
        :param _ClusterTag: <p>Stgw独占集群的标签。</p>
        :type ClusterTag: str
        :param _SlaveZoneId: <p>仅适用于公网且IP版本为IPv4的负载均衡。设置跨可用区容灾时的备可用区ID，可用区 ID 和名称均支持，例如 100001 或 ap-guangzhou-1<br>注：备可用区是主可用区故障后，需要承载流量的可用区。可通过 <a href="https://cloud.tencent.com/document/api/214/70213">DescribeResources</a> 接口查询一个地域的主/备可用区的列表。【如果您需要体验该功能，请通过 <a href="https://console.cloud.tencent.com/workorder/category">工单申请</a>】</p>
        :type SlaveZoneId: str
        :param _EipAddressId: <p>EIP 的唯一 ID，可以通过 <a href="https://cloud.tencent.com/document/product/215/16702">DescribeAddresses</a> 接口查询。形如：eip-qhx8udkc，仅适用于内网负载均衡绑定EIP。</p>
        :type EipAddressId: str
        :param _LoadBalancerPassToTarget: <p>Target是否放通来自CLB的流量。开启放通（true）：只验证CLB上的安全组；不开启放通（false）：需同时验证CLB和后端实例上的安全组。IPv6 CLB安全组默认放通，不需要传此参数。</p>
        :type LoadBalancerPassToTarget: bool
        :param _DynamicVip: <p>创建域名化负载均衡。</p>
        :type DynamicVip: bool
        :param _Egress: <p>网络出口</p>
        :type Egress: str
        :param _LBChargePrepaid: <p>负载均衡实例的预付费相关属性</p>
        :type LBChargePrepaid: :class:`tencentcloud.clb.v20180317.models.LBChargePrepaid`
        :param _LBChargeType: <p>负载均衡实例计费类型，取值：POSTPAID_BY_HOUR，PREPAID，默认是POSTPAID_BY_HOUR。</p><p>枚举值：</p><ul><li>POSTPAID_BY_HOUR： 按量计费</li><li>PREPAID： 包年包月</li></ul>
        :type LBChargeType: str
        :param _AccessLogTopicId: <p>七层访问日志主题ID</p>
        :type AccessLogTopicId: str
        :param _AdvancedRoute: <p>是否开启七层高级路由</p>
        :type AdvancedRoute: bool
        :param _AvailableZoneAffinityInfo: <p>可用区亲和信息</p>
        :type AvailableZoneAffinityInfo: :class:`tencentcloud.clb.v20180317.models.AvailableZoneAffinityInfo`
        """
        self._LoadBalancerType = None
        self._Forward = None
        self._LoadBalancerName = None
        self._VpcId = None
        self._SubnetId = None
        self._ProjectId = None
        self._AddressIPVersion = None
        self._Number = None
        self._MasterZoneId = None
        self._ZoneId = None
        self._InternetAccessible = None
        self._VipIsp = None
        self._Tags = None
        self._Vip = None
        self._BandwidthPackageId = None
        self._ExclusiveCluster = None
        self._SlaType = None
        self._ClusterIds = None
        self._ClientToken = None
        self._SnatPro = None
        self._SnatIps = None
        self._ClusterTag = None
        self._SlaveZoneId = None
        self._EipAddressId = None
        self._LoadBalancerPassToTarget = None
        self._DynamicVip = None
        self._Egress = None
        self._LBChargePrepaid = None
        self._LBChargeType = None
        self._AccessLogTopicId = None
        self._AdvancedRoute = None
        self._AvailableZoneAffinityInfo = None

    @property
    def LoadBalancerType(self):
        r"""<p>负载均衡实例的网络类型：<br>OPEN：公网属性， INTERNAL：内网属性。</p>
        :rtype: str
        """
        return self._LoadBalancerType

    @LoadBalancerType.setter
    def LoadBalancerType(self, LoadBalancerType):
        self._LoadBalancerType = LoadBalancerType

    @property
    def Forward(self):
        r"""<p>负载均衡实例的类型。1：通用的负载均衡实例，目前只支持传入1。</p>
        :rtype: int
        """
        return self._Forward

    @Forward.setter
    def Forward(self, Forward):
        self._Forward = Forward

    @property
    def LoadBalancerName(self):
        r"""<p>负载均衡实例的名称，只在创建一个实例的时候才会生效。规则：1-80 个英文字母、汉字等国际通用语言字符，数字，连接线“-”、下划线“_”等常见字符（禁止Unicode补充字符，如emoji表情、生僻汉字等）。注意：如果名称与系统中已有负载均衡实例的名称相同，则系统将会自动生成此次创建的负载均衡实例的名称。</p>
        :rtype: str
        """
        return self._LoadBalancerName

    @LoadBalancerName.setter
    def LoadBalancerName(self, LoadBalancerName):
        self._LoadBalancerName = LoadBalancerName

    @property
    def VpcId(self):
        r"""<p>负载均衡后端目标设备所属的网络 ID，如vpc-12345678，可以通过 <a href="https://cloud.tencent.com/document/product/215/15778">DescribeVpcs</a> 接口获取。 不填此参数则默认为DefaultVPC。创建内网负载均衡实例时，此参数必填。</p>
        :rtype: str
        """
        return self._VpcId

    @VpcId.setter
    def VpcId(self, VpcId):
        self._VpcId = VpcId

    @property
    def SubnetId(self):
        r"""<p>在私有网络内购买内网负载均衡实例的情况下，必须指定子网 ID，内网负载均衡实例的 VIP 将从这个子网中产生。<br>创建内网负载均衡实例，或者创建 IPv6FullChain 版本的负载均衡实例，此参数必填。<br>创建公网IPv4负载均衡实例时，不支持指定该参数。</p>
        :rtype: str
        """
        return self._SubnetId

    @SubnetId.setter
    def SubnetId(self, SubnetId):
        self._SubnetId = SubnetId

    @property
    def ProjectId(self):
        r"""<p>负载均衡实例所属的项目 ID，默认项目 ID 为0。可以通过 <a href="https://cloud.tencent.com/document/api/651/78725">DescribeProject</a> 接口获取。不填此参数则视为默认项目。</p>
        :rtype: int
        """
        return self._ProjectId

    @ProjectId.setter
    def ProjectId(self, ProjectId):
        self._ProjectId = ProjectId

    @property
    def AddressIPVersion(self):
        r"""<p>仅适用于公网负载均衡。IP版本，可取值：IPV4、IPV6、IPv6FullChain，不区分大小写，默认值 IPV4。说明：取值为IPV6表示为IPV6 NAT64版本；取值为IPv6FullChain，表示为IPv6版本。</p>
        :rtype: str
        """
        return self._AddressIPVersion

    @AddressIPVersion.setter
    def AddressIPVersion(self, AddressIPVersion):
        self._AddressIPVersion = AddressIPVersion

    @property
    def Number(self):
        r"""<p>创建负载均衡的个数，默认值 1。创建个数不能超过账号所能创建的最大值，默认创建最大值为20。</p>
        :rtype: int
        """
        return self._Number

    @Number.setter
    def Number(self, Number):
        self._Number = Number

    @property
    def MasterZoneId(self):
        r"""<p>仅适用于公网且IP版本为IPv4的负载均衡。设置跨可用区容灾时的主可用区ID， 可用区 ID 和名称均支持，例如 100001 或 ap-guangzhou-1<br>注：主可用区是需要承载流量的可用区，备可用区默认不承载流量，主可用区不可用时才使用备可用区。</p>
        :rtype: str
        """
        return self._MasterZoneId

    @MasterZoneId.setter
    def MasterZoneId(self, MasterZoneId):
        self._MasterZoneId = MasterZoneId

    @property
    def ZoneId(self):
        r"""<p>仅适用于公网且IP版本为IPv4的负载均衡。可用区ID，可用区 ID 和名称均支持，指定可用区以创建负载均衡实例。如：100001 或 ap-guangzhou-1。</p>
        :rtype: str
        """
        return self._ZoneId

    @ZoneId.setter
    def ZoneId(self, ZoneId):
        self._ZoneId = ZoneId

    @property
    def InternetAccessible(self):
        r"""<p>网络计费模式，其中的最大出带宽，仅对内网属性的性能容量型实例和公网属性的所有实例生效。</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.InternetAccessible`
        """
        return self._InternetAccessible

    @InternetAccessible.setter
    def InternetAccessible(self, InternetAccessible):
        self._InternetAccessible = InternetAccessible

    @property
    def VipIsp(self):
        r"""<p>仅适用于公网负载均衡。目前仅广州、上海、南京、济南、杭州、福州、北京、石家庄、武汉、长沙、成都、重庆地域支持静态单线 IP 线路类型，如需体验，请联系商务经理申请。申请通过后，即可选择中国移动（CMCC）、中国联通（CUCC）或中国电信（CTCC）的运营商类型，网络计费模式只能使用按带宽包计费(BANDWIDTH_PACKAGE)。 如果不指定本参数，则默认使用BGP。可通过 <a href="https://cloud.tencent.com/document/api/214/70213">DescribeResources</a>  接口查询一个地域所支持的Isp。</p>
        :rtype: str
        """
        return self._VipIsp

    @VipIsp.setter
    def VipIsp(self, VipIsp):
        self._VipIsp = VipIsp

    @property
    def Tags(self):
        r"""<p>购买负载均衡的同时，给负载均衡打上标签，最大支持20个标签键值对。</p>
        :rtype: list of TagInfo
        """
        return self._Tags

    @Tags.setter
    def Tags(self, Tags):
        self._Tags = Tags

    @property
    def Vip(self):
        r"""<p>指定VIP申请负载均衡。此参数选填，不填写此参数时自动分配VIP。IPv4和IPv6类型支持此参数，IPv6 NAT64类型不支持。<br>注意：当指定VIP创建内网实例、或公网IPv6 BGP实例时，若VIP不属于指定VPC子网的网段内时，会创建失败；若VIP已被占用，也会创建失败。</p>
        :rtype: str
        """
        return self._Vip

    @Vip.setter
    def Vip(self, Vip):
        self._Vip = Vip

    @property
    def BandwidthPackageId(self):
        r"""<p>带宽包ID，可以通过 <a href="https://cloud.tencent.com/document/api/215/19209">DescribeBandwidthPackages</a> 接口获取。指定此参数时，网络计费方式（InternetAccessible.InternetChargeType）只支持按带宽包计费（BANDWIDTH_PACKAGE），带宽包的属性即为其结算方式。非上移用户购买的 IPv6 负载均衡实例，且运营商类型非 BGP 时 ，不支持指定具体带宽包id。</p>
        :rtype: str
        """
        return self._BandwidthPackageId

    @BandwidthPackageId.setter
    def BandwidthPackageId(self, BandwidthPackageId):
        self._BandwidthPackageId = BandwidthPackageId

    @property
    def ExclusiveCluster(self):
        r"""<p>独占型实例信息。若创建独占型的内网负载均衡实例，则此参数必填。</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.ExclusiveCluster`
        """
        return self._ExclusiveCluster

    @ExclusiveCluster.setter
    def ExclusiveCluster(self, ExclusiveCluster):
        self._ExclusiveCluster = ExclusiveCluster

    @property
    def SlaType(self):
        r"""<p>性能容量型规格。</p><ul><li>若需要创建性能容量型实例，则此参数必填，取值范围：<ul><li> clb.c2.medium：标准型规格 </li><li> clb.c3.small：高阶型1规格 </li><li> clb.c3.medium：高阶型2规格 </li><li> clb.c4.small：超强型1规格 </li><li> clb.c4.medium：超强型2规格 </li><li> clb.c4.large：超强型3规格 </li><li> clb.c4.xlarge：超强型4规格 </li></ul></li><li>中国站用户若需要创建共享型实例，则无需填写此参数。国际站用户不传该参数默认购买的是标准型实例。</li></ul>如需了解规格详情，请参见[实例规格对比](https://cloud.tencent.com/document/product/214/84689)。
        :rtype: str
        """
        return self._SlaType

    @SlaType.setter
    def SlaType(self, SlaType):
        self._SlaType = SlaType

    @property
    def ClusterIds(self):
        r"""<p>集群ID，集群标识，在需要配置公有云独占集群或本地专有集群时使用。公有云独占集群申请请<a href="https://console.cloud.tencent.com/workorder/category">提交工单</a>，本地专有集群请参考<a href="https://cloud.tencent.com/document/product/1346">本地专有集群</a>描述。</p>
        :rtype: list of str
        """
        return self._ClusterIds

    @ClusterIds.setter
    def ClusterIds(self, ClusterIds):
        self._ClusterIds = ClusterIds

    @property
    def ClientToken(self):
        r"""<p>用于保证请求幂等性的字符串。该字符串由客户生成，需保证不同请求之间唯一，最大值不超过64个ASCII字符。若不指定该参数，则无法保证请求的幂等性。</p>
        :rtype: str
        """
        return self._ClientToken

    @ClientToken.setter
    def ClientToken(self, ClientToken):
        self._ClientToken = ClientToken

    @property
    def SnatPro(self):
        r"""<p>是否支持绑定跨地域/跨Vpc绑定IP的功能。</p>
        :rtype: bool
        """
        return self._SnatPro

    @SnatPro.setter
    def SnatPro(self, SnatPro):
        self._SnatPro = SnatPro

    @property
    def SnatIps(self):
        r"""<p>开启绑定跨地域/跨Vpc绑定IP的功能后，创建SnatIp。</p>
        :rtype: list of SnatIp
        """
        return self._SnatIps

    @SnatIps.setter
    def SnatIps(self, SnatIps):
        self._SnatIps = SnatIps

    @property
    def ClusterTag(self):
        r"""<p>Stgw独占集群的标签。</p>
        :rtype: str
        """
        return self._ClusterTag

    @ClusterTag.setter
    def ClusterTag(self, ClusterTag):
        self._ClusterTag = ClusterTag

    @property
    def SlaveZoneId(self):
        r"""<p>仅适用于公网且IP版本为IPv4的负载均衡。设置跨可用区容灾时的备可用区ID，可用区 ID 和名称均支持，例如 100001 或 ap-guangzhou-1<br>注：备可用区是主可用区故障后，需要承载流量的可用区。可通过 <a href="https://cloud.tencent.com/document/api/214/70213">DescribeResources</a> 接口查询一个地域的主/备可用区的列表。【如果您需要体验该功能，请通过 <a href="https://console.cloud.tencent.com/workorder/category">工单申请</a>】</p>
        :rtype: str
        """
        return self._SlaveZoneId

    @SlaveZoneId.setter
    def SlaveZoneId(self, SlaveZoneId):
        self._SlaveZoneId = SlaveZoneId

    @property
    def EipAddressId(self):
        r"""<p>EIP 的唯一 ID，可以通过 <a href="https://cloud.tencent.com/document/product/215/16702">DescribeAddresses</a> 接口查询。形如：eip-qhx8udkc，仅适用于内网负载均衡绑定EIP。</p>
        :rtype: str
        """
        return self._EipAddressId

    @EipAddressId.setter
    def EipAddressId(self, EipAddressId):
        self._EipAddressId = EipAddressId

    @property
    def LoadBalancerPassToTarget(self):
        r"""<p>Target是否放通来自CLB的流量。开启放通（true）：只验证CLB上的安全组；不开启放通（false）：需同时验证CLB和后端实例上的安全组。IPv6 CLB安全组默认放通，不需要传此参数。</p>
        :rtype: bool
        """
        return self._LoadBalancerPassToTarget

    @LoadBalancerPassToTarget.setter
    def LoadBalancerPassToTarget(self, LoadBalancerPassToTarget):
        self._LoadBalancerPassToTarget = LoadBalancerPassToTarget

    @property
    def DynamicVip(self):
        r"""<p>创建域名化负载均衡。</p>
        :rtype: bool
        """
        return self._DynamicVip

    @DynamicVip.setter
    def DynamicVip(self, DynamicVip):
        self._DynamicVip = DynamicVip

    @property
    def Egress(self):
        r"""<p>网络出口</p>
        :rtype: str
        """
        return self._Egress

    @Egress.setter
    def Egress(self, Egress):
        self._Egress = Egress

    @property
    def LBChargePrepaid(self):
        r"""<p>负载均衡实例的预付费相关属性</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.LBChargePrepaid`
        """
        return self._LBChargePrepaid

    @LBChargePrepaid.setter
    def LBChargePrepaid(self, LBChargePrepaid):
        self._LBChargePrepaid = LBChargePrepaid

    @property
    def LBChargeType(self):
        r"""<p>负载均衡实例计费类型，取值：POSTPAID_BY_HOUR，PREPAID，默认是POSTPAID_BY_HOUR。</p><p>枚举值：</p><ul><li>POSTPAID_BY_HOUR： 按量计费</li><li>PREPAID： 包年包月</li></ul>
        :rtype: str
        """
        return self._LBChargeType

    @LBChargeType.setter
    def LBChargeType(self, LBChargeType):
        self._LBChargeType = LBChargeType

    @property
    def AccessLogTopicId(self):
        r"""<p>七层访问日志主题ID</p>
        :rtype: str
        """
        return self._AccessLogTopicId

    @AccessLogTopicId.setter
    def AccessLogTopicId(self, AccessLogTopicId):
        self._AccessLogTopicId = AccessLogTopicId

    @property
    def AdvancedRoute(self):
        r"""<p>是否开启七层高级路由</p>
        :rtype: bool
        """
        return self._AdvancedRoute

    @AdvancedRoute.setter
    def AdvancedRoute(self, AdvancedRoute):
        self._AdvancedRoute = AdvancedRoute

    @property
    def AvailableZoneAffinityInfo(self):
        r"""<p>可用区亲和信息</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.AvailableZoneAffinityInfo`
        """
        return self._AvailableZoneAffinityInfo

    @AvailableZoneAffinityInfo.setter
    def AvailableZoneAffinityInfo(self, AvailableZoneAffinityInfo):
        self._AvailableZoneAffinityInfo = AvailableZoneAffinityInfo


    def _deserialize(self, params):
        self._LoadBalancerType = params.get("LoadBalancerType")
        self._Forward = params.get("Forward")
        self._LoadBalancerName = params.get("LoadBalancerName")
        self._VpcId = params.get("VpcId")
        self._SubnetId = params.get("SubnetId")
        self._ProjectId = params.get("ProjectId")
        self._AddressIPVersion = params.get("AddressIPVersion")
        self._Number = params.get("Number")
        self._MasterZoneId = params.get("MasterZoneId")
        self._ZoneId = params.get("ZoneId")
        if params.get("InternetAccessible") is not None:
            self._InternetAccessible = InternetAccessible()
            self._InternetAccessible._deserialize(params.get("InternetAccessible"))
        self._VipIsp = params.get("VipIsp")
        if params.get("Tags") is not None:
            self._Tags = []
            for item in params.get("Tags"):
                obj = TagInfo()
                obj._deserialize(item)
                self._Tags.append(obj)
        self._Vip = params.get("Vip")
        self._BandwidthPackageId = params.get("BandwidthPackageId")
        if params.get("ExclusiveCluster") is not None:
            self._ExclusiveCluster = ExclusiveCluster()
            self._ExclusiveCluster._deserialize(params.get("ExclusiveCluster"))
        self._SlaType = params.get("SlaType")
        self._ClusterIds = params.get("ClusterIds")
        self._ClientToken = params.get("ClientToken")
        self._SnatPro = params.get("SnatPro")
        if params.get("SnatIps") is not None:
            self._SnatIps = []
            for item in params.get("SnatIps"):
                obj = SnatIp()
                obj._deserialize(item)
                self._SnatIps.append(obj)
        self._ClusterTag = params.get("ClusterTag")
        self._SlaveZoneId = params.get("SlaveZoneId")
        self._EipAddressId = params.get("EipAddressId")
        self._LoadBalancerPassToTarget = params.get("LoadBalancerPassToTarget")
        self._DynamicVip = params.get("DynamicVip")
        self._Egress = params.get("Egress")
        if params.get("LBChargePrepaid") is not None:
            self._LBChargePrepaid = LBChargePrepaid()
            self._LBChargePrepaid._deserialize(params.get("LBChargePrepaid"))
        self._LBChargeType = params.get("LBChargeType")
        self._AccessLogTopicId = params.get("AccessLogTopicId")
        self._AdvancedRoute = params.get("AdvancedRoute")
        if params.get("AvailableZoneAffinityInfo") is not None:
            self._AvailableZoneAffinityInfo = AvailableZoneAffinityInfo()
            self._AvailableZoneAffinityInfo._deserialize(params.get("AvailableZoneAffinityInfo"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CreateLoadBalancerResponse(AbstractModel):
    r"""CreateLoadBalancer返回参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerIds: <p>由负载均衡实例唯一 ID 组成的数组。<br>存在某些场景，如创建出现延迟时，此字段可能返回为空；此时可以根据接口返回的RequestId或DealName参数，通过DescribeTaskStatus接口查询创建的资源ID。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type LoadBalancerIds: list of str
        :param _DealName: <p>订单号。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type DealName: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._LoadBalancerIds = None
        self._DealName = None
        self._RequestId = None

    @property
    def LoadBalancerIds(self):
        r"""<p>由负载均衡实例唯一 ID 组成的数组。<br>存在某些场景，如创建出现延迟时，此字段可能返回为空；此时可以根据接口返回的RequestId或DealName参数，通过DescribeTaskStatus接口查询创建的资源ID。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: list of str
        """
        return self._LoadBalancerIds

    @LoadBalancerIds.setter
    def LoadBalancerIds(self, LoadBalancerIds):
        self._LoadBalancerIds = LoadBalancerIds

    @property
    def DealName(self):
        r"""<p>订单号。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._DealName

    @DealName.setter
    def DealName(self, DealName):
        self._DealName = DealName

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._LoadBalancerIds = params.get("LoadBalancerIds")
        self._DealName = params.get("DealName")
        self._RequestId = params.get("RequestId")


class CreateLoadBalancerSnatIpsRequest(AbstractModel):
    r"""CreateLoadBalancerSnatIps请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡唯一性ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口查询。例如：lb-12345678。
        :type LoadBalancerId: str
        :param _SnatIps: 添加的SnatIp信息，可指定IP申请，或者指定子网自动申请。可以通过 [DescribeSubnets](https://cloud.tencent.com/document/api/215/15784) 查询获取，单个CLB实例可申请的默认上限为10个。
        :type SnatIps: list of SnatIp
        :param _Number: 添加的SnatIp的个数，可与SnatIps一起使用，但若指定IP时，则不能指定创建的SnatIp个数。默认值为1，数量上限与用户配置有关，默认上限为10。
        :type Number: int
        """
        self._LoadBalancerId = None
        self._SnatIps = None
        self._Number = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡唯一性ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口查询。例如：lb-12345678。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def SnatIps(self):
        r"""添加的SnatIp信息，可指定IP申请，或者指定子网自动申请。可以通过 [DescribeSubnets](https://cloud.tencent.com/document/api/215/15784) 查询获取，单个CLB实例可申请的默认上限为10个。
        :rtype: list of SnatIp
        """
        return self._SnatIps

    @SnatIps.setter
    def SnatIps(self, SnatIps):
        self._SnatIps = SnatIps

    @property
    def Number(self):
        r"""添加的SnatIp的个数，可与SnatIps一起使用，但若指定IP时，则不能指定创建的SnatIp个数。默认值为1，数量上限与用户配置有关，默认上限为10。
        :rtype: int
        """
        return self._Number

    @Number.setter
    def Number(self, Number):
        self._Number = Number


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        if params.get("SnatIps") is not None:
            self._SnatIps = []
            for item in params.get("SnatIps"):
                obj = SnatIp()
                obj._deserialize(item)
                self._SnatIps.append(obj)
        self._Number = params.get("Number")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CreateLoadBalancerSnatIpsResponse(AbstractModel):
    r"""CreateLoadBalancerSnatIps返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class CreateModelRequest(AbstractModel):
    r"""CreateModel请求参数结构体

    """

    def __init__(self):
        r"""
        :param _AccessType: <p>接入类型：PublicBYOK/PublicCustom/PrivateCustom</p>
        :type AccessType: str
        :param _ModelProvider: <p>模型提供商</p>
        :type ModelProvider: str
        :param _ModelIds: <p>通用模型标识列表</p>
        :type ModelIds: list of ModelItem
        :param _Keys: <p>Key 列表</p>
        :type Keys: list of KeyItem
        :param _ServiceProviderId: <p>BYOK ID(在自定义模型时在部署网络后必须填写)</p>
        :type ServiceProviderId: str
        :param _ServiceProviderName: <p>服务供应商(创建BYOK自定义名称)。</p>
        :type ServiceProviderName: str
        :param _Protocol: <p>模型协议</p>
        :type Protocol: str
        :param _ApiBase: <p>API Base URL</p>
        :type ApiBase: str
        :param _VpcId: <p>VPC ID</p>
        :type VpcId: str
        :param _SubnetId: <p>子网 ID</p>
        :type SubnetId: str
        :param _HostHeader: <p>转发请求时添加的Host请求头</p>
        :type HostHeader: str
        :param _Tags: <p>标签信息</p>
        :type Tags: list of TagInfo
        :param _VerifySSL: <p>是否校验服务提供商的SSL证书</p>
        :type VerifySSL: bool
        :param _HealthCheckConfig: <p>健康检查配置</p>
        :type HealthCheckConfig: :class:`tencentcloud.clb.v20180317.models.ServiceProviderHealthCheckConfigInput`
        """
        self._AccessType = None
        self._ModelProvider = None
        self._ModelIds = None
        self._Keys = None
        self._ServiceProviderId = None
        self._ServiceProviderName = None
        self._Protocol = None
        self._ApiBase = None
        self._VpcId = None
        self._SubnetId = None
        self._HostHeader = None
        self._Tags = None
        self._VerifySSL = None
        self._HealthCheckConfig = None

    @property
    def AccessType(self):
        r"""<p>接入类型：PublicBYOK/PublicCustom/PrivateCustom</p>
        :rtype: str
        """
        return self._AccessType

    @AccessType.setter
    def AccessType(self, AccessType):
        self._AccessType = AccessType

    @property
    def ModelProvider(self):
        r"""<p>模型提供商</p>
        :rtype: str
        """
        return self._ModelProvider

    @ModelProvider.setter
    def ModelProvider(self, ModelProvider):
        self._ModelProvider = ModelProvider

    @property
    def ModelIds(self):
        r"""<p>通用模型标识列表</p>
        :rtype: list of ModelItem
        """
        return self._ModelIds

    @ModelIds.setter
    def ModelIds(self, ModelIds):
        self._ModelIds = ModelIds

    @property
    def Keys(self):
        r"""<p>Key 列表</p>
        :rtype: list of KeyItem
        """
        return self._Keys

    @Keys.setter
    def Keys(self, Keys):
        self._Keys = Keys

    @property
    def ServiceProviderId(self):
        r"""<p>BYOK ID(在自定义模型时在部署网络后必须填写)</p>
        :rtype: str
        """
        return self._ServiceProviderId

    @ServiceProviderId.setter
    def ServiceProviderId(self, ServiceProviderId):
        self._ServiceProviderId = ServiceProviderId

    @property
    def ServiceProviderName(self):
        r"""<p>服务供应商(创建BYOK自定义名称)。</p>
        :rtype: str
        """
        return self._ServiceProviderName

    @ServiceProviderName.setter
    def ServiceProviderName(self, ServiceProviderName):
        self._ServiceProviderName = ServiceProviderName

    @property
    def Protocol(self):
        r"""<p>模型协议</p>
        :rtype: str
        """
        return self._Protocol

    @Protocol.setter
    def Protocol(self, Protocol):
        self._Protocol = Protocol

    @property
    def ApiBase(self):
        r"""<p>API Base URL</p>
        :rtype: str
        """
        return self._ApiBase

    @ApiBase.setter
    def ApiBase(self, ApiBase):
        self._ApiBase = ApiBase

    @property
    def VpcId(self):
        r"""<p>VPC ID</p>
        :rtype: str
        """
        return self._VpcId

    @VpcId.setter
    def VpcId(self, VpcId):
        self._VpcId = VpcId

    @property
    def SubnetId(self):
        r"""<p>子网 ID</p>
        :rtype: str
        """
        return self._SubnetId

    @SubnetId.setter
    def SubnetId(self, SubnetId):
        self._SubnetId = SubnetId

    @property
    def HostHeader(self):
        r"""<p>转发请求时添加的Host请求头</p>
        :rtype: str
        """
        return self._HostHeader

    @HostHeader.setter
    def HostHeader(self, HostHeader):
        self._HostHeader = HostHeader

    @property
    def Tags(self):
        r"""<p>标签信息</p>
        :rtype: list of TagInfo
        """
        return self._Tags

    @Tags.setter
    def Tags(self, Tags):
        self._Tags = Tags

    @property
    def VerifySSL(self):
        r"""<p>是否校验服务提供商的SSL证书</p>
        :rtype: bool
        """
        return self._VerifySSL

    @VerifySSL.setter
    def VerifySSL(self, VerifySSL):
        self._VerifySSL = VerifySSL

    @property
    def HealthCheckConfig(self):
        r"""<p>健康检查配置</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.ServiceProviderHealthCheckConfigInput`
        """
        return self._HealthCheckConfig

    @HealthCheckConfig.setter
    def HealthCheckConfig(self, HealthCheckConfig):
        self._HealthCheckConfig = HealthCheckConfig


    def _deserialize(self, params):
        self._AccessType = params.get("AccessType")
        self._ModelProvider = params.get("ModelProvider")
        if params.get("ModelIds") is not None:
            self._ModelIds = []
            for item in params.get("ModelIds"):
                obj = ModelItem()
                obj._deserialize(item)
                self._ModelIds.append(obj)
        if params.get("Keys") is not None:
            self._Keys = []
            for item in params.get("Keys"):
                obj = KeyItem()
                obj._deserialize(item)
                self._Keys.append(obj)
        self._ServiceProviderId = params.get("ServiceProviderId")
        self._ServiceProviderName = params.get("ServiceProviderName")
        self._Protocol = params.get("Protocol")
        self._ApiBase = params.get("ApiBase")
        self._VpcId = params.get("VpcId")
        self._SubnetId = params.get("SubnetId")
        self._HostHeader = params.get("HostHeader")
        if params.get("Tags") is not None:
            self._Tags = []
            for item in params.get("Tags"):
                obj = TagInfo()
                obj._deserialize(item)
                self._Tags.append(obj)
        self._VerifySSL = params.get("VerifySSL")
        if params.get("HealthCheckConfig") is not None:
            self._HealthCheckConfig = ServiceProviderHealthCheckConfigInput()
            self._HealthCheckConfig._deserialize(params.get("HealthCheckConfig"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CreateModelResponse(AbstractModel):
    r"""CreateModel返回参数结构体

    """

    def __init__(self):
        r"""
        :param _ServiceProviderId: <p>服务供应商ID</p>
        :type ServiceProviderId: str
        :param _KeyIds: <p>生成的 Key ID 列表</p>
        :type KeyIds: list of str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._ServiceProviderId = None
        self._KeyIds = None
        self._RequestId = None

    @property
    def ServiceProviderId(self):
        r"""<p>服务供应商ID</p>
        :rtype: str
        """
        return self._ServiceProviderId

    @ServiceProviderId.setter
    def ServiceProviderId(self, ServiceProviderId):
        self._ServiceProviderId = ServiceProviderId

    @property
    def KeyIds(self):
        r"""<p>生成的 Key ID 列表</p>
        :rtype: list of str
        """
        return self._KeyIds

    @KeyIds.setter
    def KeyIds(self, KeyIds):
        self._KeyIds = KeyIds

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._ServiceProviderId = params.get("ServiceProviderId")
        self._KeyIds = params.get("KeyIds")
        self._RequestId = params.get("RequestId")


class CreateModelRouterRequest(AbstractModel):
    r"""CreateModelRouter请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterType: <p>模型路由类型</p><p>枚举值：</p><ul><li>Shared： 共享型</li><li>Enterprise： 企业级</li></ul>
        :type ModelRouterType: str
        :param _BudgetId: <p>关联的积分预算ID</p>
        :type BudgetId: str
        :param _CertId: <p>证书ID</p><p>入参限制：当Scheme为HTTPS时，该参数必传</p>
        :type CertId: str
        :param _ClusterInfo: <p>集群信息</p>
        :type ClusterInfo: :class:`tencentcloud.clb.v20180317.models.ClusterInfoInput`
        :param _ModelRouterName: <p>模型路由实例名称</p><p>默认值：-</p>
        :type ModelRouterName: str
        :param _NetworkType: <p>网络类型</p><p>枚举值：</p><ul><li>Internet： 公网</li><li>Intranet： 内网</li></ul>
        :type NetworkType: str
        :param _Port: <p>模型路由的监听端口</p><p>取值范围：[1, 65535]</p>
        :type Port: int
        :param _RateLimitConfig: <p>限速配置</p>
        :type RateLimitConfig: :class:`tencentcloud.clb.v20180317.models.RateLimitConfigForModelRouter`
        :param _RouterSetting: <p>路由配置</p><p>新创建实例时，默认会开启粘连路由</p>
        :type RouterSetting: :class:`tencentcloud.clb.v20180317.models.RouterSettingWithoutFallBack`
        :param _Schema: <p>模型路由实例的网络协议</p><p>枚举值：</p><ul><li>HTTP： HTTP协议</li><li>HTTPS： HTTPS协议</li></ul>
        :type Schema: str
        :param _SubnetId: <p>模型路由实例所属子网的ID</p>
        :type SubnetId: str
        :param _Tags: <p>标签</p>
        :type Tags: list of TagInfo
        :param _VpcId: <p>模型路由实例所属VPC的ID</p>
        :type VpcId: str
        :param _ModelRouterBillingConfig: <p>模型路由实例计费信息</p>
        :type ModelRouterBillingConfig: :class:`tencentcloud.clb.v20180317.models.ModelRouterBillingConfigInput`
        :param _ClientToken: <p>客户端Token，用于保证请求的幂等性。  从您的客户端生成一个参数值，确保不同请求间该参数值唯一。ClientToken只支持ASCII字符。</p>
        :type ClientToken: str
        :param _EipAddressId: <p>弹性公网IP的ID</p>
        :type EipAddressId: str
        :param _Bandwidth: <p>单位</p><p>取值范围：[1, 2048]</p><p>单位：Mbps</p>
        :type Bandwidth: int
        """
        self._ModelRouterType = None
        self._BudgetId = None
        self._CertId = None
        self._ClusterInfo = None
        self._ModelRouterName = None
        self._NetworkType = None
        self._Port = None
        self._RateLimitConfig = None
        self._RouterSetting = None
        self._Schema = None
        self._SubnetId = None
        self._Tags = None
        self._VpcId = None
        self._ModelRouterBillingConfig = None
        self._ClientToken = None
        self._EipAddressId = None
        self._Bandwidth = None

    @property
    def ModelRouterType(self):
        r"""<p>模型路由类型</p><p>枚举值：</p><ul><li>Shared： 共享型</li><li>Enterprise： 企业级</li></ul>
        :rtype: str
        """
        return self._ModelRouterType

    @ModelRouterType.setter
    def ModelRouterType(self, ModelRouterType):
        self._ModelRouterType = ModelRouterType

    @property
    def BudgetId(self):
        r"""<p>关联的积分预算ID</p>
        :rtype: str
        """
        return self._BudgetId

    @BudgetId.setter
    def BudgetId(self, BudgetId):
        self._BudgetId = BudgetId

    @property
    def CertId(self):
        r"""<p>证书ID</p><p>入参限制：当Scheme为HTTPS时，该参数必传</p>
        :rtype: str
        """
        return self._CertId

    @CertId.setter
    def CertId(self, CertId):
        self._CertId = CertId

    @property
    def ClusterInfo(self):
        r"""<p>集群信息</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.ClusterInfoInput`
        """
        return self._ClusterInfo

    @ClusterInfo.setter
    def ClusterInfo(self, ClusterInfo):
        self._ClusterInfo = ClusterInfo

    @property
    def ModelRouterName(self):
        r"""<p>模型路由实例名称</p><p>默认值：-</p>
        :rtype: str
        """
        return self._ModelRouterName

    @ModelRouterName.setter
    def ModelRouterName(self, ModelRouterName):
        self._ModelRouterName = ModelRouterName

    @property
    def NetworkType(self):
        r"""<p>网络类型</p><p>枚举值：</p><ul><li>Internet： 公网</li><li>Intranet： 内网</li></ul>
        :rtype: str
        """
        return self._NetworkType

    @NetworkType.setter
    def NetworkType(self, NetworkType):
        self._NetworkType = NetworkType

    @property
    def Port(self):
        r"""<p>模型路由的监听端口</p><p>取值范围：[1, 65535]</p>
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def RateLimitConfig(self):
        r"""<p>限速配置</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.RateLimitConfigForModelRouter`
        """
        return self._RateLimitConfig

    @RateLimitConfig.setter
    def RateLimitConfig(self, RateLimitConfig):
        self._RateLimitConfig = RateLimitConfig

    @property
    def RouterSetting(self):
        r"""<p>路由配置</p><p>新创建实例时，默认会开启粘连路由</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.RouterSettingWithoutFallBack`
        """
        return self._RouterSetting

    @RouterSetting.setter
    def RouterSetting(self, RouterSetting):
        self._RouterSetting = RouterSetting

    @property
    def Schema(self):
        r"""<p>模型路由实例的网络协议</p><p>枚举值：</p><ul><li>HTTP： HTTP协议</li><li>HTTPS： HTTPS协议</li></ul>
        :rtype: str
        """
        return self._Schema

    @Schema.setter
    def Schema(self, Schema):
        self._Schema = Schema

    @property
    def SubnetId(self):
        r"""<p>模型路由实例所属子网的ID</p>
        :rtype: str
        """
        return self._SubnetId

    @SubnetId.setter
    def SubnetId(self, SubnetId):
        self._SubnetId = SubnetId

    @property
    def Tags(self):
        r"""<p>标签</p>
        :rtype: list of TagInfo
        """
        return self._Tags

    @Tags.setter
    def Tags(self, Tags):
        self._Tags = Tags

    @property
    def VpcId(self):
        r"""<p>模型路由实例所属VPC的ID</p>
        :rtype: str
        """
        return self._VpcId

    @VpcId.setter
    def VpcId(self, VpcId):
        self._VpcId = VpcId

    @property
    def ModelRouterBillingConfig(self):
        r"""<p>模型路由实例计费信息</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.ModelRouterBillingConfigInput`
        """
        return self._ModelRouterBillingConfig

    @ModelRouterBillingConfig.setter
    def ModelRouterBillingConfig(self, ModelRouterBillingConfig):
        self._ModelRouterBillingConfig = ModelRouterBillingConfig

    @property
    def ClientToken(self):
        r"""<p>客户端Token，用于保证请求的幂等性。  从您的客户端生成一个参数值，确保不同请求间该参数值唯一。ClientToken只支持ASCII字符。</p>
        :rtype: str
        """
        return self._ClientToken

    @ClientToken.setter
    def ClientToken(self, ClientToken):
        self._ClientToken = ClientToken

    @property
    def EipAddressId(self):
        r"""<p>弹性公网IP的ID</p>
        :rtype: str
        """
        return self._EipAddressId

    @EipAddressId.setter
    def EipAddressId(self, EipAddressId):
        self._EipAddressId = EipAddressId

    @property
    def Bandwidth(self):
        r"""<p>单位</p><p>取值范围：[1, 2048]</p><p>单位：Mbps</p>
        :rtype: int
        """
        return self._Bandwidth

    @Bandwidth.setter
    def Bandwidth(self, Bandwidth):
        self._Bandwidth = Bandwidth


    def _deserialize(self, params):
        self._ModelRouterType = params.get("ModelRouterType")
        self._BudgetId = params.get("BudgetId")
        self._CertId = params.get("CertId")
        if params.get("ClusterInfo") is not None:
            self._ClusterInfo = ClusterInfoInput()
            self._ClusterInfo._deserialize(params.get("ClusterInfo"))
        self._ModelRouterName = params.get("ModelRouterName")
        self._NetworkType = params.get("NetworkType")
        self._Port = params.get("Port")
        if params.get("RateLimitConfig") is not None:
            self._RateLimitConfig = RateLimitConfigForModelRouter()
            self._RateLimitConfig._deserialize(params.get("RateLimitConfig"))
        if params.get("RouterSetting") is not None:
            self._RouterSetting = RouterSettingWithoutFallBack()
            self._RouterSetting._deserialize(params.get("RouterSetting"))
        self._Schema = params.get("Schema")
        self._SubnetId = params.get("SubnetId")
        if params.get("Tags") is not None:
            self._Tags = []
            for item in params.get("Tags"):
                obj = TagInfo()
                obj._deserialize(item)
                self._Tags.append(obj)
        self._VpcId = params.get("VpcId")
        if params.get("ModelRouterBillingConfig") is not None:
            self._ModelRouterBillingConfig = ModelRouterBillingConfigInput()
            self._ModelRouterBillingConfig._deserialize(params.get("ModelRouterBillingConfig"))
        self._ClientToken = params.get("ClientToken")
        self._EipAddressId = params.get("EipAddressId")
        self._Bandwidth = params.get("Bandwidth")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CreateModelRouterResourcePackageRequest(AbstractModel):
    r"""CreateModelRouterResourcePackage请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterResourcePackageAmount: <p>模型路由资源包容量</p><p>取值范围：[1000, 10000000]</p><p>单次购买的模型路由资源包容量下限为1000，上限为10000000</p>
        :type ModelRouterResourcePackageAmount: int
        :param _AutoPurchaseFlag: <p>是否自动续订。</p><p>0:不自动续订, 1:用尽到期续订</p>
        :type AutoPurchaseFlag: int
        :param _AutoVoucher: <p>该笔订单是否自动选择代金券</p><p>默认值：false（不自动选择代金券）</p><p>true时会为本笔订单自动匹配满足条件、最优惠的代金券</p>
        :type AutoVoucher: bool
        """
        self._ModelRouterResourcePackageAmount = None
        self._AutoPurchaseFlag = None
        self._AutoVoucher = None

    @property
    def ModelRouterResourcePackageAmount(self):
        r"""<p>模型路由资源包容量</p><p>取值范围：[1000, 10000000]</p><p>单次购买的模型路由资源包容量下限为1000，上限为10000000</p>
        :rtype: int
        """
        return self._ModelRouterResourcePackageAmount

    @ModelRouterResourcePackageAmount.setter
    def ModelRouterResourcePackageAmount(self, ModelRouterResourcePackageAmount):
        self._ModelRouterResourcePackageAmount = ModelRouterResourcePackageAmount

    @property
    def AutoPurchaseFlag(self):
        r"""<p>是否自动续订。</p><p>0:不自动续订, 1:用尽到期续订</p>
        :rtype: int
        """
        return self._AutoPurchaseFlag

    @AutoPurchaseFlag.setter
    def AutoPurchaseFlag(self, AutoPurchaseFlag):
        self._AutoPurchaseFlag = AutoPurchaseFlag

    @property
    def AutoVoucher(self):
        r"""<p>该笔订单是否自动选择代金券</p><p>默认值：false（不自动选择代金券）</p><p>true时会为本笔订单自动匹配满足条件、最优惠的代金券</p>
        :rtype: bool
        """
        return self._AutoVoucher

    @AutoVoucher.setter
    def AutoVoucher(self, AutoVoucher):
        self._AutoVoucher = AutoVoucher


    def _deserialize(self, params):
        self._ModelRouterResourcePackageAmount = params.get("ModelRouterResourcePackageAmount")
        self._AutoPurchaseFlag = params.get("AutoPurchaseFlag")
        self._AutoVoucher = params.get("AutoVoucher")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CreateModelRouterResourcePackageResponse(AbstractModel):
    r"""CreateModelRouterResourcePackage返回参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterResourcePackageIds: <p>模型路由资源包Id</p>
        :type ModelRouterResourcePackageIds: list of str
        :param _DealName: <p>订单号</p>
        :type DealName: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._ModelRouterResourcePackageIds = None
        self._DealName = None
        self._RequestId = None

    @property
    def ModelRouterResourcePackageIds(self):
        r"""<p>模型路由资源包Id</p>
        :rtype: list of str
        """
        return self._ModelRouterResourcePackageIds

    @ModelRouterResourcePackageIds.setter
    def ModelRouterResourcePackageIds(self, ModelRouterResourcePackageIds):
        self._ModelRouterResourcePackageIds = ModelRouterResourcePackageIds

    @property
    def DealName(self):
        r"""<p>订单号</p>
        :rtype: str
        """
        return self._DealName

    @DealName.setter
    def DealName(self, DealName):
        self._DealName = DealName

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._ModelRouterResourcePackageIds = params.get("ModelRouterResourcePackageIds")
        self._DealName = params.get("DealName")
        self._RequestId = params.get("RequestId")


class CreateModelRouterResponse(AbstractModel):
    r"""CreateModelRouter返回参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID</p>
        :type ModelRouterId: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._ModelRouterId = None
        self._RequestId = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._RequestId = params.get("RequestId")


class CreateRuleRequest(AbstractModel):
    r"""CreateRule请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例 ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口获取
        :type LoadBalancerId: str
        :param _ListenerId: 监听器 ID，可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口获取
        :type ListenerId: str
        :param _Rules: 新建转发规则的信息。
        :type Rules: list of RuleInput
        """
        self._LoadBalancerId = None
        self._ListenerId = None
        self._Rules = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例 ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口获取
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerId(self):
        r"""监听器 ID，可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口获取
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def Rules(self):
        r"""新建转发规则的信息。
        :rtype: list of RuleInput
        """
        return self._Rules

    @Rules.setter
    def Rules(self, Rules):
        self._Rules = Rules


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerId = params.get("ListenerId")
        if params.get("Rules") is not None:
            self._Rules = []
            for item in params.get("Rules"):
                obj = RuleInput()
                obj._deserialize(item)
                self._Rules.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CreateRuleResponse(AbstractModel):
    r"""CreateRule返回参数结构体

    """

    def __init__(self):
        r"""
        :param _LocationIds: 创建的转发规则的唯一标识数组。
        :type LocationIds: list of str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._LocationIds = None
        self._RequestId = None

    @property
    def LocationIds(self):
        r"""创建的转发规则的唯一标识数组。
        :rtype: list of str
        """
        return self._LocationIds

    @LocationIds.setter
    def LocationIds(self, LocationIds):
        self._LocationIds = LocationIds

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._LocationIds = params.get("LocationIds")
        self._RequestId = params.get("RequestId")


class CreateTargetGroupRequest(AbstractModel):
    r"""CreateTargetGroup请求参数结构体

    """

    def __init__(self):
        r"""
        :param _TargetGroupName: <p>目标组名称。命名规则：1-80 个英文字母、汉字等国际通用语言字符，数字，连接线“-”、下划线“_”等常见字符（禁止Unicode补充字符，如emoji表情、生僻汉字等）。</p>
        :type TargetGroupName: str
        :param _VpcId: <p>目标组的vpcId属性，不填则使用默认vpc。</p>
        :type VpcId: str
        :param _Port: <p>目标组的默认端口， 后续添加服务器时可使用该默认端口。全监听目标组不支持此参数，非全监听目标组Port和TargetGroupInstances.N中的port二者必填其一。</p>
        :type Port: int
        :param _TargetGroupInstances: <p>目标组绑定的后端服务器，单次最多支持50个。</p>
        :type TargetGroupInstances: list of TargetGroupInstance
        :param _Type: <p>目标组类型，当前支持v1(旧版目标组), v2(新版目标组), 默认为v1(旧版目标组)。</p>
        :type Type: str
        :param _Protocol: <p>目标组后端转发协议。v2新版目标组该项必填。目前支持TCP、UDP、HTTP、HTTPS、GRPC。</p>
        :type Protocol: str
        :param _HealthCheck: <p>健康检查。</p>
        :type HealthCheck: :class:`tencentcloud.clb.v20180317.models.TargetGroupHealthCheck`
        :param _ScheduleAlgorithm: <p>调度算法，仅V2新版目标组，且后端转发协议为(HTTP|HTTPS|GRPC)时该参数有效。可选值：</p><li>WRR:按权重轮询。</li><li>LEAST_CONN:最小连接数。</li><li>IP_HASH:按IP哈希。</li><li>默认为 WRR。</li>
        :type ScheduleAlgorithm: str
        :param _Tags: <p>标签。</p>
        :type Tags: list of TagInfo
        :param _Weight: <p>后端服务默认权重, 其中：</p><ul><li>取值范围[0, 100]</li><li>设置该值后，添加后端服务到目标组时， 若后端服务不单独设置权重， 则使用这里的默认权重。 </li><li>v1 目标组类型不支持设置 Weight 参数。</li></ul>
        :type Weight: int
        :param _FullListenSwitch: <p>全监听目标组标识，true表示是全监听目标组，false表示不是全监听目标组。仅V2新版类型目标组支持该参数。</p>
        :type FullListenSwitch: bool
        :param _KeepaliveEnable: <p>是否开启长连接，此参数仅适用于HTTP/HTTPS目标组，0:关闭；1:开启， 默认关闭。</p>
        :type KeepaliveEnable: bool
        :param _SessionExpireTime: <p>会话保持时间，单位：秒。可选值：30~3600，默认 0，表示不开启。仅V2新版且后端转发协议为HTTP/HTTPS/GRPC目标组支持该参数。</p>
        :type SessionExpireTime: int
        :param _IpVersion: <p>IP版本类型。</p>
        :type IpVersion: str
        :param _SnatEnable: <p>是否开启SNAT（源IP替换），True（开启）、False（关闭）。默认为关闭。注意：SnatEnable开启时会替换客户端源IP，此时<code>透传客户端源IP</code>选项关闭，反之亦然。</p>
        :type SnatEnable: bool
        """
        self._TargetGroupName = None
        self._VpcId = None
        self._Port = None
        self._TargetGroupInstances = None
        self._Type = None
        self._Protocol = None
        self._HealthCheck = None
        self._ScheduleAlgorithm = None
        self._Tags = None
        self._Weight = None
        self._FullListenSwitch = None
        self._KeepaliveEnable = None
        self._SessionExpireTime = None
        self._IpVersion = None
        self._SnatEnable = None

    @property
    def TargetGroupName(self):
        r"""<p>目标组名称。命名规则：1-80 个英文字母、汉字等国际通用语言字符，数字，连接线“-”、下划线“_”等常见字符（禁止Unicode补充字符，如emoji表情、生僻汉字等）。</p>
        :rtype: str
        """
        return self._TargetGroupName

    @TargetGroupName.setter
    def TargetGroupName(self, TargetGroupName):
        self._TargetGroupName = TargetGroupName

    @property
    def VpcId(self):
        r"""<p>目标组的vpcId属性，不填则使用默认vpc。</p>
        :rtype: str
        """
        return self._VpcId

    @VpcId.setter
    def VpcId(self, VpcId):
        self._VpcId = VpcId

    @property
    def Port(self):
        r"""<p>目标组的默认端口， 后续添加服务器时可使用该默认端口。全监听目标组不支持此参数，非全监听目标组Port和TargetGroupInstances.N中的port二者必填其一。</p>
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def TargetGroupInstances(self):
        r"""<p>目标组绑定的后端服务器，单次最多支持50个。</p>
        :rtype: list of TargetGroupInstance
        """
        return self._TargetGroupInstances

    @TargetGroupInstances.setter
    def TargetGroupInstances(self, TargetGroupInstances):
        self._TargetGroupInstances = TargetGroupInstances

    @property
    def Type(self):
        r"""<p>目标组类型，当前支持v1(旧版目标组), v2(新版目标组), 默认为v1(旧版目标组)。</p>
        :rtype: str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type

    @property
    def Protocol(self):
        r"""<p>目标组后端转发协议。v2新版目标组该项必填。目前支持TCP、UDP、HTTP、HTTPS、GRPC。</p>
        :rtype: str
        """
        return self._Protocol

    @Protocol.setter
    def Protocol(self, Protocol):
        self._Protocol = Protocol

    @property
    def HealthCheck(self):
        r"""<p>健康检查。</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.TargetGroupHealthCheck`
        """
        return self._HealthCheck

    @HealthCheck.setter
    def HealthCheck(self, HealthCheck):
        self._HealthCheck = HealthCheck

    @property
    def ScheduleAlgorithm(self):
        r"""<p>调度算法，仅V2新版目标组，且后端转发协议为(HTTP|HTTPS|GRPC)时该参数有效。可选值：</p><li>WRR:按权重轮询。</li><li>LEAST_CONN:最小连接数。</li><li>IP_HASH:按IP哈希。</li><li>默认为 WRR。</li>
        :rtype: str
        """
        return self._ScheduleAlgorithm

    @ScheduleAlgorithm.setter
    def ScheduleAlgorithm(self, ScheduleAlgorithm):
        self._ScheduleAlgorithm = ScheduleAlgorithm

    @property
    def Tags(self):
        r"""<p>标签。</p>
        :rtype: list of TagInfo
        """
        return self._Tags

    @Tags.setter
    def Tags(self, Tags):
        self._Tags = Tags

    @property
    def Weight(self):
        r"""<p>后端服务默认权重, 其中：</p><ul><li>取值范围[0, 100]</li><li>设置该值后，添加后端服务到目标组时， 若后端服务不单独设置权重， 则使用这里的默认权重。 </li><li>v1 目标组类型不支持设置 Weight 参数。</li></ul>
        :rtype: int
        """
        return self._Weight

    @Weight.setter
    def Weight(self, Weight):
        self._Weight = Weight

    @property
    def FullListenSwitch(self):
        r"""<p>全监听目标组标识，true表示是全监听目标组，false表示不是全监听目标组。仅V2新版类型目标组支持该参数。</p>
        :rtype: bool
        """
        return self._FullListenSwitch

    @FullListenSwitch.setter
    def FullListenSwitch(self, FullListenSwitch):
        self._FullListenSwitch = FullListenSwitch

    @property
    def KeepaliveEnable(self):
        r"""<p>是否开启长连接，此参数仅适用于HTTP/HTTPS目标组，0:关闭；1:开启， 默认关闭。</p>
        :rtype: bool
        """
        return self._KeepaliveEnable

    @KeepaliveEnable.setter
    def KeepaliveEnable(self, KeepaliveEnable):
        self._KeepaliveEnable = KeepaliveEnable

    @property
    def SessionExpireTime(self):
        r"""<p>会话保持时间，单位：秒。可选值：30~3600，默认 0，表示不开启。仅V2新版且后端转发协议为HTTP/HTTPS/GRPC目标组支持该参数。</p>
        :rtype: int
        """
        return self._SessionExpireTime

    @SessionExpireTime.setter
    def SessionExpireTime(self, SessionExpireTime):
        self._SessionExpireTime = SessionExpireTime

    @property
    def IpVersion(self):
        r"""<p>IP版本类型。</p>
        :rtype: str
        """
        return self._IpVersion

    @IpVersion.setter
    def IpVersion(self, IpVersion):
        self._IpVersion = IpVersion

    @property
    def SnatEnable(self):
        r"""<p>是否开启SNAT（源IP替换），True（开启）、False（关闭）。默认为关闭。注意：SnatEnable开启时会替换客户端源IP，此时<code>透传客户端源IP</code>选项关闭，反之亦然。</p>
        :rtype: bool
        """
        return self._SnatEnable

    @SnatEnable.setter
    def SnatEnable(self, SnatEnable):
        self._SnatEnable = SnatEnable


    def _deserialize(self, params):
        self._TargetGroupName = params.get("TargetGroupName")
        self._VpcId = params.get("VpcId")
        self._Port = params.get("Port")
        if params.get("TargetGroupInstances") is not None:
            self._TargetGroupInstances = []
            for item in params.get("TargetGroupInstances"):
                obj = TargetGroupInstance()
                obj._deserialize(item)
                self._TargetGroupInstances.append(obj)
        self._Type = params.get("Type")
        self._Protocol = params.get("Protocol")
        if params.get("HealthCheck") is not None:
            self._HealthCheck = TargetGroupHealthCheck()
            self._HealthCheck._deserialize(params.get("HealthCheck"))
        self._ScheduleAlgorithm = params.get("ScheduleAlgorithm")
        if params.get("Tags") is not None:
            self._Tags = []
            for item in params.get("Tags"):
                obj = TagInfo()
                obj._deserialize(item)
                self._Tags.append(obj)
        self._Weight = params.get("Weight")
        self._FullListenSwitch = params.get("FullListenSwitch")
        self._KeepaliveEnable = params.get("KeepaliveEnable")
        self._SessionExpireTime = params.get("SessionExpireTime")
        self._IpVersion = params.get("IpVersion")
        self._SnatEnable = params.get("SnatEnable")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CreateTargetGroupResponse(AbstractModel):
    r"""CreateTargetGroup返回参数结构体

    """

    def __init__(self):
        r"""
        :param _TargetGroupId: <p>创建目标组后生成的id</p>
        :type TargetGroupId: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._TargetGroupId = None
        self._RequestId = None

    @property
    def TargetGroupId(self):
        r"""<p>创建目标组后生成的id</p>
        :rtype: str
        """
        return self._TargetGroupId

    @TargetGroupId.setter
    def TargetGroupId(self, TargetGroupId):
        self._TargetGroupId = TargetGroupId

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._TargetGroupId = params.get("TargetGroupId")
        self._RequestId = params.get("RequestId")


class CreateTopicRequest(AbstractModel):
    r"""CreateTopic请求参数结构体

    """

    def __init__(self):
        r"""
        :param _TopicName: <p>日志主题的名称。</p>
        :type TopicName: str
        :param _PartitionCount: <p>主题分区Partition的数量，不传参默认创建1个，最大创建允许10个，分裂/合并操作会改变分区数量，整体上限50个。</p>
        :type PartitionCount: int
        :param _TopicType: <p>日志类型，ACCESS：访问日志，HEALTH：健康检查日志，默认ACCESS。</p>
        :type TopicType: str
        :param _Period: <p>存储时间，单位天，默认为 30。</p><ul><li>日志接入标准存储时，支持1至3600天，值为3640时代表永久保存。</li><li>日志接入低频存储时，支持7至3600天，值为3640时代表永久保存。</li></ul>
        :type Period: int
        :param _StorageType: <p>日志主题的存储类型，可选值 HOT（标准存储），COLD（低频存储）；默认为HOT。</p>
        :type StorageType: str
        :param _Tags: <p>标签</p><p>最多支持一次传入20个</p>
        :type Tags: list of TagInfo
        """
        self._TopicName = None
        self._PartitionCount = None
        self._TopicType = None
        self._Period = None
        self._StorageType = None
        self._Tags = None

    @property
    def TopicName(self):
        r"""<p>日志主题的名称。</p>
        :rtype: str
        """
        return self._TopicName

    @TopicName.setter
    def TopicName(self, TopicName):
        self._TopicName = TopicName

    @property
    def PartitionCount(self):
        r"""<p>主题分区Partition的数量，不传参默认创建1个，最大创建允许10个，分裂/合并操作会改变分区数量，整体上限50个。</p>
        :rtype: int
        """
        return self._PartitionCount

    @PartitionCount.setter
    def PartitionCount(self, PartitionCount):
        self._PartitionCount = PartitionCount

    @property
    def TopicType(self):
        r"""<p>日志类型，ACCESS：访问日志，HEALTH：健康检查日志，默认ACCESS。</p>
        :rtype: str
        """
        return self._TopicType

    @TopicType.setter
    def TopicType(self, TopicType):
        self._TopicType = TopicType

    @property
    def Period(self):
        r"""<p>存储时间，单位天，默认为 30。</p><ul><li>日志接入标准存储时，支持1至3600天，值为3640时代表永久保存。</li><li>日志接入低频存储时，支持7至3600天，值为3640时代表永久保存。</li></ul>
        :rtype: int
        """
        return self._Period

    @Period.setter
    def Period(self, Period):
        self._Period = Period

    @property
    def StorageType(self):
        r"""<p>日志主题的存储类型，可选值 HOT（标准存储），COLD（低频存储）；默认为HOT。</p>
        :rtype: str
        """
        return self._StorageType

    @StorageType.setter
    def StorageType(self, StorageType):
        self._StorageType = StorageType

    @property
    def Tags(self):
        r"""<p>标签</p><p>最多支持一次传入20个</p>
        :rtype: list of TagInfo
        """
        return self._Tags

    @Tags.setter
    def Tags(self, Tags):
        self._Tags = Tags


    def _deserialize(self, params):
        self._TopicName = params.get("TopicName")
        self._PartitionCount = params.get("PartitionCount")
        self._TopicType = params.get("TopicType")
        self._Period = params.get("Period")
        self._StorageType = params.get("StorageType")
        if params.get("Tags") is not None:
            self._Tags = []
            for item in params.get("Tags"):
                obj = TagInfo()
                obj._deserialize(item)
                self._Tags.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CreateTopicResponse(AbstractModel):
    r"""CreateTopic返回参数结构体

    """

    def __init__(self):
        r"""
        :param _TopicId: <p>日志主题的 ID。</p>
        :type TopicId: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._TopicId = None
        self._RequestId = None

    @property
    def TopicId(self):
        r"""<p>日志主题的 ID。</p>
        :rtype: str
        """
        return self._TopicId

    @TopicId.setter
    def TopicId(self, TopicId):
        self._TopicId = TopicId

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._TopicId = params.get("TopicId")
        self._RequestId = params.get("RequestId")


class CreateUserGroupRequest(AbstractModel):
    r"""CreateUserGroup请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID。用户组将创建在该实例下。</p>
        :type ModelRouterId: str
        :param _UserGroupName: <p>用户组名称。必填。同一模型路由实例下名称唯一，长度不超过255个字符。</p>
        :type UserGroupName: str
        :param _BudgetId: <p>建组时直接关联的预算 ID（须为已存在的 Budget）。关联后由该 Budget 统一管理本组的消费上限与限速。不传表示不关联预算，可建组后再用 AssociateBudget 关联。</p>
        :type BudgetId: str
        :param _IntentRouters: <p>用户组意图路由白名单（ir-xxx）。每一项须为该实例已创建的意图路由名。命中意图路由名时其内部真实模型自动豁免白名单。为空表示不授权任何意图路由。</p>
        :type IntentRouters: list of str
        :param _KeyIds: <p>建组时同时绑定的已有 Key ID 列表，最多100个。每个 Key 须属于同一模型路由实例。建组与绑定为一个原子异步任务，任一 Key 失败则整组创建回滚。不传表示建空组。</p>
        :type KeyIds: list of str
        :param _Models: <p>用户组真实模型白名单。每一项须为该实例已关联的模型名。为空表示不在用户组层限制真实模型（按实例层白名单生效）。</p>
        :type Models: list of str
        :param _Tags: <p>标签列表，最多50个。</p>
        :type Tags: list of TagInfo
        """
        self._ModelRouterId = None
        self._UserGroupName = None
        self._BudgetId = None
        self._IntentRouters = None
        self._KeyIds = None
        self._Models = None
        self._Tags = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID。用户组将创建在该实例下。</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def UserGroupName(self):
        r"""<p>用户组名称。必填。同一模型路由实例下名称唯一，长度不超过255个字符。</p>
        :rtype: str
        """
        return self._UserGroupName

    @UserGroupName.setter
    def UserGroupName(self, UserGroupName):
        self._UserGroupName = UserGroupName

    @property
    def BudgetId(self):
        r"""<p>建组时直接关联的预算 ID（须为已存在的 Budget）。关联后由该 Budget 统一管理本组的消费上限与限速。不传表示不关联预算，可建组后再用 AssociateBudget 关联。</p>
        :rtype: str
        """
        return self._BudgetId

    @BudgetId.setter
    def BudgetId(self, BudgetId):
        self._BudgetId = BudgetId

    @property
    def IntentRouters(self):
        r"""<p>用户组意图路由白名单（ir-xxx）。每一项须为该实例已创建的意图路由名。命中意图路由名时其内部真实模型自动豁免白名单。为空表示不授权任何意图路由。</p>
        :rtype: list of str
        """
        return self._IntentRouters

    @IntentRouters.setter
    def IntentRouters(self, IntentRouters):
        self._IntentRouters = IntentRouters

    @property
    def KeyIds(self):
        r"""<p>建组时同时绑定的已有 Key ID 列表，最多100个。每个 Key 须属于同一模型路由实例。建组与绑定为一个原子异步任务，任一 Key 失败则整组创建回滚。不传表示建空组。</p>
        :rtype: list of str
        """
        return self._KeyIds

    @KeyIds.setter
    def KeyIds(self, KeyIds):
        self._KeyIds = KeyIds

    @property
    def Models(self):
        r"""<p>用户组真实模型白名单。每一项须为该实例已关联的模型名。为空表示不在用户组层限制真实模型（按实例层白名单生效）。</p>
        :rtype: list of str
        """
        return self._Models

    @Models.setter
    def Models(self, Models):
        self._Models = Models

    @property
    def Tags(self):
        r"""<p>标签列表，最多50个。</p>
        :rtype: list of TagInfo
        """
        return self._Tags

    @Tags.setter
    def Tags(self, Tags):
        self._Tags = Tags


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._UserGroupName = params.get("UserGroupName")
        self._BudgetId = params.get("BudgetId")
        self._IntentRouters = params.get("IntentRouters")
        self._KeyIds = params.get("KeyIds")
        self._Models = params.get("Models")
        if params.get("Tags") is not None:
            self._Tags = []
            for item in params.get("Tags"):
                obj = TagInfo()
                obj._deserialize(item)
                self._Tags.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CreateUserGroupResponse(AbstractModel):
    r"""CreateUserGroup返回参数结构体

    """

    def __init__(self):
        r"""
        :param _UserGroupId: <p>新建用户组的ID。</p>
        :type UserGroupId: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._UserGroupId = None
        self._RequestId = None

    @property
    def UserGroupId(self):
        r"""<p>新建用户组的ID。</p>
        :rtype: str
        """
        return self._UserGroupId

    @UserGroupId.setter
    def UserGroupId(self, UserGroupId):
        self._UserGroupId = UserGroupId

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._UserGroupId = params.get("UserGroupId")
        self._RequestId = params.get("RequestId")


class CreatedKey(AbstractModel):
    r"""批量创建的Key信息

    """

    def __init__(self):
        r"""
        :param _Key: <p>明文Key</p>
        :type Key: str
        :param _KeyId: <p>Key的ID</p>
        :type KeyId: str
        :param _KeyName: <p>Key的名称</p>
        :type KeyName: str
        """
        self._Key = None
        self._KeyId = None
        self._KeyName = None

    @property
    def Key(self):
        r"""<p>明文Key</p>
        :rtype: str
        """
        return self._Key

    @Key.setter
    def Key(self, Key):
        self._Key = Key

    @property
    def KeyId(self):
        r"""<p>Key的ID</p>
        :rtype: str
        """
        return self._KeyId

    @KeyId.setter
    def KeyId(self, KeyId):
        self._KeyId = KeyId

    @property
    def KeyName(self):
        r"""<p>Key的名称</p>
        :rtype: str
        """
        return self._KeyName

    @KeyName.setter
    def KeyName(self, KeyName):
        self._KeyName = KeyName


    def _deserialize(self, params):
        self._Key = params.get("Key")
        self._KeyId = params.get("KeyId")
        self._KeyName = params.get("KeyName")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CreditUsage(AbstractModel):
    r"""Credit使用情况。该结构用于 CreditUsageSet 数组中的逐周期用量。

    """

    def __init__(self):
        r"""
        :param _BudgetDuration: <p>Budget刷新周期。</p><p>枚举值：</p><ul><li>1d：按天刷新</li><li>7d：按周刷新</li><li>30d：按月刷新</li></ul><p>仅在 CreditUsageSet 数组元素中返回。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type BudgetDuration: str
        :param _BudgetResetAt: <p>下次刷新时间。</p><p>用户组关联Budget且Budget设置重置周期时返回；未关联Budget或未设置重置周期时为空。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type BudgetResetAt: str
        :param _Limit: <p>Credit上限。</p><p>用户组关联Budget且Budget设置最大预算时返回；未设置最大预算时为空。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type Limit: float
        :param _Used: <p>用户组已使用的Credit数量。</p>
        :type Used: float
        """
        self._BudgetDuration = None
        self._BudgetResetAt = None
        self._Limit = None
        self._Used = None

    @property
    def BudgetDuration(self):
        r"""<p>Budget刷新周期。</p><p>枚举值：</p><ul><li>1d：按天刷新</li><li>7d：按周刷新</li><li>30d：按月刷新</li></ul><p>仅在 CreditUsageSet 数组元素中返回。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._BudgetDuration

    @BudgetDuration.setter
    def BudgetDuration(self, BudgetDuration):
        self._BudgetDuration = BudgetDuration

    @property
    def BudgetResetAt(self):
        r"""<p>下次刷新时间。</p><p>用户组关联Budget且Budget设置重置周期时返回；未关联Budget或未设置重置周期时为空。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._BudgetResetAt

    @BudgetResetAt.setter
    def BudgetResetAt(self, BudgetResetAt):
        self._BudgetResetAt = BudgetResetAt

    @property
    def Limit(self):
        r"""<p>Credit上限。</p><p>用户组关联Budget且Budget设置最大预算时返回；未设置最大预算时为空。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: float
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def Used(self):
        r"""<p>用户组已使用的Credit数量。</p>
        :rtype: float
        """
        return self._Used

    @Used.setter
    def Used(self, Used):
        self._Used = Used


    def _deserialize(self, params):
        self._BudgetDuration = params.get("BudgetDuration")
        self._BudgetResetAt = params.get("BudgetResetAt")
        self._Limit = params.get("Limit")
        self._Used = params.get("Used")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class CrossTargets(AbstractModel):
    r"""跨域2.0云联网下子机和网卡信息

    """

    def __init__(self):
        r"""
        :param _LocalVpcId: 本地私有网络ID，即负载均衡的VpcId。
        :type LocalVpcId: str
        :param _VpcId: 子机或网卡所属的私有网络ID。
        :type VpcId: str
        :param _IP: 子机或网卡的IP地址
        :type IP: str
        :param _VpcName: 子机或网卡所属的私有网络名称。
        :type VpcName: str
        :param _EniId: 子机的网卡ID。
        :type EniId: str
        :param _InstanceId: 子机实例ID。
        :type InstanceId: str
        :param _InstanceName: 子机实例名称。
        :type InstanceName: str
        :param _Region: 子机或者网卡所属的地域。
        :type Region: str
        """
        self._LocalVpcId = None
        self._VpcId = None
        self._IP = None
        self._VpcName = None
        self._EniId = None
        self._InstanceId = None
        self._InstanceName = None
        self._Region = None

    @property
    def LocalVpcId(self):
        r"""本地私有网络ID，即负载均衡的VpcId。
        :rtype: str
        """
        return self._LocalVpcId

    @LocalVpcId.setter
    def LocalVpcId(self, LocalVpcId):
        self._LocalVpcId = LocalVpcId

    @property
    def VpcId(self):
        r"""子机或网卡所属的私有网络ID。
        :rtype: str
        """
        return self._VpcId

    @VpcId.setter
    def VpcId(self, VpcId):
        self._VpcId = VpcId

    @property
    def IP(self):
        r"""子机或网卡的IP地址
        :rtype: str
        """
        return self._IP

    @IP.setter
    def IP(self, IP):
        self._IP = IP

    @property
    def VpcName(self):
        r"""子机或网卡所属的私有网络名称。
        :rtype: str
        """
        return self._VpcName

    @VpcName.setter
    def VpcName(self, VpcName):
        self._VpcName = VpcName

    @property
    def EniId(self):
        r"""子机的网卡ID。
        :rtype: str
        """
        return self._EniId

    @EniId.setter
    def EniId(self, EniId):
        self._EniId = EniId

    @property
    def InstanceId(self):
        r"""子机实例ID。
        :rtype: str
        """
        return self._InstanceId

    @InstanceId.setter
    def InstanceId(self, InstanceId):
        self._InstanceId = InstanceId

    @property
    def InstanceName(self):
        r"""子机实例名称。
        :rtype: str
        """
        return self._InstanceName

    @InstanceName.setter
    def InstanceName(self, InstanceName):
        self._InstanceName = InstanceName

    @property
    def Region(self):
        r"""子机或者网卡所属的地域。
        :rtype: str
        """
        return self._Region

    @Region.setter
    def Region(self, Region):
        self._Region = Region


    def _deserialize(self, params):
        self._LocalVpcId = params.get("LocalVpcId")
        self._VpcId = params.get("VpcId")
        self._IP = params.get("IP")
        self._VpcName = params.get("VpcName")
        self._EniId = params.get("EniId")
        self._InstanceId = params.get("InstanceId")
        self._InstanceName = params.get("InstanceName")
        self._Region = params.get("Region")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DeleteBudgetsRequest(AbstractModel):
    r"""DeleteBudgets请求参数结构体

    """

    def __init__(self):
        r"""
        :param _BudgetIds: <p>要删除的Budget ID列表。</p>
        :type BudgetIds: list of str
        """
        self._BudgetIds = None

    @property
    def BudgetIds(self):
        r"""<p>要删除的Budget ID列表。</p>
        :rtype: list of str
        """
        return self._BudgetIds

    @BudgetIds.setter
    def BudgetIds(self, BudgetIds):
        self._BudgetIds = BudgetIds


    def _deserialize(self, params):
        self._BudgetIds = params.get("BudgetIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DeleteBudgetsResponse(AbstractModel):
    r"""DeleteBudgets返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DeleteIntentRouterRequest(AbstractModel):
    r"""DeleteIntentRouter请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID。</p>
        :type ModelRouterId: str
        :param _IntentRouterId: <p>意图路由ID（ir-xxx格式）。</p>
        :type IntentRouterId: str
        """
        self._ModelRouterId = None
        self._IntentRouterId = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID。</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def IntentRouterId(self):
        r"""<p>意图路由ID（ir-xxx格式）。</p>
        :rtype: str
        """
        return self._IntentRouterId

    @IntentRouterId.setter
    def IntentRouterId(self, IntentRouterId):
        self._IntentRouterId = IntentRouterId


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._IntentRouterId = params.get("IntentRouterId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DeleteIntentRouterResponse(AbstractModel):
    r"""DeleteIntentRouter返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DeleteKeysRequest(AbstractModel):
    r"""DeleteKeys请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由ID</p>
        :type ModelRouterId: str
        :param _KeyIds: <p>key的ID列表</p>
        :type KeyIds: list of str
        """
        self._ModelRouterId = None
        self._KeyIds = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def KeyIds(self):
        r"""<p>key的ID列表</p>
        :rtype: list of str
        """
        return self._KeyIds

    @KeyIds.setter
    def KeyIds(self, KeyIds):
        self._KeyIds = KeyIds


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._KeyIds = params.get("KeyIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DeleteKeysResponse(AbstractModel):
    r"""DeleteKeys返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DeleteListenerRequest(AbstractModel):
    r"""DeleteListener请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口查询。
        :type LoadBalancerId: str
        :param _ListenerId: 要删除的监听器ID，可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口查询。
        :type ListenerId: str
        """
        self._LoadBalancerId = None
        self._ListenerId = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口查询。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerId(self):
        r"""要删除的监听器ID，可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口查询。
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerId = params.get("ListenerId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DeleteListenerResponse(AbstractModel):
    r"""DeleteListener返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DeleteLoadBalancerListenersRequest(AbstractModel):
    r"""DeleteLoadBalancerListeners请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口查询。
        :type LoadBalancerId: str
        :param _ListenerIds: 指定删除的监听器ID数组，最大为20个。若不填则删除负载均衡的所有监听器，可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口查询。
        :type ListenerIds: list of str
        """
        self._LoadBalancerId = None
        self._ListenerIds = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口查询。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerIds(self):
        r"""指定删除的监听器ID数组，最大为20个。若不填则删除负载均衡的所有监听器，可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口查询。
        :rtype: list of str
        """
        return self._ListenerIds

    @ListenerIds.setter
    def ListenerIds(self, ListenerIds):
        self._ListenerIds = ListenerIds


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerIds = params.get("ListenerIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DeleteLoadBalancerListenersResponse(AbstractModel):
    r"""DeleteLoadBalancerListeners返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DeleteLoadBalancerRequest(AbstractModel):
    r"""DeleteLoadBalancer请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerIds: 要删除的负载均衡实例 ID 数组，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口获取，数组大小最大支持20。
        :type LoadBalancerIds: list of str
        :param _ForceDelete: 是否强制删除clb。true表示强制删除，false表示不是强制删除，需要做拦截校验。
默认为false。
以下几种情况会默认拦截删除操作，如果触发情况1、2但确认强制删除则需要传强制校验参数ForceDelete为true。
1、删除后端绑定大于等于 20 个 RS 的实例时。
2、删除后端有 RS 且 5 分钟 内“出/入带宽”峰值取大 > 10Mbps 的实例时。
3、单地域内 5 分钟 内删除大于等于 30 个实例时。
        :type ForceDelete: bool
        """
        self._LoadBalancerIds = None
        self._ForceDelete = None

    @property
    def LoadBalancerIds(self):
        r"""要删除的负载均衡实例 ID 数组，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口获取，数组大小最大支持20。
        :rtype: list of str
        """
        return self._LoadBalancerIds

    @LoadBalancerIds.setter
    def LoadBalancerIds(self, LoadBalancerIds):
        self._LoadBalancerIds = LoadBalancerIds

    @property
    def ForceDelete(self):
        r"""是否强制删除clb。true表示强制删除，false表示不是强制删除，需要做拦截校验。
默认为false。
以下几种情况会默认拦截删除操作，如果触发情况1、2但确认强制删除则需要传强制校验参数ForceDelete为true。
1、删除后端绑定大于等于 20 个 RS 的实例时。
2、删除后端有 RS 且 5 分钟 内“出/入带宽”峰值取大 > 10Mbps 的实例时。
3、单地域内 5 分钟 内删除大于等于 30 个实例时。
        :rtype: bool
        """
        return self._ForceDelete

    @ForceDelete.setter
    def ForceDelete(self, ForceDelete):
        self._ForceDelete = ForceDelete


    def _deserialize(self, params):
        self._LoadBalancerIds = params.get("LoadBalancerIds")
        self._ForceDelete = params.get("ForceDelete")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DeleteLoadBalancerResponse(AbstractModel):
    r"""DeleteLoadBalancer返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DeleteLoadBalancerSnatIpsRequest(AbstractModel):
    r"""DeleteLoadBalancerSnatIps请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡唯一ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。例如：lb-12345678。
        :type LoadBalancerId: str
        :param _Ips: 删除SnatIp地址数组，最大支持删除数量为20个。
        :type Ips: list of str
        """
        self._LoadBalancerId = None
        self._Ips = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡唯一ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。例如：lb-12345678。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def Ips(self):
        r"""删除SnatIp地址数组，最大支持删除数量为20个。
        :rtype: list of str
        """
        return self._Ips

    @Ips.setter
    def Ips(self, Ips):
        self._Ips = Ips


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._Ips = params.get("Ips")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DeleteLoadBalancerSnatIpsResponse(AbstractModel):
    r"""DeleteLoadBalancerSnatIps返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DeleteModelRequest(AbstractModel):
    r"""DeleteModel请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ServiceProviderIds: <p>服务提供商ID列表</p>
        :type ServiceProviderIds: list of str
        """
        self._ServiceProviderIds = None

    @property
    def ServiceProviderIds(self):
        r"""<p>服务提供商ID列表</p>
        :rtype: list of str
        """
        return self._ServiceProviderIds

    @ServiceProviderIds.setter
    def ServiceProviderIds(self, ServiceProviderIds):
        self._ServiceProviderIds = ServiceProviderIds


    def _deserialize(self, params):
        self._ServiceProviderIds = params.get("ServiceProviderIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DeleteModelResponse(AbstractModel):
    r"""DeleteModel返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DeleteModelRoutersRequest(AbstractModel):
    r"""DeleteModelRouters请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterIds: <p>模型路由实例ID列表</p>
        :type ModelRouterIds: list of str
        """
        self._ModelRouterIds = None

    @property
    def ModelRouterIds(self):
        r"""<p>模型路由实例ID列表</p>
        :rtype: list of str
        """
        return self._ModelRouterIds

    @ModelRouterIds.setter
    def ModelRouterIds(self, ModelRouterIds):
        self._ModelRouterIds = ModelRouterIds


    def _deserialize(self, params):
        self._ModelRouterIds = params.get("ModelRouterIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DeleteModelRoutersResponse(AbstractModel):
    r"""DeleteModelRouters返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DeleteRewriteRequest(AbstractModel):
    r"""DeleteRewrite请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例ID。
        :type LoadBalancerId: str
        :param _SourceListenerId: 源监听器ID。
        :type SourceListenerId: str
        :param _TargetListenerId: 目标监听器ID。
        :type TargetListenerId: str
        :param _RewriteInfos: 转发规则之间的重定向关系。
        :type RewriteInfos: list of RewriteLocationMap
        """
        self._LoadBalancerId = None
        self._SourceListenerId = None
        self._TargetListenerId = None
        self._RewriteInfos = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def SourceListenerId(self):
        r"""源监听器ID。
        :rtype: str
        """
        return self._SourceListenerId

    @SourceListenerId.setter
    def SourceListenerId(self, SourceListenerId):
        self._SourceListenerId = SourceListenerId

    @property
    def TargetListenerId(self):
        r"""目标监听器ID。
        :rtype: str
        """
        return self._TargetListenerId

    @TargetListenerId.setter
    def TargetListenerId(self, TargetListenerId):
        self._TargetListenerId = TargetListenerId

    @property
    def RewriteInfos(self):
        r"""转发规则之间的重定向关系。
        :rtype: list of RewriteLocationMap
        """
        return self._RewriteInfos

    @RewriteInfos.setter
    def RewriteInfos(self, RewriteInfos):
        self._RewriteInfos = RewriteInfos


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._SourceListenerId = params.get("SourceListenerId")
        self._TargetListenerId = params.get("TargetListenerId")
        if params.get("RewriteInfos") is not None:
            self._RewriteInfos = []
            for item in params.get("RewriteInfos"):
                obj = RewriteLocationMap()
                obj._deserialize(item)
                self._RewriteInfos.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DeleteRewriteResponse(AbstractModel):
    r"""DeleteRewrite返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DeleteRuleRequest(AbstractModel):
    r"""DeleteRule请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口查询。
        :type LoadBalancerId: str
        :param _ListenerId: 负载均衡监听器ID，可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口查询。
        :type ListenerId: str
        :param _LocationIds: 要删除的转发规则的ID组成的数组，可以通过 [DescribeLoadBalancersDetail](https://cloud.tencent.com/document/api/214/46916) 接口查询。
        :type LocationIds: list of str
        :param _Domain: 要删除的转发规则的域名，如果是多域名，可以指定多域名列表中的任意一个，可以通过 [DescribeLoadBalancersDetail](https://cloud.tencent.com/document/api/214/46916) 接口查询。
        :type Domain: str
        :param _Url: 要删除的转发规则的转发路径，可以通过 [DescribeLoadBalancersDetail](https://cloud.tencent.com/document/api/214/46916) 接口查询。
        :type Url: str
        :param _NewDefaultServerDomain: 监听器下必须配置一个默认域名，当需要删除默认域名时，可以指定另一个域名作为新的默认域名，如果新的默认域名是多域名，可以指定多域名列表中的任意一个，可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口查询。
        :type NewDefaultServerDomain: str
        """
        self._LoadBalancerId = None
        self._ListenerId = None
        self._LocationIds = None
        self._Domain = None
        self._Url = None
        self._NewDefaultServerDomain = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口查询。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerId(self):
        r"""负载均衡监听器ID，可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口查询。
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def LocationIds(self):
        r"""要删除的转发规则的ID组成的数组，可以通过 [DescribeLoadBalancersDetail](https://cloud.tencent.com/document/api/214/46916) 接口查询。
        :rtype: list of str
        """
        return self._LocationIds

    @LocationIds.setter
    def LocationIds(self, LocationIds):
        self._LocationIds = LocationIds

    @property
    def Domain(self):
        r"""要删除的转发规则的域名，如果是多域名，可以指定多域名列表中的任意一个，可以通过 [DescribeLoadBalancersDetail](https://cloud.tencent.com/document/api/214/46916) 接口查询。
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def Url(self):
        r"""要删除的转发规则的转发路径，可以通过 [DescribeLoadBalancersDetail](https://cloud.tencent.com/document/api/214/46916) 接口查询。
        :rtype: str
        """
        return self._Url

    @Url.setter
    def Url(self, Url):
        self._Url = Url

    @property
    def NewDefaultServerDomain(self):
        r"""监听器下必须配置一个默认域名，当需要删除默认域名时，可以指定另一个域名作为新的默认域名，如果新的默认域名是多域名，可以指定多域名列表中的任意一个，可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口查询。
        :rtype: str
        """
        return self._NewDefaultServerDomain

    @NewDefaultServerDomain.setter
    def NewDefaultServerDomain(self, NewDefaultServerDomain):
        self._NewDefaultServerDomain = NewDefaultServerDomain


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerId = params.get("ListenerId")
        self._LocationIds = params.get("LocationIds")
        self._Domain = params.get("Domain")
        self._Url = params.get("Url")
        self._NewDefaultServerDomain = params.get("NewDefaultServerDomain")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DeleteRuleResponse(AbstractModel):
    r"""DeleteRule返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DeleteTargetGroupsRequest(AbstractModel):
    r"""DeleteTargetGroups请求参数结构体

    """

    def __init__(self):
        r"""
        :param _TargetGroupIds: 目标组的ID数组，单次最多支持删除20个。
        :type TargetGroupIds: list of str
        """
        self._TargetGroupIds = None

    @property
    def TargetGroupIds(self):
        r"""目标组的ID数组，单次最多支持删除20个。
        :rtype: list of str
        """
        return self._TargetGroupIds

    @TargetGroupIds.setter
    def TargetGroupIds(self, TargetGroupIds):
        self._TargetGroupIds = TargetGroupIds


    def _deserialize(self, params):
        self._TargetGroupIds = params.get("TargetGroupIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DeleteTargetGroupsResponse(AbstractModel):
    r"""DeleteTargetGroups返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DeleteUserGroupsRequest(AbstractModel):
    r"""DeleteUserGroups请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID。</p>
        :type ModelRouterId: str
        :param _UserGroupIds: <p>待删除的用户组ID列表，单次1-100个。不可包含「未分组」虚拟分组 ugrp-ungrouped。组内仍有 Key 时将拒绝删除，需先将 Key 移出或迁移到其他组。</p>
        :type UserGroupIds: list of str
        """
        self._ModelRouterId = None
        self._UserGroupIds = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID。</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def UserGroupIds(self):
        r"""<p>待删除的用户组ID列表，单次1-100个。不可包含「未分组」虚拟分组 ugrp-ungrouped。组内仍有 Key 时将拒绝删除，需先将 Key 移出或迁移到其他组。</p>
        :rtype: list of str
        """
        return self._UserGroupIds

    @UserGroupIds.setter
    def UserGroupIds(self, UserGroupIds):
        self._UserGroupIds = UserGroupIds


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._UserGroupIds = params.get("UserGroupIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DeleteUserGroupsResponse(AbstractModel):
    r"""DeleteUserGroups返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DeregisterFunctionTargetsRequest(AbstractModel):
    r"""DeregisterFunctionTargets请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例 ID。
        :type LoadBalancerId: str
        :param _ListenerId: 负载均衡监听器 ID。
        :type ListenerId: str
        :param _FunctionTargets: 待解绑的云函数列表。
        :type FunctionTargets: list of FunctionTarget
        :param _LocationId: 目标转发规则的 ID，当将云函数从七层转发规则上解绑时，必须输入此参数或 Domain+Url 参数。
        :type LocationId: str
        :param _Domain: 目标转发规则的域名，若已经输入 LocationId 参数，则本参数不生效。
        :type Domain: str
        :param _Url: 目标转发规则的 URL，若已经输入 LocationId 参数，则本参数不生效。
        :type Url: str
        """
        self._LoadBalancerId = None
        self._ListenerId = None
        self._FunctionTargets = None
        self._LocationId = None
        self._Domain = None
        self._Url = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例 ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerId(self):
        r"""负载均衡监听器 ID。
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def FunctionTargets(self):
        r"""待解绑的云函数列表。
        :rtype: list of FunctionTarget
        """
        return self._FunctionTargets

    @FunctionTargets.setter
    def FunctionTargets(self, FunctionTargets):
        self._FunctionTargets = FunctionTargets

    @property
    def LocationId(self):
        r"""目标转发规则的 ID，当将云函数从七层转发规则上解绑时，必须输入此参数或 Domain+Url 参数。
        :rtype: str
        """
        return self._LocationId

    @LocationId.setter
    def LocationId(self, LocationId):
        self._LocationId = LocationId

    @property
    def Domain(self):
        r"""目标转发规则的域名，若已经输入 LocationId 参数，则本参数不生效。
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def Url(self):
        r"""目标转发规则的 URL，若已经输入 LocationId 参数，则本参数不生效。
        :rtype: str
        """
        return self._Url

    @Url.setter
    def Url(self, Url):
        self._Url = Url


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerId = params.get("ListenerId")
        if params.get("FunctionTargets") is not None:
            self._FunctionTargets = []
            for item in params.get("FunctionTargets"):
                obj = FunctionTarget()
                obj._deserialize(item)
                self._FunctionTargets.append(obj)
        self._LocationId = params.get("LocationId")
        self._Domain = params.get("Domain")
        self._Url = params.get("Url")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DeregisterFunctionTargetsResponse(AbstractModel):
    r"""DeregisterFunctionTargets返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DeregisterModelsFromServiceProviderRequest(AbstractModel):
    r"""DeregisterModelsFromServiceProvider请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ServiceProviderId: <p>BYOK的ID</p>
        :type ServiceProviderId: str
        :param _ModelAliases: <p>模型别名列表</p>
        :type ModelAliases: list of str
        """
        self._ServiceProviderId = None
        self._ModelAliases = None

    @property
    def ServiceProviderId(self):
        r"""<p>BYOK的ID</p>
        :rtype: str
        """
        return self._ServiceProviderId

    @ServiceProviderId.setter
    def ServiceProviderId(self, ServiceProviderId):
        self._ServiceProviderId = ServiceProviderId

    @property
    def ModelAliases(self):
        r"""<p>模型别名列表</p>
        :rtype: list of str
        """
        return self._ModelAliases

    @ModelAliases.setter
    def ModelAliases(self, ModelAliases):
        self._ModelAliases = ModelAliases


    def _deserialize(self, params):
        self._ServiceProviderId = params.get("ServiceProviderId")
        self._ModelAliases = params.get("ModelAliases")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DeregisterModelsFromServiceProviderResponse(AbstractModel):
    r"""DeregisterModelsFromServiceProvider返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DeregisterTargetGroupInstancesRequest(AbstractModel):
    r"""DeregisterTargetGroupInstances请求参数结构体

    """

    def __init__(self):
        r"""
        :param _TargetGroupId: 目标组ID。
        :type TargetGroupId: str
        :param _TargetGroupInstances: 待解绑的服务器信息，支持批量解除绑定，单次批量解除数量最多为20个。
在这个接口 Port 参数为必填项。
        :type TargetGroupInstances: list of TargetGroupInstance
        """
        self._TargetGroupId = None
        self._TargetGroupInstances = None

    @property
    def TargetGroupId(self):
        r"""目标组ID。
        :rtype: str
        """
        return self._TargetGroupId

    @TargetGroupId.setter
    def TargetGroupId(self, TargetGroupId):
        self._TargetGroupId = TargetGroupId

    @property
    def TargetGroupInstances(self):
        r"""待解绑的服务器信息，支持批量解除绑定，单次批量解除数量最多为20个。
在这个接口 Port 参数为必填项。
        :rtype: list of TargetGroupInstance
        """
        return self._TargetGroupInstances

    @TargetGroupInstances.setter
    def TargetGroupInstances(self, TargetGroupInstances):
        self._TargetGroupInstances = TargetGroupInstances


    def _deserialize(self, params):
        self._TargetGroupId = params.get("TargetGroupId")
        if params.get("TargetGroupInstances") is not None:
            self._TargetGroupInstances = []
            for item in params.get("TargetGroupInstances"):
                obj = TargetGroupInstance()
                obj._deserialize(item)
                self._TargetGroupInstances.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DeregisterTargetGroupInstancesResponse(AbstractModel):
    r"""DeregisterTargetGroupInstances返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DeregisterTargetsFromClassicalLBRequest(AbstractModel):
    r"""DeregisterTargetsFromClassicalLB请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例ID。
        :type LoadBalancerId: str
        :param _InstanceIds: 后端服务的实例ID列表。
        :type InstanceIds: list of str
        """
        self._LoadBalancerId = None
        self._InstanceIds = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def InstanceIds(self):
        r"""后端服务的实例ID列表。
        :rtype: list of str
        """
        return self._InstanceIds

    @InstanceIds.setter
    def InstanceIds(self, InstanceIds):
        self._InstanceIds = InstanceIds


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._InstanceIds = params.get("InstanceIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DeregisterTargetsFromClassicalLBResponse(AbstractModel):
    r"""DeregisterTargetsFromClassicalLB返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DeregisterTargetsRequest(AbstractModel):
    r"""DeregisterTargets请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例 ID，格式如 lb-12345678。
        :type LoadBalancerId: str
        :param _ListenerId: 监听器 ID，格式如 lbl-12345678。
        :type ListenerId: str
        :param _Targets: 要解绑的后端服务列表，数组长度最大支持20。
        :type Targets: list of Target
        :param _LocationId: 转发规则的ID，格式如 loc-12345678，当从七层转发规则解绑机器时，必须提供此参数或Domain+URL两者之一。
        :type LocationId: str
        :param _Domain: 目标规则的域名，提供LocationId参数时本参数不生效。
        :type Domain: str
        :param _Url: 目标规则的URL，提供LocationId参数时本参数不生效。
        :type Url: str
        """
        self._LoadBalancerId = None
        self._ListenerId = None
        self._Targets = None
        self._LocationId = None
        self._Domain = None
        self._Url = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例 ID，格式如 lb-12345678。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerId(self):
        r"""监听器 ID，格式如 lbl-12345678。
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def Targets(self):
        r"""要解绑的后端服务列表，数组长度最大支持20。
        :rtype: list of Target
        """
        return self._Targets

    @Targets.setter
    def Targets(self, Targets):
        self._Targets = Targets

    @property
    def LocationId(self):
        r"""转发规则的ID，格式如 loc-12345678，当从七层转发规则解绑机器时，必须提供此参数或Domain+URL两者之一。
        :rtype: str
        """
        return self._LocationId

    @LocationId.setter
    def LocationId(self, LocationId):
        self._LocationId = LocationId

    @property
    def Domain(self):
        r"""目标规则的域名，提供LocationId参数时本参数不生效。
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def Url(self):
        r"""目标规则的URL，提供LocationId参数时本参数不生效。
        :rtype: str
        """
        return self._Url

    @Url.setter
    def Url(self, Url):
        self._Url = Url


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerId = params.get("ListenerId")
        if params.get("Targets") is not None:
            self._Targets = []
            for item in params.get("Targets"):
                obj = Target()
                obj._deserialize(item)
                self._Targets.append(obj)
        self._LocationId = params.get("LocationId")
        self._Domain = params.get("Domain")
        self._Url = params.get("Url")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DeregisterTargetsResponse(AbstractModel):
    r"""DeregisterTargets返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DescribeAssociatedModelAvailabilityRequest(AbstractModel):
    r"""DescribeAssociatedModelAvailability请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由ID</p>
        :type ModelRouterId: str
        :param _Models: <p>模型列表</p>
        :type Models: list of str
        """
        self._ModelRouterId = None
        self._Models = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def Models(self):
        r"""<p>模型列表</p>
        :rtype: list of str
        """
        return self._Models

    @Models.setter
    def Models(self, Models):
        self._Models = Models


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._Models = params.get("Models")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeAssociatedModelAvailabilityResponse(AbstractModel):
    r"""DescribeAssociatedModelAvailability返回参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelAvailability: <p>模型可用性列表</p>
        :type ModelAvailability: list of ModelAvailability
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._ModelAvailability = None
        self._RequestId = None

    @property
    def ModelAvailability(self):
        r"""<p>模型可用性列表</p>
        :rtype: list of ModelAvailability
        """
        return self._ModelAvailability

    @ModelAvailability.setter
    def ModelAvailability(self, ModelAvailability):
        self._ModelAvailability = ModelAvailability

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("ModelAvailability") is not None:
            self._ModelAvailability = []
            for item in params.get("ModelAvailability"):
                obj = ModelAvailability()
                obj._deserialize(item)
                self._ModelAvailability.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeAsyncJobsRequest(AbstractModel):
    r"""DescribeAsyncJobs请求参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestIds: <p>请求ID列表</p>
        :type RequestIds: list of str
        :param _NextToken: <p>分页游标</p>
        :type NextToken: str
        :param _MaxResults: <p>本次查询最大数量</p><p>取值范围：[1, 100]</p><p>默认值：20</p>
        :type MaxResults: int
        """
        self._RequestIds = None
        self._NextToken = None
        self._MaxResults = None

    @property
    def RequestIds(self):
        r"""<p>请求ID列表</p>
        :rtype: list of str
        """
        return self._RequestIds

    @RequestIds.setter
    def RequestIds(self, RequestIds):
        self._RequestIds = RequestIds

    @property
    def NextToken(self):
        r"""<p>分页游标</p>
        :rtype: str
        """
        return self._NextToken

    @NextToken.setter
    def NextToken(self, NextToken):
        self._NextToken = NextToken

    @property
    def MaxResults(self):
        r"""<p>本次查询最大数量</p><p>取值范围：[1, 100]</p><p>默认值：20</p>
        :rtype: int
        """
        return self._MaxResults

    @MaxResults.setter
    def MaxResults(self, MaxResults):
        self._MaxResults = MaxResults


    def _deserialize(self, params):
        self._RequestIds = params.get("RequestIds")
        self._NextToken = params.get("NextToken")
        self._MaxResults = params.get("MaxResults")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeAsyncJobsResponse(AbstractModel):
    r"""DescribeAsyncJobs返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Jobs: <p>异步任务列表</p>
        :type Jobs: list of Job
        :param _NextToken: <p>分页游标</p>
        :type NextToken: str
        :param _MaxResults: <p>本次查询最大数量</p>
        :type MaxResults: int
        :param _TotalCount: <p>本次查询总数</p>
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Jobs = None
        self._NextToken = None
        self._MaxResults = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def Jobs(self):
        r"""<p>异步任务列表</p>
        :rtype: list of Job
        """
        return self._Jobs

    @Jobs.setter
    def Jobs(self, Jobs):
        self._Jobs = Jobs

    @property
    def NextToken(self):
        r"""<p>分页游标</p>
        :rtype: str
        """
        return self._NextToken

    @NextToken.setter
    def NextToken(self, NextToken):
        self._NextToken = NextToken

    @property
    def MaxResults(self):
        r"""<p>本次查询最大数量</p>
        :rtype: int
        """
        return self._MaxResults

    @MaxResults.setter
    def MaxResults(self, MaxResults):
        self._MaxResults = MaxResults

    @property
    def TotalCount(self):
        r"""<p>本次查询总数</p>
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("Jobs") is not None:
            self._Jobs = []
            for item in params.get("Jobs"):
                obj = Job()
                obj._deserialize(item)
                self._Jobs.append(obj)
        self._NextToken = params.get("NextToken")
        self._MaxResults = params.get("MaxResults")
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeBlockIPListRequest(AbstractModel):
    r"""DescribeBlockIPList请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例 ID。
        :type LoadBalancerId: str
        :param _Offset: 数据偏移量，默认为 0。
        :type Offset: int
        :param _Limit: 返回IP的最大个数，默认为 100000。
        :type Limit: int
        """
        self._LoadBalancerId = None
        self._Offset = None
        self._Limit = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例 ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def Offset(self):
        r"""数据偏移量，默认为 0。
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset

    @property
    def Limit(self):
        r"""返回IP的最大个数，默认为 100000。
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._Offset = params.get("Offset")
        self._Limit = params.get("Limit")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeBlockIPListResponse(AbstractModel):
    r"""DescribeBlockIPList返回参数结构体

    """

    def __init__(self):
        r"""
        :param _BlockedIPCount: 返回的IP的数量
        :type BlockedIPCount: int
        :param _ClientIPField: 获取用户真实IP的字段
        :type ClientIPField: str
        :param _BlockedIPList: 加入了12360黑名单的IP列表
        :type BlockedIPList: list of BlockedIP
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._BlockedIPCount = None
        self._ClientIPField = None
        self._BlockedIPList = None
        self._RequestId = None

    @property
    def BlockedIPCount(self):
        r"""返回的IP的数量
        :rtype: int
        """
        return self._BlockedIPCount

    @BlockedIPCount.setter
    def BlockedIPCount(self, BlockedIPCount):
        self._BlockedIPCount = BlockedIPCount

    @property
    def ClientIPField(self):
        r"""获取用户真实IP的字段
        :rtype: str
        """
        return self._ClientIPField

    @ClientIPField.setter
    def ClientIPField(self, ClientIPField):
        self._ClientIPField = ClientIPField

    @property
    def BlockedIPList(self):
        r"""加入了12360黑名单的IP列表
        :rtype: list of BlockedIP
        """
        return self._BlockedIPList

    @BlockedIPList.setter
    def BlockedIPList(self, BlockedIPList):
        self._BlockedIPList = BlockedIPList

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._BlockedIPCount = params.get("BlockedIPCount")
        self._ClientIPField = params.get("ClientIPField")
        if params.get("BlockedIPList") is not None:
            self._BlockedIPList = []
            for item in params.get("BlockedIPList"):
                obj = BlockedIP()
                obj._deserialize(item)
                self._BlockedIPList.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeBlockIPTaskRequest(AbstractModel):
    r"""DescribeBlockIPTask请求参数结构体

    """

    def __init__(self):
        r"""
        :param _TaskId: ModifyBlockIPList 接口返回的异步任务的ID。
        :type TaskId: str
        """
        self._TaskId = None

    @property
    def TaskId(self):
        r"""ModifyBlockIPList 接口返回的异步任务的ID。
        :rtype: str
        """
        return self._TaskId

    @TaskId.setter
    def TaskId(self, TaskId):
        self._TaskId = TaskId


    def _deserialize(self, params):
        self._TaskId = params.get("TaskId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeBlockIPTaskResponse(AbstractModel):
    r"""DescribeBlockIPTask返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Status: 1 running，2 fail，6 succ
        :type Status: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Status = None
        self._RequestId = None

    @property
    def Status(self):
        r"""1 running，2 fail，6 succ
        :rtype: int
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._Status = params.get("Status")
        self._RequestId = params.get("RequestId")


class DescribeBudgetAssociationsRequest(AbstractModel):
    r"""DescribeBudgetAssociations请求参数结构体

    """

    def __init__(self):
        r"""
        :param _BudgetId: <p>Budget ID。</p><p>一次只允许查询一个Budget。</p>
        :type BudgetId: str
        :param _Limit: <p>本次查询限制的数量</p>
        :type Limit: int
        :param _Offset: <p>本次查询偏移量</p>
        :type Offset: int
        :param _Type: <p>资源类型。</p><p>枚举值：</p><ul><li>ModelRouter：模型路由实例</li><li>Key：模型路由Key</li></ul><p>不传时返回全部资源类型。</p>
        :type Type: str
        """
        self._BudgetId = None
        self._Limit = None
        self._Offset = None
        self._Type = None

    @property
    def BudgetId(self):
        r"""<p>Budget ID。</p><p>一次只允许查询一个Budget。</p>
        :rtype: str
        """
        return self._BudgetId

    @BudgetId.setter
    def BudgetId(self, BudgetId):
        self._BudgetId = BudgetId

    @property
    def Limit(self):
        r"""<p>本次查询限制的数量</p>
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def Offset(self):
        r"""<p>本次查询偏移量</p>
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset

    @property
    def Type(self):
        r"""<p>资源类型。</p><p>枚举值：</p><ul><li>ModelRouter：模型路由实例</li><li>Key：模型路由Key</li></ul><p>不传时返回全部资源类型。</p>
        :rtype: str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type


    def _deserialize(self, params):
        self._BudgetId = params.get("BudgetId")
        self._Limit = params.get("Limit")
        self._Offset = params.get("Offset")
        self._Type = params.get("Type")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeBudgetAssociationsResponse(AbstractModel):
    r"""DescribeBudgetAssociations返回参数结构体

    """

    def __init__(self):
        r"""
        :param _AssociationSet: <p>Budget关联资源列表。</p>
        :type AssociationSet: list of BudgetAssociation
        :param _TotalCount: <p>符合条件的总数。</p>
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._AssociationSet = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def AssociationSet(self):
        r"""<p>Budget关联资源列表。</p>
        :rtype: list of BudgetAssociation
        """
        return self._AssociationSet

    @AssociationSet.setter
    def AssociationSet(self, AssociationSet):
        self._AssociationSet = AssociationSet

    @property
    def TotalCount(self):
        r"""<p>符合条件的总数。</p>
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("AssociationSet") is not None:
            self._AssociationSet = []
            for item in params.get("AssociationSet"):
                obj = BudgetAssociation()
                obj._deserialize(item)
                self._AssociationSet.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeBudgetsRequest(AbstractModel):
    r"""DescribeBudgets请求参数结构体

    """

    def __init__(self):
        r"""
        :param _BudgetIds: <p>Budget ID列表。</p>
        :type BudgetIds: list of str
        :param _Filters: <p>过滤列表。</p><p>支持：BudgetId、BudgetName、Status。</p>
        :type Filters: list of Filter
        :param _Limit: <p>本次查询限制的数量。</p><p>取值范围：[1, 100]</p><p>默认值：20。</p>
        :type Limit: int
        :param _Offset: <p>本次查询偏移量。</p><p>默认值：0。</p>
        :type Offset: int
        """
        self._BudgetIds = None
        self._Filters = None
        self._Limit = None
        self._Offset = None

    @property
    def BudgetIds(self):
        r"""<p>Budget ID列表。</p>
        :rtype: list of str
        """
        return self._BudgetIds

    @BudgetIds.setter
    def BudgetIds(self, BudgetIds):
        self._BudgetIds = BudgetIds

    @property
    def Filters(self):
        r"""<p>过滤列表。</p><p>支持：BudgetId、BudgetName、Status。</p>
        :rtype: list of Filter
        """
        return self._Filters

    @Filters.setter
    def Filters(self, Filters):
        self._Filters = Filters

    @property
    def Limit(self):
        r"""<p>本次查询限制的数量。</p><p>取值范围：[1, 100]</p><p>默认值：20。</p>
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def Offset(self):
        r"""<p>本次查询偏移量。</p><p>默认值：0。</p>
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset


    def _deserialize(self, params):
        self._BudgetIds = params.get("BudgetIds")
        if params.get("Filters") is not None:
            self._Filters = []
            for item in params.get("Filters"):
                obj = Filter()
                obj._deserialize(item)
                self._Filters.append(obj)
        self._Limit = params.get("Limit")
        self._Offset = params.get("Offset")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeBudgetsResponse(AbstractModel):
    r"""DescribeBudgets返回参数结构体

    """

    def __init__(self):
        r"""
        :param _BudgetSet: <p>Budget列表。</p>
        :type BudgetSet: list of BudgetInfo
        :param _TotalCount: <p>符合条件的总数。</p>
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._BudgetSet = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def BudgetSet(self):
        r"""<p>Budget列表。</p>
        :rtype: list of BudgetInfo
        """
        return self._BudgetSet

    @BudgetSet.setter
    def BudgetSet(self, BudgetSet):
        self._BudgetSet = BudgetSet

    @property
    def TotalCount(self):
        r"""<p>符合条件的总数。</p>
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("BudgetSet") is not None:
            self._BudgetSet = []
            for item in params.get("BudgetSet"):
                obj = BudgetInfo()
                obj._deserialize(item)
                self._BudgetSet.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeClassicalLBByInstanceIdRequest(AbstractModel):
    r"""DescribeClassicalLBByInstanceId请求参数结构体

    """

    def __init__(self):
        r"""
        :param _InstanceIds: 后端实例ID列表。
        :type InstanceIds: list of str
        """
        self._InstanceIds = None

    @property
    def InstanceIds(self):
        r"""后端实例ID列表。
        :rtype: list of str
        """
        return self._InstanceIds

    @InstanceIds.setter
    def InstanceIds(self, InstanceIds):
        self._InstanceIds = InstanceIds


    def _deserialize(self, params):
        self._InstanceIds = params.get("InstanceIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeClassicalLBByInstanceIdResponse(AbstractModel):
    r"""DescribeClassicalLBByInstanceId返回参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerInfoList: 负载均衡相关信息列表。
        :type LoadBalancerInfoList: list of ClassicalLoadBalancerInfo
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._LoadBalancerInfoList = None
        self._RequestId = None

    @property
    def LoadBalancerInfoList(self):
        r"""负载均衡相关信息列表。
        :rtype: list of ClassicalLoadBalancerInfo
        """
        return self._LoadBalancerInfoList

    @LoadBalancerInfoList.setter
    def LoadBalancerInfoList(self, LoadBalancerInfoList):
        self._LoadBalancerInfoList = LoadBalancerInfoList

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("LoadBalancerInfoList") is not None:
            self._LoadBalancerInfoList = []
            for item in params.get("LoadBalancerInfoList"):
                obj = ClassicalLoadBalancerInfo()
                obj._deserialize(item)
                self._LoadBalancerInfoList.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeClassicalLBHealthStatusRequest(AbstractModel):
    r"""DescribeClassicalLBHealthStatus请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例ID。
        :type LoadBalancerId: str
        :param _ListenerId: 负载均衡监听器ID。
        :type ListenerId: str
        """
        self._LoadBalancerId = None
        self._ListenerId = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerId(self):
        r"""负载均衡监听器ID。
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerId = params.get("ListenerId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeClassicalLBHealthStatusResponse(AbstractModel):
    r"""DescribeClassicalLBHealthStatus返回参数结构体

    """

    def __init__(self):
        r"""
        :param _HealthList: 后端健康状态列表。
        :type HealthList: list of ClassicalHealth
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._HealthList = None
        self._RequestId = None

    @property
    def HealthList(self):
        r"""后端健康状态列表。
        :rtype: list of ClassicalHealth
        """
        return self._HealthList

    @HealthList.setter
    def HealthList(self, HealthList):
        self._HealthList = HealthList

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("HealthList") is not None:
            self._HealthList = []
            for item in params.get("HealthList"):
                obj = ClassicalHealth()
                obj._deserialize(item)
                self._HealthList.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeClassicalLBListenersRequest(AbstractModel):
    r"""DescribeClassicalLBListeners请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例ID。
        :type LoadBalancerId: str
        :param _ListenerIds: 负载均衡监听器ID列表。
        :type ListenerIds: list of str
        :param _Protocol: 负载均衡监听的协议：'TCP', 'UDP', 'HTTP', 'HTTPS'。
        :type Protocol: str
        :param _ListenerPort: 负载均衡监听端口，范围为[1-65535]。
        :type ListenerPort: int
        :param _Status: 监听器的状态，0：创建中，1：运行中。
        :type Status: int
        """
        self._LoadBalancerId = None
        self._ListenerIds = None
        self._Protocol = None
        self._ListenerPort = None
        self._Status = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerIds(self):
        r"""负载均衡监听器ID列表。
        :rtype: list of str
        """
        return self._ListenerIds

    @ListenerIds.setter
    def ListenerIds(self, ListenerIds):
        self._ListenerIds = ListenerIds

    @property
    def Protocol(self):
        r"""负载均衡监听的协议：'TCP', 'UDP', 'HTTP', 'HTTPS'。
        :rtype: str
        """
        return self._Protocol

    @Protocol.setter
    def Protocol(self, Protocol):
        self._Protocol = Protocol

    @property
    def ListenerPort(self):
        r"""负载均衡监听端口，范围为[1-65535]。
        :rtype: int
        """
        return self._ListenerPort

    @ListenerPort.setter
    def ListenerPort(self, ListenerPort):
        self._ListenerPort = ListenerPort

    @property
    def Status(self):
        r"""监听器的状态，0：创建中，1：运行中。
        :rtype: int
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerIds = params.get("ListenerIds")
        self._Protocol = params.get("Protocol")
        self._ListenerPort = params.get("ListenerPort")
        self._Status = params.get("Status")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeClassicalLBListenersResponse(AbstractModel):
    r"""DescribeClassicalLBListeners返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Listeners: 监听器列表。
        :type Listeners: list of ClassicalListener
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Listeners = None
        self._RequestId = None

    @property
    def Listeners(self):
        r"""监听器列表。
        :rtype: list of ClassicalListener
        """
        return self._Listeners

    @Listeners.setter
    def Listeners(self, Listeners):
        self._Listeners = Listeners

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("Listeners") is not None:
            self._Listeners = []
            for item in params.get("Listeners"):
                obj = ClassicalListener()
                obj._deserialize(item)
                self._Listeners.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeClassicalLBTargetsRequest(AbstractModel):
    r"""DescribeClassicalLBTargets请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例 ID。
        :type LoadBalancerId: str
        """
        self._LoadBalancerId = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例 ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeClassicalLBTargetsResponse(AbstractModel):
    r"""DescribeClassicalLBTargets返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Targets: 后端服务列表。
        :type Targets: list of ClassicalTarget
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Targets = None
        self._RequestId = None

    @property
    def Targets(self):
        r"""后端服务列表。
        :rtype: list of ClassicalTarget
        """
        return self._Targets

    @Targets.setter
    def Targets(self, Targets):
        self._Targets = Targets

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("Targets") is not None:
            self._Targets = []
            for item in params.get("Targets"):
                obj = ClassicalTarget()
                obj._deserialize(item)
                self._Targets.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeClsLogSetRequest(AbstractModel):
    r"""DescribeClsLogSet请求参数结构体

    """


class DescribeClsLogSetResponse(AbstractModel):
    r"""DescribeClsLogSet返回参数结构体

    """

    def __init__(self):
        r"""
        :param _LogsetId: 日志集的 ID。
        :type LogsetId: str
        :param _HealthLogsetId: 健康检查日志集的 ID。
        :type HealthLogsetId: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._LogsetId = None
        self._HealthLogsetId = None
        self._RequestId = None

    @property
    def LogsetId(self):
        r"""日志集的 ID。
        :rtype: str
        """
        return self._LogsetId

    @LogsetId.setter
    def LogsetId(self, LogsetId):
        self._LogsetId = LogsetId

    @property
    def HealthLogsetId(self):
        r"""健康检查日志集的 ID。
        :rtype: str
        """
        return self._HealthLogsetId

    @HealthLogsetId.setter
    def HealthLogsetId(self, HealthLogsetId):
        self._HealthLogsetId = HealthLogsetId

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._LogsetId = params.get("LogsetId")
        self._HealthLogsetId = params.get("HealthLogsetId")
        self._RequestId = params.get("RequestId")


class DescribeClusterResourcesRequest(AbstractModel):
    r"""DescribeClusterResources请求参数结构体

    """

    def __init__(self):
        r"""
        :param _Limit: 返回集群中资源列表数目，默认为20，最大值为100。
        :type Limit: int
        :param _Offset: 返回集群中资源列表起始偏移量，默认为0。
        :type Offset: int
        :param _Filters: 查询集群中资源列表条件，详细的过滤条件如下：
<li> cluster-id - String - 是否必填：否 - （过滤条件）按照 集群 的唯一ID过滤，如 ："tgw-12345678","stgw-12345678","vpcgw-12345678"。</li>
<li> vip - String - 是否必填：否 - （过滤条件）按照vip过滤。</li>
<li> loadbalancer-id - String - 是否必填：否 - （过滤条件）按照负载均衡唯一ID过滤。</li>
<li> idle - String 是否必填：否 - （过滤条件）按照是否闲置过滤，如"True","False"。</li>
        :type Filters: list of Filter
        """
        self._Limit = None
        self._Offset = None
        self._Filters = None

    @property
    def Limit(self):
        r"""返回集群中资源列表数目，默认为20，最大值为100。
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def Offset(self):
        r"""返回集群中资源列表起始偏移量，默认为0。
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset

    @property
    def Filters(self):
        r"""查询集群中资源列表条件，详细的过滤条件如下：
<li> cluster-id - String - 是否必填：否 - （过滤条件）按照 集群 的唯一ID过滤，如 ："tgw-12345678","stgw-12345678","vpcgw-12345678"。</li>
<li> vip - String - 是否必填：否 - （过滤条件）按照vip过滤。</li>
<li> loadbalancer-id - String - 是否必填：否 - （过滤条件）按照负载均衡唯一ID过滤。</li>
<li> idle - String 是否必填：否 - （过滤条件）按照是否闲置过滤，如"True","False"。</li>
        :rtype: list of Filter
        """
        return self._Filters

    @Filters.setter
    def Filters(self, Filters):
        self._Filters = Filters


    def _deserialize(self, params):
        self._Limit = params.get("Limit")
        self._Offset = params.get("Offset")
        if params.get("Filters") is not None:
            self._Filters = []
            for item in params.get("Filters"):
                obj = Filter()
                obj._deserialize(item)
                self._Filters.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeClusterResourcesResponse(AbstractModel):
    r"""DescribeClusterResources返回参数结构体

    """

    def __init__(self):
        r"""
        :param _ClusterResourceSet: 集群中资源列表。
        :type ClusterResourceSet: list of ClusterResource
        :param _TotalCount: 集群中资源总数。
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._ClusterResourceSet = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def ClusterResourceSet(self):
        r"""集群中资源列表。
        :rtype: list of ClusterResource
        """
        return self._ClusterResourceSet

    @ClusterResourceSet.setter
    def ClusterResourceSet(self, ClusterResourceSet):
        self._ClusterResourceSet = ClusterResourceSet

    @property
    def TotalCount(self):
        r"""集群中资源总数。
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("ClusterResourceSet") is not None:
            self._ClusterResourceSet = []
            for item in params.get("ClusterResourceSet"):
                obj = ClusterResource()
                obj._deserialize(item)
                self._ClusterResourceSet.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeCrossTargetsRequest(AbstractModel):
    r"""DescribeCrossTargets请求参数结构体

    """

    def __init__(self):
        r"""
        :param _Limit: 返回后端服务列表数目，默认20，最大值100。
        :type Limit: int
        :param _Offset: 返回后端服务列表起始偏移量，默认0。
        :type Offset: int
        :param _Filters: 查询跨域2.0版本云联网后端子机和网卡服务列表条件，详细的过滤条件如下：
<li> vpc-id - String - 是否必填：否 - （过滤条件）按照 本地私有网络ID，即负载均衡的VpcId 过滤，如："vpc-12345678"。</li>
<li> ip - String - 是否必填：否 - （过滤条件）按照 后端服务ip 过滤，如："192.168.0.1"。</li>
<li> listener-id - String - 是否必填：否 - （过滤条件）按照 监听器ID 过滤，如："lbl-12345678"。</li>
<li> location-id - String - 是否必填：否 - （过滤条件）按照 七层监听器规则ID 过滤，如："loc-12345678"。</li>
        :type Filters: list of Filter
        """
        self._Limit = None
        self._Offset = None
        self._Filters = None

    @property
    def Limit(self):
        r"""返回后端服务列表数目，默认20，最大值100。
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def Offset(self):
        r"""返回后端服务列表起始偏移量，默认0。
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset

    @property
    def Filters(self):
        r"""查询跨域2.0版本云联网后端子机和网卡服务列表条件，详细的过滤条件如下：
<li> vpc-id - String - 是否必填：否 - （过滤条件）按照 本地私有网络ID，即负载均衡的VpcId 过滤，如："vpc-12345678"。</li>
<li> ip - String - 是否必填：否 - （过滤条件）按照 后端服务ip 过滤，如："192.168.0.1"。</li>
<li> listener-id - String - 是否必填：否 - （过滤条件）按照 监听器ID 过滤，如："lbl-12345678"。</li>
<li> location-id - String - 是否必填：否 - （过滤条件）按照 七层监听器规则ID 过滤，如："loc-12345678"。</li>
        :rtype: list of Filter
        """
        return self._Filters

    @Filters.setter
    def Filters(self, Filters):
        self._Filters = Filters


    def _deserialize(self, params):
        self._Limit = params.get("Limit")
        self._Offset = params.get("Offset")
        if params.get("Filters") is not None:
            self._Filters = []
            for item in params.get("Filters"):
                obj = Filter()
                obj._deserialize(item)
                self._Filters.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeCrossTargetsResponse(AbstractModel):
    r"""DescribeCrossTargets返回参数结构体

    """

    def __init__(self):
        r"""
        :param _TotalCount: 后端服务列表总数。
        :type TotalCount: int
        :param _CrossTargetSet: 后端服务列表。
        :type CrossTargetSet: list of CrossTargets
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._TotalCount = None
        self._CrossTargetSet = None
        self._RequestId = None

    @property
    def TotalCount(self):
        r"""后端服务列表总数。
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def CrossTargetSet(self):
        r"""后端服务列表。
        :rtype: list of CrossTargets
        """
        return self._CrossTargetSet

    @CrossTargetSet.setter
    def CrossTargetSet(self, CrossTargetSet):
        self._CrossTargetSet = CrossTargetSet

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._TotalCount = params.get("TotalCount")
        if params.get("CrossTargetSet") is not None:
            self._CrossTargetSet = []
            for item in params.get("CrossTargetSet"):
                obj = CrossTargets()
                obj._deserialize(item)
                self._CrossTargetSet.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeCustomizedConfigAssociateListRequest(AbstractModel):
    r"""DescribeCustomizedConfigAssociateList请求参数结构体

    """

    def __init__(self):
        r"""
        :param _UconfigId: 配置ID，可以通过 [DescribeCustomizedConfigList](https://cloud.tencent.com/document/product/214/60009) 接口获取。
        :type UconfigId: str
        :param _Offset: 拉取绑定关系列表开始位置，默认值 0
        :type Offset: int
        :param _Limit: 拉取绑定关系列表数目，默认值 20
        :type Limit: int
        :param _Domain: 搜索域名，可以通过 [DescribeLoadBalancersDetail](https://cloud.tencent.com/document/product/214/46916) 接口返回值的 `Domain` 字段查询。
        :type Domain: str
        """
        self._UconfigId = None
        self._Offset = None
        self._Limit = None
        self._Domain = None

    @property
    def UconfigId(self):
        r"""配置ID，可以通过 [DescribeCustomizedConfigList](https://cloud.tencent.com/document/product/214/60009) 接口获取。
        :rtype: str
        """
        return self._UconfigId

    @UconfigId.setter
    def UconfigId(self, UconfigId):
        self._UconfigId = UconfigId

    @property
    def Offset(self):
        r"""拉取绑定关系列表开始位置，默认值 0
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset

    @property
    def Limit(self):
        r"""拉取绑定关系列表数目，默认值 20
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def Domain(self):
        r"""搜索域名，可以通过 [DescribeLoadBalancersDetail](https://cloud.tencent.com/document/product/214/46916) 接口返回值的 `Domain` 字段查询。
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain


    def _deserialize(self, params):
        self._UconfigId = params.get("UconfigId")
        self._Offset = params.get("Offset")
        self._Limit = params.get("Limit")
        self._Domain = params.get("Domain")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeCustomizedConfigAssociateListResponse(AbstractModel):
    r"""DescribeCustomizedConfigAssociateList返回参数结构体

    """

    def __init__(self):
        r"""
        :param _BindList: 绑定关系列表
        :type BindList: list of BindDetailItem
        :param _TotalCount: 绑定关系总数目
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._BindList = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def BindList(self):
        r"""绑定关系列表
        :rtype: list of BindDetailItem
        """
        return self._BindList

    @BindList.setter
    def BindList(self, BindList):
        self._BindList = BindList

    @property
    def TotalCount(self):
        r"""绑定关系总数目
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("BindList") is not None:
            self._BindList = []
            for item in params.get("BindList"):
                obj = BindDetailItem()
                obj._deserialize(item)
                self._BindList.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeCustomizedConfigListRequest(AbstractModel):
    r"""DescribeCustomizedConfigList请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ConfigType: 配置类型:CLB 负载均衡维度。 SERVER 域名维度。 LOCATION 规则维度。
        :type ConfigType: str
        :param _Offset: 拉取页偏移，默认值0。
        :type Offset: int
        :param _Limit: 拉取数目，默认值20。
        :type Limit: int
        :param _ConfigName: 拉取指定配置名字，模糊匹配。
        :type ConfigName: str
        :param _UconfigIds: 配置ID，可以通过 [DescribeCustomizedConfigList](https://cloud.tencent.com/document/api/214/60009) 接口查询。
        :type UconfigIds: list of str
        :param _Filters: 过滤条件如下：
- loadbalancer-id
按照【负载均衡 ID】进行过滤。实例计费模式例如：lb-9vxezxza。
类型：String
必选：否
获取方式：[DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459)
- vip
按照【负载均衡VIP】进行过滤。网络计费模式例如："1.1.1.1","2204::22:3"。
类型：String
必选：否
获取方式：[DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459)
        :type Filters: list of Filter
        """
        self._ConfigType = None
        self._Offset = None
        self._Limit = None
        self._ConfigName = None
        self._UconfigIds = None
        self._Filters = None

    @property
    def ConfigType(self):
        r"""配置类型:CLB 负载均衡维度。 SERVER 域名维度。 LOCATION 规则维度。
        :rtype: str
        """
        return self._ConfigType

    @ConfigType.setter
    def ConfigType(self, ConfigType):
        self._ConfigType = ConfigType

    @property
    def Offset(self):
        r"""拉取页偏移，默认值0。
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset

    @property
    def Limit(self):
        r"""拉取数目，默认值20。
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def ConfigName(self):
        r"""拉取指定配置名字，模糊匹配。
        :rtype: str
        """
        return self._ConfigName

    @ConfigName.setter
    def ConfigName(self, ConfigName):
        self._ConfigName = ConfigName

    @property
    def UconfigIds(self):
        r"""配置ID，可以通过 [DescribeCustomizedConfigList](https://cloud.tencent.com/document/api/214/60009) 接口查询。
        :rtype: list of str
        """
        return self._UconfigIds

    @UconfigIds.setter
    def UconfigIds(self, UconfigIds):
        self._UconfigIds = UconfigIds

    @property
    def Filters(self):
        r"""过滤条件如下：
- loadbalancer-id
按照【负载均衡 ID】进行过滤。实例计费模式例如：lb-9vxezxza。
类型：String
必选：否
获取方式：[DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459)
- vip
按照【负载均衡VIP】进行过滤。网络计费模式例如："1.1.1.1","2204::22:3"。
类型：String
必选：否
获取方式：[DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459)
        :rtype: list of Filter
        """
        return self._Filters

    @Filters.setter
    def Filters(self, Filters):
        self._Filters = Filters


    def _deserialize(self, params):
        self._ConfigType = params.get("ConfigType")
        self._Offset = params.get("Offset")
        self._Limit = params.get("Limit")
        self._ConfigName = params.get("ConfigName")
        self._UconfigIds = params.get("UconfigIds")
        if params.get("Filters") is not None:
            self._Filters = []
            for item in params.get("Filters"):
                obj = Filter()
                obj._deserialize(item)
                self._Filters.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeCustomizedConfigListResponse(AbstractModel):
    r"""DescribeCustomizedConfigList返回参数结构体

    """

    def __init__(self):
        r"""
        :param _ConfigList: 配置列表
        :type ConfigList: list of ConfigListItem
        :param _TotalCount: 配置数目
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._ConfigList = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def ConfigList(self):
        r"""配置列表
        :rtype: list of ConfigListItem
        """
        return self._ConfigList

    @ConfigList.setter
    def ConfigList(self, ConfigList):
        self._ConfigList = ConfigList

    @property
    def TotalCount(self):
        r"""配置数目
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("ConfigList") is not None:
            self._ConfigList = []
            for item in params.get("ConfigList"):
                obj = ConfigListItem()
                obj._deserialize(item)
                self._ConfigList.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeExclusiveClustersRequest(AbstractModel):
    r"""DescribeExclusiveClusters请求参数结构体

    """

    def __init__(self):
        r"""
        :param _Limit: 返回集群列表数目，默认值为20，最大值为100。
        :type Limit: int
        :param _Offset: 返回集群列表起始偏移量，默认为0。
        :type Offset: int
        :param _Filters: 查询集群列表条件，详细的过滤条件如下：
<li> cluster-type - String - 是否必填：否 - （过滤条件）按照 集群 的类型过滤，包括"TGW","STGW","VPCGW"。</li>
<li> cluster-id - String - 是否必填：否 - （过滤条件）按照 集群 的唯一ID过滤，如 ："tgw-12345678","stgw-12345678","vpcgw-12345678"。</li>
<li> cluster-name - String - 是否必填：否 - （过滤条件）按照 集群 的名称过滤。</li>
<li> cluster-tag - String - 是否必填：否 - （过滤条件）按照 集群 的标签过滤。（只有TGW/STGW集群有集群标签） </li>
<li> vip - String - 是否必填：否 - （过滤条件）按照 集群 内的vip过滤。</li>
<li> loadbalancer-id - String - 是否必填：否 - （过滤条件）按照 集群 内的负载均衡唯一ID过滤。</li>
<li> network - String - 是否必填：否 - （过滤条件）按照 集群 的网络类型过滤，如："Public","Private"。</li>
<li> zone - String - 是否必填：否 - （过滤条件）按照 集群 所在可用区过滤，如："ap-guangzhou-1"（广州一区）。</li>
<li> isp -- String - 是否必填：否 - （过滤条件）按照TGW集群的 Isp 类型过滤，如："BGP","CMCC","CUCC","CTCC","INTERNAL"。</li>
        :type Filters: list of Filter
        """
        self._Limit = None
        self._Offset = None
        self._Filters = None

    @property
    def Limit(self):
        r"""返回集群列表数目，默认值为20，最大值为100。
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def Offset(self):
        r"""返回集群列表起始偏移量，默认为0。
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset

    @property
    def Filters(self):
        r"""查询集群列表条件，详细的过滤条件如下：
<li> cluster-type - String - 是否必填：否 - （过滤条件）按照 集群 的类型过滤，包括"TGW","STGW","VPCGW"。</li>
<li> cluster-id - String - 是否必填：否 - （过滤条件）按照 集群 的唯一ID过滤，如 ："tgw-12345678","stgw-12345678","vpcgw-12345678"。</li>
<li> cluster-name - String - 是否必填：否 - （过滤条件）按照 集群 的名称过滤。</li>
<li> cluster-tag - String - 是否必填：否 - （过滤条件）按照 集群 的标签过滤。（只有TGW/STGW集群有集群标签） </li>
<li> vip - String - 是否必填：否 - （过滤条件）按照 集群 内的vip过滤。</li>
<li> loadbalancer-id - String - 是否必填：否 - （过滤条件）按照 集群 内的负载均衡唯一ID过滤。</li>
<li> network - String - 是否必填：否 - （过滤条件）按照 集群 的网络类型过滤，如："Public","Private"。</li>
<li> zone - String - 是否必填：否 - （过滤条件）按照 集群 所在可用区过滤，如："ap-guangzhou-1"（广州一区）。</li>
<li> isp -- String - 是否必填：否 - （过滤条件）按照TGW集群的 Isp 类型过滤，如："BGP","CMCC","CUCC","CTCC","INTERNAL"。</li>
        :rtype: list of Filter
        """
        return self._Filters

    @Filters.setter
    def Filters(self, Filters):
        self._Filters = Filters


    def _deserialize(self, params):
        self._Limit = params.get("Limit")
        self._Offset = params.get("Offset")
        if params.get("Filters") is not None:
            self._Filters = []
            for item in params.get("Filters"):
                obj = Filter()
                obj._deserialize(item)
                self._Filters.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeExclusiveClustersResponse(AbstractModel):
    r"""DescribeExclusiveClusters返回参数结构体

    """

    def __init__(self):
        r"""
        :param _ClusterSet: 集群列表。
        :type ClusterSet: list of Cluster
        :param _TotalCount: 集群总数量。
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._ClusterSet = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def ClusterSet(self):
        r"""集群列表。
        :rtype: list of Cluster
        """
        return self._ClusterSet

    @ClusterSet.setter
    def ClusterSet(self, ClusterSet):
        self._ClusterSet = ClusterSet

    @property
    def TotalCount(self):
        r"""集群总数量。
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("ClusterSet") is not None:
            self._ClusterSet = []
            for item in params.get("ClusterSet"):
                obj = Cluster()
                obj._deserialize(item)
                self._ClusterSet.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeIdleLoadBalancersRequest(AbstractModel):
    r"""DescribeIdleLoadBalancers请求参数结构体

    """

    def __init__(self):
        r"""
        :param _Offset: 数据偏移量，默认为0。
        :type Offset: int
        :param _Limit: 返回负载均衡实例的数量，默认为20，最大值为100。
        :type Limit: int
        :param _LoadBalancerRegion: 负载均衡所在地域，可以通过 [DescribeRegions](https://cloud.tencent.com/document/product/1596/77930) 接口返回值 `RegionSet.Region` 字段获取。
        :type LoadBalancerRegion: str
        """
        self._Offset = None
        self._Limit = None
        self._LoadBalancerRegion = None

    @property
    def Offset(self):
        r"""数据偏移量，默认为0。
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset

    @property
    def Limit(self):
        r"""返回负载均衡实例的数量，默认为20，最大值为100。
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def LoadBalancerRegion(self):
        r"""负载均衡所在地域，可以通过 [DescribeRegions](https://cloud.tencent.com/document/product/1596/77930) 接口返回值 `RegionSet.Region` 字段获取。
        :rtype: str
        """
        return self._LoadBalancerRegion

    @LoadBalancerRegion.setter
    def LoadBalancerRegion(self, LoadBalancerRegion):
        self._LoadBalancerRegion = LoadBalancerRegion


    def _deserialize(self, params):
        self._Offset = params.get("Offset")
        self._Limit = params.get("Limit")
        self._LoadBalancerRegion = params.get("LoadBalancerRegion")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeIdleLoadBalancersResponse(AbstractModel):
    r"""DescribeIdleLoadBalancers返回参数结构体

    """

    def __init__(self):
        r"""
        :param _IdleLoadBalancers: 闲置实例列表
        :type IdleLoadBalancers: list of IdleLoadBalancer
        :param _TotalCount: 所有闲置实例数目
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._IdleLoadBalancers = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def IdleLoadBalancers(self):
        r"""闲置实例列表
        :rtype: list of IdleLoadBalancer
        """
        return self._IdleLoadBalancers

    @IdleLoadBalancers.setter
    def IdleLoadBalancers(self, IdleLoadBalancers):
        self._IdleLoadBalancers = IdleLoadBalancers

    @property
    def TotalCount(self):
        r"""所有闲置实例数目
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("IdleLoadBalancers") is not None:
            self._IdleLoadBalancers = []
            for item in params.get("IdleLoadBalancers"):
                obj = IdleLoadBalancer()
                obj._deserialize(item)
                self._IdleLoadBalancers.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeIntentRouterTiersRequest(AbstractModel):
    r"""DescribeIntentRouterTiers请求参数结构体

    """


class DescribeIntentRouterTiersResponse(AbstractModel):
    r"""DescribeIntentRouterTiers返回参数结构体

    """

    def __init__(self):
        r"""
        :param _TierSet: <p>Tier 字典列表（按 tier_id 升序排列）</p>
        :type TierSet: list of IntentRouterTierDictItem
        :param _TotalCount: <p>Tier 总条数</p>
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._TierSet = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def TierSet(self):
        r"""<p>Tier 字典列表（按 tier_id 升序排列）</p>
        :rtype: list of IntentRouterTierDictItem
        """
        return self._TierSet

    @TierSet.setter
    def TierSet(self, TierSet):
        self._TierSet = TierSet

    @property
    def TotalCount(self):
        r"""<p>Tier 总条数</p>
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("TierSet") is not None:
            self._TierSet = []
            for item in params.get("TierSet"):
                obj = IntentRouterTierDictItem()
                obj._deserialize(item)
                self._TierSet.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeIntentRoutersRequest(AbstractModel):
    r"""DescribeIntentRouters请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID。</p>
        :type ModelRouterId: str
        :param _IntentRouterIds: <p>意图路由ID列表</p>
        :type IntentRouterIds: list of str
        """
        self._ModelRouterId = None
        self._IntentRouterIds = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID。</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def IntentRouterIds(self):
        r"""<p>意图路由ID列表</p>
        :rtype: list of str
        """
        return self._IntentRouterIds

    @IntentRouterIds.setter
    def IntentRouterIds(self, IntentRouterIds):
        self._IntentRouterIds = IntentRouterIds


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._IntentRouterIds = params.get("IntentRouterIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeIntentRoutersResponse(AbstractModel):
    r"""DescribeIntentRouters返回参数结构体

    """

    def __init__(self):
        r"""
        :param _IntentRouterSet: <p>意图路由列表。</p>
        :type IntentRouterSet: list of IntentRouterItem
        :param _TotalCount: <p>意图路由总数。</p>
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._IntentRouterSet = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def IntentRouterSet(self):
        r"""<p>意图路由列表。</p>
        :rtype: list of IntentRouterItem
        """
        return self._IntentRouterSet

    @IntentRouterSet.setter
    def IntentRouterSet(self, IntentRouterSet):
        self._IntentRouterSet = IntentRouterSet

    @property
    def TotalCount(self):
        r"""<p>意图路由总数。</p>
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("IntentRouterSet") is not None:
            self._IntentRouterSet = []
            for item in params.get("IntentRouterSet"):
                obj = IntentRouterItem()
                obj._deserialize(item)
                self._IntentRouterSet.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeKeysRequest(AbstractModel):
    r"""DescribeKeys请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID</p>
        :type ModelRouterId: str
        :param _Filters: <p>过滤列表</p><p>支持：KeyName、BudgetId、tag-key、tag:&lt;tag-key&gt;。</p>
        :type Filters: list of Filter
        :param _KeyIds: <p>API Key的ID列表</p>
        :type KeyIds: list of str
        :param _Limit: <p>本次查询限制的数量</p><p>取值范围：[1, 100]</p><p>默认值：20</p>
        :type Limit: int
        :param _Offset: <p>本次查询偏移量</p>
        :type Offset: int
        """
        self._ModelRouterId = None
        self._Filters = None
        self._KeyIds = None
        self._Limit = None
        self._Offset = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def Filters(self):
        r"""<p>过滤列表</p><p>支持：KeyName、BudgetId、tag-key、tag:&lt;tag-key&gt;。</p>
        :rtype: list of Filter
        """
        return self._Filters

    @Filters.setter
    def Filters(self, Filters):
        self._Filters = Filters

    @property
    def KeyIds(self):
        r"""<p>API Key的ID列表</p>
        :rtype: list of str
        """
        return self._KeyIds

    @KeyIds.setter
    def KeyIds(self, KeyIds):
        self._KeyIds = KeyIds

    @property
    def Limit(self):
        r"""<p>本次查询限制的数量</p><p>取值范围：[1, 100]</p><p>默认值：20</p>
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def Offset(self):
        r"""<p>本次查询偏移量</p>
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        if params.get("Filters") is not None:
            self._Filters = []
            for item in params.get("Filters"):
                obj = Filter()
                obj._deserialize(item)
                self._Filters.append(obj)
        self._KeyIds = params.get("KeyIds")
        self._Limit = params.get("Limit")
        self._Offset = params.get("Offset")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeKeysResponse(AbstractModel):
    r"""DescribeKeys返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Keys: <p>API Key列表</p>
        :type Keys: list of KeyInfo
        :param _TotalCount: <p>符合条件的总数</p>
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Keys = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def Keys(self):
        r"""<p>API Key列表</p>
        :rtype: list of KeyInfo
        """
        return self._Keys

    @Keys.setter
    def Keys(self, Keys):
        self._Keys = Keys

    @property
    def TotalCount(self):
        r"""<p>符合条件的总数</p>
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("Keys") is not None:
            self._Keys = []
            for item in params.get("Keys"):
                obj = KeyInfo()
                obj._deserialize(item)
                self._Keys.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeLBListenersRequest(AbstractModel):
    r"""DescribeLBListeners请求参数结构体

    """

    def __init__(self):
        r"""
        :param _Backends: 需要查询的内网ip列表
        :type Backends: list of LbRsItem
        """
        self._Backends = None

    @property
    def Backends(self):
        r"""需要查询的内网ip列表
        :rtype: list of LbRsItem
        """
        return self._Backends

    @Backends.setter
    def Backends(self, Backends):
        self._Backends = Backends


    def _deserialize(self, params):
        if params.get("Backends") is not None:
            self._Backends = []
            for item in params.get("Backends"):
                obj = LbRsItem()
                obj._deserialize(item)
                self._Backends.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeLBListenersResponse(AbstractModel):
    r"""DescribeLBListeners返回参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancers: 绑定的后端规则
        :type LoadBalancers: list of LBItem
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._LoadBalancers = None
        self._RequestId = None

    @property
    def LoadBalancers(self):
        r"""绑定的后端规则
        :rtype: list of LBItem
        """
        return self._LoadBalancers

    @LoadBalancers.setter
    def LoadBalancers(self, LoadBalancers):
        self._LoadBalancers = LoadBalancers

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("LoadBalancers") is not None:
            self._LoadBalancers = []
            for item in params.get("LoadBalancers"):
                obj = LBItem()
                obj._deserialize(item)
                self._LoadBalancers.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeLBOperateProtectRequest(AbstractModel):
    r"""DescribeLBOperateProtect请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerIds: 负载均衡实例ID。
        :type LoadBalancerIds: list of str
        """
        self._LoadBalancerIds = None

    @property
    def LoadBalancerIds(self):
        r"""负载均衡实例ID。
        :rtype: list of str
        """
        return self._LoadBalancerIds

    @LoadBalancerIds.setter
    def LoadBalancerIds(self, LoadBalancerIds):
        self._LoadBalancerIds = LoadBalancerIds


    def _deserialize(self, params):
        self._LoadBalancerIds = params.get("LoadBalancerIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeLBOperateProtectResponse(AbstractModel):
    r"""DescribeLBOperateProtect返回参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerSet: 返回的负载均衡操作保护信息数组。
        :type LoadBalancerSet: list of LBOperateProtectInfo
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._LoadBalancerSet = None
        self._RequestId = None

    @property
    def LoadBalancerSet(self):
        r"""返回的负载均衡操作保护信息数组。
        :rtype: list of LBOperateProtectInfo
        """
        return self._LoadBalancerSet

    @LoadBalancerSet.setter
    def LoadBalancerSet(self, LoadBalancerSet):
        self._LoadBalancerSet = LoadBalancerSet

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("LoadBalancerSet") is not None:
            self._LoadBalancerSet = []
            for item in params.get("LoadBalancerSet"):
                obj = LBOperateProtectInfo()
                obj._deserialize(item)
                self._LoadBalancerSet.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeListenersRequest(AbstractModel):
    r"""DescribeListeners请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例 ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/api/214/30685) 接口获取。
        :type LoadBalancerId: str
        :param _ListenerIds: 要查询的负载均衡监听器 ID 数组，最大为100个，可以通过 [DescribeListeners](https://cloud.tencent.com/document/api/214/30686) 接口获取。
        :type ListenerIds: list of str
        :param _Protocol: 要查询的监听器协议类型，取值 TCP | UDP | HTTP | HTTPS | TCP_SSL | QUIC。
        :type Protocol: str
        :param _Port: 要查询的监听器的端口，端口范围：1-65535
        :type Port: int
        """
        self._LoadBalancerId = None
        self._ListenerIds = None
        self._Protocol = None
        self._Port = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例 ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/api/214/30685) 接口获取。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerIds(self):
        r"""要查询的负载均衡监听器 ID 数组，最大为100个，可以通过 [DescribeListeners](https://cloud.tencent.com/document/api/214/30686) 接口获取。
        :rtype: list of str
        """
        return self._ListenerIds

    @ListenerIds.setter
    def ListenerIds(self, ListenerIds):
        self._ListenerIds = ListenerIds

    @property
    def Protocol(self):
        r"""要查询的监听器协议类型，取值 TCP | UDP | HTTP | HTTPS | TCP_SSL | QUIC。
        :rtype: str
        """
        return self._Protocol

    @Protocol.setter
    def Protocol(self, Protocol):
        self._Protocol = Protocol

    @property
    def Port(self):
        r"""要查询的监听器的端口，端口范围：1-65535
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerIds = params.get("ListenerIds")
        self._Protocol = params.get("Protocol")
        self._Port = params.get("Port")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeListenersResponse(AbstractModel):
    r"""DescribeListeners返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Listeners: 监听器列表。
        :type Listeners: list of Listener
        :param _TotalCount: 总的监听器个数（根据端口、协议、监听器ID过滤后）。
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Listeners = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def Listeners(self):
        r"""监听器列表。
        :rtype: list of Listener
        """
        return self._Listeners

    @Listeners.setter
    def Listeners(self, Listeners):
        self._Listeners = Listeners

    @property
    def TotalCount(self):
        r"""总的监听器个数（根据端口、协议、监听器ID过滤后）。
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("Listeners") is not None:
            self._Listeners = []
            for item in params.get("Listeners"):
                obj = Listener()
                obj._deserialize(item)
                self._Listeners.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeLoadBalancerListByCertIdRequest(AbstractModel):
    r"""DescribeLoadBalancerListByCertId请求参数结构体

    """

    def __init__(self):
        r"""
        :param _CertIds: 服务端证书的ID，或客户端证书的ID。可以通过 [DescribeCertificate](https://cloud.tencent.com/document/api/400/41674) 接口查询。
数组最大长度为20。
        :type CertIds: list of str
        """
        self._CertIds = None

    @property
    def CertIds(self):
        r"""服务端证书的ID，或客户端证书的ID。可以通过 [DescribeCertificate](https://cloud.tencent.com/document/api/400/41674) 接口查询。
数组最大长度为20。
        :rtype: list of str
        """
        return self._CertIds

    @CertIds.setter
    def CertIds(self, CertIds):
        self._CertIds = CertIds


    def _deserialize(self, params):
        self._CertIds = params.get("CertIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeLoadBalancerListByCertIdResponse(AbstractModel):
    r"""DescribeLoadBalancerListByCertId返回参数结构体

    """

    def __init__(self):
        r"""
        :param _CertSet: 证书ID，以及与该证书ID关联的负载均衡实例列表
        :type CertSet: list of CertIdRelatedWithLoadBalancers
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._CertSet = None
        self._RequestId = None

    @property
    def CertSet(self):
        r"""证书ID，以及与该证书ID关联的负载均衡实例列表
        :rtype: list of CertIdRelatedWithLoadBalancers
        """
        return self._CertSet

    @CertSet.setter
    def CertSet(self, CertSet):
        self._CertSet = CertSet

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("CertSet") is not None:
            self._CertSet = []
            for item in params.get("CertSet"):
                obj = CertIdRelatedWithLoadBalancers()
                obj._deserialize(item)
                self._CertSet.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeLoadBalancerOverviewRequest(AbstractModel):
    r"""DescribeLoadBalancerOverview请求参数结构体

    """


class DescribeLoadBalancerOverviewResponse(AbstractModel):
    r"""DescribeLoadBalancerOverview返回参数结构体

    """

    def __init__(self):
        r"""
        :param _TotalCount: 负载均衡总数
        :type TotalCount: int
        :param _RunningCount: 运行中的负载均衡数目
        :type RunningCount: int
        :param _IsolationCount: 隔离中的负载均衡数目
        :type IsolationCount: int
        :param _WillExpireCount: 即将到期的负载均衡数目
        :type WillExpireCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._TotalCount = None
        self._RunningCount = None
        self._IsolationCount = None
        self._WillExpireCount = None
        self._RequestId = None

    @property
    def TotalCount(self):
        r"""负载均衡总数
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RunningCount(self):
        r"""运行中的负载均衡数目
        :rtype: int
        """
        return self._RunningCount

    @RunningCount.setter
    def RunningCount(self, RunningCount):
        self._RunningCount = RunningCount

    @property
    def IsolationCount(self):
        r"""隔离中的负载均衡数目
        :rtype: int
        """
        return self._IsolationCount

    @IsolationCount.setter
    def IsolationCount(self, IsolationCount):
        self._IsolationCount = IsolationCount

    @property
    def WillExpireCount(self):
        r"""即将到期的负载均衡数目
        :rtype: int
        """
        return self._WillExpireCount

    @WillExpireCount.setter
    def WillExpireCount(self, WillExpireCount):
        self._WillExpireCount = WillExpireCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._TotalCount = params.get("TotalCount")
        self._RunningCount = params.get("RunningCount")
        self._IsolationCount = params.get("IsolationCount")
        self._WillExpireCount = params.get("WillExpireCount")
        self._RequestId = params.get("RequestId")


class DescribeLoadBalancerTrafficRequest(AbstractModel):
    r"""DescribeLoadBalancerTraffic请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerRegion: 负载均衡所在地域，不传默认返回所有地域负载均衡。
        :type LoadBalancerRegion: str
        """
        self._LoadBalancerRegion = None

    @property
    def LoadBalancerRegion(self):
        r"""负载均衡所在地域，不传默认返回所有地域负载均衡。
        :rtype: str
        """
        return self._LoadBalancerRegion

    @LoadBalancerRegion.setter
    def LoadBalancerRegion(self, LoadBalancerRegion):
        self._LoadBalancerRegion = LoadBalancerRegion


    def _deserialize(self, params):
        self._LoadBalancerRegion = params.get("LoadBalancerRegion")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeLoadBalancerTrafficResponse(AbstractModel):
    r"""DescribeLoadBalancerTraffic返回参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerTraffic: 按出带宽从高到低排序后的负载均衡信息。
        :type LoadBalancerTraffic: list of LoadBalancerTraffic
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._LoadBalancerTraffic = None
        self._RequestId = None

    @property
    def LoadBalancerTraffic(self):
        r"""按出带宽从高到低排序后的负载均衡信息。
        :rtype: list of LoadBalancerTraffic
        """
        return self._LoadBalancerTraffic

    @LoadBalancerTraffic.setter
    def LoadBalancerTraffic(self, LoadBalancerTraffic):
        self._LoadBalancerTraffic = LoadBalancerTraffic

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("LoadBalancerTraffic") is not None:
            self._LoadBalancerTraffic = []
            for item in params.get("LoadBalancerTraffic"):
                obj = LoadBalancerTraffic()
                obj._deserialize(item)
                self._LoadBalancerTraffic.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeLoadBalancersDetailRequest(AbstractModel):
    r"""DescribeLoadBalancersDetail请求参数结构体

    """

    def __init__(self):
        r"""
        :param _Limit: 返回负载均衡列表数目，默认20，最大值100。
        :type Limit: int
        :param _Offset: 返回负载均衡列表起始偏移量，默认0。
        :type Offset: int
        :param _Fields: 选择返回的Fields列表，系统仅会返回Fileds中填写的字段，可填写的字段详情请参见<a href="https://cloud.tencent.com/document/api/214/30694#LoadBalancerDetail">LoadBalancerDetail</a>。若未在Fileds填写相关字段，则此字段返回null。Fileds中默认添加LoadBalancerId和LoadBalancerName字段。
        :type Fields: list of str
        :param _TargetType: 当Fields包含TargetId、TargetAddress、TargetPort、TargetWeight、ListenerId、Protocol、Port、LocationId、Domain、Url等Fields时，必选选择导出目标组的Target或者非目标组Target，取值范围NODE、GROUP。
        :type TargetType: str
        :param _Filters: 查询负载均衡详细信息列表条件，详细的过滤条件如下：
- loadbalancer-id
按照【负载均衡ID】进行过滤。例如：lb-rbw5skde。
类型：String
必选：否
获取方式：[DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459)
- project-id
按照【项目ID】进行过滤。例如： "0"、"123"。
类型：String
必选：否
获取方式：[DescribeProject](https://cloud.tencent.com/document/api/651/78725)
- network
按照【负载均衡网络类型】进行过滤。例如：Public。
类型：String
必选：否
可选值：Private（内网）、Public（公网）
- vip
按照【负载均衡 VIP】进行过滤。例如："1.1.1.1","2204::22:3"。
类型：String
必选：否
- vpcid
按照【负载均衡所属 VPCID】进行过滤。例如："vpc-12345678"。
类型：String
必选：否
获取方式：[DescribeZones](https://cloud.tencent.com/document/product/213/15707)
- target-ip
按照【后端目标内网 IP】进行过滤。例如："1.1.1.1","2203::214:4"。
类型：String
必选：否
- zone
按照【负载均衡所属的可用区】进行过滤。例如："ap-guangzhou-1"。
类型：String
必选：否
获取方式：[DescribeZones](https://cloud.tencent.com/document/product/213/15707)
- tag-key
按照【负载均衡标签的标签键】进行过滤，例如："name"。
类型：String
必选：否
获取方式：[DescribeTags](https://cloud.tencent.com/document/api/651/35316)
- tag:*
按照【负载均衡的标签】进行过滤，':' 后面跟的是标签键。如过滤标签键name，标签值zhangsan,lisi，{"Name": "tag:name","Values": ["zhangsan", "lisi"]}。
类型：String
必选：否
获取方式：[DescribeTagKeys](https://cloud.tencent.com/document/api/651/35318)
- fuzzy-search
按照【负载均衡VIP，负载均衡名称】模糊搜索，例如："1.1"。
类型：String
必选：否
        :type Filters: list of Filter
        """
        self._Limit = None
        self._Offset = None
        self._Fields = None
        self._TargetType = None
        self._Filters = None

    @property
    def Limit(self):
        r"""返回负载均衡列表数目，默认20，最大值100。
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def Offset(self):
        r"""返回负载均衡列表起始偏移量，默认0。
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset

    @property
    def Fields(self):
        r"""选择返回的Fields列表，系统仅会返回Fileds中填写的字段，可填写的字段详情请参见<a href="https://cloud.tencent.com/document/api/214/30694#LoadBalancerDetail">LoadBalancerDetail</a>。若未在Fileds填写相关字段，则此字段返回null。Fileds中默认添加LoadBalancerId和LoadBalancerName字段。
        :rtype: list of str
        """
        return self._Fields

    @Fields.setter
    def Fields(self, Fields):
        self._Fields = Fields

    @property
    def TargetType(self):
        r"""当Fields包含TargetId、TargetAddress、TargetPort、TargetWeight、ListenerId、Protocol、Port、LocationId、Domain、Url等Fields时，必选选择导出目标组的Target或者非目标组Target，取值范围NODE、GROUP。
        :rtype: str
        """
        return self._TargetType

    @TargetType.setter
    def TargetType(self, TargetType):
        self._TargetType = TargetType

    @property
    def Filters(self):
        r"""查询负载均衡详细信息列表条件，详细的过滤条件如下：
- loadbalancer-id
按照【负载均衡ID】进行过滤。例如：lb-rbw5skde。
类型：String
必选：否
获取方式：[DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459)
- project-id
按照【项目ID】进行过滤。例如： "0"、"123"。
类型：String
必选：否
获取方式：[DescribeProject](https://cloud.tencent.com/document/api/651/78725)
- network
按照【负载均衡网络类型】进行过滤。例如：Public。
类型：String
必选：否
可选值：Private（内网）、Public（公网）
- vip
按照【负载均衡 VIP】进行过滤。例如："1.1.1.1","2204::22:3"。
类型：String
必选：否
- vpcid
按照【负载均衡所属 VPCID】进行过滤。例如："vpc-12345678"。
类型：String
必选：否
获取方式：[DescribeZones](https://cloud.tencent.com/document/product/213/15707)
- target-ip
按照【后端目标内网 IP】进行过滤。例如："1.1.1.1","2203::214:4"。
类型：String
必选：否
- zone
按照【负载均衡所属的可用区】进行过滤。例如："ap-guangzhou-1"。
类型：String
必选：否
获取方式：[DescribeZones](https://cloud.tencent.com/document/product/213/15707)
- tag-key
按照【负载均衡标签的标签键】进行过滤，例如："name"。
类型：String
必选：否
获取方式：[DescribeTags](https://cloud.tencent.com/document/api/651/35316)
- tag:*
按照【负载均衡的标签】进行过滤，':' 后面跟的是标签键。如过滤标签键name，标签值zhangsan,lisi，{"Name": "tag:name","Values": ["zhangsan", "lisi"]}。
类型：String
必选：否
获取方式：[DescribeTagKeys](https://cloud.tencent.com/document/api/651/35318)
- fuzzy-search
按照【负载均衡VIP，负载均衡名称】模糊搜索，例如："1.1"。
类型：String
必选：否
        :rtype: list of Filter
        """
        return self._Filters

    @Filters.setter
    def Filters(self, Filters):
        self._Filters = Filters


    def _deserialize(self, params):
        self._Limit = params.get("Limit")
        self._Offset = params.get("Offset")
        self._Fields = params.get("Fields")
        self._TargetType = params.get("TargetType")
        if params.get("Filters") is not None:
            self._Filters = []
            for item in params.get("Filters"):
                obj = Filter()
                obj._deserialize(item)
                self._Filters.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeLoadBalancersDetailResponse(AbstractModel):
    r"""DescribeLoadBalancersDetail返回参数结构体

    """

    def __init__(self):
        r"""
        :param _TotalCount: 负载均衡详情列表总数。
        :type TotalCount: int
        :param _LoadBalancerDetailSet: 负载均衡详情列表。
        :type LoadBalancerDetailSet: list of LoadBalancerDetail
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._TotalCount = None
        self._LoadBalancerDetailSet = None
        self._RequestId = None

    @property
    def TotalCount(self):
        r"""负载均衡详情列表总数。
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def LoadBalancerDetailSet(self):
        r"""负载均衡详情列表。
        :rtype: list of LoadBalancerDetail
        """
        return self._LoadBalancerDetailSet

    @LoadBalancerDetailSet.setter
    def LoadBalancerDetailSet(self, LoadBalancerDetailSet):
        self._LoadBalancerDetailSet = LoadBalancerDetailSet

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._TotalCount = params.get("TotalCount")
        if params.get("LoadBalancerDetailSet") is not None:
            self._LoadBalancerDetailSet = []
            for item in params.get("LoadBalancerDetailSet"):
                obj = LoadBalancerDetail()
                obj._deserialize(item)
                self._LoadBalancerDetailSet.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeLoadBalancersRequest(AbstractModel):
    r"""DescribeLoadBalancers请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerIds: 负载均衡实例ID。实例ID数量上限为20个。
        :type LoadBalancerIds: list of str
        :param _LoadBalancerType: 负载均衡实例的网络类型：
OPEN：公网属性， INTERNAL：内网属性。
        :type LoadBalancerType: str
        :param _Forward: 负载均衡实例的类型。1：通用的负载均衡实例，0：传统型负载均衡实例。如果不传此参数，则查询所有类型的负载均衡实例。
        :type Forward: int
        :param _LoadBalancerName: 负载均衡实例的名称，支持模糊查询。
        :type LoadBalancerName: str
        :param _Domain: 腾讯云为负载均衡实例分配的域名，支持模糊查询。
        :type Domain: str
        :param _LoadBalancerVips: 负载均衡实例的 VIP 地址，支持多个。
        :type LoadBalancerVips: list of str
        :param _BackendPublicIps: 负载均衡绑定的后端服务的外网 IP，只支持查询云服务器的公网 IP。
        :type BackendPublicIps: list of str
        :param _BackendPrivateIps: 负载均衡绑定的后端服务的内网 IP，只支持查询云服务器的内网 IP。
        :type BackendPrivateIps: list of str
        :param _Offset: 数据偏移量，默认为0。
        :type Offset: int
        :param _Limit: 返回负载均衡实例的数量，默认为20，最大值为100。
        :type Limit: int
        :param _OrderBy: 排序参数，支持以下字段：
- LoadBalancerName
- CreateTime
- Domain
- LoadBalancerType

默认为 CreateTime。

        :type OrderBy: str
        :param _OrderType: 1：倒序，0：顺序，默认为1，按照创建时间倒序。
        :type OrderType: int
        :param _SearchKey: 模糊搜索字段，模糊匹配负载均衡实例的名称、域名、负载均衡实例的 VIP 地址，负载均衡实例ID。
        :type SearchKey: str
        :param _ProjectId: 负载均衡实例所属的项目 ID，可以通过[DescribeProject](https://cloud.tencent.com/document/api/651/78725)接口获取，不传默认所有项目。
        :type ProjectId: int
        :param _WithRs: 负载均衡是否绑定后端服务，0：没有绑定后端服务，1：绑定后端服务，-1：查询全部。
        :type WithRs: int
        :param _VpcId: 负载均衡实例所属私有网络唯一ID，如 vpc-bhqkbhdx，可以通过[DescribeVpcs](https://cloud.tencent.com/document/api/215/15778)接口获取。
查找基础网络类型的负载均衡可传入'0'。
        :type VpcId: str
        :param _SecurityGroup: 安全组ID，如 sg-m1cc****，可以通过接口[DescribeSecurityGroups](https://cloud.tencent.com/document/product/215/15808)获取。
        :type SecurityGroup: str
        :param _MasterZone: 主可用区ID，如 ："100001" （对应的是广州一区）。可通过[DescribeZones](https://cloud.tencent.com/document/product/213/15707)获取可用区列表。
        :type MasterZone: str
        :param _Filters: 每次请求的`Filters`的上限为10，`Filter.Values`的上限为100。<br/>`Filter.Name`和`Filter.Values`皆为必填项。详细的过滤条件如下：
- charge-type
按照【实例计费模式】进行过滤。实例计费模式例如：PREPAID。
类型：String
必选：否
可选项：PREPAID(预付费)、POSTPAID_BY_HOUR(后付费)
- internet-charge-type
按照【网络计费模式】进行过滤。网络计费模式例如：BANDWIDTH_PREPAID。
类型：String
必选：否
可选项：BANDWIDTH_PREPAID(预付费按带宽结算)、 TRAFFIC_POSTPAID_BY_HOUR(流量按小时后付费)、BANDWIDTH_POSTPAID_BY_HOUR(带宽按小时后付费)、BANDWIDTH_PACKAGE(带宽包用户)
- master-zone-id
按照【CLB主可用区ID】进行过滤。例如：100001（对应的是广州一区）。
类型：String
必选：否
获取方式：[DescribeZones](https://cloud.tencent.com/document/product/213/15707)
- tag-key
按照【CLB 标签的键】进行过滤，例如：tag-key。
类型：String
必选：否
获取方式：[DescribeTags](https://cloud.tencent.com/document/api/651/35316)
- tag:tag-key
按照【CLB标签键值】进行过滤，例如：tag-test。
类型：String
必选：否
获取方式：[DescribeTagKeys](https://cloud.tencent.com/document/api/651/35318)
- function-name
按照【后端绑定SCF云函数的函数名称】进行过滤，例如：helloworld-1744958255。
类型：String
必选：否
获取方式：[ListFunctions](https://cloud.tencent.com/document/api/583/18582)
- vip-isp
按照【CLB VIP的运营商类型】进行过滤，例如：BGP。
类型：String
必选：否
公网类型可选项：BGP(多线)、CMCC(中国移动)、CTCC(中国电信)、CUCC(中国联通)
内网类型可选项：INTERNAL(内网)
- sla-type
按照【CLB 的性能容量型规格】进行过滤，例如：clb.c4.xlarge。
类型：String
必选：否
可选项：clb.c2.medium(标准型)、clb.c3.small(高阶型1)、clb.c3.medium(高阶型2)、clb.c4.small(超强型1)、clb.c4.medium(超强型2)、clb.c4.large(超强型3)、clb.c4.xlarge(超强型4)
具体规格参数参考：
- exclusive
按照【独占实例】进行过滤。例如：1，代表筛选独占型实例。
类型：String
必选：否
可选项：0、1
        :type Filters: list of Filter
        :param _AdditionalFields: 选择返回的扩充字段，不指定时，扩充字段默认不返回。详细支持的扩充字段如下：
<li> TargetCount：绑定的后端服务数量</li>
        :type AdditionalFields: list of str
        """
        self._LoadBalancerIds = None
        self._LoadBalancerType = None
        self._Forward = None
        self._LoadBalancerName = None
        self._Domain = None
        self._LoadBalancerVips = None
        self._BackendPublicIps = None
        self._BackendPrivateIps = None
        self._Offset = None
        self._Limit = None
        self._OrderBy = None
        self._OrderType = None
        self._SearchKey = None
        self._ProjectId = None
        self._WithRs = None
        self._VpcId = None
        self._SecurityGroup = None
        self._MasterZone = None
        self._Filters = None
        self._AdditionalFields = None

    @property
    def LoadBalancerIds(self):
        r"""负载均衡实例ID。实例ID数量上限为20个。
        :rtype: list of str
        """
        return self._LoadBalancerIds

    @LoadBalancerIds.setter
    def LoadBalancerIds(self, LoadBalancerIds):
        self._LoadBalancerIds = LoadBalancerIds

    @property
    def LoadBalancerType(self):
        r"""负载均衡实例的网络类型：
OPEN：公网属性， INTERNAL：内网属性。
        :rtype: str
        """
        return self._LoadBalancerType

    @LoadBalancerType.setter
    def LoadBalancerType(self, LoadBalancerType):
        self._LoadBalancerType = LoadBalancerType

    @property
    def Forward(self):
        r"""负载均衡实例的类型。1：通用的负载均衡实例，0：传统型负载均衡实例。如果不传此参数，则查询所有类型的负载均衡实例。
        :rtype: int
        """
        return self._Forward

    @Forward.setter
    def Forward(self, Forward):
        self._Forward = Forward

    @property
    def LoadBalancerName(self):
        r"""负载均衡实例的名称，支持模糊查询。
        :rtype: str
        """
        return self._LoadBalancerName

    @LoadBalancerName.setter
    def LoadBalancerName(self, LoadBalancerName):
        self._LoadBalancerName = LoadBalancerName

    @property
    def Domain(self):
        r"""腾讯云为负载均衡实例分配的域名，支持模糊查询。
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def LoadBalancerVips(self):
        r"""负载均衡实例的 VIP 地址，支持多个。
        :rtype: list of str
        """
        return self._LoadBalancerVips

    @LoadBalancerVips.setter
    def LoadBalancerVips(self, LoadBalancerVips):
        self._LoadBalancerVips = LoadBalancerVips

    @property
    def BackendPublicIps(self):
        r"""负载均衡绑定的后端服务的外网 IP，只支持查询云服务器的公网 IP。
        :rtype: list of str
        """
        return self._BackendPublicIps

    @BackendPublicIps.setter
    def BackendPublicIps(self, BackendPublicIps):
        self._BackendPublicIps = BackendPublicIps

    @property
    def BackendPrivateIps(self):
        r"""负载均衡绑定的后端服务的内网 IP，只支持查询云服务器的内网 IP。
        :rtype: list of str
        """
        return self._BackendPrivateIps

    @BackendPrivateIps.setter
    def BackendPrivateIps(self, BackendPrivateIps):
        self._BackendPrivateIps = BackendPrivateIps

    @property
    def Offset(self):
        r"""数据偏移量，默认为0。
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset

    @property
    def Limit(self):
        r"""返回负载均衡实例的数量，默认为20，最大值为100。
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def OrderBy(self):
        r"""排序参数，支持以下字段：
- LoadBalancerName
- CreateTime
- Domain
- LoadBalancerType

默认为 CreateTime。

        :rtype: str
        """
        return self._OrderBy

    @OrderBy.setter
    def OrderBy(self, OrderBy):
        self._OrderBy = OrderBy

    @property
    def OrderType(self):
        r"""1：倒序，0：顺序，默认为1，按照创建时间倒序。
        :rtype: int
        """
        return self._OrderType

    @OrderType.setter
    def OrderType(self, OrderType):
        self._OrderType = OrderType

    @property
    def SearchKey(self):
        r"""模糊搜索字段，模糊匹配负载均衡实例的名称、域名、负载均衡实例的 VIP 地址，负载均衡实例ID。
        :rtype: str
        """
        return self._SearchKey

    @SearchKey.setter
    def SearchKey(self, SearchKey):
        self._SearchKey = SearchKey

    @property
    def ProjectId(self):
        r"""负载均衡实例所属的项目 ID，可以通过[DescribeProject](https://cloud.tencent.com/document/api/651/78725)接口获取，不传默认所有项目。
        :rtype: int
        """
        return self._ProjectId

    @ProjectId.setter
    def ProjectId(self, ProjectId):
        self._ProjectId = ProjectId

    @property
    def WithRs(self):
        r"""负载均衡是否绑定后端服务，0：没有绑定后端服务，1：绑定后端服务，-1：查询全部。
        :rtype: int
        """
        return self._WithRs

    @WithRs.setter
    def WithRs(self, WithRs):
        self._WithRs = WithRs

    @property
    def VpcId(self):
        r"""负载均衡实例所属私有网络唯一ID，如 vpc-bhqkbhdx，可以通过[DescribeVpcs](https://cloud.tencent.com/document/api/215/15778)接口获取。
查找基础网络类型的负载均衡可传入'0'。
        :rtype: str
        """
        return self._VpcId

    @VpcId.setter
    def VpcId(self, VpcId):
        self._VpcId = VpcId

    @property
    def SecurityGroup(self):
        r"""安全组ID，如 sg-m1cc****，可以通过接口[DescribeSecurityGroups](https://cloud.tencent.com/document/product/215/15808)获取。
        :rtype: str
        """
        return self._SecurityGroup

    @SecurityGroup.setter
    def SecurityGroup(self, SecurityGroup):
        self._SecurityGroup = SecurityGroup

    @property
    def MasterZone(self):
        r"""主可用区ID，如 ："100001" （对应的是广州一区）。可通过[DescribeZones](https://cloud.tencent.com/document/product/213/15707)获取可用区列表。
        :rtype: str
        """
        return self._MasterZone

    @MasterZone.setter
    def MasterZone(self, MasterZone):
        self._MasterZone = MasterZone

    @property
    def Filters(self):
        r"""每次请求的`Filters`的上限为10，`Filter.Values`的上限为100。<br/>`Filter.Name`和`Filter.Values`皆为必填项。详细的过滤条件如下：
- charge-type
按照【实例计费模式】进行过滤。实例计费模式例如：PREPAID。
类型：String
必选：否
可选项：PREPAID(预付费)、POSTPAID_BY_HOUR(后付费)
- internet-charge-type
按照【网络计费模式】进行过滤。网络计费模式例如：BANDWIDTH_PREPAID。
类型：String
必选：否
可选项：BANDWIDTH_PREPAID(预付费按带宽结算)、 TRAFFIC_POSTPAID_BY_HOUR(流量按小时后付费)、BANDWIDTH_POSTPAID_BY_HOUR(带宽按小时后付费)、BANDWIDTH_PACKAGE(带宽包用户)
- master-zone-id
按照【CLB主可用区ID】进行过滤。例如：100001（对应的是广州一区）。
类型：String
必选：否
获取方式：[DescribeZones](https://cloud.tencent.com/document/product/213/15707)
- tag-key
按照【CLB 标签的键】进行过滤，例如：tag-key。
类型：String
必选：否
获取方式：[DescribeTags](https://cloud.tencent.com/document/api/651/35316)
- tag:tag-key
按照【CLB标签键值】进行过滤，例如：tag-test。
类型：String
必选：否
获取方式：[DescribeTagKeys](https://cloud.tencent.com/document/api/651/35318)
- function-name
按照【后端绑定SCF云函数的函数名称】进行过滤，例如：helloworld-1744958255。
类型：String
必选：否
获取方式：[ListFunctions](https://cloud.tencent.com/document/api/583/18582)
- vip-isp
按照【CLB VIP的运营商类型】进行过滤，例如：BGP。
类型：String
必选：否
公网类型可选项：BGP(多线)、CMCC(中国移动)、CTCC(中国电信)、CUCC(中国联通)
内网类型可选项：INTERNAL(内网)
- sla-type
按照【CLB 的性能容量型规格】进行过滤，例如：clb.c4.xlarge。
类型：String
必选：否
可选项：clb.c2.medium(标准型)、clb.c3.small(高阶型1)、clb.c3.medium(高阶型2)、clb.c4.small(超强型1)、clb.c4.medium(超强型2)、clb.c4.large(超强型3)、clb.c4.xlarge(超强型4)
具体规格参数参考：
- exclusive
按照【独占实例】进行过滤。例如：1，代表筛选独占型实例。
类型：String
必选：否
可选项：0、1
        :rtype: list of Filter
        """
        return self._Filters

    @Filters.setter
    def Filters(self, Filters):
        self._Filters = Filters

    @property
    def AdditionalFields(self):
        r"""选择返回的扩充字段，不指定时，扩充字段默认不返回。详细支持的扩充字段如下：
<li> TargetCount：绑定的后端服务数量</li>
        :rtype: list of str
        """
        return self._AdditionalFields

    @AdditionalFields.setter
    def AdditionalFields(self, AdditionalFields):
        self._AdditionalFields = AdditionalFields


    def _deserialize(self, params):
        self._LoadBalancerIds = params.get("LoadBalancerIds")
        self._LoadBalancerType = params.get("LoadBalancerType")
        self._Forward = params.get("Forward")
        self._LoadBalancerName = params.get("LoadBalancerName")
        self._Domain = params.get("Domain")
        self._LoadBalancerVips = params.get("LoadBalancerVips")
        self._BackendPublicIps = params.get("BackendPublicIps")
        self._BackendPrivateIps = params.get("BackendPrivateIps")
        self._Offset = params.get("Offset")
        self._Limit = params.get("Limit")
        self._OrderBy = params.get("OrderBy")
        self._OrderType = params.get("OrderType")
        self._SearchKey = params.get("SearchKey")
        self._ProjectId = params.get("ProjectId")
        self._WithRs = params.get("WithRs")
        self._VpcId = params.get("VpcId")
        self._SecurityGroup = params.get("SecurityGroup")
        self._MasterZone = params.get("MasterZone")
        if params.get("Filters") is not None:
            self._Filters = []
            for item in params.get("Filters"):
                obj = Filter()
                obj._deserialize(item)
                self._Filters.append(obj)
        self._AdditionalFields = params.get("AdditionalFields")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeLoadBalancersResponse(AbstractModel):
    r"""DescribeLoadBalancers返回参数结构体

    """

    def __init__(self):
        r"""
        :param _TotalCount: 满足过滤条件的负载均衡实例总数。此数值与入参中的Limit无关。
        :type TotalCount: int
        :param _LoadBalancerSet: 返回的负载均衡实例数组。
        :type LoadBalancerSet: list of LoadBalancer
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._TotalCount = None
        self._LoadBalancerSet = None
        self._RequestId = None

    @property
    def TotalCount(self):
        r"""满足过滤条件的负载均衡实例总数。此数值与入参中的Limit无关。
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def LoadBalancerSet(self):
        r"""返回的负载均衡实例数组。
        :rtype: list of LoadBalancer
        """
        return self._LoadBalancerSet

    @LoadBalancerSet.setter
    def LoadBalancerSet(self, LoadBalancerSet):
        self._LoadBalancerSet = LoadBalancerSet

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._TotalCount = params.get("TotalCount")
        if params.get("LoadBalancerSet") is not None:
            self._LoadBalancerSet = []
            for item in params.get("LoadBalancerSet"):
                obj = LoadBalancer()
                obj._deserialize(item)
                self._LoadBalancerSet.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeModelAliasesRequest(AbstractModel):
    r"""DescribeModelAliases请求参数结构体

    """

    def __init__(self):
        r"""
        :param _Filters: <p>过滤条件</p><p>支持的过滤键：</p><ul><li>ModelAliasName：按模型别名过滤。</li></ul>
        :type Filters: list of Filter
        :param _Limit: <p>每页数量，取值范围：[1, 100]，默认值：20。</p>
        :type Limit: int
        :param _Offset: <p>分页偏移量，默认值：0。</p>
        :type Offset: int
        :param _Sort: <p>排序条件。支持按 InputCoefficient、InputCachedCoefficient 或 OutputCoefficient 排序，Order 支持 ASC、DESC。不传或传空数组时，默认按 OutputCoefficient 降序排列。最多支持 3 个排序条件，排序字段不可重复。</p>
        :type Sort: list of Sort
        """
        self._Filters = None
        self._Limit = None
        self._Offset = None
        self._Sort = None

    @property
    def Filters(self):
        r"""<p>过滤条件</p><p>支持的过滤键：</p><ul><li>ModelAliasName：按模型别名过滤。</li></ul>
        :rtype: list of Filter
        """
        return self._Filters

    @Filters.setter
    def Filters(self, Filters):
        self._Filters = Filters

    @property
    def Limit(self):
        r"""<p>每页数量，取值范围：[1, 100]，默认值：20。</p>
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def Offset(self):
        r"""<p>分页偏移量，默认值：0。</p>
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset

    @property
    def Sort(self):
        r"""<p>排序条件。支持按 InputCoefficient、InputCachedCoefficient 或 OutputCoefficient 排序，Order 支持 ASC、DESC。不传或传空数组时，默认按 OutputCoefficient 降序排列。最多支持 3 个排序条件，排序字段不可重复。</p>
        :rtype: list of Sort
        """
        return self._Sort

    @Sort.setter
    def Sort(self, Sort):
        self._Sort = Sort


    def _deserialize(self, params):
        if params.get("Filters") is not None:
            self._Filters = []
            for item in params.get("Filters"):
                obj = Filter()
                obj._deserialize(item)
                self._Filters.append(obj)
        self._Limit = params.get("Limit")
        self._Offset = params.get("Offset")
        if params.get("Sort") is not None:
            self._Sort = []
            for item in params.get("Sort"):
                obj = Sort()
                obj._deserialize(item)
                self._Sort.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeModelAliasesResponse(AbstractModel):
    r"""DescribeModelAliases返回参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelAliasSet: <p>模型别名列表。</p>
        :type ModelAliasSet: list of ModelAlias
        :param _TotalCount: <p>符合条件的总数。</p>
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._ModelAliasSet = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def ModelAliasSet(self):
        r"""<p>模型别名列表。</p>
        :rtype: list of ModelAlias
        """
        return self._ModelAliasSet

    @ModelAliasSet.setter
    def ModelAliasSet(self, ModelAliasSet):
        self._ModelAliasSet = ModelAliasSet

    @property
    def TotalCount(self):
        r"""<p>符合条件的总数。</p>
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("ModelAliasSet") is not None:
            self._ModelAliasSet = []
            for item in params.get("ModelAliasSet"):
                obj = ModelAlias()
                obj._deserialize(item)
                self._ModelAliasSet.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeModelAssociationsRequest(AbstractModel):
    r"""DescribeModelAssociations请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID</p>
        :type ModelRouterId: str
        :param _Limit: <p>翻页限制</p><p>取值范围：[1, 100]</p><p>默认值：20</p>
        :type Limit: int
        :param _Offset: <p>翻页偏移量</p><p>默认值：0</p>
        :type Offset: int
        """
        self._ModelRouterId = None
        self._Limit = None
        self._Offset = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def Limit(self):
        r"""<p>翻页限制</p><p>取值范围：[1, 100]</p><p>默认值：20</p>
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def Offset(self):
        r"""<p>翻页偏移量</p><p>默认值：0</p>
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._Limit = params.get("Limit")
        self._Offset = params.get("Offset")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeModelAssociationsResponse(AbstractModel):
    r"""DescribeModelAssociations返回参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelAssociationSet: <p>模型路由实例与模型的关联关系集合</p>
        :type ModelAssociationSet: list of ModelAssociation
        :param _ModelRouterId: <p>模型路由实例ID</p>
        :type ModelRouterId: str
        :param _TotalCount: <p>符合条件的总数</p>
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._ModelAssociationSet = None
        self._ModelRouterId = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def ModelAssociationSet(self):
        r"""<p>模型路由实例与模型的关联关系集合</p>
        :rtype: list of ModelAssociation
        """
        return self._ModelAssociationSet

    @ModelAssociationSet.setter
    def ModelAssociationSet(self, ModelAssociationSet):
        self._ModelAssociationSet = ModelAssociationSet

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def TotalCount(self):
        r"""<p>符合条件的总数</p>
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("ModelAssociationSet") is not None:
            self._ModelAssociationSet = []
            for item in params.get("ModelAssociationSet"):
                obj = ModelAssociation()
                obj._deserialize(item)
                self._ModelAssociationSet.append(obj)
        self._ModelRouterId = params.get("ModelRouterId")
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeModelKeysRequest(AbstractModel):
    r"""DescribeModelKeys请求参数结构体

    """

    def __init__(self):
        r"""
        :param _AccessType: <p>接入类型过滤：PublicBYOK/PublicCustom/PrivateCustom</p>
        :type AccessType: str
        :param _Filters: <p>过滤条件</p>
        :type Filters: list of Filter
        :param _Limit: <p>返回数量限制</p>
        :type Limit: int
        :param _Offset: <p>翻页启始索引</p>
        :type Offset: int
        :param _ServiceProviderIds: <p>服务提供商ID</p>
        :type ServiceProviderIds: list of str
        """
        self._AccessType = None
        self._Filters = None
        self._Limit = None
        self._Offset = None
        self._ServiceProviderIds = None

    @property
    def AccessType(self):
        r"""<p>接入类型过滤：PublicBYOK/PublicCustom/PrivateCustom</p>
        :rtype: str
        """
        return self._AccessType

    @AccessType.setter
    def AccessType(self, AccessType):
        self._AccessType = AccessType

    @property
    def Filters(self):
        r"""<p>过滤条件</p>
        :rtype: list of Filter
        """
        return self._Filters

    @Filters.setter
    def Filters(self, Filters):
        self._Filters = Filters

    @property
    def Limit(self):
        r"""<p>返回数量限制</p>
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def Offset(self):
        r"""<p>翻页启始索引</p>
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset

    @property
    def ServiceProviderIds(self):
        r"""<p>服务提供商ID</p>
        :rtype: list of str
        """
        return self._ServiceProviderIds

    @ServiceProviderIds.setter
    def ServiceProviderIds(self, ServiceProviderIds):
        self._ServiceProviderIds = ServiceProviderIds


    def _deserialize(self, params):
        self._AccessType = params.get("AccessType")
        if params.get("Filters") is not None:
            self._Filters = []
            for item in params.get("Filters"):
                obj = Filter()
                obj._deserialize(item)
                self._Filters.append(obj)
        self._Limit = params.get("Limit")
        self._Offset = params.get("Offset")
        self._ServiceProviderIds = params.get("ServiceProviderIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeModelKeysResponse(AbstractModel):
    r"""DescribeModelKeys返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Models: <p>模型列表（含 Key 信息）</p>
        :type Models: list of ModelKeyInfoItem
        :param _TotalCount: <p>模型总数</p>
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Models = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def Models(self):
        r"""<p>模型列表（含 Key 信息）</p>
        :rtype: list of ModelKeyInfoItem
        """
        return self._Models

    @Models.setter
    def Models(self, Models):
        self._Models = Models

    @property
    def TotalCount(self):
        r"""<p>模型总数</p>
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("Models") is not None:
            self._Models = []
            for item in params.get("Models"):
                obj = ModelKeyInfoItem()
                obj._deserialize(item)
                self._Models.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeModelNamesRequest(AbstractModel):
    r"""DescribeModelNames请求参数结构体

    """

    def __init__(self):
        r"""
        :param _Offset: <p>分页偏移量（&gt;=0）</p>
        :type Offset: int
        :param _Limit: <p>每页数量（1-100）</p>
        :type Limit: int
        :param _VpcId: <p>过滤PrivateCustom类型自建模型。如果传递了此参数，则只返回具有相同VPC Id的模型。</p>
        :type VpcId: str
        :param _Filters: <p>过滤器，Name取值：</p><ul><li>ModelName：按照模型名称过滤。</li><li>ServiceProviderId：按照BYOK ID过滤。</li><li>InputModalitiesUnion：按照模态过滤。</li></ul>
        :type Filters: list of Filter
        """
        self._Offset = None
        self._Limit = None
        self._VpcId = None
        self._Filters = None

    @property
    def Offset(self):
        r"""<p>分页偏移量（&gt;=0）</p>
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset

    @property
    def Limit(self):
        r"""<p>每页数量（1-100）</p>
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def VpcId(self):
        r"""<p>过滤PrivateCustom类型自建模型。如果传递了此参数，则只返回具有相同VPC Id的模型。</p>
        :rtype: str
        """
        return self._VpcId

    @VpcId.setter
    def VpcId(self, VpcId):
        self._VpcId = VpcId

    @property
    def Filters(self):
        r"""<p>过滤器，Name取值：</p><ul><li>ModelName：按照模型名称过滤。</li><li>ServiceProviderId：按照BYOK ID过滤。</li><li>InputModalitiesUnion：按照模态过滤。</li></ul>
        :rtype: list of Filter
        """
        return self._Filters

    @Filters.setter
    def Filters(self, Filters):
        self._Filters = Filters


    def _deserialize(self, params):
        self._Offset = params.get("Offset")
        self._Limit = params.get("Limit")
        self._VpcId = params.get("VpcId")
        if params.get("Filters") is not None:
            self._Filters = []
            for item in params.get("Filters"):
                obj = Filter()
                obj._deserialize(item)
                self._Filters.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeModelNamesResponse(AbstractModel):
    r"""DescribeModelNames返回参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelNames: <p>模型标识聚合列表</p>
        :type ModelNames: list of ModelNameAggregatedItem
        :param _TotalCount: <p>聚合后的模型标识总数</p>
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._ModelNames = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def ModelNames(self):
        r"""<p>模型标识聚合列表</p>
        :rtype: list of ModelNameAggregatedItem
        """
        return self._ModelNames

    @ModelNames.setter
    def ModelNames(self, ModelNames):
        self._ModelNames = ModelNames

    @property
    def TotalCount(self):
        r"""<p>聚合后的模型标识总数</p>
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("ModelNames") is not None:
            self._ModelNames = []
            for item in params.get("ModelNames"):
                obj = ModelNameAggregatedItem()
                obj._deserialize(item)
                self._ModelNames.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeModelRewriteRequest(AbstractModel):
    r"""DescribeModelRewrite请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例 ID。</p>
        :type ModelRouterId: str
        :param _SourceModel: <p>选填，按源模型名精确过滤（大小写敏感）。</p><p>长度 1-255 字符；不传则返回该实例的全部重写规则；命中至多 1 条；未命中返回空列表（不报错）。</p>
        :type SourceModel: str
        """
        self._ModelRouterId = None
        self._SourceModel = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例 ID。</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def SourceModel(self):
        r"""<p>选填，按源模型名精确过滤（大小写敏感）。</p><p>长度 1-255 字符；不传则返回该实例的全部重写规则；命中至多 1 条；未命中返回空列表（不报错）。</p>
        :rtype: str
        """
        return self._SourceModel

    @SourceModel.setter
    def SourceModel(self, SourceModel):
        self._SourceModel = SourceModel


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._SourceModel = params.get("SourceModel")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeModelRewriteResponse(AbstractModel):
    r"""DescribeModelRewrite返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Rewrites: <p>重写规则列表，按 SourceModel 字典序排序。无规则或过滤未命中时为空数组。</p>
        :type Rewrites: list of RewriteItem
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Rewrites = None
        self._RequestId = None

    @property
    def Rewrites(self):
        r"""<p>重写规则列表，按 SourceModel 字典序排序。无规则或过滤未命中时为空数组。</p>
        :rtype: list of RewriteItem
        """
        return self._Rewrites

    @Rewrites.setter
    def Rewrites(self, Rewrites):
        self._Rewrites = Rewrites

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("Rewrites") is not None:
            self._Rewrites = []
            for item in params.get("Rewrites"):
                obj = RewriteItem()
                obj._deserialize(item)
                self._Rewrites.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeModelRouterDetailRequest(AbstractModel):
    r"""DescribeModelRouterDetail请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID</p>
        :type ModelRouterId: str
        """
        self._ModelRouterId = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeModelRouterDetailResponse(AbstractModel):
    r"""DescribeModelRouterDetail返回参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouter: <p>模型路由实例详情</p>
        :type ModelRouter: :class:`tencentcloud.clb.v20180317.models.ModelRouterDetail`
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._ModelRouter = None
        self._RequestId = None

    @property
    def ModelRouter(self):
        r"""<p>模型路由实例详情</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.ModelRouterDetail`
        """
        return self._ModelRouter

    @ModelRouter.setter
    def ModelRouter(self, ModelRouter):
        self._ModelRouter = ModelRouter

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("ModelRouter") is not None:
            self._ModelRouter = ModelRouterDetail()
            self._ModelRouter._deserialize(params.get("ModelRouter"))
        self._RequestId = params.get("RequestId")


class DescribeModelRouterGuardrailsRequest(AbstractModel):
    r"""DescribeModelRouterGuardrails请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例 ID。</p>
        :type ModelRouterId: str
        """
        self._ModelRouterId = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例 ID。</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeModelRouterGuardrailsResponse(AbstractModel):
    r"""DescribeModelRouterGuardrails返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Guardrails: <p>当前已关联的 Guardrail 防护配置列表。</p><p>当前最多返回 1 个元素。</p>
        :type Guardrails: list of GuardrailConfig
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Guardrails = None
        self._RequestId = None

    @property
    def Guardrails(self):
        r"""<p>当前已关联的 Guardrail 防护配置列表。</p><p>当前最多返回 1 个元素。</p>
        :rtype: list of GuardrailConfig
        """
        return self._Guardrails

    @Guardrails.setter
    def Guardrails(self, Guardrails):
        self._Guardrails = Guardrails

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("Guardrails") is not None:
            self._Guardrails = []
            for item in params.get("Guardrails"):
                obj = GuardrailConfig()
                obj._deserialize(item)
                self._Guardrails.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeModelRouterLogsRequest(AbstractModel):
    r"""DescribeModelRouterLogs请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID</p>
        :type ModelRouterId: str
        :param _KeyId: <p>Key的ID</p>
        :type KeyId: str
        :param _Model: <p>模型名称</p>
        :type Model: str
        :param _Status: <p>请求状态</p>
        :type Status: str
        :param _StartTime: <p>开始时间，与EndTime需要同时传入、开始时间不得早于24小时前，默认仅查询近5分钟日志</p>
        :type StartTime: str
        :param _EndTime: <p>结束时间，与StartTime需要同时传入、开始时间不得早于24小时前，默认仅查询近5分钟日志</p>
        :type EndTime: str
        :param _NextToken: <p>游标NextToken</p>
        :type NextToken: str
        :param _MaxResults: <p>本次查询最大数量</p><p>取值范围：[1, 100]</p><p>默认值：20</p>
        :type MaxResults: int
        """
        self._ModelRouterId = None
        self._KeyId = None
        self._Model = None
        self._Status = None
        self._StartTime = None
        self._EndTime = None
        self._NextToken = None
        self._MaxResults = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def KeyId(self):
        r"""<p>Key的ID</p>
        :rtype: str
        """
        return self._KeyId

    @KeyId.setter
    def KeyId(self, KeyId):
        self._KeyId = KeyId

    @property
    def Model(self):
        r"""<p>模型名称</p>
        :rtype: str
        """
        return self._Model

    @Model.setter
    def Model(self, Model):
        self._Model = Model

    @property
    def Status(self):
        r"""<p>请求状态</p>
        :rtype: str
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status

    @property
    def StartTime(self):
        r"""<p>开始时间，与EndTime需要同时传入、开始时间不得早于24小时前，默认仅查询近5分钟日志</p>
        :rtype: str
        """
        return self._StartTime

    @StartTime.setter
    def StartTime(self, StartTime):
        self._StartTime = StartTime

    @property
    def EndTime(self):
        r"""<p>结束时间，与StartTime需要同时传入、开始时间不得早于24小时前，默认仅查询近5分钟日志</p>
        :rtype: str
        """
        return self._EndTime

    @EndTime.setter
    def EndTime(self, EndTime):
        self._EndTime = EndTime

    @property
    def NextToken(self):
        r"""<p>游标NextToken</p>
        :rtype: str
        """
        return self._NextToken

    @NextToken.setter
    def NextToken(self, NextToken):
        self._NextToken = NextToken

    @property
    def MaxResults(self):
        r"""<p>本次查询最大数量</p><p>取值范围：[1, 100]</p><p>默认值：20</p>
        :rtype: int
        """
        return self._MaxResults

    @MaxResults.setter
    def MaxResults(self, MaxResults):
        self._MaxResults = MaxResults


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._KeyId = params.get("KeyId")
        self._Model = params.get("Model")
        self._Status = params.get("Status")
        self._StartTime = params.get("StartTime")
        self._EndTime = params.get("EndTime")
        self._NextToken = params.get("NextToken")
        self._MaxResults = params.get("MaxResults")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeModelRouterLogsResponse(AbstractModel):
    r"""DescribeModelRouterLogs返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Logs: <p>日志列表</p>
        :type Logs: list of ModelRouterLog
        :param _TotalCount: <p>满足条件的数量</p>
        :type TotalCount: int
        :param _NextToken: <p>游标NextToken</p>
        :type NextToken: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Logs = None
        self._TotalCount = None
        self._NextToken = None
        self._RequestId = None

    @property
    def Logs(self):
        r"""<p>日志列表</p>
        :rtype: list of ModelRouterLog
        """
        return self._Logs

    @Logs.setter
    def Logs(self, Logs):
        self._Logs = Logs

    @property
    def TotalCount(self):
        r"""<p>满足条件的数量</p>
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def NextToken(self):
        r"""<p>游标NextToken</p>
        :rtype: str
        """
        return self._NextToken

    @NextToken.setter
    def NextToken(self, NextToken):
        self._NextToken = NextToken

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("Logs") is not None:
            self._Logs = []
            for item in params.get("Logs"):
                obj = ModelRouterLog()
                obj._deserialize(item)
                self._Logs.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._NextToken = params.get("NextToken")
        self._RequestId = params.get("RequestId")


class DescribeModelRouterQuotaRequest(AbstractModel):
    r"""DescribeModelRouterQuota请求参数结构体

    """

    def __init__(self):
        r"""
        :param _QuotaTypes: <p>配额类型</p>
        :type QuotaTypes: list of str
        :param _ResourceIds: <p>要查询的资源ID</p>
        :type ResourceIds: list of str
        :param _DisplayFields: <p>需要展示的字段</p><p>枚举值：</p><ul><li>Used： 已使用的配额数量</li><li>Available： 剩余的配额数量</li></ul>
        :type DisplayFields: list of str
        """
        self._QuotaTypes = None
        self._ResourceIds = None
        self._DisplayFields = None

    @property
    def QuotaTypes(self):
        r"""<p>配额类型</p>
        :rtype: list of str
        """
        return self._QuotaTypes

    @QuotaTypes.setter
    def QuotaTypes(self, QuotaTypes):
        self._QuotaTypes = QuotaTypes

    @property
    def ResourceIds(self):
        r"""<p>要查询的资源ID</p>
        :rtype: list of str
        """
        return self._ResourceIds

    @ResourceIds.setter
    def ResourceIds(self, ResourceIds):
        self._ResourceIds = ResourceIds

    @property
    def DisplayFields(self):
        r"""<p>需要展示的字段</p><p>枚举值：</p><ul><li>Used： 已使用的配额数量</li><li>Available： 剩余的配额数量</li></ul>
        :rtype: list of str
        """
        return self._DisplayFields

    @DisplayFields.setter
    def DisplayFields(self, DisplayFields):
        self._DisplayFields = DisplayFields


    def _deserialize(self, params):
        self._QuotaTypes = params.get("QuotaTypes")
        self._ResourceIds = params.get("ResourceIds")
        self._DisplayFields = params.get("DisplayFields")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeModelRouterQuotaResponse(AbstractModel):
    r"""DescribeModelRouterQuota返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Quotas: <p>配额信息</p>
        :type Quotas: list of ModelRouterQuota
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Quotas = None
        self._RequestId = None

    @property
    def Quotas(self):
        r"""<p>配额信息</p>
        :rtype: list of ModelRouterQuota
        """
        return self._Quotas

    @Quotas.setter
    def Quotas(self, Quotas):
        self._Quotas = Quotas

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("Quotas") is not None:
            self._Quotas = []
            for item in params.get("Quotas"):
                obj = ModelRouterQuota()
                obj._deserialize(item)
                self._Quotas.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeModelRouterResourcePackageDeductionRequest(AbstractModel):
    r"""DescribeModelRouterResourcePackageDeduction请求参数结构体

    """

    def __init__(self):
        r"""
        :param _DeductionTimeBegin: <p>抵扣起始时间</p>
        :type DeductionTimeBegin: str
        :param _DeductionTimeEnd: <p>抵扣截止时间</p>
        :type DeductionTimeEnd: str
        :param _ModelRouterResourcePackageId: <p>模型路由资源包Id</p>
        :type ModelRouterResourcePackageId: str
        :param _Limit: <p>返回的数量</p><p>取值范围：[0, 100]</p><p>默认值：20</p>
        :type Limit: int
        :param _Offset: <p>数据偏移量</p><p>默认值：0</p>
        :type Offset: int
        :param _SortBy: <p>排序方式：asc，desc</p>
        :type SortBy: str
        """
        self._DeductionTimeBegin = None
        self._DeductionTimeEnd = None
        self._ModelRouterResourcePackageId = None
        self._Limit = None
        self._Offset = None
        self._SortBy = None

    @property
    def DeductionTimeBegin(self):
        r"""<p>抵扣起始时间</p>
        :rtype: str
        """
        return self._DeductionTimeBegin

    @DeductionTimeBegin.setter
    def DeductionTimeBegin(self, DeductionTimeBegin):
        self._DeductionTimeBegin = DeductionTimeBegin

    @property
    def DeductionTimeEnd(self):
        r"""<p>抵扣截止时间</p>
        :rtype: str
        """
        return self._DeductionTimeEnd

    @DeductionTimeEnd.setter
    def DeductionTimeEnd(self, DeductionTimeEnd):
        self._DeductionTimeEnd = DeductionTimeEnd

    @property
    def ModelRouterResourcePackageId(self):
        r"""<p>模型路由资源包Id</p>
        :rtype: str
        """
        return self._ModelRouterResourcePackageId

    @ModelRouterResourcePackageId.setter
    def ModelRouterResourcePackageId(self, ModelRouterResourcePackageId):
        self._ModelRouterResourcePackageId = ModelRouterResourcePackageId

    @property
    def Limit(self):
        r"""<p>返回的数量</p><p>取值范围：[0, 100]</p><p>默认值：20</p>
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def Offset(self):
        r"""<p>数据偏移量</p><p>默认值：0</p>
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset

    @property
    def SortBy(self):
        r"""<p>排序方式：asc，desc</p>
        :rtype: str
        """
        return self._SortBy

    @SortBy.setter
    def SortBy(self, SortBy):
        self._SortBy = SortBy


    def _deserialize(self, params):
        self._DeductionTimeBegin = params.get("DeductionTimeBegin")
        self._DeductionTimeEnd = params.get("DeductionTimeEnd")
        self._ModelRouterResourcePackageId = params.get("ModelRouterResourcePackageId")
        self._Limit = params.get("Limit")
        self._Offset = params.get("Offset")
        self._SortBy = params.get("SortBy")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeModelRouterResourcePackageDeductionResponse(AbstractModel):
    r"""DescribeModelRouterResourcePackageDeduction返回参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterResourcePackageDeductionSet: <p>模型路由资源包抵扣信息</p>
        :type ModelRouterResourcePackageDeductionSet: list of ModelRouterResourcePackageDeduction
        :param _TotalCount: <p>符合查询条件的详情信息总数</p>
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._ModelRouterResourcePackageDeductionSet = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def ModelRouterResourcePackageDeductionSet(self):
        r"""<p>模型路由资源包抵扣信息</p>
        :rtype: list of ModelRouterResourcePackageDeduction
        """
        return self._ModelRouterResourcePackageDeductionSet

    @ModelRouterResourcePackageDeductionSet.setter
    def ModelRouterResourcePackageDeductionSet(self, ModelRouterResourcePackageDeductionSet):
        self._ModelRouterResourcePackageDeductionSet = ModelRouterResourcePackageDeductionSet

    @property
    def TotalCount(self):
        r"""<p>符合查询条件的详情信息总数</p>
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("ModelRouterResourcePackageDeductionSet") is not None:
            self._ModelRouterResourcePackageDeductionSet = []
            for item in params.get("ModelRouterResourcePackageDeductionSet"):
                obj = ModelRouterResourcePackageDeduction()
                obj._deserialize(item)
                self._ModelRouterResourcePackageDeductionSet.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeModelRouterResourcePackagesRequest(AbstractModel):
    r"""DescribeModelRouterResourcePackages请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterResourcePackageIds: <p>模型路由资源包Id。</p>
        :type ModelRouterResourcePackageIds: list of str
        :param _Offset: <p>数据偏移量。</p><p>默认值：0</p>
        :type Offset: int
        :param _Limit: <p>返回的数量，最大值为100。</p><p>取值范围：[1, 100]</p><p>默认值：20</p>
        :type Limit: int
        :param _OrderBy: <p>排序参数，支持以下字段：&quot;buyTime&quot;, &quot;startTime&quot;, &quot;endTime&quot;</p>
        :type OrderBy: str
        :param _SortBy: <p>排序方式：asc，desc，默认asc</p>
        :type SortBy: str
        :param _Filters: <p>查询的过滤条件。</p><p>每次请求的Filters的上限为10，Filter.Values的上限为100。 Filter.Name和Filter.Values皆为必填项。详细的过滤条件如下： status - Integer - 是否必填：否 - 状态：0-有效 1-已退款 2-已过期 3-已用完。 effect_time_start - String - 是否必填：否 - 生效起始时间,YYYY-MM-DD HH:MM:SS格式。 effect_time_end - String - 是否必填：否 - 生效截止时间。 expire_time_start - String - 是否必填：否 - 失效起始时间。 expire_time_end - String - 是否必填：否 - 失效截止时间。</p>
        :type Filters: list of Filter
        """
        self._ModelRouterResourcePackageIds = None
        self._Offset = None
        self._Limit = None
        self._OrderBy = None
        self._SortBy = None
        self._Filters = None

    @property
    def ModelRouterResourcePackageIds(self):
        r"""<p>模型路由资源包Id。</p>
        :rtype: list of str
        """
        return self._ModelRouterResourcePackageIds

    @ModelRouterResourcePackageIds.setter
    def ModelRouterResourcePackageIds(self, ModelRouterResourcePackageIds):
        self._ModelRouterResourcePackageIds = ModelRouterResourcePackageIds

    @property
    def Offset(self):
        r"""<p>数据偏移量。</p><p>默认值：0</p>
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset

    @property
    def Limit(self):
        r"""<p>返回的数量，最大值为100。</p><p>取值范围：[1, 100]</p><p>默认值：20</p>
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def OrderBy(self):
        r"""<p>排序参数，支持以下字段：&quot;buyTime&quot;, &quot;startTime&quot;, &quot;endTime&quot;</p>
        :rtype: str
        """
        return self._OrderBy

    @OrderBy.setter
    def OrderBy(self, OrderBy):
        self._OrderBy = OrderBy

    @property
    def SortBy(self):
        r"""<p>排序方式：asc，desc，默认asc</p>
        :rtype: str
        """
        return self._SortBy

    @SortBy.setter
    def SortBy(self, SortBy):
        self._SortBy = SortBy

    @property
    def Filters(self):
        r"""<p>查询的过滤条件。</p><p>每次请求的Filters的上限为10，Filter.Values的上限为100。 Filter.Name和Filter.Values皆为必填项。详细的过滤条件如下： status - Integer - 是否必填：否 - 状态：0-有效 1-已退款 2-已过期 3-已用完。 effect_time_start - String - 是否必填：否 - 生效起始时间,YYYY-MM-DD HH:MM:SS格式。 effect_time_end - String - 是否必填：否 - 生效截止时间。 expire_time_start - String - 是否必填：否 - 失效起始时间。 expire_time_end - String - 是否必填：否 - 失效截止时间。</p>
        :rtype: list of Filter
        """
        return self._Filters

    @Filters.setter
    def Filters(self, Filters):
        self._Filters = Filters


    def _deserialize(self, params):
        self._ModelRouterResourcePackageIds = params.get("ModelRouterResourcePackageIds")
        self._Offset = params.get("Offset")
        self._Limit = params.get("Limit")
        self._OrderBy = params.get("OrderBy")
        self._SortBy = params.get("SortBy")
        if params.get("Filters") is not None:
            self._Filters = []
            for item in params.get("Filters"):
                obj = Filter()
                obj._deserialize(item)
                self._Filters.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeModelRouterResourcePackagesResponse(AbstractModel):
    r"""DescribeModelRouterResourcePackages返回参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterResourcePackageSet: <p>模型路由资源包信息</p>
        :type ModelRouterResourcePackageSet: list of ModelRouterPackage
        :param _TotalCount: <p>符合查询条件的模型路由资源包数量</p>
        :type TotalCount: int
        :param _TotalDosage: <p>资源包的剩余总量</p>
        :type TotalDosage: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._ModelRouterResourcePackageSet = None
        self._TotalCount = None
        self._TotalDosage = None
        self._RequestId = None

    @property
    def ModelRouterResourcePackageSet(self):
        r"""<p>模型路由资源包信息</p>
        :rtype: list of ModelRouterPackage
        """
        return self._ModelRouterResourcePackageSet

    @ModelRouterResourcePackageSet.setter
    def ModelRouterResourcePackageSet(self, ModelRouterResourcePackageSet):
        self._ModelRouterResourcePackageSet = ModelRouterResourcePackageSet

    @property
    def TotalCount(self):
        r"""<p>符合查询条件的模型路由资源包数量</p>
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def TotalDosage(self):
        r"""<p>资源包的剩余总量</p>
        :rtype: int
        """
        return self._TotalDosage

    @TotalDosage.setter
    def TotalDosage(self, TotalDosage):
        self._TotalDosage = TotalDosage

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("ModelRouterResourcePackageSet") is not None:
            self._ModelRouterResourcePackageSet = []
            for item in params.get("ModelRouterResourcePackageSet"):
                obj = ModelRouterPackage()
                obj._deserialize(item)
                self._ModelRouterResourcePackageSet.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._TotalDosage = params.get("TotalDosage")
        self._RequestId = params.get("RequestId")


class DescribeModelRoutersRequest(AbstractModel):
    r"""DescribeModelRouters请求参数结构体

    """

    def __init__(self):
        r"""
        :param _Filters: <p>过滤条件</p><p>支持：ModelRouterName、ModelRouterType、Status、BudgetId、tag-key、tag:&lt;tag-key&gt;。</p>
        :type Filters: list of Filter
        :param _Limit: <p>每页数量，1-100，默认 20</p>
        :type Limit: int
        :param _ModelRouterIds: <p>模型路由实例ID列表</p>
        :type ModelRouterIds: list of str
        :param _Offset: <p>分页偏移量，默认 0</p>
        :type Offset: int
        """
        self._Filters = None
        self._Limit = None
        self._ModelRouterIds = None
        self._Offset = None

    @property
    def Filters(self):
        r"""<p>过滤条件</p><p>支持：ModelRouterName、ModelRouterType、Status、BudgetId、tag-key、tag:&lt;tag-key&gt;。</p>
        :rtype: list of Filter
        """
        return self._Filters

    @Filters.setter
    def Filters(self, Filters):
        self._Filters = Filters

    @property
    def Limit(self):
        r"""<p>每页数量，1-100，默认 20</p>
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def ModelRouterIds(self):
        r"""<p>模型路由实例ID列表</p>
        :rtype: list of str
        """
        return self._ModelRouterIds

    @ModelRouterIds.setter
    def ModelRouterIds(self, ModelRouterIds):
        self._ModelRouterIds = ModelRouterIds

    @property
    def Offset(self):
        r"""<p>分页偏移量，默认 0</p>
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset


    def _deserialize(self, params):
        if params.get("Filters") is not None:
            self._Filters = []
            for item in params.get("Filters"):
                obj = Filter()
                obj._deserialize(item)
                self._Filters.append(obj)
        self._Limit = params.get("Limit")
        self._ModelRouterIds = params.get("ModelRouterIds")
        self._Offset = params.get("Offset")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeModelRoutersResponse(AbstractModel):
    r"""DescribeModelRouters返回参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterSet: <p>模型路由实例列表</p>
        :type ModelRouterSet: list of ModelRouterSet
        :param _TotalCount: <p>符合条件的总数</p>
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._ModelRouterSet = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def ModelRouterSet(self):
        r"""<p>模型路由实例列表</p>
        :rtype: list of ModelRouterSet
        """
        return self._ModelRouterSet

    @ModelRouterSet.setter
    def ModelRouterSet(self, ModelRouterSet):
        self._ModelRouterSet = ModelRouterSet

    @property
    def TotalCount(self):
        r"""<p>符合条件的总数</p>
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("ModelRouterSet") is not None:
            self._ModelRouterSet = []
            for item in params.get("ModelRouterSet"):
                obj = ModelRouterSet()
                obj._deserialize(item)
                self._ModelRouterSet.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeQuotaRequest(AbstractModel):
    r"""DescribeQuota请求参数结构体

    """


class DescribeQuotaResponse(AbstractModel):
    r"""DescribeQuota返回参数结构体

    """

    def __init__(self):
        r"""
        :param _QuotaSet: 配额列表
        :type QuotaSet: list of Quota
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._QuotaSet = None
        self._RequestId = None

    @property
    def QuotaSet(self):
        r"""配额列表
        :rtype: list of Quota
        """
        return self._QuotaSet

    @QuotaSet.setter
    def QuotaSet(self, QuotaSet):
        self._QuotaSet = QuotaSet

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("QuotaSet") is not None:
            self._QuotaSet = []
            for item in params.get("QuotaSet"):
                obj = Quota()
                obj._deserialize(item)
                self._QuotaSet.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeResourcesRequest(AbstractModel):
    r"""DescribeResources请求参数结构体

    """

    def __init__(self):
        r"""
        :param _Limit: 返回可用区资源列表数目，默认20，最大值100。
        :type Limit: int
        :param _Offset: 返回可用区资源列表起始偏移量，默认0。
        :type Offset: int
        :param _Filters: 查询可用区资源列表条件，详细的过滤条件如下：
- master-zone
按照【地域可用区】进行过滤，例如：ap-guangzhou-2。
类型：String
必选：否
- ip-version
按照【IP 类型】进行过滤，例如：IPv4。
类型：String
必选：否
可选项：IPv4、IPv6、IPv6_Nat
- isp
按照【ISP 类型】进行过滤，例如：BGP。
类型：String
必选：否
可选项：BGP、CMCC（中国移动）、CUCC（中国联通）、CTCC（中国电信）、BGP_PRO、INTERNAL（内网）
        :type Filters: list of Filter
        """
        self._Limit = None
        self._Offset = None
        self._Filters = None

    @property
    def Limit(self):
        r"""返回可用区资源列表数目，默认20，最大值100。
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def Offset(self):
        r"""返回可用区资源列表起始偏移量，默认0。
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset

    @property
    def Filters(self):
        r"""查询可用区资源列表条件，详细的过滤条件如下：
- master-zone
按照【地域可用区】进行过滤，例如：ap-guangzhou-2。
类型：String
必选：否
- ip-version
按照【IP 类型】进行过滤，例如：IPv4。
类型：String
必选：否
可选项：IPv4、IPv6、IPv6_Nat
- isp
按照【ISP 类型】进行过滤，例如：BGP。
类型：String
必选：否
可选项：BGP、CMCC（中国移动）、CUCC（中国联通）、CTCC（中国电信）、BGP_PRO、INTERNAL（内网）
        :rtype: list of Filter
        """
        return self._Filters

    @Filters.setter
    def Filters(self, Filters):
        self._Filters = Filters


    def _deserialize(self, params):
        self._Limit = params.get("Limit")
        self._Offset = params.get("Offset")
        if params.get("Filters") is not None:
            self._Filters = []
            for item in params.get("Filters"):
                obj = Filter()
                obj._deserialize(item)
                self._Filters.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeResourcesResponse(AbstractModel):
    r"""DescribeResources返回参数结构体

    """

    def __init__(self):
        r"""
        :param _ZoneResourceSet: 可用区支持的资源列表。
        :type ZoneResourceSet: list of ZoneResource
        :param _TotalCount: 可用区资源列表数目。
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._ZoneResourceSet = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def ZoneResourceSet(self):
        r"""可用区支持的资源列表。
        :rtype: list of ZoneResource
        """
        return self._ZoneResourceSet

    @ZoneResourceSet.setter
    def ZoneResourceSet(self, ZoneResourceSet):
        self._ZoneResourceSet = ZoneResourceSet

    @property
    def TotalCount(self):
        r"""可用区资源列表数目。
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("ZoneResourceSet") is not None:
            self._ZoneResourceSet = []
            for item in params.get("ZoneResourceSet"):
                obj = ZoneResource()
                obj._deserialize(item)
                self._ZoneResourceSet.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeRewriteRequest(AbstractModel):
    r"""DescribeRewrite请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例ID。
        :type LoadBalancerId: str
        :param _SourceListenerIds: 负载均衡监听器ID数组。
        :type SourceListenerIds: list of str
        :param _SourceLocationIds: 负载均衡转发规则的ID数组。
        :type SourceLocationIds: list of str
        """
        self._LoadBalancerId = None
        self._SourceListenerIds = None
        self._SourceLocationIds = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def SourceListenerIds(self):
        r"""负载均衡监听器ID数组。
        :rtype: list of str
        """
        return self._SourceListenerIds

    @SourceListenerIds.setter
    def SourceListenerIds(self, SourceListenerIds):
        self._SourceListenerIds = SourceListenerIds

    @property
    def SourceLocationIds(self):
        r"""负载均衡转发规则的ID数组。
        :rtype: list of str
        """
        return self._SourceLocationIds

    @SourceLocationIds.setter
    def SourceLocationIds(self, SourceLocationIds):
        self._SourceLocationIds = SourceLocationIds


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._SourceListenerIds = params.get("SourceListenerIds")
        self._SourceLocationIds = params.get("SourceLocationIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeRewriteResponse(AbstractModel):
    r"""DescribeRewrite返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RewriteSet: 重定向转发规则构成的数组，若无重定向规则，则返回空数组。
        :type RewriteSet: list of RuleOutput
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RewriteSet = None
        self._RequestId = None

    @property
    def RewriteSet(self):
        r"""重定向转发规则构成的数组，若无重定向规则，则返回空数组。
        :rtype: list of RuleOutput
        """
        return self._RewriteSet

    @RewriteSet.setter
    def RewriteSet(self, RewriteSet):
        self._RewriteSet = RewriteSet

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("RewriteSet") is not None:
            self._RewriteSet = []
            for item in params.get("RewriteSet"):
                obj = RuleOutput()
                obj._deserialize(item)
                self._RewriteSet.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeServiceProviderHealthStatusRequest(AbstractModel):
    r"""DescribeServiceProviderHealthStatus请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ServiceProviderId: <p>BYOK的ID</p>
        :type ServiceProviderId: str
        :param _Limit: <p>本次查询的限制数量</p><p>取值范围：[1, 100]</p><p>默认值：20</p>
        :type Limit: int
        :param _Offset: <p>本次查询翻页的偏移量</p>
        :type Offset: int
        """
        self._ServiceProviderId = None
        self._Limit = None
        self._Offset = None

    @property
    def ServiceProviderId(self):
        r"""<p>BYOK的ID</p>
        :rtype: str
        """
        return self._ServiceProviderId

    @ServiceProviderId.setter
    def ServiceProviderId(self, ServiceProviderId):
        self._ServiceProviderId = ServiceProviderId

    @property
    def Limit(self):
        r"""<p>本次查询的限制数量</p><p>取值范围：[1, 100]</p><p>默认值：20</p>
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def Offset(self):
        r"""<p>本次查询翻页的偏移量</p>
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset


    def _deserialize(self, params):
        self._ServiceProviderId = params.get("ServiceProviderId")
        self._Limit = params.get("Limit")
        self._Offset = params.get("Offset")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeServiceProviderHealthStatusResponse(AbstractModel):
    r"""DescribeServiceProviderHealthStatus返回参数结构体

    """

    def __init__(self):
        r"""
        :param _HealthCheckResults: <p>健康检查的结果</p>
        :type HealthCheckResults: list of ModelHealthCheckResults
        :param _TotalCount: <p>本次请求总数</p>
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._HealthCheckResults = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def HealthCheckResults(self):
        r"""<p>健康检查的结果</p>
        :rtype: list of ModelHealthCheckResults
        """
        return self._HealthCheckResults

    @HealthCheckResults.setter
    def HealthCheckResults(self, HealthCheckResults):
        self._HealthCheckResults = HealthCheckResults

    @property
    def TotalCount(self):
        r"""<p>本次请求总数</p>
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("HealthCheckResults") is not None:
            self._HealthCheckResults = []
            for item in params.get("HealthCheckResults"):
                obj = ModelHealthCheckResults()
                obj._deserialize(item)
                self._HealthCheckResults.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeSupportedProvidersRequest(AbstractModel):
    r"""DescribeSupportedProviders请求参数结构体

    """


class DescribeSupportedProvidersResponse(AbstractModel):
    r"""DescribeSupportedProviders返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Providers: <p>Provider 列表</p>
        :type Providers: list of ProviderItem
        :param _TotalCount: <p>Provider 总数</p>
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Providers = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def Providers(self):
        r"""<p>Provider 列表</p>
        :rtype: list of ProviderItem
        """
        return self._Providers

    @Providers.setter
    def Providers(self, Providers):
        self._Providers = Providers

    @property
    def TotalCount(self):
        r"""<p>Provider 总数</p>
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("Providers") is not None:
            self._Providers = []
            for item in params.get("Providers"):
                obj = ProviderItem()
                obj._deserialize(item)
                self._Providers.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DescribeTargetGroupInstanceStatusRequest(AbstractModel):
    r"""DescribeTargetGroupInstanceStatus请求参数结构体

    """

    def __init__(self):
        r"""
        :param _TargetGroupId: 目标组唯一id
        :type TargetGroupId: str
        :param _TargetGroupInstanceIps: 目标组绑定的后端服务ip列表
        :type TargetGroupInstanceIps: list of str
        """
        self._TargetGroupId = None
        self._TargetGroupInstanceIps = None

    @property
    def TargetGroupId(self):
        r"""目标组唯一id
        :rtype: str
        """
        return self._TargetGroupId

    @TargetGroupId.setter
    def TargetGroupId(self, TargetGroupId):
        self._TargetGroupId = TargetGroupId

    @property
    def TargetGroupInstanceIps(self):
        r"""目标组绑定的后端服务ip列表
        :rtype: list of str
        """
        return self._TargetGroupInstanceIps

    @TargetGroupInstanceIps.setter
    def TargetGroupInstanceIps(self, TargetGroupInstanceIps):
        self._TargetGroupInstanceIps = TargetGroupInstanceIps


    def _deserialize(self, params):
        self._TargetGroupId = params.get("TargetGroupId")
        self._TargetGroupInstanceIps = params.get("TargetGroupInstanceIps")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeTargetGroupInstanceStatusResponse(AbstractModel):
    r"""DescribeTargetGroupInstanceStatus返回参数结构体

    """

    def __init__(self):
        r"""
        :param _TargetGroupInstanceSet: 健康检查后端rs状态列表
        :type TargetGroupInstanceSet: list of TargetGroupInstanceStatus
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._TargetGroupInstanceSet = None
        self._RequestId = None

    @property
    def TargetGroupInstanceSet(self):
        r"""健康检查后端rs状态列表
        :rtype: list of TargetGroupInstanceStatus
        """
        return self._TargetGroupInstanceSet

    @TargetGroupInstanceSet.setter
    def TargetGroupInstanceSet(self, TargetGroupInstanceSet):
        self._TargetGroupInstanceSet = TargetGroupInstanceSet

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("TargetGroupInstanceSet") is not None:
            self._TargetGroupInstanceSet = []
            for item in params.get("TargetGroupInstanceSet"):
                obj = TargetGroupInstanceStatus()
                obj._deserialize(item)
                self._TargetGroupInstanceSet.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeTargetGroupInstancesRequest(AbstractModel):
    r"""DescribeTargetGroupInstances请求参数结构体

    """

    def __init__(self):
        r"""
        :param _Filters: 过滤条件，当前支持按照 TargetGroupId，BindIP，InstanceId 多个条件组合过滤。
        :type Filters: list of Filter
        :param _Limit: 显示数量限制，默认20。
        :type Limit: int
        :param _Offset: 显示的偏移量，默认为0。
        :type Offset: int
        """
        self._Filters = None
        self._Limit = None
        self._Offset = None

    @property
    def Filters(self):
        r"""过滤条件，当前支持按照 TargetGroupId，BindIP，InstanceId 多个条件组合过滤。
        :rtype: list of Filter
        """
        return self._Filters

    @Filters.setter
    def Filters(self, Filters):
        self._Filters = Filters

    @property
    def Limit(self):
        r"""显示数量限制，默认20。
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def Offset(self):
        r"""显示的偏移量，默认为0。
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset


    def _deserialize(self, params):
        if params.get("Filters") is not None:
            self._Filters = []
            for item in params.get("Filters"):
                obj = Filter()
                obj._deserialize(item)
                self._Filters.append(obj)
        self._Limit = params.get("Limit")
        self._Offset = params.get("Offset")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeTargetGroupInstancesResponse(AbstractModel):
    r"""DescribeTargetGroupInstances返回参数结构体

    """

    def __init__(self):
        r"""
        :param _TotalCount: 本次查询的结果数量。
        :type TotalCount: int
        :param _TargetGroupInstanceSet: 绑定的服务器信息。
        :type TargetGroupInstanceSet: list of TargetGroupBackend
        :param _RealCount: 实际统计数量，不受Limit、Offset、CAM的影响。
        :type RealCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._TotalCount = None
        self._TargetGroupInstanceSet = None
        self._RealCount = None
        self._RequestId = None

    @property
    def TotalCount(self):
        r"""本次查询的结果数量。
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def TargetGroupInstanceSet(self):
        r"""绑定的服务器信息。
        :rtype: list of TargetGroupBackend
        """
        return self._TargetGroupInstanceSet

    @TargetGroupInstanceSet.setter
    def TargetGroupInstanceSet(self, TargetGroupInstanceSet):
        self._TargetGroupInstanceSet = TargetGroupInstanceSet

    @property
    def RealCount(self):
        r"""实际统计数量，不受Limit、Offset、CAM的影响。
        :rtype: int
        """
        return self._RealCount

    @RealCount.setter
    def RealCount(self, RealCount):
        self._RealCount = RealCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._TotalCount = params.get("TotalCount")
        if params.get("TargetGroupInstanceSet") is not None:
            self._TargetGroupInstanceSet = []
            for item in params.get("TargetGroupInstanceSet"):
                obj = TargetGroupBackend()
                obj._deserialize(item)
                self._TargetGroupInstanceSet.append(obj)
        self._RealCount = params.get("RealCount")
        self._RequestId = params.get("RequestId")


class DescribeTargetGroupListRequest(AbstractModel):
    r"""DescribeTargetGroupList请求参数结构体

    """

    def __init__(self):
        r"""
        :param _TargetGroupIds: <p>目标组ID数组。</p>
        :type TargetGroupIds: list of str
        :param _Filters: <p>过滤条件数组，支持TargetGroupVpcId和TargetGroupName。与TargetGroupIds互斥，优先使用目标组ID。</p>
        :type Filters: list of Filter
        :param _Offset: <p>显示的偏移起始量。</p>
        :type Offset: int
        :param _Limit: <p>每页显示条目数。</p><p>取值范围：[0, 100]</p><p>默认值：20</p>
        :type Limit: int
        """
        self._TargetGroupIds = None
        self._Filters = None
        self._Offset = None
        self._Limit = None

    @property
    def TargetGroupIds(self):
        r"""<p>目标组ID数组。</p>
        :rtype: list of str
        """
        return self._TargetGroupIds

    @TargetGroupIds.setter
    def TargetGroupIds(self, TargetGroupIds):
        self._TargetGroupIds = TargetGroupIds

    @property
    def Filters(self):
        r"""<p>过滤条件数组，支持TargetGroupVpcId和TargetGroupName。与TargetGroupIds互斥，优先使用目标组ID。</p>
        :rtype: list of Filter
        """
        return self._Filters

    @Filters.setter
    def Filters(self, Filters):
        self._Filters = Filters

    @property
    def Offset(self):
        r"""<p>显示的偏移起始量。</p>
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset

    @property
    def Limit(self):
        r"""<p>每页显示条目数。</p><p>取值范围：[0, 100]</p><p>默认值：20</p>
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit


    def _deserialize(self, params):
        self._TargetGroupIds = params.get("TargetGroupIds")
        if params.get("Filters") is not None:
            self._Filters = []
            for item in params.get("Filters"):
                obj = Filter()
                obj._deserialize(item)
                self._Filters.append(obj)
        self._Offset = params.get("Offset")
        self._Limit = params.get("Limit")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeTargetGroupListResponse(AbstractModel):
    r"""DescribeTargetGroupList返回参数结构体

    """

    def __init__(self):
        r"""
        :param _TotalCount: <p>显示的结果数量。</p>
        :type TotalCount: int
        :param _TargetGroupSet: <p>显示的目标组信息集合。</p>
        :type TargetGroupSet: list of TargetGroupInfo
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._TotalCount = None
        self._TargetGroupSet = None
        self._RequestId = None

    @property
    def TotalCount(self):
        r"""<p>显示的结果数量。</p>
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def TargetGroupSet(self):
        r"""<p>显示的目标组信息集合。</p>
        :rtype: list of TargetGroupInfo
        """
        return self._TargetGroupSet

    @TargetGroupSet.setter
    def TargetGroupSet(self, TargetGroupSet):
        self._TargetGroupSet = TargetGroupSet

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._TotalCount = params.get("TotalCount")
        if params.get("TargetGroupSet") is not None:
            self._TargetGroupSet = []
            for item in params.get("TargetGroupSet"):
                obj = TargetGroupInfo()
                obj._deserialize(item)
                self._TargetGroupSet.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeTargetGroupsRequest(AbstractModel):
    r"""DescribeTargetGroups请求参数结构体

    """

    def __init__(self):
        r"""
        :param _TargetGroupIds: 目标组ID，与Filters互斥。
        :type TargetGroupIds: list of str
        :param _Limit: 显示条数限制，默认为20。
        :type Limit: int
        :param _Offset: 显示的偏移起始量。
        :type Offset: int
        :param _Filters: 过滤条件数组，与TargetGroupIds互斥，支持 TargetGroupVpcId（私有网络 ID）和 TargetGroupName（目标组名称）以及 Tag（标签）。
        :type Filters: list of Filter
        """
        self._TargetGroupIds = None
        self._Limit = None
        self._Offset = None
        self._Filters = None

    @property
    def TargetGroupIds(self):
        r"""目标组ID，与Filters互斥。
        :rtype: list of str
        """
        return self._TargetGroupIds

    @TargetGroupIds.setter
    def TargetGroupIds(self, TargetGroupIds):
        self._TargetGroupIds = TargetGroupIds

    @property
    def Limit(self):
        r"""显示条数限制，默认为20。
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def Offset(self):
        r"""显示的偏移起始量。
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset

    @property
    def Filters(self):
        r"""过滤条件数组，与TargetGroupIds互斥，支持 TargetGroupVpcId（私有网络 ID）和 TargetGroupName（目标组名称）以及 Tag（标签）。
        :rtype: list of Filter
        """
        return self._Filters

    @Filters.setter
    def Filters(self, Filters):
        self._Filters = Filters


    def _deserialize(self, params):
        self._TargetGroupIds = params.get("TargetGroupIds")
        self._Limit = params.get("Limit")
        self._Offset = params.get("Offset")
        if params.get("Filters") is not None:
            self._Filters = []
            for item in params.get("Filters"):
                obj = Filter()
                obj._deserialize(item)
                self._Filters.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeTargetGroupsResponse(AbstractModel):
    r"""DescribeTargetGroups返回参数结构体

    """

    def __init__(self):
        r"""
        :param _TotalCount: 显示的结果数量。
        :type TotalCount: int
        :param _TargetGroupSet: 显示的目标组信息集合。
        :type TargetGroupSet: list of TargetGroupInfo
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._TotalCount = None
        self._TargetGroupSet = None
        self._RequestId = None

    @property
    def TotalCount(self):
        r"""显示的结果数量。
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def TargetGroupSet(self):
        r"""显示的目标组信息集合。
        :rtype: list of TargetGroupInfo
        """
        return self._TargetGroupSet

    @TargetGroupSet.setter
    def TargetGroupSet(self, TargetGroupSet):
        self._TargetGroupSet = TargetGroupSet

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._TotalCount = params.get("TotalCount")
        if params.get("TargetGroupSet") is not None:
            self._TargetGroupSet = []
            for item in params.get("TargetGroupSet"):
                obj = TargetGroupInfo()
                obj._deserialize(item)
                self._TargetGroupSet.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeTargetHealthRequest(AbstractModel):
    r"""DescribeTargetHealth请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerIds: <p>要查询的负载均衡实例ID列表。数组大小最大支持30。</p>
        :type LoadBalancerIds: list of str
        :param _ListenerIds: <p>要查询的监听器ID列表。</p>
        :type ListenerIds: list of str
        :param _LocationIds: <p>要查询的转发规则ID列表。</p>
        :type LocationIds: list of str
        """
        self._LoadBalancerIds = None
        self._ListenerIds = None
        self._LocationIds = None

    @property
    def LoadBalancerIds(self):
        r"""<p>要查询的负载均衡实例ID列表。数组大小最大支持30。</p>
        :rtype: list of str
        """
        return self._LoadBalancerIds

    @LoadBalancerIds.setter
    def LoadBalancerIds(self, LoadBalancerIds):
        self._LoadBalancerIds = LoadBalancerIds

    @property
    def ListenerIds(self):
        r"""<p>要查询的监听器ID列表。</p>
        :rtype: list of str
        """
        return self._ListenerIds

    @ListenerIds.setter
    def ListenerIds(self, ListenerIds):
        self._ListenerIds = ListenerIds

    @property
    def LocationIds(self):
        r"""<p>要查询的转发规则ID列表。</p>
        :rtype: list of str
        """
        return self._LocationIds

    @LocationIds.setter
    def LocationIds(self, LocationIds):
        self._LocationIds = LocationIds


    def _deserialize(self, params):
        self._LoadBalancerIds = params.get("LoadBalancerIds")
        self._ListenerIds = params.get("ListenerIds")
        self._LocationIds = params.get("LocationIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeTargetHealthResponse(AbstractModel):
    r"""DescribeTargetHealth返回参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancers: <p>负载均衡实例列表。</p>
        :type LoadBalancers: list of LoadBalancerHealth
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._LoadBalancers = None
        self._RequestId = None

    @property
    def LoadBalancers(self):
        r"""<p>负载均衡实例列表。</p>
        :rtype: list of LoadBalancerHealth
        """
        return self._LoadBalancers

    @LoadBalancers.setter
    def LoadBalancers(self, LoadBalancers):
        self._LoadBalancers = LoadBalancers

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("LoadBalancers") is not None:
            self._LoadBalancers = []
            for item in params.get("LoadBalancers"):
                obj = LoadBalancerHealth()
                obj._deserialize(item)
                self._LoadBalancers.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeTargetsRequest(AbstractModel):
    r"""DescribeTargets请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例 ID。
        :type LoadBalancerId: str
        :param _ListenerIds: 监听器 ID 列表。ID 数量上限为20个。
        :type ListenerIds: list of str
        :param _Protocol: 监听器协议类型。
        :type Protocol: str
        :param _Port: 监听器端口。
        :type Port: int
        :param _Filters: 查询负载均衡绑定的后端服务列表，过滤条件如下：
<li> location-id - String - 是否必填：否 - （过滤条件）按照 规则ID 过滤，如："loc-12345678"。</li>
<li> private-ip-address - String - 是否必填：否 - （过滤条件）按照 后端服务内网IP 过滤，如："172.16.1.1"。</li>
<li> tag - String - 是否必填：否 - （过滤条件）按照 标签 过滤，如："tag-test"。</li>
        :type Filters: list of Filter
        """
        self._LoadBalancerId = None
        self._ListenerIds = None
        self._Protocol = None
        self._Port = None
        self._Filters = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例 ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerIds(self):
        r"""监听器 ID 列表。ID 数量上限为20个。
        :rtype: list of str
        """
        return self._ListenerIds

    @ListenerIds.setter
    def ListenerIds(self, ListenerIds):
        self._ListenerIds = ListenerIds

    @property
    def Protocol(self):
        r"""监听器协议类型。
        :rtype: str
        """
        return self._Protocol

    @Protocol.setter
    def Protocol(self, Protocol):
        self._Protocol = Protocol

    @property
    def Port(self):
        r"""监听器端口。
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def Filters(self):
        r"""查询负载均衡绑定的后端服务列表，过滤条件如下：
<li> location-id - String - 是否必填：否 - （过滤条件）按照 规则ID 过滤，如："loc-12345678"。</li>
<li> private-ip-address - String - 是否必填：否 - （过滤条件）按照 后端服务内网IP 过滤，如："172.16.1.1"。</li>
<li> tag - String - 是否必填：否 - （过滤条件）按照 标签 过滤，如："tag-test"。</li>
        :rtype: list of Filter
        """
        return self._Filters

    @Filters.setter
    def Filters(self, Filters):
        self._Filters = Filters


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerIds = params.get("ListenerIds")
        self._Protocol = params.get("Protocol")
        self._Port = params.get("Port")
        if params.get("Filters") is not None:
            self._Filters = []
            for item in params.get("Filters"):
                obj = Filter()
                obj._deserialize(item)
                self._Filters.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeTargetsResponse(AbstractModel):
    r"""DescribeTargets返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Listeners: 监听器后端绑定的机器信息。
        :type Listeners: list of ListenerBackend
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Listeners = None
        self._RequestId = None

    @property
    def Listeners(self):
        r"""监听器后端绑定的机器信息。
        :rtype: list of ListenerBackend
        """
        return self._Listeners

    @Listeners.setter
    def Listeners(self, Listeners):
        self._Listeners = Listeners

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("Listeners") is not None:
            self._Listeners = []
            for item in params.get("Listeners"):
                obj = ListenerBackend()
                obj._deserialize(item)
                self._Listeners.append(obj)
        self._RequestId = params.get("RequestId")


class DescribeTaskStatusRequest(AbstractModel):
    r"""DescribeTaskStatus请求参数结构体

    """

    def __init__(self):
        r"""
        :param _TaskId: 请求ID，即接口返回的 RequestId 参数。
        :type TaskId: str
        :param _DealName: 订单ID。
注意：参数TaskId和DealName必须传一个。
        :type DealName: str
        """
        self._TaskId = None
        self._DealName = None

    @property
    def TaskId(self):
        r"""请求ID，即接口返回的 RequestId 参数。
        :rtype: str
        """
        return self._TaskId

    @TaskId.setter
    def TaskId(self, TaskId):
        self._TaskId = TaskId

    @property
    def DealName(self):
        r"""订单ID。
注意：参数TaskId和DealName必须传一个。
        :rtype: str
        """
        return self._DealName

    @DealName.setter
    def DealName(self, DealName):
        self._DealName = DealName


    def _deserialize(self, params):
        self._TaskId = params.get("TaskId")
        self._DealName = params.get("DealName")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeTaskStatusResponse(AbstractModel):
    r"""DescribeTaskStatus返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Status: 任务的当前状态。 0：成功，1：失败，2：进行中。
        :type Status: int
        :param _LoadBalancerIds: 由负载均衡实例唯一 ID 组成的数组。
注意：此字段可能返回 null，表示取不到有效值。
        :type LoadBalancerIds: list of str
        :param _Message: 辅助描述信息，如失败原因等。
注意：此字段可能返回 null，表示取不到有效值。
        :type Message: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Status = None
        self._LoadBalancerIds = None
        self._Message = None
        self._RequestId = None

    @property
    def Status(self):
        r"""任务的当前状态。 0：成功，1：失败，2：进行中。
        :rtype: int
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status

    @property
    def LoadBalancerIds(self):
        r"""由负载均衡实例唯一 ID 组成的数组。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: list of str
        """
        return self._LoadBalancerIds

    @LoadBalancerIds.setter
    def LoadBalancerIds(self, LoadBalancerIds):
        self._LoadBalancerIds = LoadBalancerIds

    @property
    def Message(self):
        r"""辅助描述信息，如失败原因等。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Message

    @Message.setter
    def Message(self, Message):
        self._Message = Message

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._Status = params.get("Status")
        self._LoadBalancerIds = params.get("LoadBalancerIds")
        self._Message = params.get("Message")
        self._RequestId = params.get("RequestId")


class DescribeUpperModelsRequest(AbstractModel):
    r"""DescribeUpperModels请求参数结构体

    """

    def __init__(self):
        r"""
        :param _AccessType: <p>接入类型：PublicBYOK/PublicCustom/PrivateCustom</p>
        :type AccessType: str
        :param _ApiBase: <p>上游 Provider API 地址</p><p>示例：https://api.moonshot.cn</p>
        :type ApiBase: str
        :param _ApiKey: <p>上游 Provider API Key</p><p>用于鉴权访问上游模型列表接口</p>
        :type ApiKey: str
        :param _HostHeader: <p>自定义 Host Header，可选</p><p>仅 VPC 内网场景需要，用于指定请求的 Host 头</p>
        :type HostHeader: str
        :param _KeyId: <p>Key Id 配合ServiceProviderId一同输入，不指定则默认选用最近创建的Key</p>
        :type KeyId: str
        :param _ModelPath: <p>模型列表端点路径，可选</p><p>默认值：/v1/models</p>
        :type ModelPath: str
        :param _ModelProtocol: <p>模型协议</p>
        :type ModelProtocol: str
        :param _ModelProvider: <p>模型提供商</p>
        :type ModelProvider: str
        :param _ServiceProviderId: <p>BYOK 业务 ID，可选</p><p>格式：byok-xxxxxxxx</p>
        :type ServiceProviderId: str
        """
        self._AccessType = None
        self._ApiBase = None
        self._ApiKey = None
        self._HostHeader = None
        self._KeyId = None
        self._ModelPath = None
        self._ModelProtocol = None
        self._ModelProvider = None
        self._ServiceProviderId = None

    @property
    def AccessType(self):
        r"""<p>接入类型：PublicBYOK/PublicCustom/PrivateCustom</p>
        :rtype: str
        """
        return self._AccessType

    @AccessType.setter
    def AccessType(self, AccessType):
        self._AccessType = AccessType

    @property
    def ApiBase(self):
        r"""<p>上游 Provider API 地址</p><p>示例：https://api.moonshot.cn</p>
        :rtype: str
        """
        return self._ApiBase

    @ApiBase.setter
    def ApiBase(self, ApiBase):
        self._ApiBase = ApiBase

    @property
    def ApiKey(self):
        r"""<p>上游 Provider API Key</p><p>用于鉴权访问上游模型列表接口</p>
        :rtype: str
        """
        return self._ApiKey

    @ApiKey.setter
    def ApiKey(self, ApiKey):
        self._ApiKey = ApiKey

    @property
    def HostHeader(self):
        r"""<p>自定义 Host Header，可选</p><p>仅 VPC 内网场景需要，用于指定请求的 Host 头</p>
        :rtype: str
        """
        return self._HostHeader

    @HostHeader.setter
    def HostHeader(self, HostHeader):
        self._HostHeader = HostHeader

    @property
    def KeyId(self):
        r"""<p>Key Id 配合ServiceProviderId一同输入，不指定则默认选用最近创建的Key</p>
        :rtype: str
        """
        return self._KeyId

    @KeyId.setter
    def KeyId(self, KeyId):
        self._KeyId = KeyId

    @property
    def ModelPath(self):
        r"""<p>模型列表端点路径，可选</p><p>默认值：/v1/models</p>
        :rtype: str
        """
        return self._ModelPath

    @ModelPath.setter
    def ModelPath(self, ModelPath):
        self._ModelPath = ModelPath

    @property
    def ModelProtocol(self):
        r"""<p>模型协议</p>
        :rtype: str
        """
        return self._ModelProtocol

    @ModelProtocol.setter
    def ModelProtocol(self, ModelProtocol):
        self._ModelProtocol = ModelProtocol

    @property
    def ModelProvider(self):
        r"""<p>模型提供商</p>
        :rtype: str
        """
        return self._ModelProvider

    @ModelProvider.setter
    def ModelProvider(self, ModelProvider):
        self._ModelProvider = ModelProvider

    @property
    def ServiceProviderId(self):
        r"""<p>BYOK 业务 ID，可选</p><p>格式：byok-xxxxxxxx</p>
        :rtype: str
        """
        return self._ServiceProviderId

    @ServiceProviderId.setter
    def ServiceProviderId(self, ServiceProviderId):
        self._ServiceProviderId = ServiceProviderId


    def _deserialize(self, params):
        self._AccessType = params.get("AccessType")
        self._ApiBase = params.get("ApiBase")
        self._ApiKey = params.get("ApiKey")
        self._HostHeader = params.get("HostHeader")
        self._KeyId = params.get("KeyId")
        self._ModelPath = params.get("ModelPath")
        self._ModelProtocol = params.get("ModelProtocol")
        self._ModelProvider = params.get("ModelProvider")
        self._ServiceProviderId = params.get("ServiceProviderId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeUpperModelsResponse(AbstractModel):
    r"""DescribeUpperModels返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Models: <p>上游模型列表</p>
        :type Models: list of str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Models = None
        self._RequestId = None

    @property
    def Models(self):
        r"""<p>上游模型列表</p>
        :rtype: list of str
        """
        return self._Models

    @Models.setter
    def Models(self, Models):
        self._Models = Models

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._Models = params.get("Models")
        self._RequestId = params.get("RequestId")


class DescribeUserGroupsRequest(AbstractModel):
    r"""DescribeUserGroups请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID。</p>
        :type ModelRouterId: str
        :param _UserGroupIds: <p>用户组ID列表，用于按ID过滤，单次最多100个；可包含「未分组」虚拟分组 ugrp-ungrouped。</p>
        :type UserGroupIds: list of str
        :param _Filters: <p>过滤列表。支持：UserGroupName、Status、tag-key、tag:&lt;tag-key&gt;。</p>
        :type Filters: list of Filter
        :param _Limit: <p>本次查询限制的数量</p><p>取值范围：[1, 100]</p><p>默认值：20</p>
        :type Limit: int
        :param _Offset: <p>本次查询偏移量</p><p>默认值：0</p>
        :type Offset: int
        """
        self._ModelRouterId = None
        self._UserGroupIds = None
        self._Filters = None
        self._Limit = None
        self._Offset = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID。</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def UserGroupIds(self):
        r"""<p>用户组ID列表，用于按ID过滤，单次最多100个；可包含「未分组」虚拟分组 ugrp-ungrouped。</p>
        :rtype: list of str
        """
        return self._UserGroupIds

    @UserGroupIds.setter
    def UserGroupIds(self, UserGroupIds):
        self._UserGroupIds = UserGroupIds

    @property
    def Filters(self):
        r"""<p>过滤列表。支持：UserGroupName、Status、tag-key、tag:&lt;tag-key&gt;。</p>
        :rtype: list of Filter
        """
        return self._Filters

    @Filters.setter
    def Filters(self, Filters):
        self._Filters = Filters

    @property
    def Limit(self):
        r"""<p>本次查询限制的数量</p><p>取值范围：[1, 100]</p><p>默认值：20</p>
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def Offset(self):
        r"""<p>本次查询偏移量</p><p>默认值：0</p>
        :rtype: int
        """
        return self._Offset

    @Offset.setter
    def Offset(self, Offset):
        self._Offset = Offset


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._UserGroupIds = params.get("UserGroupIds")
        if params.get("Filters") is not None:
            self._Filters = []
            for item in params.get("Filters"):
                obj = Filter()
                obj._deserialize(item)
                self._Filters.append(obj)
        self._Limit = params.get("Limit")
        self._Offset = params.get("Offset")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DescribeUserGroupsResponse(AbstractModel):
    r"""DescribeUserGroups返回参数结构体

    """

    def __init__(self):
        r"""
        :param _UserGroups: <p>用户组列表。</p>
        :type UserGroups: list of UserGroupInfo
        :param _TotalCount: <p>符合条件的总数（含「未分组」逻辑组 ugrp-ungrouped：当其未被过滤条件排除时计入，即 TotalCount = 真实用户组数 + 1）。</p>
        :type TotalCount: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._UserGroups = None
        self._TotalCount = None
        self._RequestId = None

    @property
    def UserGroups(self):
        r"""<p>用户组列表。</p>
        :rtype: list of UserGroupInfo
        """
        return self._UserGroups

    @UserGroups.setter
    def UserGroups(self, UserGroups):
        self._UserGroups = UserGroups

    @property
    def TotalCount(self):
        r"""<p>符合条件的总数（含「未分组」逻辑组 ugrp-ungrouped：当其未被过滤条件排除时计入，即 TotalCount = 真实用户组数 + 1）。</p>
        :rtype: int
        """
        return self._TotalCount

    @TotalCount.setter
    def TotalCount(self, TotalCount):
        self._TotalCount = TotalCount

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("UserGroups") is not None:
            self._UserGroups = []
            for item in params.get("UserGroups"):
                obj = UserGroupInfo()
                obj._deserialize(item)
                self._UserGroups.append(obj)
        self._TotalCount = params.get("TotalCount")
        self._RequestId = params.get("RequestId")


class DisassociateBudgetRequest(AbstractModel):
    r"""DisassociateBudget请求参数结构体

    """

    def __init__(self):
        r"""
        :param _BudgetId: <p>Budget ID。</p>
        :type BudgetId: str
        :param _Resources: <p>要解除关联的资源列表。</p>
        :type Resources: list of BudgetResource
        """
        self._BudgetId = None
        self._Resources = None

    @property
    def BudgetId(self):
        r"""<p>Budget ID。</p>
        :rtype: str
        """
        return self._BudgetId

    @BudgetId.setter
    def BudgetId(self, BudgetId):
        self._BudgetId = BudgetId

    @property
    def Resources(self):
        r"""<p>要解除关联的资源列表。</p>
        :rtype: list of BudgetResource
        """
        return self._Resources

    @Resources.setter
    def Resources(self, Resources):
        self._Resources = Resources


    def _deserialize(self, params):
        self._BudgetId = params.get("BudgetId")
        if params.get("Resources") is not None:
            self._Resources = []
            for item in params.get("Resources"):
                obj = BudgetResource()
                obj._deserialize(item)
                self._Resources.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DisassociateBudgetResponse(AbstractModel):
    r"""DisassociateBudget返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DisassociateCustomizedConfigRequest(AbstractModel):
    r"""DisassociateCustomizedConfig请求参数结构体

    """

    def __init__(self):
        r"""
        :param _UconfigId: 配置ID
        :type UconfigId: str
        :param _BindList: 解绑的列表
        :type BindList: list of BindItem
        """
        self._UconfigId = None
        self._BindList = None

    @property
    def UconfigId(self):
        r"""配置ID
        :rtype: str
        """
        return self._UconfigId

    @UconfigId.setter
    def UconfigId(self, UconfigId):
        self._UconfigId = UconfigId

    @property
    def BindList(self):
        r"""解绑的列表
        :rtype: list of BindItem
        """
        return self._BindList

    @BindList.setter
    def BindList(self, BindList):
        self._BindList = BindList


    def _deserialize(self, params):
        self._UconfigId = params.get("UconfigId")
        if params.get("BindList") is not None:
            self._BindList = []
            for item in params.get("BindList"):
                obj = BindItem()
                obj._deserialize(item)
                self._BindList.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DisassociateCustomizedConfigResponse(AbstractModel):
    r"""DisassociateCustomizedConfig返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DisassociateGuardrailConfig(AbstractModel):
    r"""模型路由待解除关联 Guardrail 防护配置

    """

    def __init__(self):
        r"""
        :param _GuardrailId: <p>Guardrail 防护配置 ID。</p><p>可通过 DescribeModelRouterGuardrails 获取；DisassociateModelRouterGuardrails 使用该字段定位要解除关联的防护配置。</p>
        :type GuardrailId: str
        """
        self._GuardrailId = None

    @property
    def GuardrailId(self):
        r"""<p>Guardrail 防护配置 ID。</p><p>可通过 DescribeModelRouterGuardrails 获取；DisassociateModelRouterGuardrails 使用该字段定位要解除关联的防护配置。</p>
        :rtype: str
        """
        return self._GuardrailId

    @GuardrailId.setter
    def GuardrailId(self, GuardrailId):
        self._GuardrailId = GuardrailId


    def _deserialize(self, params):
        self._GuardrailId = params.get("GuardrailId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DisassociateModelRouterGuardrailsRequest(AbstractModel):
    r"""DisassociateModelRouterGuardrails请求参数结构体

    """

    def __init__(self):
        r"""
        :param _Guardrails: <p>待解除关联的 Guardrail 防护配置列表。</p><p>每个元素只需要填写 GuardrailId。</p>
        :type Guardrails: list of DisassociateGuardrailConfig
        :param _ModelRouterId: <p>模型路由实例 ID。</p>
        :type ModelRouterId: str
        """
        self._Guardrails = None
        self._ModelRouterId = None

    @property
    def Guardrails(self):
        r"""<p>待解除关联的 Guardrail 防护配置列表。</p><p>每个元素只需要填写 GuardrailId。</p>
        :rtype: list of DisassociateGuardrailConfig
        """
        return self._Guardrails

    @Guardrails.setter
    def Guardrails(self, Guardrails):
        self._Guardrails = Guardrails

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例 ID。</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId


    def _deserialize(self, params):
        if params.get("Guardrails") is not None:
            self._Guardrails = []
            for item in params.get("Guardrails"):
                obj = DisassociateGuardrailConfig()
                obj._deserialize(item)
                self._Guardrails.append(obj)
        self._ModelRouterId = params.get("ModelRouterId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DisassociateModelRouterGuardrailsResponse(AbstractModel):
    r"""DisassociateModelRouterGuardrails返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DisassociateModelsFromModelRouterRequest(AbstractModel):
    r"""DisassociateModelsFromModelRouter请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID</p>
        :type ModelRouterId: str
        :param _Models: <p>需要解除关联的模型信息</p>
        :type Models: list of ModelRouterModelToDisassociate
        """
        self._ModelRouterId = None
        self._Models = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def Models(self):
        r"""<p>需要解除关联的模型信息</p>
        :rtype: list of ModelRouterModelToDisassociate
        """
        return self._Models

    @Models.setter
    def Models(self, Models):
        self._Models = Models


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        if params.get("Models") is not None:
            self._Models = []
            for item in params.get("Models"):
                obj = ModelRouterModelToDisassociate()
                obj._deserialize(item)
                self._Models.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DisassociateModelsFromModelRouterResponse(AbstractModel):
    r"""DisassociateModelsFromModelRouter返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class DisassociateTargetGroupsRequest(AbstractModel):
    r"""DisassociateTargetGroups请求参数结构体

    """

    def __init__(self):
        r"""
        :param _Associations: 待解绑的规则关系数组，支持批量解绑多个监听器，单次批量解除最多20个。
        :type Associations: list of TargetGroupAssociation
        """
        self._Associations = None

    @property
    def Associations(self):
        r"""待解绑的规则关系数组，支持批量解绑多个监听器，单次批量解除最多20个。
        :rtype: list of TargetGroupAssociation
        """
        return self._Associations

    @Associations.setter
    def Associations(self, Associations):
        self._Associations = Associations


    def _deserialize(self, params):
        if params.get("Associations") is not None:
            self._Associations = []
            for item in params.get("Associations"):
                obj = TargetGroupAssociation()
                obj._deserialize(item)
                self._Associations.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class DisassociateTargetGroupsResponse(AbstractModel):
    r"""DisassociateTargetGroups返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ExclusiveCluster(AbstractModel):
    r"""独占集群

    """

    def __init__(self):
        r"""
        :param _L4Clusters: 4层独占集群列表
注意：此字段可能返回 null，表示取不到有效值。
        :type L4Clusters: list of ClusterItem
        :param _L7Clusters: 7层独占集群列表
注意：此字段可能返回 null，表示取不到有效值。
        :type L7Clusters: list of ClusterItem
        :param _ClassicalCluster: vpcgw集群
注意：此字段可能返回 null，表示取不到有效值。
        :type ClassicalCluster: :class:`tencentcloud.clb.v20180317.models.ClusterItem`
        """
        self._L4Clusters = None
        self._L7Clusters = None
        self._ClassicalCluster = None

    @property
    def L4Clusters(self):
        r"""4层独占集群列表
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: list of ClusterItem
        """
        return self._L4Clusters

    @L4Clusters.setter
    def L4Clusters(self, L4Clusters):
        self._L4Clusters = L4Clusters

    @property
    def L7Clusters(self):
        r"""7层独占集群列表
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: list of ClusterItem
        """
        return self._L7Clusters

    @L7Clusters.setter
    def L7Clusters(self, L7Clusters):
        self._L7Clusters = L7Clusters

    @property
    def ClassicalCluster(self):
        r"""vpcgw集群
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.ClusterItem`
        """
        return self._ClassicalCluster

    @ClassicalCluster.setter
    def ClassicalCluster(self, ClassicalCluster):
        self._ClassicalCluster = ClassicalCluster


    def _deserialize(self, params):
        if params.get("L4Clusters") is not None:
            self._L4Clusters = []
            for item in params.get("L4Clusters"):
                obj = ClusterItem()
                obj._deserialize(item)
                self._L4Clusters.append(obj)
        if params.get("L7Clusters") is not None:
            self._L7Clusters = []
            for item in params.get("L7Clusters"):
                obj = ClusterItem()
                obj._deserialize(item)
                self._L7Clusters.append(obj)
        if params.get("ClassicalCluster") is not None:
            self._ClassicalCluster = ClusterItem()
            self._ClassicalCluster._deserialize(params.get("ClassicalCluster"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ExtraInfo(AbstractModel):
    r"""暂做保留，一般用户无需关注。

    """

    def __init__(self):
        r"""
        :param _ZhiTong: 是否开通VIP直通
        :type ZhiTong: bool
        :param _TgwGroupName: TgwGroup名称
        :type TgwGroupName: str
        """
        self._ZhiTong = None
        self._TgwGroupName = None

    @property
    def ZhiTong(self):
        r"""是否开通VIP直通
        :rtype: bool
        """
        return self._ZhiTong

    @ZhiTong.setter
    def ZhiTong(self, ZhiTong):
        self._ZhiTong = ZhiTong

    @property
    def TgwGroupName(self):
        r"""TgwGroup名称
        :rtype: str
        """
        return self._TgwGroupName

    @TgwGroupName.setter
    def TgwGroupName(self, TgwGroupName):
        self._TgwGroupName = TgwGroupName


    def _deserialize(self, params):
        self._ZhiTong = params.get("ZhiTong")
        self._TgwGroupName = params.get("TgwGroupName")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class FallBackItem(AbstractModel):
    r"""路由FallBack配置

    """

    def __init__(self):
        r"""
        :param _DefaultFallBackModels: <p>默认回退模型列表</p>
        :type DefaultFallBackModels: list of str
        """
        self._DefaultFallBackModels = None

    @property
    def DefaultFallBackModels(self):
        r"""<p>默认回退模型列表</p>
        :rtype: list of str
        """
        return self._DefaultFallBackModels

    @DefaultFallBackModels.setter
    def DefaultFallBackModels(self, DefaultFallBackModels):
        self._DefaultFallBackModels = DefaultFallBackModels


    def _deserialize(self, params):
        self._DefaultFallBackModels = params.get("DefaultFallBackModels")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class Filter(AbstractModel):
    r"""过滤器条件

    """

    def __init__(self):
        r"""
        :param _Name: <p>过滤器的名称</p>
        :type Name: str
        :param _Values: <p>过滤器的值数组</p>
        :type Values: list of str
        """
        self._Name = None
        self._Values = None

    @property
    def Name(self):
        r"""<p>过滤器的名称</p>
        :rtype: str
        """
        return self._Name

    @Name.setter
    def Name(self, Name):
        self._Name = Name

    @property
    def Values(self):
        r"""<p>过滤器的值数组</p>
        :rtype: list of str
        """
        return self._Values

    @Values.setter
    def Values(self, Values):
        self._Values = Values


    def _deserialize(self, params):
        self._Name = params.get("Name")
        self._Values = params.get("Values")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class FunctionInfo(AbstractModel):
    r"""SCF云函数（Serverless Cloud Function）相关信息。

    """

    def __init__(self):
        r"""
        :param _FunctionNamespace: 函数命名空间
        :type FunctionNamespace: str
        :param _FunctionName: 函数名称
        :type FunctionName: str
        :param _FunctionQualifier: 函数的版本名称或别名
        :type FunctionQualifier: str
        :param _FunctionQualifierType: 标识 FunctionQualifier 参数的类型，可取值： VERSION（版本）、ALIAS（别名）
注意：此字段可能返回 null，表示取不到有效值。
        :type FunctionQualifierType: str
        """
        self._FunctionNamespace = None
        self._FunctionName = None
        self._FunctionQualifier = None
        self._FunctionQualifierType = None

    @property
    def FunctionNamespace(self):
        r"""函数命名空间
        :rtype: str
        """
        return self._FunctionNamespace

    @FunctionNamespace.setter
    def FunctionNamespace(self, FunctionNamespace):
        self._FunctionNamespace = FunctionNamespace

    @property
    def FunctionName(self):
        r"""函数名称
        :rtype: str
        """
        return self._FunctionName

    @FunctionName.setter
    def FunctionName(self, FunctionName):
        self._FunctionName = FunctionName

    @property
    def FunctionQualifier(self):
        r"""函数的版本名称或别名
        :rtype: str
        """
        return self._FunctionQualifier

    @FunctionQualifier.setter
    def FunctionQualifier(self, FunctionQualifier):
        self._FunctionQualifier = FunctionQualifier

    @property
    def FunctionQualifierType(self):
        r"""标识 FunctionQualifier 参数的类型，可取值： VERSION（版本）、ALIAS（别名）
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._FunctionQualifierType

    @FunctionQualifierType.setter
    def FunctionQualifierType(self, FunctionQualifierType):
        self._FunctionQualifierType = FunctionQualifierType


    def _deserialize(self, params):
        self._FunctionNamespace = params.get("FunctionNamespace")
        self._FunctionName = params.get("FunctionName")
        self._FunctionQualifier = params.get("FunctionQualifier")
        self._FunctionQualifierType = params.get("FunctionQualifierType")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class FunctionTarget(AbstractModel):
    r"""SCF云函数（Serverless Cloud Function）作为后端服务

    """

    def __init__(self):
        r"""
        :param _Function: 云函数相关信息
        :type Function: :class:`tencentcloud.clb.v20180317.models.FunctionInfo`
        :param _Weight: 权重
        :type Weight: int
        """
        self._Function = None
        self._Weight = None

    @property
    def Function(self):
        r"""云函数相关信息
        :rtype: :class:`tencentcloud.clb.v20180317.models.FunctionInfo`
        """
        return self._Function

    @Function.setter
    def Function(self, Function):
        self._Function = Function

    @property
    def Weight(self):
        r"""权重
        :rtype: int
        """
        return self._Weight

    @Weight.setter
    def Weight(self, Weight):
        self._Weight = Weight


    def _deserialize(self, params):
        if params.get("Function") is not None:
            self._Function = FunctionInfo()
            self._Function._deserialize(params.get("Function"))
        self._Weight = params.get("Weight")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class GuardrailConfig(AbstractModel):
    r"""模型路由 Guardrail 防护配置

    """

    def __init__(self):
        r"""
        :param _GuardrailId: <p>Guardrail 防护配置 ID。</p><p>DescribeModelRouterGuardrails 会返回该字段；DisassociateModelRouterGuardrails 和 ModifyModelRouterGuardrails 需要使用该字段定位要操作的防护配置。</p>
        :type GuardrailId: str
        :param _Type: <p>Guardrail 防护类型。</p><p>枚举值：</p><ul><li>WAF：使用腾讯云 WAF LLM SDK 接入配置对模型路由请求进行安全防护。</li></ul><p>当前仅支持 WAF；AssociateModelRouterGuardrails 不传时默认为 WAF，ModifyModelRouterGuardrails 不传时沿用当前已关联 Guardrail 的 Type。</p>
        :type Type: str
        :param _InstanceId: <p>关联的腾讯云 WAF 实例 ID。</p><p>ModifyModelRouterGuardrails 在 Type 为 WAF 时必填。DescribeModelRouterGuardrails 返回。接口会校验该 WAF 实例存在且属于当前账号。</p>
        :type InstanceId: str
        :param _ServiceId: <p>WAF LLM SDK 接入服务 ID。</p><p>该字段对应 WAF LLM SDK 接入配置中的服务标识，用于指定模型路由请求要绑定的 WAF 防护配置。ModifyModelRouterGuardrails 在 Type 为 WAF 时必填。DescribeModelRouterGuardrails 返回。接口会校验该服务配置存在于指定的 WAF 实例下。</p>
        :type ServiceId: str
        :param _InputCheckDepth: <p>最大检测对话轮数。</p><p>ModifyModelRouterGuardrails 选填；未传时沿用当前已关联 Guardrail 的 InputCheckDepth。DescribeModelRouterGuardrails 返回。若传入，取值必须为正整数。</p>
        :type InputCheckDepth: int
        """
        self._GuardrailId = None
        self._Type = None
        self._InstanceId = None
        self._ServiceId = None
        self._InputCheckDepth = None

    @property
    def GuardrailId(self):
        r"""<p>Guardrail 防护配置 ID。</p><p>DescribeModelRouterGuardrails 会返回该字段；DisassociateModelRouterGuardrails 和 ModifyModelRouterGuardrails 需要使用该字段定位要操作的防护配置。</p>
        :rtype: str
        """
        return self._GuardrailId

    @GuardrailId.setter
    def GuardrailId(self, GuardrailId):
        self._GuardrailId = GuardrailId

    @property
    def Type(self):
        r"""<p>Guardrail 防护类型。</p><p>枚举值：</p><ul><li>WAF：使用腾讯云 WAF LLM SDK 接入配置对模型路由请求进行安全防护。</li></ul><p>当前仅支持 WAF；AssociateModelRouterGuardrails 不传时默认为 WAF，ModifyModelRouterGuardrails 不传时沿用当前已关联 Guardrail 的 Type。</p>
        :rtype: str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type

    @property
    def InstanceId(self):
        r"""<p>关联的腾讯云 WAF 实例 ID。</p><p>ModifyModelRouterGuardrails 在 Type 为 WAF 时必填。DescribeModelRouterGuardrails 返回。接口会校验该 WAF 实例存在且属于当前账号。</p>
        :rtype: str
        """
        return self._InstanceId

    @InstanceId.setter
    def InstanceId(self, InstanceId):
        self._InstanceId = InstanceId

    @property
    def ServiceId(self):
        r"""<p>WAF LLM SDK 接入服务 ID。</p><p>该字段对应 WAF LLM SDK 接入配置中的服务标识，用于指定模型路由请求要绑定的 WAF 防护配置。ModifyModelRouterGuardrails 在 Type 为 WAF 时必填。DescribeModelRouterGuardrails 返回。接口会校验该服务配置存在于指定的 WAF 实例下。</p>
        :rtype: str
        """
        return self._ServiceId

    @ServiceId.setter
    def ServiceId(self, ServiceId):
        self._ServiceId = ServiceId

    @property
    def InputCheckDepth(self):
        r"""<p>最大检测对话轮数。</p><p>ModifyModelRouterGuardrails 选填；未传时沿用当前已关联 Guardrail 的 InputCheckDepth。DescribeModelRouterGuardrails 返回。若传入，取值必须为正整数。</p>
        :rtype: int
        """
        return self._InputCheckDepth

    @InputCheckDepth.setter
    def InputCheckDepth(self, InputCheckDepth):
        self._InputCheckDepth = InputCheckDepth


    def _deserialize(self, params):
        self._GuardrailId = params.get("GuardrailId")
        self._Type = params.get("Type")
        self._InstanceId = params.get("InstanceId")
        self._ServiceId = params.get("ServiceId")
        self._InputCheckDepth = params.get("InputCheckDepth")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class HealthCheck(AbstractModel):
    r"""健康检查信息。
    注意，自定义探测相关参数 目前只有少量区域灰度支持。

    """

    def __init__(self):
        r"""
        :param _HealthSwitch: 是否开启健康检查：1（开启）、0（关闭）。
默认为开启。
        :type HealthSwitch: int
        :param _TimeOut: 健康检查的响应超时时间，可选值：2~60，默认值：2，单位：秒。响应超时时间要小于检查间隔时间。
        :type TimeOut: int
        :param _IntervalTime: 健康检查探测间隔时间，默认值：5，IPv4 CLB实例的取值范围为：2-300，IPv6 CLB 实例的取值范围为：5-300。单位：秒。
说明：部分老旧 IPv4 CLB实例的取值范围为：5-300。
        :type IntervalTime: int
        :param _HealthNum: 健康阈值，默认值：3，表示当连续探测三次健康则表示该转发正常，可选值：2~10，单位：次。
        :type HealthNum: int
        :param _UnHealthNum: 不健康阈值，默认值：3，表示当连续探测三次不健康则表示该转发异常，可选值：2~10，单位：次。
        :type UnHealthNum: int
        :param _HttpCode: 健康检查状态码（仅适用于HTTP/HTTPS转发规则、TCP监听器的HTTP健康检查方式）。可选值：1~31，默认 31。
1 表示探测后返回值 1xx 代表健康，2 表示返回 2xx 代表健康，4 表示返回 3xx 代表健康，8 表示返回 4xx 代表健康，16 表示返回 5xx 代表健康。若希望多种返回码都可代表健康，则将相应的值相加。
注意：此字段可能返回 null，表示取不到有效值。
        :type HttpCode: int
        :param _HttpCheckPath: 健康检查路径（仅适用于HTTP/HTTPS转发规则、TCP监听器的HTTP健康检查方式）。
注意：此字段可能返回 null，表示取不到有效值。
        :type HttpCheckPath: str
        :param _HttpCheckDomain: 健康检查域名，将在HTTP协议 Host 头字段中携带。（仅适用于HTTP/HTTPS监听器和TCP监听器的HTTP健康检查方式。针对TCP监听器，当使用HTTP健康检查方式时，该参数为必填项）。
注意：此字段可能返回 null，表示取不到有效值。
        :type HttpCheckDomain: str
        :param _HttpCheckMethod: 健康检查方法（仅适用于HTTP/HTTPS转发规则、TCP监听器的HTTP健康检查方式），默认值：HEAD，可选值HEAD或GET。
注意：此字段可能返回 null，表示取不到有效值。
        :type HttpCheckMethod: str
        :param _CheckPort: 自定义探测相关参数。健康检查端口，默认为后端服务的端口，除非您希望指定特定端口，否则建议留空。传参数值-1可恢复默认设置。（仅适用于TCP/UDP监听器）。
注意：此字段可能返回 null，表示取不到有效值。
        :type CheckPort: int
        :param _ContextType: 自定义探测相关参数。健康检查协议CheckType的值取CUSTOM时，必填此字段，代表健康检查的输入格式，可取值：HEX或TEXT；取值为HEX时，SendContext和RecvContext的字符只能在0123456789ABCDEF中选取且长度必须是偶数位。（仅适用于TCP/UDP监听器）
注意：此字段可能返回 null，表示取不到有效值。
        :type ContextType: str
        :param _SendContext: 自定义探测相关参数。健康检查协议CheckType的值取CUSTOM时，必填此字段，代表健康检查发送的请求内容，只允许ASCII可见字符，最大长度限制500。（仅适用于TCP/UDP监听器）。
注意：此字段可能返回 null，表示取不到有效值。
        :type SendContext: str
        :param _RecvContext: 自定义探测相关参数。健康检查协议CheckType的值取CUSTOM时，必填此字段，代表健康检查返回的结果，只允许ASCII可见字符，最大长度限制500。（仅适用于TCP/UDP监听器）。
注意：此字段可能返回 null，表示取不到有效值。
        :type RecvContext: str
        :param _CheckType: 健康检查使用的协议。取值 TCP | HTTP | HTTPS | GRPC | PING | CUSTOM，UDP监听器支持PING/CUSTOM，TCP监听器支持TCP/HTTP/CUSTOM，TCP_SSL/QUIC监听器支持TCP/HTTP，HTTP规则支持HTTP/GRPC，HTTPS规则支持HTTP/HTTPS/GRPC。HTTP监听器默认值为HTTP;TCP、TCP_SSL、QUIC监听器默认值为TCP;UDP监听器默认为PING;HTTPS监听器的CheckType默认值与后端转发协议一致。
        :type CheckType: str
        :param _HttpVersion: HTTP版本。健康检查协议CheckType的值取HTTP时，必传此字段，代表后端服务的HTTP版本：HTTP/1.0、HTTP/1.1；（仅适用于TCP监听器）
注意：此字段可能返回 null，表示取不到有效值。
        :type HttpVersion: str
        :param _SourceIpType: 健康检查源IP类型：0（使用LB的VIP作为源IP），1（使用100.64网段IP作为源IP）。
        :type SourceIpType: int
        :param _ExtendedCode: GRPC健康检查状态码（仅适用于后端转发协议为GRPC的规则）。默认值为 12，可输入值为数值、多个数值、或者范围，例如 20 或 20,25 或 0-99
注意：此字段可能返回 null，表示取不到有效值。
        :type ExtendedCode: str
        """
        self._HealthSwitch = None
        self._TimeOut = None
        self._IntervalTime = None
        self._HealthNum = None
        self._UnHealthNum = None
        self._HttpCode = None
        self._HttpCheckPath = None
        self._HttpCheckDomain = None
        self._HttpCheckMethod = None
        self._CheckPort = None
        self._ContextType = None
        self._SendContext = None
        self._RecvContext = None
        self._CheckType = None
        self._HttpVersion = None
        self._SourceIpType = None
        self._ExtendedCode = None

    @property
    def HealthSwitch(self):
        r"""是否开启健康检查：1（开启）、0（关闭）。
默认为开启。
        :rtype: int
        """
        return self._HealthSwitch

    @HealthSwitch.setter
    def HealthSwitch(self, HealthSwitch):
        self._HealthSwitch = HealthSwitch

    @property
    def TimeOut(self):
        r"""健康检查的响应超时时间，可选值：2~60，默认值：2，单位：秒。响应超时时间要小于检查间隔时间。
        :rtype: int
        """
        return self._TimeOut

    @TimeOut.setter
    def TimeOut(self, TimeOut):
        self._TimeOut = TimeOut

    @property
    def IntervalTime(self):
        r"""健康检查探测间隔时间，默认值：5，IPv4 CLB实例的取值范围为：2-300，IPv6 CLB 实例的取值范围为：5-300。单位：秒。
说明：部分老旧 IPv4 CLB实例的取值范围为：5-300。
        :rtype: int
        """
        return self._IntervalTime

    @IntervalTime.setter
    def IntervalTime(self, IntervalTime):
        self._IntervalTime = IntervalTime

    @property
    def HealthNum(self):
        r"""健康阈值，默认值：3，表示当连续探测三次健康则表示该转发正常，可选值：2~10，单位：次。
        :rtype: int
        """
        return self._HealthNum

    @HealthNum.setter
    def HealthNum(self, HealthNum):
        self._HealthNum = HealthNum

    @property
    def UnHealthNum(self):
        r"""不健康阈值，默认值：3，表示当连续探测三次不健康则表示该转发异常，可选值：2~10，单位：次。
        :rtype: int
        """
        return self._UnHealthNum

    @UnHealthNum.setter
    def UnHealthNum(self, UnHealthNum):
        self._UnHealthNum = UnHealthNum

    @property
    def HttpCode(self):
        r"""健康检查状态码（仅适用于HTTP/HTTPS转发规则、TCP监听器的HTTP健康检查方式）。可选值：1~31，默认 31。
1 表示探测后返回值 1xx 代表健康，2 表示返回 2xx 代表健康，4 表示返回 3xx 代表健康，8 表示返回 4xx 代表健康，16 表示返回 5xx 代表健康。若希望多种返回码都可代表健康，则将相应的值相加。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._HttpCode

    @HttpCode.setter
    def HttpCode(self, HttpCode):
        self._HttpCode = HttpCode

    @property
    def HttpCheckPath(self):
        r"""健康检查路径（仅适用于HTTP/HTTPS转发规则、TCP监听器的HTTP健康检查方式）。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._HttpCheckPath

    @HttpCheckPath.setter
    def HttpCheckPath(self, HttpCheckPath):
        self._HttpCheckPath = HttpCheckPath

    @property
    def HttpCheckDomain(self):
        r"""健康检查域名，将在HTTP协议 Host 头字段中携带。（仅适用于HTTP/HTTPS监听器和TCP监听器的HTTP健康检查方式。针对TCP监听器，当使用HTTP健康检查方式时，该参数为必填项）。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._HttpCheckDomain

    @HttpCheckDomain.setter
    def HttpCheckDomain(self, HttpCheckDomain):
        self._HttpCheckDomain = HttpCheckDomain

    @property
    def HttpCheckMethod(self):
        r"""健康检查方法（仅适用于HTTP/HTTPS转发规则、TCP监听器的HTTP健康检查方式），默认值：HEAD，可选值HEAD或GET。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._HttpCheckMethod

    @HttpCheckMethod.setter
    def HttpCheckMethod(self, HttpCheckMethod):
        self._HttpCheckMethod = HttpCheckMethod

    @property
    def CheckPort(self):
        r"""自定义探测相关参数。健康检查端口，默认为后端服务的端口，除非您希望指定特定端口，否则建议留空。传参数值-1可恢复默认设置。（仅适用于TCP/UDP监听器）。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._CheckPort

    @CheckPort.setter
    def CheckPort(self, CheckPort):
        self._CheckPort = CheckPort

    @property
    def ContextType(self):
        r"""自定义探测相关参数。健康检查协议CheckType的值取CUSTOM时，必填此字段，代表健康检查的输入格式，可取值：HEX或TEXT；取值为HEX时，SendContext和RecvContext的字符只能在0123456789ABCDEF中选取且长度必须是偶数位。（仅适用于TCP/UDP监听器）
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ContextType

    @ContextType.setter
    def ContextType(self, ContextType):
        self._ContextType = ContextType

    @property
    def SendContext(self):
        r"""自定义探测相关参数。健康检查协议CheckType的值取CUSTOM时，必填此字段，代表健康检查发送的请求内容，只允许ASCII可见字符，最大长度限制500。（仅适用于TCP/UDP监听器）。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._SendContext

    @SendContext.setter
    def SendContext(self, SendContext):
        self._SendContext = SendContext

    @property
    def RecvContext(self):
        r"""自定义探测相关参数。健康检查协议CheckType的值取CUSTOM时，必填此字段，代表健康检查返回的结果，只允许ASCII可见字符，最大长度限制500。（仅适用于TCP/UDP监听器）。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._RecvContext

    @RecvContext.setter
    def RecvContext(self, RecvContext):
        self._RecvContext = RecvContext

    @property
    def CheckType(self):
        r"""健康检查使用的协议。取值 TCP | HTTP | HTTPS | GRPC | PING | CUSTOM，UDP监听器支持PING/CUSTOM，TCP监听器支持TCP/HTTP/CUSTOM，TCP_SSL/QUIC监听器支持TCP/HTTP，HTTP规则支持HTTP/GRPC，HTTPS规则支持HTTP/HTTPS/GRPC。HTTP监听器默认值为HTTP;TCP、TCP_SSL、QUIC监听器默认值为TCP;UDP监听器默认为PING;HTTPS监听器的CheckType默认值与后端转发协议一致。
        :rtype: str
        """
        return self._CheckType

    @CheckType.setter
    def CheckType(self, CheckType):
        self._CheckType = CheckType

    @property
    def HttpVersion(self):
        r"""HTTP版本。健康检查协议CheckType的值取HTTP时，必传此字段，代表后端服务的HTTP版本：HTTP/1.0、HTTP/1.1；（仅适用于TCP监听器）
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._HttpVersion

    @HttpVersion.setter
    def HttpVersion(self, HttpVersion):
        self._HttpVersion = HttpVersion

    @property
    def SourceIpType(self):
        r"""健康检查源IP类型：0（使用LB的VIP作为源IP），1（使用100.64网段IP作为源IP）。
        :rtype: int
        """
        return self._SourceIpType

    @SourceIpType.setter
    def SourceIpType(self, SourceIpType):
        self._SourceIpType = SourceIpType

    @property
    def ExtendedCode(self):
        r"""GRPC健康检查状态码（仅适用于后端转发协议为GRPC的规则）。默认值为 12，可输入值为数值、多个数值、或者范围，例如 20 或 20,25 或 0-99
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ExtendedCode

    @ExtendedCode.setter
    def ExtendedCode(self, ExtendedCode):
        self._ExtendedCode = ExtendedCode


    def _deserialize(self, params):
        self._HealthSwitch = params.get("HealthSwitch")
        self._TimeOut = params.get("TimeOut")
        self._IntervalTime = params.get("IntervalTime")
        self._HealthNum = params.get("HealthNum")
        self._UnHealthNum = params.get("UnHealthNum")
        self._HttpCode = params.get("HttpCode")
        self._HttpCheckPath = params.get("HttpCheckPath")
        self._HttpCheckDomain = params.get("HttpCheckDomain")
        self._HttpCheckMethod = params.get("HttpCheckMethod")
        self._CheckPort = params.get("CheckPort")
        self._ContextType = params.get("ContextType")
        self._SendContext = params.get("SendContext")
        self._RecvContext = params.get("RecvContext")
        self._CheckType = params.get("CheckType")
        self._HttpVersion = params.get("HttpVersion")
        self._SourceIpType = params.get("SourceIpType")
        self._ExtendedCode = params.get("ExtendedCode")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class IdleLoadBalancer(AbstractModel):
    r"""闲置实例。

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡ID
        :type LoadBalancerId: str
        :param _LoadBalancerName: 负载均衡名字
        :type LoadBalancerName: str
        :param _Region: 负载均衡所在地域
        :type Region: str
        :param _Vip: 负载均衡的vip
        :type Vip: str
        :param _IdleReason: 闲置原因。NO_RULES：没有规则，NO_RS：有规则没有绑定子机。
        :type IdleReason: str
        :param _Status: 负载均衡实例的状态，包括
0：创建中，1：正常运行。
        :type Status: int
        :param _Forward: 负载均衡类型标识，1：负载均衡，0：传统型负载均衡。
        :type Forward: int
        :param _Domain: 负载均衡域名
        :type Domain: str
        """
        self._LoadBalancerId = None
        self._LoadBalancerName = None
        self._Region = None
        self._Vip = None
        self._IdleReason = None
        self._Status = None
        self._Forward = None
        self._Domain = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡ID
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def LoadBalancerName(self):
        r"""负载均衡名字
        :rtype: str
        """
        return self._LoadBalancerName

    @LoadBalancerName.setter
    def LoadBalancerName(self, LoadBalancerName):
        self._LoadBalancerName = LoadBalancerName

    @property
    def Region(self):
        r"""负载均衡所在地域
        :rtype: str
        """
        return self._Region

    @Region.setter
    def Region(self, Region):
        self._Region = Region

    @property
    def Vip(self):
        r"""负载均衡的vip
        :rtype: str
        """
        return self._Vip

    @Vip.setter
    def Vip(self, Vip):
        self._Vip = Vip

    @property
    def IdleReason(self):
        r"""闲置原因。NO_RULES：没有规则，NO_RS：有规则没有绑定子机。
        :rtype: str
        """
        return self._IdleReason

    @IdleReason.setter
    def IdleReason(self, IdleReason):
        self._IdleReason = IdleReason

    @property
    def Status(self):
        r"""负载均衡实例的状态，包括
0：创建中，1：正常运行。
        :rtype: int
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status

    @property
    def Forward(self):
        r"""负载均衡类型标识，1：负载均衡，0：传统型负载均衡。
        :rtype: int
        """
        return self._Forward

    @Forward.setter
    def Forward(self, Forward):
        self._Forward = Forward

    @property
    def Domain(self):
        r"""负载均衡域名
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._LoadBalancerName = params.get("LoadBalancerName")
        self._Region = params.get("Region")
        self._Vip = params.get("Vip")
        self._IdleReason = params.get("IdleReason")
        self._Status = params.get("Status")
        self._Forward = params.get("Forward")
        self._Domain = params.get("Domain")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class InputKeyInfo(AbstractModel):
    r"""创建Key的信息

    """

    def __init__(self):
        r"""
        :param _KeyName: <p>Key的名称</p>
        :type KeyName: str
        :param _PlainKey: <p>导入的明文Key</p><p>仅允许导入Key模式下输入</p>
        :type PlainKey: str
        """
        self._KeyName = None
        self._PlainKey = None

    @property
    def KeyName(self):
        r"""<p>Key的名称</p>
        :rtype: str
        """
        return self._KeyName

    @KeyName.setter
    def KeyName(self, KeyName):
        self._KeyName = KeyName

    @property
    def PlainKey(self):
        r"""<p>导入的明文Key</p><p>仅允许导入Key模式下输入</p>
        :rtype: str
        """
        return self._PlainKey

    @PlainKey.setter
    def PlainKey(self, PlainKey):
        self._PlainKey = PlainKey


    def _deserialize(self, params):
        self._KeyName = params.get("KeyName")
        self._PlainKey = params.get("PlainKey")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class InquirePriceCreateModelRouterResourcePackageRequest(AbstractModel):
    r"""InquirePriceCreateModelRouterResourcePackage请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterResourcePackageAmount: <p>模型路由资源包容量</p><p>取值范围：[1000, 10000000]</p><p>单次购买的模型路由资源包容量下限为1000，上限为10000000</p>
        :type ModelRouterResourcePackageAmount: int
        """
        self._ModelRouterResourcePackageAmount = None

    @property
    def ModelRouterResourcePackageAmount(self):
        r"""<p>模型路由资源包容量</p><p>取值范围：[1000, 10000000]</p><p>单次购买的模型路由资源包容量下限为1000，上限为10000000</p>
        :rtype: int
        """
        return self._ModelRouterResourcePackageAmount

    @ModelRouterResourcePackageAmount.setter
    def ModelRouterResourcePackageAmount(self, ModelRouterResourcePackageAmount):
        self._ModelRouterResourcePackageAmount = ModelRouterResourcePackageAmount


    def _deserialize(self, params):
        self._ModelRouterResourcePackageAmount = params.get("ModelRouterResourcePackageAmount")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class InquirePriceCreateModelRouterResourcePackageResponse(AbstractModel):
    r"""InquirePriceCreateModelRouterResourcePackage返回参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterResourcePackagePrice: <p>模型路由资源包价格</p>
        :type ModelRouterResourcePackagePrice: :class:`tencentcloud.clb.v20180317.models.ItemPrice`
        :param _FirstBuy: <p>本次购买资源包是否可享受首购优惠</p><p>1:可享受首购优惠，0:不可享受首购优惠</p>
        :type FirstBuy: int
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._ModelRouterResourcePackagePrice = None
        self._FirstBuy = None
        self._RequestId = None

    @property
    def ModelRouterResourcePackagePrice(self):
        r"""<p>模型路由资源包价格</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.ItemPrice`
        """
        return self._ModelRouterResourcePackagePrice

    @ModelRouterResourcePackagePrice.setter
    def ModelRouterResourcePackagePrice(self, ModelRouterResourcePackagePrice):
        self._ModelRouterResourcePackagePrice = ModelRouterResourcePackagePrice

    @property
    def FirstBuy(self):
        r"""<p>本次购买资源包是否可享受首购优惠</p><p>1:可享受首购优惠，0:不可享受首购优惠</p>
        :rtype: int
        """
        return self._FirstBuy

    @FirstBuy.setter
    def FirstBuy(self, FirstBuy):
        self._FirstBuy = FirstBuy

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("ModelRouterResourcePackagePrice") is not None:
            self._ModelRouterResourcePackagePrice = ItemPrice()
            self._ModelRouterResourcePackagePrice._deserialize(params.get("ModelRouterResourcePackagePrice"))
        self._FirstBuy = params.get("FirstBuy")
        self._RequestId = params.get("RequestId")


class InquirePriceRefundModelRouterResourcePackageRequest(AbstractModel):
    r"""InquirePriceRefundModelRouterResourcePackage请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterResourcePackageIds: <p>待退款的模型路由资源包Id</p><p>非有效状态或者设置了自动续订且自动续订已生效的资源包不允许退款。</p>
        :type ModelRouterResourcePackageIds: list of str
        """
        self._ModelRouterResourcePackageIds = None

    @property
    def ModelRouterResourcePackageIds(self):
        r"""<p>待退款的模型路由资源包Id</p><p>非有效状态或者设置了自动续订且自动续订已生效的资源包不允许退款。</p>
        :rtype: list of str
        """
        return self._ModelRouterResourcePackageIds

    @ModelRouterResourcePackageIds.setter
    def ModelRouterResourcePackageIds(self, ModelRouterResourcePackageIds):
        self._ModelRouterResourcePackageIds = ModelRouterResourcePackageIds


    def _deserialize(self, params):
        self._ModelRouterResourcePackageIds = params.get("ModelRouterResourcePackageIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class InquirePriceRefundModelRouterResourcePackageResponse(AbstractModel):
    r"""InquirePriceRefundModelRouterResourcePackage返回参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterResourcePackageRefundPrice: <p>待退款的模型路由资源包可退价格</p>
        :type ModelRouterResourcePackageRefundPrice: list of ModelRouterResourcePackageRefundPrice
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._ModelRouterResourcePackageRefundPrice = None
        self._RequestId = None

    @property
    def ModelRouterResourcePackageRefundPrice(self):
        r"""<p>待退款的模型路由资源包可退价格</p>
        :rtype: list of ModelRouterResourcePackageRefundPrice
        """
        return self._ModelRouterResourcePackageRefundPrice

    @ModelRouterResourcePackageRefundPrice.setter
    def ModelRouterResourcePackageRefundPrice(self, ModelRouterResourcePackageRefundPrice):
        self._ModelRouterResourcePackageRefundPrice = ModelRouterResourcePackageRefundPrice

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("ModelRouterResourcePackageRefundPrice") is not None:
            self._ModelRouterResourcePackageRefundPrice = []
            for item in params.get("ModelRouterResourcePackageRefundPrice"):
                obj = ModelRouterResourcePackageRefundPrice()
                obj._deserialize(item)
                self._ModelRouterResourcePackageRefundPrice.append(obj)
        self._RequestId = params.get("RequestId")


class InquiryPriceCreateLoadBalancerRequest(AbstractModel):
    r"""InquiryPriceCreateLoadBalancer请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerType: 询价的负载均衡类型，OPEN为公网类型，INTERNAL为内网类型
        :type LoadBalancerType: str
        :param _LoadBalancerChargeType: 询价的收费类型，POSTPAID为按量计费，"PREPAID"为预付费包年包月
        :type LoadBalancerChargeType: str
        :param _LoadBalancerChargePrepaid: 询价的收费周期。（仅包年包月支持该参数）
        :type LoadBalancerChargePrepaid: :class:`tencentcloud.clb.v20180317.models.LBChargePrepaid`
        :param _InternetAccessible: 询价的网络计费方式
        :type InternetAccessible: :class:`tencentcloud.clb.v20180317.models.InternetAccessible`
        :param _GoodsNum: 询价的负载均衡实例个数，默认为1
        :type GoodsNum: int
        :param _ZoneId: 指定可用区询价。如：ap-guangzhou-1
        :type ZoneId: str
        :param _SlaType: 包年包月询价时传性能容量型规格，如：<li>clb.c2.medium（标准型）</li><li>clb.c3.small（高阶型1）</li><li>clb.c3.medium（高阶型2）</li>
<li>clb.c4.small（超强型1）</li><li>clb.c4.medium（超强型2）</li><li>clb.c4.large（超强型3）</li><li>clb.c4.xlarge（超强型4）</li>
按量付费询价时传SLA
        :type SlaType: str
        :param _AddressIPVersion: IP版本，可取值：IPV4、IPV6、IPv6FullChain，不区分大小写，默认值 IPV4。说明：取值为IPV6表示为IPV6 NAT64版本；取值为IPv6FullChain，表示为IPv6版本。
        :type AddressIPVersion: str
        :param _VipIsp: 仅适用于公网负载均衡。目前仅广州、上海、南京、济南、杭州、福州、北京、石家庄、武汉、长沙、成都、重庆地域支持静态单线 IP 线路类型，如需体验，请联系商务经理申请。申请通过后，即可选择中国移动（CMCC）、中国联通（CUCC）或中国电信（CTCC）的运营商类型，网络计费模式只能使用按带宽包计费(BANDWIDTH_PACKAGE)。 如果不指定本参数，则默认使用BGP。可通过 DescribeResources 接口查询一个地域所支持的Isp。
        :type VipIsp: str
        """
        self._LoadBalancerType = None
        self._LoadBalancerChargeType = None
        self._LoadBalancerChargePrepaid = None
        self._InternetAccessible = None
        self._GoodsNum = None
        self._ZoneId = None
        self._SlaType = None
        self._AddressIPVersion = None
        self._VipIsp = None

    @property
    def LoadBalancerType(self):
        r"""询价的负载均衡类型，OPEN为公网类型，INTERNAL为内网类型
        :rtype: str
        """
        return self._LoadBalancerType

    @LoadBalancerType.setter
    def LoadBalancerType(self, LoadBalancerType):
        self._LoadBalancerType = LoadBalancerType

    @property
    def LoadBalancerChargeType(self):
        r"""询价的收费类型，POSTPAID为按量计费，"PREPAID"为预付费包年包月
        :rtype: str
        """
        return self._LoadBalancerChargeType

    @LoadBalancerChargeType.setter
    def LoadBalancerChargeType(self, LoadBalancerChargeType):
        self._LoadBalancerChargeType = LoadBalancerChargeType

    @property
    def LoadBalancerChargePrepaid(self):
        r"""询价的收费周期。（仅包年包月支持该参数）
        :rtype: :class:`tencentcloud.clb.v20180317.models.LBChargePrepaid`
        """
        return self._LoadBalancerChargePrepaid

    @LoadBalancerChargePrepaid.setter
    def LoadBalancerChargePrepaid(self, LoadBalancerChargePrepaid):
        self._LoadBalancerChargePrepaid = LoadBalancerChargePrepaid

    @property
    def InternetAccessible(self):
        r"""询价的网络计费方式
        :rtype: :class:`tencentcloud.clb.v20180317.models.InternetAccessible`
        """
        return self._InternetAccessible

    @InternetAccessible.setter
    def InternetAccessible(self, InternetAccessible):
        self._InternetAccessible = InternetAccessible

    @property
    def GoodsNum(self):
        r"""询价的负载均衡实例个数，默认为1
        :rtype: int
        """
        return self._GoodsNum

    @GoodsNum.setter
    def GoodsNum(self, GoodsNum):
        self._GoodsNum = GoodsNum

    @property
    def ZoneId(self):
        r"""指定可用区询价。如：ap-guangzhou-1
        :rtype: str
        """
        return self._ZoneId

    @ZoneId.setter
    def ZoneId(self, ZoneId):
        self._ZoneId = ZoneId

    @property
    def SlaType(self):
        r"""包年包月询价时传性能容量型规格，如：<li>clb.c2.medium（标准型）</li><li>clb.c3.small（高阶型1）</li><li>clb.c3.medium（高阶型2）</li>
<li>clb.c4.small（超强型1）</li><li>clb.c4.medium（超强型2）</li><li>clb.c4.large（超强型3）</li><li>clb.c4.xlarge（超强型4）</li>
按量付费询价时传SLA
        :rtype: str
        """
        return self._SlaType

    @SlaType.setter
    def SlaType(self, SlaType):
        self._SlaType = SlaType

    @property
    def AddressIPVersion(self):
        r"""IP版本，可取值：IPV4、IPV6、IPv6FullChain，不区分大小写，默认值 IPV4。说明：取值为IPV6表示为IPV6 NAT64版本；取值为IPv6FullChain，表示为IPv6版本。
        :rtype: str
        """
        return self._AddressIPVersion

    @AddressIPVersion.setter
    def AddressIPVersion(self, AddressIPVersion):
        self._AddressIPVersion = AddressIPVersion

    @property
    def VipIsp(self):
        r"""仅适用于公网负载均衡。目前仅广州、上海、南京、济南、杭州、福州、北京、石家庄、武汉、长沙、成都、重庆地域支持静态单线 IP 线路类型，如需体验，请联系商务经理申请。申请通过后，即可选择中国移动（CMCC）、中国联通（CUCC）或中国电信（CTCC）的运营商类型，网络计费模式只能使用按带宽包计费(BANDWIDTH_PACKAGE)。 如果不指定本参数，则默认使用BGP。可通过 DescribeResources 接口查询一个地域所支持的Isp。
        :rtype: str
        """
        return self._VipIsp

    @VipIsp.setter
    def VipIsp(self, VipIsp):
        self._VipIsp = VipIsp


    def _deserialize(self, params):
        self._LoadBalancerType = params.get("LoadBalancerType")
        self._LoadBalancerChargeType = params.get("LoadBalancerChargeType")
        if params.get("LoadBalancerChargePrepaid") is not None:
            self._LoadBalancerChargePrepaid = LBChargePrepaid()
            self._LoadBalancerChargePrepaid._deserialize(params.get("LoadBalancerChargePrepaid"))
        if params.get("InternetAccessible") is not None:
            self._InternetAccessible = InternetAccessible()
            self._InternetAccessible._deserialize(params.get("InternetAccessible"))
        self._GoodsNum = params.get("GoodsNum")
        self._ZoneId = params.get("ZoneId")
        self._SlaType = params.get("SlaType")
        self._AddressIPVersion = params.get("AddressIPVersion")
        self._VipIsp = params.get("VipIsp")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class InquiryPriceCreateLoadBalancerResponse(AbstractModel):
    r"""InquiryPriceCreateLoadBalancer返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Price: 该参数表示对应的价格。
        :type Price: :class:`tencentcloud.clb.v20180317.models.Price`
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Price = None
        self._RequestId = None

    @property
    def Price(self):
        r"""该参数表示对应的价格。
        :rtype: :class:`tencentcloud.clb.v20180317.models.Price`
        """
        return self._Price

    @Price.setter
    def Price(self, Price):
        self._Price = Price

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("Price") is not None:
            self._Price = Price()
            self._Price._deserialize(params.get("Price"))
        self._RequestId = params.get("RequestId")


class InquiryPriceModifyLoadBalancerRequest(AbstractModel):
    r"""InquiryPriceModifyLoadBalancer请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例 ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
        :type LoadBalancerId: str
        :param _InternetAccessible: 修改后的网络带宽信息
        :type InternetAccessible: :class:`tencentcloud.clb.v20180317.models.InternetAccessible`
        """
        self._LoadBalancerId = None
        self._InternetAccessible = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例 ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def InternetAccessible(self):
        r"""修改后的网络带宽信息
        :rtype: :class:`tencentcloud.clb.v20180317.models.InternetAccessible`
        """
        return self._InternetAccessible

    @InternetAccessible.setter
    def InternetAccessible(self, InternetAccessible):
        self._InternetAccessible = InternetAccessible


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        if params.get("InternetAccessible") is not None:
            self._InternetAccessible = InternetAccessible()
            self._InternetAccessible._deserialize(params.get("InternetAccessible"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class InquiryPriceModifyLoadBalancerResponse(AbstractModel):
    r"""InquiryPriceModifyLoadBalancer返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Price: 描述价格信息
        :type Price: :class:`tencentcloud.clb.v20180317.models.Price`
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Price = None
        self._RequestId = None

    @property
    def Price(self):
        r"""描述价格信息
        :rtype: :class:`tencentcloud.clb.v20180317.models.Price`
        """
        return self._Price

    @Price.setter
    def Price(self, Price):
        self._Price = Price

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("Price") is not None:
            self._Price = Price()
            self._Price._deserialize(params.get("Price"))
        self._RequestId = params.get("RequestId")


class InquiryPriceRefundLoadBalancerRequest(AbstractModel):
    r"""InquiryPriceRefundLoadBalancer请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例ID。可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
        :type LoadBalancerId: str
        """
        self._LoadBalancerId = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例ID。可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class InquiryPriceRefundLoadBalancerResponse(AbstractModel):
    r"""InquiryPriceRefundLoadBalancer返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Price: 该参数表示对应的价格。
        :type Price: :class:`tencentcloud.clb.v20180317.models.Price`
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Price = None
        self._RequestId = None

    @property
    def Price(self):
        r"""该参数表示对应的价格。
        :rtype: :class:`tencentcloud.clb.v20180317.models.Price`
        """
        return self._Price

    @Price.setter
    def Price(self, Price):
        self._Price = Price

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("Price") is not None:
            self._Price = Price()
            self._Price._deserialize(params.get("Price"))
        self._RequestId = params.get("RequestId")


class InquiryPriceRenewLoadBalancerRequest(AbstractModel):
    r"""InquiryPriceRenewLoadBalancer请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例 ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
        :type LoadBalancerId: str
        :param _LoadBalancerChargePrepaid: 续费周期
        :type LoadBalancerChargePrepaid: :class:`tencentcloud.clb.v20180317.models.LBChargePrepaid`
        """
        self._LoadBalancerId = None
        self._LoadBalancerChargePrepaid = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例 ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def LoadBalancerChargePrepaid(self):
        r"""续费周期
        :rtype: :class:`tencentcloud.clb.v20180317.models.LBChargePrepaid`
        """
        return self._LoadBalancerChargePrepaid

    @LoadBalancerChargePrepaid.setter
    def LoadBalancerChargePrepaid(self, LoadBalancerChargePrepaid):
        self._LoadBalancerChargePrepaid = LoadBalancerChargePrepaid


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        if params.get("LoadBalancerChargePrepaid") is not None:
            self._LoadBalancerChargePrepaid = LBChargePrepaid()
            self._LoadBalancerChargePrepaid._deserialize(params.get("LoadBalancerChargePrepaid"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class InquiryPriceRenewLoadBalancerResponse(AbstractModel):
    r"""InquiryPriceRenewLoadBalancer返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Price: 表示续费价格
        :type Price: :class:`tencentcloud.clb.v20180317.models.Price`
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Price = None
        self._RequestId = None

    @property
    def Price(self):
        r"""表示续费价格
        :rtype: :class:`tencentcloud.clb.v20180317.models.Price`
        """
        return self._Price

    @Price.setter
    def Price(self, Price):
        self._Price = Price

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("Price") is not None:
            self._Price = Price()
            self._Price._deserialize(params.get("Price"))
        self._RequestId = params.get("RequestId")


class IntentRouterItem(AbstractModel):
    r"""意图路由摘要信息对象（不含分层详情）。

    """

    def __init__(self):
        r"""
        :param _CreatedTime: <p>创建时间（ISO 8601格式）。</p>
        :type CreatedTime: str
        :param _IntentRouterId: <p>意图路由ID（ir-xxx格式）。</p>
        :type IntentRouterId: str
        :param _RouteName: <p>路由名称（例如 IntentRouter/customer-support）。</p>
        :type RouteName: str
        :param _RouterDescribe: <p>意图路由描述。</p>
        :type RouterDescribe: str
        :param _Status: <p>状态。</p><p>枚举值：</p><ul><li>Provisioning：创建中</li><li>Active：正常</li><li>Configuring：配置中</li><li>ConfigureFailed：配置失败</li></ul>
        :type Status: str
        :param _Tiers: <p>分层配置列表。</p>
        :type Tiers: list of IntentRouterTierItem
        :param _UpdatedTime: <p>更新时间（ISO 8601格式）。</p>
        :type UpdatedTime: str
        """
        self._CreatedTime = None
        self._IntentRouterId = None
        self._RouteName = None
        self._RouterDescribe = None
        self._Status = None
        self._Tiers = None
        self._UpdatedTime = None

    @property
    def CreatedTime(self):
        r"""<p>创建时间（ISO 8601格式）。</p>
        :rtype: str
        """
        return self._CreatedTime

    @CreatedTime.setter
    def CreatedTime(self, CreatedTime):
        self._CreatedTime = CreatedTime

    @property
    def IntentRouterId(self):
        r"""<p>意图路由ID（ir-xxx格式）。</p>
        :rtype: str
        """
        return self._IntentRouterId

    @IntentRouterId.setter
    def IntentRouterId(self, IntentRouterId):
        self._IntentRouterId = IntentRouterId

    @property
    def RouteName(self):
        r"""<p>路由名称（例如 IntentRouter/customer-support）。</p>
        :rtype: str
        """
        return self._RouteName

    @RouteName.setter
    def RouteName(self, RouteName):
        self._RouteName = RouteName

    @property
    def RouterDescribe(self):
        r"""<p>意图路由描述。</p>
        :rtype: str
        """
        return self._RouterDescribe

    @RouterDescribe.setter
    def RouterDescribe(self, RouterDescribe):
        self._RouterDescribe = RouterDescribe

    @property
    def Status(self):
        r"""<p>状态。</p><p>枚举值：</p><ul><li>Provisioning：创建中</li><li>Active：正常</li><li>Configuring：配置中</li><li>ConfigureFailed：配置失败</li></ul>
        :rtype: str
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status

    @property
    def Tiers(self):
        r"""<p>分层配置列表。</p>
        :rtype: list of IntentRouterTierItem
        """
        return self._Tiers

    @Tiers.setter
    def Tiers(self, Tiers):
        self._Tiers = Tiers

    @property
    def UpdatedTime(self):
        r"""<p>更新时间（ISO 8601格式）。</p>
        :rtype: str
        """
        return self._UpdatedTime

    @UpdatedTime.setter
    def UpdatedTime(self, UpdatedTime):
        self._UpdatedTime = UpdatedTime


    def _deserialize(self, params):
        self._CreatedTime = params.get("CreatedTime")
        self._IntentRouterId = params.get("IntentRouterId")
        self._RouteName = params.get("RouteName")
        self._RouterDescribe = params.get("RouterDescribe")
        self._Status = params.get("Status")
        if params.get("Tiers") is not None:
            self._Tiers = []
            for item in params.get("Tiers"):
                obj = IntentRouterTierItem()
                obj._deserialize(item)
                self._Tiers.append(obj)
        self._UpdatedTime = params.get("UpdatedTime")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class IntentRouterTierDictItem(AbstractModel):
    r"""IntentRouter Tier 字典项

    """

    def __init__(self):
        r"""
        :param _TierId: <p>Tier 标识</p><p>枚举值：</p><ul><li>default： 默认</li><li>general_chat： 通用对话</li><li>transformation_rewrite： 转换与改写</li><li>knowledge_qa： 知识问答</li><li>summarization： 摘要</li><li>extraction_structuring： 抽取与结构化输出</li><li>content_generation： 内容生成</li><li>coding_technical： 编码与技术</li><li>data_math_analysis： 数据、数学与分析</li><li>reasoning_planning： 推理与规划</li><li>tool_agentic_workflow： 工具与智能体工作流</li></ul>
        :type TierId: str
        :param _DisplayName: <p>Tier 显示名称（已国际化）</p>
        :type DisplayName: str
        :param _Description: <p>Tier 描述（已国际化）</p>
        :type Description: str
        """
        self._TierId = None
        self._DisplayName = None
        self._Description = None

    @property
    def TierId(self):
        r"""<p>Tier 标识</p><p>枚举值：</p><ul><li>default： 默认</li><li>general_chat： 通用对话</li><li>transformation_rewrite： 转换与改写</li><li>knowledge_qa： 知识问答</li><li>summarization： 摘要</li><li>extraction_structuring： 抽取与结构化输出</li><li>content_generation： 内容生成</li><li>coding_technical： 编码与技术</li><li>data_math_analysis： 数据、数学与分析</li><li>reasoning_planning： 推理与规划</li><li>tool_agentic_workflow： 工具与智能体工作流</li></ul>
        :rtype: str
        """
        return self._TierId

    @TierId.setter
    def TierId(self, TierId):
        self._TierId = TierId

    @property
    def DisplayName(self):
        r"""<p>Tier 显示名称（已国际化）</p>
        :rtype: str
        """
        return self._DisplayName

    @DisplayName.setter
    def DisplayName(self, DisplayName):
        self._DisplayName = DisplayName

    @property
    def Description(self):
        r"""<p>Tier 描述（已国际化）</p>
        :rtype: str
        """
        return self._Description

    @Description.setter
    def Description(self, Description):
        self._Description = Description


    def _deserialize(self, params):
        self._TierId = params.get("TierId")
        self._DisplayName = params.get("DisplayName")
        self._Description = params.get("Description")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class IntentRouterTierItem(AbstractModel):
    r"""意图路由分层配置对象，包含分层名称和该分层下的模型列表。

    """

    def __init__(self):
        r"""
        :param _Models: <p>该分层下的模型显示名称列表。</p>
        :type Models: list of str
        :param _TierName: <p>Tier 标识。<br>枚举值：</p><ul><li>复杂度分层（4 个固定值，需全部包含）：SIMPLE、MEDIUM、COMPLEX、REASONING</li><li>default： 默认</li><li>general_chat： 通用对话</li><li>transformation_rewrite： 转换与改写</li><li>knowledge_qa： 知识问答</li><li>summarization： 摘要</li><li>extraction_structuring： 抽取与结构化输出</li><li>content_generation： 内容生成</li><li>coding_technical： 编码与技术</li><li>data_math_analysis： 数据、数学与分析</li><li>reasoning_planning： 推理与规划</li><li>tool_agentic_workflow： 工具与智能体工作流</li></ul>
        :type TierName: str
        """
        self._Models = None
        self._TierName = None

    @property
    def Models(self):
        r"""<p>该分层下的模型显示名称列表。</p>
        :rtype: list of str
        """
        return self._Models

    @Models.setter
    def Models(self, Models):
        self._Models = Models

    @property
    def TierName(self):
        r"""<p>Tier 标识。<br>枚举值：</p><ul><li>复杂度分层（4 个固定值，需全部包含）：SIMPLE、MEDIUM、COMPLEX、REASONING</li><li>default： 默认</li><li>general_chat： 通用对话</li><li>transformation_rewrite： 转换与改写</li><li>knowledge_qa： 知识问答</li><li>summarization： 摘要</li><li>extraction_structuring： 抽取与结构化输出</li><li>content_generation： 内容生成</li><li>coding_technical： 编码与技术</li><li>data_math_analysis： 数据、数学与分析</li><li>reasoning_planning： 推理与规划</li><li>tool_agentic_workflow： 工具与智能体工作流</li></ul>
        :rtype: str
        """
        return self._TierName

    @TierName.setter
    def TierName(self, TierName):
        self._TierName = TierName


    def _deserialize(self, params):
        self._Models = params.get("Models")
        self._TierName = params.get("TierName")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class InternetAccessible(AbstractModel):
    r"""网络计费模式，最大出带宽

    """

    def __init__(self):
        r"""
        :param _InternetChargeType: TRAFFIC_POSTPAID_BY_HOUR 按流量按小时后计费 ; BANDWIDTH_POSTPAID_BY_HOUR 按带宽按小时后计费，国际站用户不支持该计费模式; BANDWIDTH_PACKAGE 按带宽包计费;BANDWIDTH_PREPAID按带宽预付费。
        :type InternetChargeType: str
        :param _InternetMaxBandwidthOut: 最大出带宽，单位Mbps，仅对公网属性的共享型、性能容量型和独占型 CLB 实例、以及内网属性的性能容量型 CLB 实例生效。
- 对于公网属性的共享型和独占型 CLB 实例，最大出带宽的范围为1Mbps-2048Mbps。
- 对于公网属性和内网属性的性能容量型 CLB实例，最大出带宽的范围为1Mbps-61440Mbps。
（调用CreateLoadBalancer创建LB时不指定此参数则设置为默认值10Mbps。此上限可调整）
        :type InternetMaxBandwidthOut: int
        :param _BandwidthpkgSubType: 带宽包的类型，如 BGP（多线）。
类型如下：
SINGLEISP: 单线
BGP: 多线
HIGH_QUALITY_BGP: 精品BGP共享带宽包
SINGLEISP_CMCC: 中国移动共享带宽包
SINGLEISP_CTCC: 中国电信共享带宽包
SINGLEISP_CUCC: 中国联通共享带宽包
注意：此字段可能返回 null，表示取不到有效值。
        :type BandwidthpkgSubType: str
        """
        self._InternetChargeType = None
        self._InternetMaxBandwidthOut = None
        self._BandwidthpkgSubType = None

    @property
    def InternetChargeType(self):
        r"""TRAFFIC_POSTPAID_BY_HOUR 按流量按小时后计费 ; BANDWIDTH_POSTPAID_BY_HOUR 按带宽按小时后计费，国际站用户不支持该计费模式; BANDWIDTH_PACKAGE 按带宽包计费;BANDWIDTH_PREPAID按带宽预付费。
        :rtype: str
        """
        return self._InternetChargeType

    @InternetChargeType.setter
    def InternetChargeType(self, InternetChargeType):
        self._InternetChargeType = InternetChargeType

    @property
    def InternetMaxBandwidthOut(self):
        r"""最大出带宽，单位Mbps，仅对公网属性的共享型、性能容量型和独占型 CLB 实例、以及内网属性的性能容量型 CLB 实例生效。
- 对于公网属性的共享型和独占型 CLB 实例，最大出带宽的范围为1Mbps-2048Mbps。
- 对于公网属性和内网属性的性能容量型 CLB实例，最大出带宽的范围为1Mbps-61440Mbps。
（调用CreateLoadBalancer创建LB时不指定此参数则设置为默认值10Mbps。此上限可调整）
        :rtype: int
        """
        return self._InternetMaxBandwidthOut

    @InternetMaxBandwidthOut.setter
    def InternetMaxBandwidthOut(self, InternetMaxBandwidthOut):
        self._InternetMaxBandwidthOut = InternetMaxBandwidthOut

    @property
    def BandwidthpkgSubType(self):
        r"""带宽包的类型，如 BGP（多线）。
类型如下：
SINGLEISP: 单线
BGP: 多线
HIGH_QUALITY_BGP: 精品BGP共享带宽包
SINGLEISP_CMCC: 中国移动共享带宽包
SINGLEISP_CTCC: 中国电信共享带宽包
SINGLEISP_CUCC: 中国联通共享带宽包
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._BandwidthpkgSubType

    @BandwidthpkgSubType.setter
    def BandwidthpkgSubType(self, BandwidthpkgSubType):
        self._BandwidthpkgSubType = BandwidthpkgSubType


    def _deserialize(self, params):
        self._InternetChargeType = params.get("InternetChargeType")
        self._InternetMaxBandwidthOut = params.get("InternetMaxBandwidthOut")
        self._BandwidthpkgSubType = params.get("BandwidthpkgSubType")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ItemPrice(AbstractModel):
    r"""描述了单项的价格信息

    """

    def __init__(self):
        r"""
        :param _UnitPrice: 后付费单价，单位：元。
注意：此字段可能返回 null，表示取不到有效值。
        :type UnitPrice: float
        :param _ChargeUnit: 后续计价单元，可取值范围： 
HOUR：表示计价单元是按每小时来计算。当前涉及该计价单元的场景有：实例按小时后付费（POSTPAID_BY_HOUR）、带宽按小时后付费（BANDWIDTH_POSTPAID_BY_HOUR）；
GB：表示计价单元是按每GB来计算。当前涉及该计价单元的场景有：流量按小时后付费（TRAFFIC_POSTPAID_BY_HOUR）。
注意：此字段可能返回 null，表示取不到有效值。
        :type ChargeUnit: str
        :param _OriginalPrice: 预支费用的原价，单位：元。
注意：此字段可能返回 null，表示取不到有效值。
        :type OriginalPrice: float
        :param _DiscountPrice: 预支费用的折扣价，单位：元。
注意：此字段可能返回 null，表示取不到有效值。
        :type DiscountPrice: float
        :param _UnitPriceDiscount: 后付费的折扣单价，单位:元
注意：此字段可能返回 null，表示取不到有效值。
        :type UnitPriceDiscount: float
        :param _Discount: 折扣，如20.0代表2折。
注意：此字段可能返回 null，表示取不到有效值。
        :type Discount: float
        """
        self._UnitPrice = None
        self._ChargeUnit = None
        self._OriginalPrice = None
        self._DiscountPrice = None
        self._UnitPriceDiscount = None
        self._Discount = None

    @property
    def UnitPrice(self):
        r"""后付费单价，单位：元。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: float
        """
        return self._UnitPrice

    @UnitPrice.setter
    def UnitPrice(self, UnitPrice):
        self._UnitPrice = UnitPrice

    @property
    def ChargeUnit(self):
        r"""后续计价单元，可取值范围： 
HOUR：表示计价单元是按每小时来计算。当前涉及该计价单元的场景有：实例按小时后付费（POSTPAID_BY_HOUR）、带宽按小时后付费（BANDWIDTH_POSTPAID_BY_HOUR）；
GB：表示计价单元是按每GB来计算。当前涉及该计价单元的场景有：流量按小时后付费（TRAFFIC_POSTPAID_BY_HOUR）。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ChargeUnit

    @ChargeUnit.setter
    def ChargeUnit(self, ChargeUnit):
        self._ChargeUnit = ChargeUnit

    @property
    def OriginalPrice(self):
        r"""预支费用的原价，单位：元。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: float
        """
        return self._OriginalPrice

    @OriginalPrice.setter
    def OriginalPrice(self, OriginalPrice):
        self._OriginalPrice = OriginalPrice

    @property
    def DiscountPrice(self):
        r"""预支费用的折扣价，单位：元。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: float
        """
        return self._DiscountPrice

    @DiscountPrice.setter
    def DiscountPrice(self, DiscountPrice):
        self._DiscountPrice = DiscountPrice

    @property
    def UnitPriceDiscount(self):
        r"""后付费的折扣单价，单位:元
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: float
        """
        return self._UnitPriceDiscount

    @UnitPriceDiscount.setter
    def UnitPriceDiscount(self, UnitPriceDiscount):
        self._UnitPriceDiscount = UnitPriceDiscount

    @property
    def Discount(self):
        r"""折扣，如20.0代表2折。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: float
        """
        return self._Discount

    @Discount.setter
    def Discount(self, Discount):
        self._Discount = Discount


    def _deserialize(self, params):
        self._UnitPrice = params.get("UnitPrice")
        self._ChargeUnit = params.get("ChargeUnit")
        self._OriginalPrice = params.get("OriginalPrice")
        self._DiscountPrice = params.get("DiscountPrice")
        self._UnitPriceDiscount = params.get("UnitPriceDiscount")
        self._Discount = params.get("Discount")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class Job(AbstractModel):
    r"""异步任务信息

    """

    def __init__(self):
        r"""
        :param _ApiName: <p>接口名称</p>
        :type ApiName: str
        :param _RequestId: <p>请求ID</p>
        :type RequestId: str
        :param _Status: <p>异步任务状态</p><p>枚举值：</p><ul><li>Processing： 进行中</li><li>Succeeded： 成功</li><li>Failed： 失败</li></ul>
        :type Status: str
        :param _ResourceIds: <p>资源ID</p>
        :type ResourceIds: list of str
        """
        self._ApiName = None
        self._RequestId = None
        self._Status = None
        self._ResourceIds = None

    @property
    def ApiName(self):
        r"""<p>接口名称</p>
        :rtype: str
        """
        return self._ApiName

    @ApiName.setter
    def ApiName(self, ApiName):
        self._ApiName = ApiName

    @property
    def RequestId(self):
        r"""<p>请求ID</p>
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId

    @property
    def Status(self):
        r"""<p>异步任务状态</p><p>枚举值：</p><ul><li>Processing： 进行中</li><li>Succeeded： 成功</li><li>Failed： 失败</li></ul>
        :rtype: str
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status

    @property
    def ResourceIds(self):
        r"""<p>资源ID</p>
        :rtype: list of str
        """
        return self._ResourceIds

    @ResourceIds.setter
    def ResourceIds(self, ResourceIds):
        self._ResourceIds = ResourceIds


    def _deserialize(self, params):
        self._ApiName = params.get("ApiName")
        self._RequestId = params.get("RequestId")
        self._Status = params.get("Status")
        self._ResourceIds = params.get("ResourceIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class KeyDetailItem(AbstractModel):
    r"""Key 详情

    """

    def __init__(self):
        r"""
        :param _KeyId: Key 业务 ID
        :type KeyId: str
        :param _CreatedAt: Key 创建时间（ISO 8601）
注意：此字段可能返回 null，表示取不到有效值。
        :type CreatedAt: str
        :param _Name: Key 显示名称
注意：此字段可能返回 null，表示取不到有效值。
        :type Name: str
        """
        self._KeyId = None
        self._CreatedAt = None
        self._Name = None

    @property
    def KeyId(self):
        r"""Key 业务 ID
        :rtype: str
        """
        return self._KeyId

    @KeyId.setter
    def KeyId(self, KeyId):
        self._KeyId = KeyId

    @property
    def CreatedAt(self):
        r"""Key 创建时间（ISO 8601）
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._CreatedAt

    @CreatedAt.setter
    def CreatedAt(self, CreatedAt):
        self._CreatedAt = CreatedAt

    @property
    def Name(self):
        r"""Key 显示名称
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Name

    @Name.setter
    def Name(self, Name):
        self._Name = Name


    def _deserialize(self, params):
        self._KeyId = params.get("KeyId")
        self._CreatedAt = params.get("CreatedAt")
        self._Name = params.get("Name")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class KeyInfo(AbstractModel):
    r"""Key信息

    """

    def __init__(self):
        r"""
        :param _Blocked: <p>是否禁用Key</p>
        :type Blocked: bool
        :param _BudgetId: <p>Key关联的Budget ID。</p><p>未关联Budget时返回空字符串。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type BudgetId: str
        :param _BudgetName: <p>Key关联的Budget名称。</p><p>未关联Budget时返回空字符串。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type BudgetName: str
        :param _CreatedTime: <p>创建时间</p>
        :type CreatedTime: str
        :param _CreditUsageSet: <p>Key按Budget刷新周期划分的Credit使用情况。</p><p>当关联Budget配置多个刷新周期时，按1d、7d、30d顺序返回各周期用量；未关联Budget时返回空数组。</p>
        :type CreditUsageSet: list of CreditUsage
        :param _Key: <p>Key的值</p>
        :type Key: str
        :param _KeyId: <p>Key的ID</p>
        :type KeyId: str
        :param _KeyName: <p>Key名称</p>
        :type KeyName: str
        :param _ModifiedTime: <p>修改时间</p>
        :type ModifiedTime: str
        :param _RateLimitConfig: <p>限速信息</p>
        :type RateLimitConfig: :class:`tencentcloud.clb.v20180317.models.RateLimitConfigForKey`
        :param _Status: <p>Key状态</p><p>枚举值：</p><ul><li>Active： 正常</li></ul>
        :type Status: str
        :param _Tags: <p>标签</p>
        :type Tags: list of TagInfo
        :param _UserGroupId: <p>所属的用户组ID</p>
        :type UserGroupId: str
        :param _UserGroupName: <p>所属的用户组名称</p>
        :type UserGroupName: str
        """
        self._Blocked = None
        self._BudgetId = None
        self._BudgetName = None
        self._CreatedTime = None
        self._CreditUsageSet = None
        self._Key = None
        self._KeyId = None
        self._KeyName = None
        self._ModifiedTime = None
        self._RateLimitConfig = None
        self._Status = None
        self._Tags = None
        self._UserGroupId = None
        self._UserGroupName = None

    @property
    def Blocked(self):
        r"""<p>是否禁用Key</p>
        :rtype: bool
        """
        return self._Blocked

    @Blocked.setter
    def Blocked(self, Blocked):
        self._Blocked = Blocked

    @property
    def BudgetId(self):
        r"""<p>Key关联的Budget ID。</p><p>未关联Budget时返回空字符串。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._BudgetId

    @BudgetId.setter
    def BudgetId(self, BudgetId):
        self._BudgetId = BudgetId

    @property
    def BudgetName(self):
        r"""<p>Key关联的Budget名称。</p><p>未关联Budget时返回空字符串。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._BudgetName

    @BudgetName.setter
    def BudgetName(self, BudgetName):
        self._BudgetName = BudgetName

    @property
    def CreatedTime(self):
        r"""<p>创建时间</p>
        :rtype: str
        """
        return self._CreatedTime

    @CreatedTime.setter
    def CreatedTime(self, CreatedTime):
        self._CreatedTime = CreatedTime

    @property
    def CreditUsageSet(self):
        r"""<p>Key按Budget刷新周期划分的Credit使用情况。</p><p>当关联Budget配置多个刷新周期时，按1d、7d、30d顺序返回各周期用量；未关联Budget时返回空数组。</p>
        :rtype: list of CreditUsage
        """
        return self._CreditUsageSet

    @CreditUsageSet.setter
    def CreditUsageSet(self, CreditUsageSet):
        self._CreditUsageSet = CreditUsageSet

    @property
    def Key(self):
        r"""<p>Key的值</p>
        :rtype: str
        """
        return self._Key

    @Key.setter
    def Key(self, Key):
        self._Key = Key

    @property
    def KeyId(self):
        r"""<p>Key的ID</p>
        :rtype: str
        """
        return self._KeyId

    @KeyId.setter
    def KeyId(self, KeyId):
        self._KeyId = KeyId

    @property
    def KeyName(self):
        r"""<p>Key名称</p>
        :rtype: str
        """
        return self._KeyName

    @KeyName.setter
    def KeyName(self, KeyName):
        self._KeyName = KeyName

    @property
    def ModifiedTime(self):
        r"""<p>修改时间</p>
        :rtype: str
        """
        return self._ModifiedTime

    @ModifiedTime.setter
    def ModifiedTime(self, ModifiedTime):
        self._ModifiedTime = ModifiedTime

    @property
    def RateLimitConfig(self):
        r"""<p>限速信息</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.RateLimitConfigForKey`
        """
        return self._RateLimitConfig

    @RateLimitConfig.setter
    def RateLimitConfig(self, RateLimitConfig):
        self._RateLimitConfig = RateLimitConfig

    @property
    def Status(self):
        r"""<p>Key状态</p><p>枚举值：</p><ul><li>Active： 正常</li></ul>
        :rtype: str
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status

    @property
    def Tags(self):
        r"""<p>标签</p>
        :rtype: list of TagInfo
        """
        return self._Tags

    @Tags.setter
    def Tags(self, Tags):
        self._Tags = Tags

    @property
    def UserGroupId(self):
        r"""<p>所属的用户组ID</p>
        :rtype: str
        """
        return self._UserGroupId

    @UserGroupId.setter
    def UserGroupId(self, UserGroupId):
        self._UserGroupId = UserGroupId

    @property
    def UserGroupName(self):
        r"""<p>所属的用户组名称</p>
        :rtype: str
        """
        return self._UserGroupName

    @UserGroupName.setter
    def UserGroupName(self, UserGroupName):
        self._UserGroupName = UserGroupName


    def _deserialize(self, params):
        self._Blocked = params.get("Blocked")
        self._BudgetId = params.get("BudgetId")
        self._BudgetName = params.get("BudgetName")
        self._CreatedTime = params.get("CreatedTime")
        if params.get("CreditUsageSet") is not None:
            self._CreditUsageSet = []
            for item in params.get("CreditUsageSet"):
                obj = CreditUsage()
                obj._deserialize(item)
                self._CreditUsageSet.append(obj)
        self._Key = params.get("Key")
        self._KeyId = params.get("KeyId")
        self._KeyName = params.get("KeyName")
        self._ModifiedTime = params.get("ModifiedTime")
        if params.get("RateLimitConfig") is not None:
            self._RateLimitConfig = RateLimitConfigForKey()
            self._RateLimitConfig._deserialize(params.get("RateLimitConfig"))
        self._Status = params.get("Status")
        if params.get("Tags") is not None:
            self._Tags = []
            for item in params.get("Tags"):
                obj = TagInfo()
                obj._deserialize(item)
                self._Tags.append(obj)
        self._UserGroupId = params.get("UserGroupId")
        self._UserGroupName = params.get("UserGroupName")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class KeyItem(AbstractModel):
    r"""Key 项

    """

    def __init__(self):
        r"""
        :param _ApiKey: Provider API Key
        :type ApiKey: str
        :param _Name: Key 标识名称
注意：此字段可能返回 null，表示取不到有效值。
        :type Name: str
        """
        self._ApiKey = None
        self._Name = None

    @property
    def ApiKey(self):
        r"""Provider API Key
        :rtype: str
        """
        return self._ApiKey

    @ApiKey.setter
    def ApiKey(self, ApiKey):
        self._ApiKey = ApiKey

    @property
    def Name(self):
        r"""Key 标识名称
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Name

    @Name.setter
    def Name(self, Name):
        self._Name = Name


    def _deserialize(self, params):
        self._ApiKey = params.get("ApiKey")
        self._Name = params.get("Name")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class LBChargePrepaid(AbstractModel):
    r"""lb实例包年包月相关配置属性

    """

    def __init__(self):
        r"""
        :param _RenewFlag: 续费类型：AUTO_RENEW 自动续费，  MANUAL_RENEW 手动续费
        :type RenewFlag: str
        :param _Period: 购买时长，单位：月
        :type Period: int
        """
        self._RenewFlag = None
        self._Period = None

    @property
    def RenewFlag(self):
        r"""续费类型：AUTO_RENEW 自动续费，  MANUAL_RENEW 手动续费
        :rtype: str
        """
        return self._RenewFlag

    @RenewFlag.setter
    def RenewFlag(self, RenewFlag):
        self._RenewFlag = RenewFlag

    @property
    def Period(self):
        r"""购买时长，单位：月
        :rtype: int
        """
        return self._Period

    @Period.setter
    def Period(self, Period):
        self._Period = Period


    def _deserialize(self, params):
        self._RenewFlag = params.get("RenewFlag")
        self._Period = params.get("Period")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class LBItem(AbstractModel):
    r"""反查Lb绑定关系。

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: lb的字符串id
        :type LoadBalancerId: str
        :param _Vip: lb的vip
        :type Vip: str
        :param _Listeners: 监听器规则
        :type Listeners: list of ListenerItem
        :param _Region: LB所在地域
        :type Region: str
        """
        self._LoadBalancerId = None
        self._Vip = None
        self._Listeners = None
        self._Region = None

    @property
    def LoadBalancerId(self):
        r"""lb的字符串id
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def Vip(self):
        r"""lb的vip
        :rtype: str
        """
        return self._Vip

    @Vip.setter
    def Vip(self, Vip):
        self._Vip = Vip

    @property
    def Listeners(self):
        r"""监听器规则
        :rtype: list of ListenerItem
        """
        return self._Listeners

    @Listeners.setter
    def Listeners(self, Listeners):
        self._Listeners = Listeners

    @property
    def Region(self):
        r"""LB所在地域
        :rtype: str
        """
        return self._Region

    @Region.setter
    def Region(self, Region):
        self._Region = Region


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._Vip = params.get("Vip")
        if params.get("Listeners") is not None:
            self._Listeners = []
            for item in params.get("Listeners"):
                obj = ListenerItem()
                obj._deserialize(item)
                self._Listeners.append(obj)
        self._Region = params.get("Region")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class LBOperateProtectInfo(AbstractModel):
    r"""负载均衡的操作保护信息

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例 ID。
        :type LoadBalancerId: str
        :param _ProtectState: 保护状态，true：表示开启了操作保护，false：表示未开启操作保护。
        :type ProtectState: bool
        :param _OperatorUin: 操作保护的设置uin。
注意：此字段可能返回 null，表示取不到有效值。
        :type OperatorUin: str
        :param _Description: 设置操作保护时的描述信息。
注意：此字段可能返回 null，表示取不到有效值。
        :type Description: str
        :param _ModifyTime: 最后修改时间。
注意：此字段可能返回 null，表示取不到有效值。
        :type ModifyTime: str
        """
        self._LoadBalancerId = None
        self._ProtectState = None
        self._OperatorUin = None
        self._Description = None
        self._ModifyTime = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例 ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ProtectState(self):
        r"""保护状态，true：表示开启了操作保护，false：表示未开启操作保护。
        :rtype: bool
        """
        return self._ProtectState

    @ProtectState.setter
    def ProtectState(self, ProtectState):
        self._ProtectState = ProtectState

    @property
    def OperatorUin(self):
        r"""操作保护的设置uin。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._OperatorUin

    @OperatorUin.setter
    def OperatorUin(self, OperatorUin):
        self._OperatorUin = OperatorUin

    @property
    def Description(self):
        r"""设置操作保护时的描述信息。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Description

    @Description.setter
    def Description(self, Description):
        self._Description = Description

    @property
    def ModifyTime(self):
        r"""最后修改时间。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ModifyTime

    @ModifyTime.setter
    def ModifyTime(self, ModifyTime):
        self._ModifyTime = ModifyTime


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ProtectState = params.get("ProtectState")
        self._OperatorUin = params.get("OperatorUin")
        self._Description = params.get("Description")
        self._ModifyTime = params.get("ModifyTime")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class LbRsItem(AbstractModel):
    r"""查询类型

    """

    def __init__(self):
        r"""
        :param _VpcId: vpc的字符串id，只支持字符串id。
可以通过 [DescribeVpcs](https://cloud.tencent.com/document/api/215/15778) 接口查询。
        :type VpcId: str
        :param _PrivateIp: 需要查询后端的内网 IP，可以是 CVM 和弹性网卡。
可以通过 [DescribeAddresses](https://cloud.tencent.com/document/product/215/16702) 接口查询。
        :type PrivateIp: str
        """
        self._VpcId = None
        self._PrivateIp = None

    @property
    def VpcId(self):
        r"""vpc的字符串id，只支持字符串id。
可以通过 [DescribeVpcs](https://cloud.tencent.com/document/api/215/15778) 接口查询。
        :rtype: str
        """
        return self._VpcId

    @VpcId.setter
    def VpcId(self, VpcId):
        self._VpcId = VpcId

    @property
    def PrivateIp(self):
        r"""需要查询后端的内网 IP，可以是 CVM 和弹性网卡。
可以通过 [DescribeAddresses](https://cloud.tencent.com/document/product/215/16702) 接口查询。
        :rtype: str
        """
        return self._PrivateIp

    @PrivateIp.setter
    def PrivateIp(self, PrivateIp):
        self._PrivateIp = PrivateIp


    def _deserialize(self, params):
        self._VpcId = params.get("VpcId")
        self._PrivateIp = params.get("PrivateIp")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class LbRsTargets(AbstractModel):
    r"""反查结果数据类型。

    """

    def __init__(self):
        r"""
        :param _Type: 内网ip类型。“cvm”或“eni”
        :type Type: str
        :param _PrivateIp: 后端实例的内网ip。
        :type PrivateIp: str
        :param _Port: 绑定后端实例的端口。
        :type Port: int
        :param _VpcId: rs的vpcId
        :type VpcId: int
        :param _Weight: rs的权重
        :type Weight: int
        """
        self._Type = None
        self._PrivateIp = None
        self._Port = None
        self._VpcId = None
        self._Weight = None

    @property
    def Type(self):
        r"""内网ip类型。“cvm”或“eni”
        :rtype: str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type

    @property
    def PrivateIp(self):
        r"""后端实例的内网ip。
        :rtype: str
        """
        return self._PrivateIp

    @PrivateIp.setter
    def PrivateIp(self, PrivateIp):
        self._PrivateIp = PrivateIp

    @property
    def Port(self):
        r"""绑定后端实例的端口。
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def VpcId(self):
        r"""rs的vpcId
        :rtype: int
        """
        return self._VpcId

    @VpcId.setter
    def VpcId(self, VpcId):
        self._VpcId = VpcId

    @property
    def Weight(self):
        r"""rs的权重
        :rtype: int
        """
        return self._Weight

    @Weight.setter
    def Weight(self, Weight):
        self._Weight = Weight


    def _deserialize(self, params):
        self._Type = params.get("Type")
        self._PrivateIp = params.get("PrivateIp")
        self._Port = params.get("Port")
        self._VpcId = params.get("VpcId")
        self._Weight = params.get("Weight")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class Listener(AbstractModel):
    r"""监听器的信息

    """

    def __init__(self):
        r"""
        :param _ListenerId: <p>负载均衡监听器 ID</p>
        :type ListenerId: str
        :param _Protocol: <p>监听器协议，可选值：TCP、UDP、HTTP、HTTPS、TCP_SSL、QUIC</p>
        :type Protocol: str
        :param _Port: <p>监听器端口，端口范围：1-65535</p>
        :type Port: int
        :param _Certificate: <p>监听器绑定的证书信息</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type Certificate: :class:`tencentcloud.clb.v20180317.models.CertificateOutput`
        :param _HealthCheck: <p>监听器的健康检查信息</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type HealthCheck: :class:`tencentcloud.clb.v20180317.models.HealthCheck`
        :param _Scheduler: <p>请求的调度方式。 WRR、LEAST_CONN、IP_HASH分别表示按权重轮询、最小连接数、IP Hash。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type Scheduler: str
        :param _SessionExpireTime: <p>会话保持时间，单位：秒。可选值：30~3600，默认 0，默认不开启。此参数仅适用于TCP/UDP监听器。</p><p>单位：秒</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type SessionExpireTime: int
        :param _SniSwitch: <p>是否开启SNI特性，1：表示开启，0：表示不开启（本参数仅对于HTTPS监听器有意义）</p>
        :type SniSwitch: int
        :param _Rules: <p>监听器下的全部转发规则（本参数仅对于HTTP/HTTPS监听器有意义）</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type Rules: list of RuleOutput
        :param _ListenerName: <p>监听器的名称</p>
        :type ListenerName: str
        :param _CreateTime: <p>监听器的创建时间。</p>
        :type CreateTime: str
        :param _EndPort: <p>端口段结束端口，端口范围：2-65535</p>
        :type EndPort: int
        :param _TargetType: <p>后端服务器类型，可选值：NODE、POLARIS、TARGETGROUP、TARGETGROUP-V2</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type TargetType: str
        :param _TargetGroup: <p>绑定的目标组基本信息；当监听器绑定目标组时，会返回该字段</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type TargetGroup: :class:`tencentcloud.clb.v20180317.models.BasicTargetGroupInfo`
        :param _SessionType: <p>会话保持类型。NORMAL表示默认会话保持类型。QUIC_CID 表示根据Quic Connection ID做会话保持。</p>
        :type SessionType: str
        :param _KeepaliveEnable: <p>是否开启长连接，1开启，0关闭，（本参数仅对于HTTP/HTTPS监听器有意义）</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type KeepaliveEnable: int
        :param _Toa: <p>仅支持Nat64 CLB TCP监听器</p>
        :type Toa: bool
        :param _DeregisterTargetRst: <p>重新调度功能，解绑后端服务开关，打开此开关，当解绑后端服务时触发重新调度。仅TCP/UDP监听器支持。</p>
        :type DeregisterTargetRst: bool
        :param _AttrFlags: <p>监听器的属性</p>
        :type AttrFlags: list of str
        :param _TargetGroupList: <p>绑定的目标组列表</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type TargetGroupList: list of BasicTargetGroupInfo
        :param _MaxConn: <p>监听器最大连接数，-1表示监听器维度不限速。</p>
        :type MaxConn: int
        :param _MaxCps: <p>监听器最大新增连接数，-1表示监听器维度不限速。</p>
        :type MaxCps: int
        :param _IdleConnectTimeout: <p>空闲连接超时时间，仅支持TCP监听器。默认值:900；共享型实例和独占型实例取值范围：300～900，性能容量型实例取值范围:300～1980。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type IdleConnectTimeout: int
        :param _RescheduleInterval: <p>重新调度触发持续时间，取值0~3600s。仅TCP/UDP监听器支持。触发重新调度后，长连接将会在设置的调度时间内断开并完成重新分配。</p><p>单位：秒</p>
        :type RescheduleInterval: int
        :param _DataCompressMode: <p>数据压缩模式</p>
        :type DataCompressMode: str
        :param _RescheduleStartTime: <p>重新调度启动时间，配置了重新调度启动时间后，会在启动时间到达时触发重新调度。</p>
        :type RescheduleStartTime: int
        """
        self._ListenerId = None
        self._Protocol = None
        self._Port = None
        self._Certificate = None
        self._HealthCheck = None
        self._Scheduler = None
        self._SessionExpireTime = None
        self._SniSwitch = None
        self._Rules = None
        self._ListenerName = None
        self._CreateTime = None
        self._EndPort = None
        self._TargetType = None
        self._TargetGroup = None
        self._SessionType = None
        self._KeepaliveEnable = None
        self._Toa = None
        self._DeregisterTargetRst = None
        self._AttrFlags = None
        self._TargetGroupList = None
        self._MaxConn = None
        self._MaxCps = None
        self._IdleConnectTimeout = None
        self._RescheduleInterval = None
        self._DataCompressMode = None
        self._RescheduleStartTime = None

    @property
    def ListenerId(self):
        r"""<p>负载均衡监听器 ID</p>
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def Protocol(self):
        r"""<p>监听器协议，可选值：TCP、UDP、HTTP、HTTPS、TCP_SSL、QUIC</p>
        :rtype: str
        """
        return self._Protocol

    @Protocol.setter
    def Protocol(self, Protocol):
        self._Protocol = Protocol

    @property
    def Port(self):
        r"""<p>监听器端口，端口范围：1-65535</p>
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def Certificate(self):
        r"""<p>监听器绑定的证书信息</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.CertificateOutput`
        """
        return self._Certificate

    @Certificate.setter
    def Certificate(self, Certificate):
        self._Certificate = Certificate

    @property
    def HealthCheck(self):
        r"""<p>监听器的健康检查信息</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.HealthCheck`
        """
        return self._HealthCheck

    @HealthCheck.setter
    def HealthCheck(self, HealthCheck):
        self._HealthCheck = HealthCheck

    @property
    def Scheduler(self):
        r"""<p>请求的调度方式。 WRR、LEAST_CONN、IP_HASH分别表示按权重轮询、最小连接数、IP Hash。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Scheduler

    @Scheduler.setter
    def Scheduler(self, Scheduler):
        self._Scheduler = Scheduler

    @property
    def SessionExpireTime(self):
        r"""<p>会话保持时间，单位：秒。可选值：30~3600，默认 0，默认不开启。此参数仅适用于TCP/UDP监听器。</p><p>单位：秒</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._SessionExpireTime

    @SessionExpireTime.setter
    def SessionExpireTime(self, SessionExpireTime):
        self._SessionExpireTime = SessionExpireTime

    @property
    def SniSwitch(self):
        r"""<p>是否开启SNI特性，1：表示开启，0：表示不开启（本参数仅对于HTTPS监听器有意义）</p>
        :rtype: int
        """
        return self._SniSwitch

    @SniSwitch.setter
    def SniSwitch(self, SniSwitch):
        self._SniSwitch = SniSwitch

    @property
    def Rules(self):
        r"""<p>监听器下的全部转发规则（本参数仅对于HTTP/HTTPS监听器有意义）</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: list of RuleOutput
        """
        return self._Rules

    @Rules.setter
    def Rules(self, Rules):
        self._Rules = Rules

    @property
    def ListenerName(self):
        r"""<p>监听器的名称</p>
        :rtype: str
        """
        return self._ListenerName

    @ListenerName.setter
    def ListenerName(self, ListenerName):
        self._ListenerName = ListenerName

    @property
    def CreateTime(self):
        r"""<p>监听器的创建时间。</p>
        :rtype: str
        """
        return self._CreateTime

    @CreateTime.setter
    def CreateTime(self, CreateTime):
        self._CreateTime = CreateTime

    @property
    def EndPort(self):
        r"""<p>端口段结束端口，端口范围：2-65535</p>
        :rtype: int
        """
        return self._EndPort

    @EndPort.setter
    def EndPort(self, EndPort):
        self._EndPort = EndPort

    @property
    def TargetType(self):
        r"""<p>后端服务器类型，可选值：NODE、POLARIS、TARGETGROUP、TARGETGROUP-V2</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._TargetType

    @TargetType.setter
    def TargetType(self, TargetType):
        self._TargetType = TargetType

    @property
    def TargetGroup(self):
        r"""<p>绑定的目标组基本信息；当监听器绑定目标组时，会返回该字段</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.BasicTargetGroupInfo`
        """
        return self._TargetGroup

    @TargetGroup.setter
    def TargetGroup(self, TargetGroup):
        self._TargetGroup = TargetGroup

    @property
    def SessionType(self):
        r"""<p>会话保持类型。NORMAL表示默认会话保持类型。QUIC_CID 表示根据Quic Connection ID做会话保持。</p>
        :rtype: str
        """
        return self._SessionType

    @SessionType.setter
    def SessionType(self, SessionType):
        self._SessionType = SessionType

    @property
    def KeepaliveEnable(self):
        r"""<p>是否开启长连接，1开启，0关闭，（本参数仅对于HTTP/HTTPS监听器有意义）</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._KeepaliveEnable

    @KeepaliveEnable.setter
    def KeepaliveEnable(self, KeepaliveEnable):
        self._KeepaliveEnable = KeepaliveEnable

    @property
    def Toa(self):
        r"""<p>仅支持Nat64 CLB TCP监听器</p>
        :rtype: bool
        """
        return self._Toa

    @Toa.setter
    def Toa(self, Toa):
        self._Toa = Toa

    @property
    def DeregisterTargetRst(self):
        r"""<p>重新调度功能，解绑后端服务开关，打开此开关，当解绑后端服务时触发重新调度。仅TCP/UDP监听器支持。</p>
        :rtype: bool
        """
        return self._DeregisterTargetRst

    @DeregisterTargetRst.setter
    def DeregisterTargetRst(self, DeregisterTargetRst):
        self._DeregisterTargetRst = DeregisterTargetRst

    @property
    def AttrFlags(self):
        r"""<p>监听器的属性</p>
        :rtype: list of str
        """
        return self._AttrFlags

    @AttrFlags.setter
    def AttrFlags(self, AttrFlags):
        self._AttrFlags = AttrFlags

    @property
    def TargetGroupList(self):
        r"""<p>绑定的目标组列表</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: list of BasicTargetGroupInfo
        """
        return self._TargetGroupList

    @TargetGroupList.setter
    def TargetGroupList(self, TargetGroupList):
        self._TargetGroupList = TargetGroupList

    @property
    def MaxConn(self):
        r"""<p>监听器最大连接数，-1表示监听器维度不限速。</p>
        :rtype: int
        """
        return self._MaxConn

    @MaxConn.setter
    def MaxConn(self, MaxConn):
        self._MaxConn = MaxConn

    @property
    def MaxCps(self):
        r"""<p>监听器最大新增连接数，-1表示监听器维度不限速。</p>
        :rtype: int
        """
        return self._MaxCps

    @MaxCps.setter
    def MaxCps(self, MaxCps):
        self._MaxCps = MaxCps

    @property
    def IdleConnectTimeout(self):
        r"""<p>空闲连接超时时间，仅支持TCP监听器。默认值:900；共享型实例和独占型实例取值范围：300～900，性能容量型实例取值范围:300～1980。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._IdleConnectTimeout

    @IdleConnectTimeout.setter
    def IdleConnectTimeout(self, IdleConnectTimeout):
        self._IdleConnectTimeout = IdleConnectTimeout

    @property
    def RescheduleInterval(self):
        r"""<p>重新调度触发持续时间，取值0~3600s。仅TCP/UDP监听器支持。触发重新调度后，长连接将会在设置的调度时间内断开并完成重新分配。</p><p>单位：秒</p>
        :rtype: int
        """
        return self._RescheduleInterval

    @RescheduleInterval.setter
    def RescheduleInterval(self, RescheduleInterval):
        self._RescheduleInterval = RescheduleInterval

    @property
    def DataCompressMode(self):
        r"""<p>数据压缩模式</p>
        :rtype: str
        """
        return self._DataCompressMode

    @DataCompressMode.setter
    def DataCompressMode(self, DataCompressMode):
        self._DataCompressMode = DataCompressMode

    @property
    def RescheduleStartTime(self):
        r"""<p>重新调度启动时间，配置了重新调度启动时间后，会在启动时间到达时触发重新调度。</p>
        :rtype: int
        """
        return self._RescheduleStartTime

    @RescheduleStartTime.setter
    def RescheduleStartTime(self, RescheduleStartTime):
        self._RescheduleStartTime = RescheduleStartTime


    def _deserialize(self, params):
        self._ListenerId = params.get("ListenerId")
        self._Protocol = params.get("Protocol")
        self._Port = params.get("Port")
        if params.get("Certificate") is not None:
            self._Certificate = CertificateOutput()
            self._Certificate._deserialize(params.get("Certificate"))
        if params.get("HealthCheck") is not None:
            self._HealthCheck = HealthCheck()
            self._HealthCheck._deserialize(params.get("HealthCheck"))
        self._Scheduler = params.get("Scheduler")
        self._SessionExpireTime = params.get("SessionExpireTime")
        self._SniSwitch = params.get("SniSwitch")
        if params.get("Rules") is not None:
            self._Rules = []
            for item in params.get("Rules"):
                obj = RuleOutput()
                obj._deserialize(item)
                self._Rules.append(obj)
        self._ListenerName = params.get("ListenerName")
        self._CreateTime = params.get("CreateTime")
        self._EndPort = params.get("EndPort")
        self._TargetType = params.get("TargetType")
        if params.get("TargetGroup") is not None:
            self._TargetGroup = BasicTargetGroupInfo()
            self._TargetGroup._deserialize(params.get("TargetGroup"))
        self._SessionType = params.get("SessionType")
        self._KeepaliveEnable = params.get("KeepaliveEnable")
        self._Toa = params.get("Toa")
        self._DeregisterTargetRst = params.get("DeregisterTargetRst")
        self._AttrFlags = params.get("AttrFlags")
        if params.get("TargetGroupList") is not None:
            self._TargetGroupList = []
            for item in params.get("TargetGroupList"):
                obj = BasicTargetGroupInfo()
                obj._deserialize(item)
                self._TargetGroupList.append(obj)
        self._MaxConn = params.get("MaxConn")
        self._MaxCps = params.get("MaxCps")
        self._IdleConnectTimeout = params.get("IdleConnectTimeout")
        self._RescheduleInterval = params.get("RescheduleInterval")
        self._DataCompressMode = params.get("DataCompressMode")
        self._RescheduleStartTime = params.get("RescheduleStartTime")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ListenerBackend(AbstractModel):
    r"""监听器上绑定的后端服务的信息

    """

    def __init__(self):
        r"""
        :param _ListenerId: 监听器 ID
        :type ListenerId: str
        :param _Protocol: 监听器的协议
        :type Protocol: str
        :param _Port: 监听器的端口
        :type Port: int
        :param _Rules: 监听器下的规则信息（仅适用于HTTP/HTTPS监听器）
        :type Rules: list of RuleTargets
        :param _Targets: 监听器上绑定的后端服务列表（仅适用于TCP/UDP/TCP_SSL监听器）
        :type Targets: list of Backend
        :param _EndPort: 若支持端口段，则为端口段结束端口；若不支持端口段，则为0
        :type EndPort: int
        """
        self._ListenerId = None
        self._Protocol = None
        self._Port = None
        self._Rules = None
        self._Targets = None
        self._EndPort = None

    @property
    def ListenerId(self):
        r"""监听器 ID
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def Protocol(self):
        r"""监听器的协议
        :rtype: str
        """
        return self._Protocol

    @Protocol.setter
    def Protocol(self, Protocol):
        self._Protocol = Protocol

    @property
    def Port(self):
        r"""监听器的端口
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def Rules(self):
        r"""监听器下的规则信息（仅适用于HTTP/HTTPS监听器）
        :rtype: list of RuleTargets
        """
        return self._Rules

    @Rules.setter
    def Rules(self, Rules):
        self._Rules = Rules

    @property
    def Targets(self):
        r"""监听器上绑定的后端服务列表（仅适用于TCP/UDP/TCP_SSL监听器）
        :rtype: list of Backend
        """
        return self._Targets

    @Targets.setter
    def Targets(self, Targets):
        self._Targets = Targets

    @property
    def EndPort(self):
        r"""若支持端口段，则为端口段结束端口；若不支持端口段，则为0
        :rtype: int
        """
        return self._EndPort

    @EndPort.setter
    def EndPort(self, EndPort):
        self._EndPort = EndPort


    def _deserialize(self, params):
        self._ListenerId = params.get("ListenerId")
        self._Protocol = params.get("Protocol")
        self._Port = params.get("Port")
        if params.get("Rules") is not None:
            self._Rules = []
            for item in params.get("Rules"):
                obj = RuleTargets()
                obj._deserialize(item)
                self._Rules.append(obj)
        if params.get("Targets") is not None:
            self._Targets = []
            for item in params.get("Targets"):
                obj = Backend()
                obj._deserialize(item)
                self._Targets.append(obj)
        self._EndPort = params.get("EndPort")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ListenerHealth(AbstractModel):
    r"""监听器的健康检查信息

    """

    def __init__(self):
        r"""
        :param _ListenerId: 监听器ID
        :type ListenerId: str
        :param _ListenerName: 监听器名称
        :type ListenerName: str
        :param _Protocol: 监听器的协议
        :type Protocol: str
        :param _Port: 监听器的端口
        :type Port: int
        :param _Rules: 监听器的转发规则列表
        :type Rules: list of RuleHealth
        """
        self._ListenerId = None
        self._ListenerName = None
        self._Protocol = None
        self._Port = None
        self._Rules = None

    @property
    def ListenerId(self):
        r"""监听器ID
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def ListenerName(self):
        r"""监听器名称
        :rtype: str
        """
        return self._ListenerName

    @ListenerName.setter
    def ListenerName(self, ListenerName):
        self._ListenerName = ListenerName

    @property
    def Protocol(self):
        r"""监听器的协议
        :rtype: str
        """
        return self._Protocol

    @Protocol.setter
    def Protocol(self, Protocol):
        self._Protocol = Protocol

    @property
    def Port(self):
        r"""监听器的端口
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def Rules(self):
        r"""监听器的转发规则列表
        :rtype: list of RuleHealth
        """
        return self._Rules

    @Rules.setter
    def Rules(self, Rules):
        self._Rules = Rules


    def _deserialize(self, params):
        self._ListenerId = params.get("ListenerId")
        self._ListenerName = params.get("ListenerName")
        self._Protocol = params.get("Protocol")
        self._Port = params.get("Port")
        if params.get("Rules") is not None:
            self._Rules = []
            for item in params.get("Rules"):
                obj = RuleHealth()
                obj._deserialize(item)
                self._Rules.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ListenerItem(AbstractModel):
    r"""反查监听器类型

    """

    def __init__(self):
        r"""
        :param _ListenerId: 监听器ID
        :type ListenerId: str
        :param _Protocol: 监听器协议
        :type Protocol: str
        :param _Port: 监听器端口
        :type Port: int
        :param _Rules: 绑定规则
注意：此字段可能返回 null，表示取不到有效值。
        :type Rules: list of RulesItems
        :param _Targets: 四层绑定对象
注意：此字段可能返回 null，表示取不到有效值。
        :type Targets: list of LbRsTargets
        :param _EndPort: 端口段监听器的结束端口
        :type EndPort: int
        """
        self._ListenerId = None
        self._Protocol = None
        self._Port = None
        self._Rules = None
        self._Targets = None
        self._EndPort = None

    @property
    def ListenerId(self):
        r"""监听器ID
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def Protocol(self):
        r"""监听器协议
        :rtype: str
        """
        return self._Protocol

    @Protocol.setter
    def Protocol(self, Protocol):
        self._Protocol = Protocol

    @property
    def Port(self):
        r"""监听器端口
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def Rules(self):
        r"""绑定规则
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: list of RulesItems
        """
        return self._Rules

    @Rules.setter
    def Rules(self, Rules):
        self._Rules = Rules

    @property
    def Targets(self):
        r"""四层绑定对象
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: list of LbRsTargets
        """
        return self._Targets

    @Targets.setter
    def Targets(self, Targets):
        self._Targets = Targets

    @property
    def EndPort(self):
        r"""端口段监听器的结束端口
        :rtype: int
        """
        return self._EndPort

    @EndPort.setter
    def EndPort(self, EndPort):
        self._EndPort = EndPort


    def _deserialize(self, params):
        self._ListenerId = params.get("ListenerId")
        self._Protocol = params.get("Protocol")
        self._Port = params.get("Port")
        if params.get("Rules") is not None:
            self._Rules = []
            for item in params.get("Rules"):
                obj = RulesItems()
                obj._deserialize(item)
                self._Rules.append(obj)
        if params.get("Targets") is not None:
            self._Targets = []
            for item in params.get("Targets"):
                obj = LbRsTargets()
                obj._deserialize(item)
                self._Targets.append(obj)
        self._EndPort = params.get("EndPort")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class LoadBalancer(AbstractModel):
    r"""负载均衡实例的信息

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例 ID。
        :type LoadBalancerId: str
        :param _LoadBalancerName: 负载均衡实例的名称。
        :type LoadBalancerName: str
        :param _LoadBalancerType: 负载均衡实例的网络类型：
OPEN：公网属性， INTERNAL：内网属性；对于内网属性的负载均衡，可通过绑定EIP出公网，具体可参考EIP文档[绑定弹性公网IP](https://cloud.tencent.com/document/product/215/16700)。
        :type LoadBalancerType: str
        :param _Forward: 负载均衡类型标识，1：负载均衡，0：传统型负载均衡。
        :type Forward: int
        :param _Domain: 负载均衡实例的域名，仅公网传统型和域名型负载均衡实例才提供该字段。逐步下线中，建议用LoadBalancerDomain替代。
        :type Domain: str
        :param _LoadBalancerVips: 负载均衡实例的 VIP 列表。
        :type LoadBalancerVips: list of str
        :param _Status: 负载均衡实例的状态，包括
0：创建中，1：正常运行。
        :type Status: int
        :param _CreateTime: 负载均衡实例的创建时间。
格式：YYYY-MM-DD HH:mm:ss
        :type CreateTime: str
        :param _StatusTime: 负载均衡实例的上次状态转换时间。
格式：YYYY-MM-DD HH:mm:ss
        :type StatusTime: str
        :param _ProjectId: 负载均衡实例所属的项目 ID， 0 表示默认项目。
        :type ProjectId: int
        :param _VpcId: 私有网络的 ID
        :type VpcId: str
        :param _OpenBgp: 高防 LB 的标识，1：高防负载均衡 0：非高防负载均衡。
        :type OpenBgp: int
        :param _Snat: 是否开启 SNAT，在 2016 年 12 月份之前的传统型内网负载均衡都是开启了 SNAT 的。
        :type Snat: bool
        :param _Isolation: 是否被隔离，0：表示未被隔离，1：表示被隔离。
        :type Isolation: int
        :param _Log: 用户开启日志的信息，日志只有公网属性创建了 HTTP 、HTTPS 监听器的负载均衡才会有日志。
注意：此字段可能返回 null，表示取不到有效值。
        :type Log: str
        :param _SubnetId: 负载均衡实例所在的子网（仅对内网VPC型LB有意义）
        :type SubnetId: str
        :param _Tags: 负载均衡实例的标签信息
        :type Tags: list of TagInfo
        :param _SecureGroups: 负载均衡实例的安全组
        :type SecureGroups: list of str
        :param _TargetRegionInfo: 负载均衡实例绑定的后端设备的基本信息
        :type TargetRegionInfo: :class:`tencentcloud.clb.v20180317.models.TargetRegionInfo`
        :param _AnycastZone: anycast负载均衡的发布域，对于非anycast的负载均衡，此字段返回为空字符串
        :type AnycastZone: str
        :param _AddressIPVersion: IP版本，ipv4 | ipv6
        :type AddressIPVersion: str
        :param _NumericalVpcId: 数值形式的私有网络 ID，可以通过[DescribeVpcs](https://cloud.tencent.com/document/product/215/15778)接口获取。
        :type NumericalVpcId: int
        :param _VipIsp: 负载均衡IP地址所属的运营商。

- BGP :  BGP（多线）
- CMCC：中国移动单线
- CTCC：中国电信单线
- CUCC：中国联通单线
注意：此字段可能返回 null，表示取不到有效值。
        :type VipIsp: str
        :param _MasterZone: 主可用区
注意：此字段可能返回 null，表示取不到有效值。
        :type MasterZone: :class:`tencentcloud.clb.v20180317.models.ZoneInfo`
        :param _BackupZoneSet: 备可用区
注意：此字段可能返回 null，表示取不到有效值。
        :type BackupZoneSet: list of ZoneInfo
        :param _IsolatedTime: 负载均衡实例被隔离的时间。
格式：YYYY-MM-DD HH:mm:ss
注意：此字段可能返回 null，表示取不到有效值。
        :type IsolatedTime: str
        :param _ExpireTime: 负载均衡实例的过期时间，仅对预付费负载均衡生效。
格式：YYYY-MM-DD HH:mm:ss
注意：此字段可能返回 null，表示取不到有效值。
        :type ExpireTime: str
        :param _ChargeType: 负载均衡实例的计费类型，PREPAID：包年包月，POSTPAID_BY_HOUR：按量计费
注意：此字段可能返回 null，表示取不到有效值。
        :type ChargeType: str
        :param _NetworkAttributes: 负载均衡实例的网络属性
注意：此字段可能返回 null，表示取不到有效值。
        :type NetworkAttributes: :class:`tencentcloud.clb.v20180317.models.InternetAccessible`
        :param _PrepaidAttributes: 负载均衡实例的预付费相关属性，仅在 ChargeType=PREPAID 时显示。
注意：此字段可能返回 null，表示取不到有效值。
        :type PrepaidAttributes: :class:`tencentcloud.clb.v20180317.models.LBChargePrepaid`
        :param _LogSetId: 负载均衡日志服务(CLS)的日志集ID
        :type LogSetId: str
        :param _LogTopicId: 负载均衡日志服务(CLS)的日志主题ID
        :type LogTopicId: str
        :param _AddressIPv6: 负载均衡实例的IPv6地址
注意：此字段可能返回 null，表示取不到有效值。
        :type AddressIPv6: str
        :param _ExtraInfo: 暂做保留，一般用户无需关注。
注意：此字段可能返回 null，表示取不到有效值。
        :type ExtraInfo: :class:`tencentcloud.clb.v20180317.models.ExtraInfo`
        :param _IsDDos: 是否可绑定高防包
        :type IsDDos: bool
        :param _ConfigId: 负载均衡维度的个性化配置ID
        :type ConfigId: str
        :param _LoadBalancerPassToTarget: 后端服务是否放通来自LB的流量
        :type LoadBalancerPassToTarget: bool
        :param _ExclusiveCluster: 内网独占集群
        :type ExclusiveCluster: :class:`tencentcloud.clb.v20180317.models.ExclusiveCluster`
        :param _IPv6Mode: IP地址版本为ipv6时此字段有意义，IPv6Nat64 | IPv6FullChain。
IPv6Nat64: 基于 NAT64 IPv6 过渡技术实现的负载均衡器。
IPv6FullChain：基于 IPv6 单栈技术实现的负载均衡。
注意：此字段可能返回 null，表示取不到有效值。
        :type IPv6Mode: str
        :param _SnatPro: 是否开启SnatPro。
        :type SnatPro: bool
        :param _SnatIps: 开启SnatPro负载均衡后，SnatIp列表。
        :type SnatIps: list of SnatIp
        :param _SlaType: 性能容量型规格。<ul><li> clb.c1.small：简约型规格 </li><li> clb.c2.medium：标准型规格 </li><li> clb.c3.small：高阶型1规格 </li><li> clb.c3.medium：高阶型2规格 </li><li> clb.c4.small：超强型1规格 </li><li> clb.c4.medium：超强型2规格 </li><li> clb.c4.large：超强型3规格 </li><li> clb.c4.xlarge：超强型4规格 </li><li>""：非性能容量型实例</li></ul>
        :type SlaType: str
        :param _IsBlock: vip是否被封堵
        :type IsBlock: bool
        :param _IsBlockTime: 封堵或解封时间。
格式：YYYY-MM-DD HH:mm:ss。
        :type IsBlockTime: str
        :param _LocalBgp: IP类型是否是本地BGP
        :type LocalBgp: bool
        :param _ClusterTag: 7层独占标签。
注意：此字段可能返回 null，表示取不到有效值。
        :type ClusterTag: str
        :param _MixIpTarget: 开启IPv6FullChain负载均衡7层监听器支持混绑IPv4/IPv6目标功能。
        :type MixIpTarget: bool
        :param _Zones: 私有网络内网负载均衡，就近接入模式下规则所落在的可用区
注意：此字段可能返回 null，表示取不到有效值。
        :type Zones: list of str
        :param _NfvInfo: CLB是否为NFV，空：不是，l7nfv：七层是NFV。
注意：此字段可能返回 null，表示取不到有效值。
        :type NfvInfo: str
        :param _HealthLogSetId: 负载均衡日志服务(CLS)的健康检查日志集ID
        :type HealthLogSetId: str
        :param _HealthLogTopicId: 负载均衡日志服务(CLS)的健康检查日志主题ID
        :type HealthLogTopicId: str
        :param _ClusterIds: 集群ID
注意：此字段可能返回 null，表示取不到有效值。
        :type ClusterIds: list of str
        :param _AttributeFlags: 负载均衡的属性，传入字符串数组来决定是否开启
DeleteProtect: 删除保护，开启后防止负载均衡被误删除。 
UserInVisible: 用户不可见，控制负载均衡对用户的可见性。 
BlockStatus: 阻塞状态，用于限制负载均衡的某些操作或流量。 
NoLBNat: 禁用负载均衡的NAT功能，用于特定场景下的流量直接转发。 
BanStatus: 封禁状态，用于暂停负载均衡服务或限制访问。 
ShiftupFlag: 升配标志，用于标识负载均衡需要升级配置或性能。 
Stop: 停止状态，开启后负载均衡暂停服务。 
NoVpcGw: 不使用VPC网关，用于绕过VPC网关直接处理流量。 
SgInTgw: 安全组在TGW（Transit Gateway）中，涉及网络安全策略配置。 
SharedLimitFlag: 共享限制标志，用于控制负载均衡的共享资源限制。 
WafFlag: Web应用防火墙（WAF）标志，开启后启用WAF保护。 
IsDomainCLB: 域名型负载均衡，标识负载均衡是否基于域名进行流量分发。 
IPv6Snat: IPv6源地址转换（SNAT），用于IPv6网络的源地址处理。 
HideDomain: 隐藏域名，用于隐私保护或特定场景下不暴露域名。 
JumboFrame: 巨型帧支持，开启后支持更大的数据帧以提高网络效率。 
NoLBNatL4IPdc: 四层IP直连无NAT，用于四层负载均衡直接转发IP流量。 
VpcGwL3Service: VPC网关三层服务，涉及三层网络服务的网关功能。 
Ipv62Flag: IPv6扩展标志，用于特定的IPv6功能支持。 
Ipv62ExclusiveFlag: IPv6独占标志，用于专属IPv6流量处理。 
BgpPro: BGP Pro 支持。 
ToaClean: TOA（TCP Option Address）清理，清除TCP选项中的地址信息。 

        :type AttributeFlags: list of str
        :param _LoadBalancerDomain: 负载均衡实例的域名。
        :type LoadBalancerDomain: str
        :param _Egress: 网络出口
        :type Egress: str
        :param _Exclusive: 实例类型是否为独占型。1：独占型实例。0：非独占型实例。
注意：此字段可能返回 null，表示取不到有效值。
        :type Exclusive: int
        :param _TargetCount: 已绑定的后端服务数量。
        :type TargetCount: int
        :param _AssociateEndpoint: 负载均衡实例关联的Endpoint id。
        :type AssociateEndpoint: str
        :param _AvailableZoneAffinityInfo: 可用区转发亲和信息
        :type AvailableZoneAffinityInfo: :class:`tencentcloud.clb.v20180317.models.AvailableZoneAffinityInfo`
        """
        self._LoadBalancerId = None
        self._LoadBalancerName = None
        self._LoadBalancerType = None
        self._Forward = None
        self._Domain = None
        self._LoadBalancerVips = None
        self._Status = None
        self._CreateTime = None
        self._StatusTime = None
        self._ProjectId = None
        self._VpcId = None
        self._OpenBgp = None
        self._Snat = None
        self._Isolation = None
        self._Log = None
        self._SubnetId = None
        self._Tags = None
        self._SecureGroups = None
        self._TargetRegionInfo = None
        self._AnycastZone = None
        self._AddressIPVersion = None
        self._NumericalVpcId = None
        self._VipIsp = None
        self._MasterZone = None
        self._BackupZoneSet = None
        self._IsolatedTime = None
        self._ExpireTime = None
        self._ChargeType = None
        self._NetworkAttributes = None
        self._PrepaidAttributes = None
        self._LogSetId = None
        self._LogTopicId = None
        self._AddressIPv6 = None
        self._ExtraInfo = None
        self._IsDDos = None
        self._ConfigId = None
        self._LoadBalancerPassToTarget = None
        self._ExclusiveCluster = None
        self._IPv6Mode = None
        self._SnatPro = None
        self._SnatIps = None
        self._SlaType = None
        self._IsBlock = None
        self._IsBlockTime = None
        self._LocalBgp = None
        self._ClusterTag = None
        self._MixIpTarget = None
        self._Zones = None
        self._NfvInfo = None
        self._HealthLogSetId = None
        self._HealthLogTopicId = None
        self._ClusterIds = None
        self._AttributeFlags = None
        self._LoadBalancerDomain = None
        self._Egress = None
        self._Exclusive = None
        self._TargetCount = None
        self._AssociateEndpoint = None
        self._AvailableZoneAffinityInfo = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例 ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def LoadBalancerName(self):
        r"""负载均衡实例的名称。
        :rtype: str
        """
        return self._LoadBalancerName

    @LoadBalancerName.setter
    def LoadBalancerName(self, LoadBalancerName):
        self._LoadBalancerName = LoadBalancerName

    @property
    def LoadBalancerType(self):
        r"""负载均衡实例的网络类型：
OPEN：公网属性， INTERNAL：内网属性；对于内网属性的负载均衡，可通过绑定EIP出公网，具体可参考EIP文档[绑定弹性公网IP](https://cloud.tencent.com/document/product/215/16700)。
        :rtype: str
        """
        return self._LoadBalancerType

    @LoadBalancerType.setter
    def LoadBalancerType(self, LoadBalancerType):
        self._LoadBalancerType = LoadBalancerType

    @property
    def Forward(self):
        r"""负载均衡类型标识，1：负载均衡，0：传统型负载均衡。
        :rtype: int
        """
        return self._Forward

    @Forward.setter
    def Forward(self, Forward):
        self._Forward = Forward

    @property
    def Domain(self):
        r"""负载均衡实例的域名，仅公网传统型和域名型负载均衡实例才提供该字段。逐步下线中，建议用LoadBalancerDomain替代。
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def LoadBalancerVips(self):
        r"""负载均衡实例的 VIP 列表。
        :rtype: list of str
        """
        return self._LoadBalancerVips

    @LoadBalancerVips.setter
    def LoadBalancerVips(self, LoadBalancerVips):
        self._LoadBalancerVips = LoadBalancerVips

    @property
    def Status(self):
        r"""负载均衡实例的状态，包括
0：创建中，1：正常运行。
        :rtype: int
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status

    @property
    def CreateTime(self):
        r"""负载均衡实例的创建时间。
格式：YYYY-MM-DD HH:mm:ss
        :rtype: str
        """
        return self._CreateTime

    @CreateTime.setter
    def CreateTime(self, CreateTime):
        self._CreateTime = CreateTime

    @property
    def StatusTime(self):
        r"""负载均衡实例的上次状态转换时间。
格式：YYYY-MM-DD HH:mm:ss
        :rtype: str
        """
        return self._StatusTime

    @StatusTime.setter
    def StatusTime(self, StatusTime):
        self._StatusTime = StatusTime

    @property
    def ProjectId(self):
        r"""负载均衡实例所属的项目 ID， 0 表示默认项目。
        :rtype: int
        """
        return self._ProjectId

    @ProjectId.setter
    def ProjectId(self, ProjectId):
        self._ProjectId = ProjectId

    @property
    def VpcId(self):
        r"""私有网络的 ID
        :rtype: str
        """
        return self._VpcId

    @VpcId.setter
    def VpcId(self, VpcId):
        self._VpcId = VpcId

    @property
    def OpenBgp(self):
        r"""高防 LB 的标识，1：高防负载均衡 0：非高防负载均衡。
        :rtype: int
        """
        return self._OpenBgp

    @OpenBgp.setter
    def OpenBgp(self, OpenBgp):
        self._OpenBgp = OpenBgp

    @property
    def Snat(self):
        r"""是否开启 SNAT，在 2016 年 12 月份之前的传统型内网负载均衡都是开启了 SNAT 的。
        :rtype: bool
        """
        return self._Snat

    @Snat.setter
    def Snat(self, Snat):
        self._Snat = Snat

    @property
    def Isolation(self):
        r"""是否被隔离，0：表示未被隔离，1：表示被隔离。
        :rtype: int
        """
        return self._Isolation

    @Isolation.setter
    def Isolation(self, Isolation):
        self._Isolation = Isolation

    @property
    def Log(self):
        warnings.warn("parameter `Log` is deprecated", DeprecationWarning) 

        r"""用户开启日志的信息，日志只有公网属性创建了 HTTP 、HTTPS 监听器的负载均衡才会有日志。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Log

    @Log.setter
    def Log(self, Log):
        warnings.warn("parameter `Log` is deprecated", DeprecationWarning) 

        self._Log = Log

    @property
    def SubnetId(self):
        r"""负载均衡实例所在的子网（仅对内网VPC型LB有意义）
        :rtype: str
        """
        return self._SubnetId

    @SubnetId.setter
    def SubnetId(self, SubnetId):
        self._SubnetId = SubnetId

    @property
    def Tags(self):
        r"""负载均衡实例的标签信息
        :rtype: list of TagInfo
        """
        return self._Tags

    @Tags.setter
    def Tags(self, Tags):
        self._Tags = Tags

    @property
    def SecureGroups(self):
        r"""负载均衡实例的安全组
        :rtype: list of str
        """
        return self._SecureGroups

    @SecureGroups.setter
    def SecureGroups(self, SecureGroups):
        self._SecureGroups = SecureGroups

    @property
    def TargetRegionInfo(self):
        r"""负载均衡实例绑定的后端设备的基本信息
        :rtype: :class:`tencentcloud.clb.v20180317.models.TargetRegionInfo`
        """
        return self._TargetRegionInfo

    @TargetRegionInfo.setter
    def TargetRegionInfo(self, TargetRegionInfo):
        self._TargetRegionInfo = TargetRegionInfo

    @property
    def AnycastZone(self):
        r"""anycast负载均衡的发布域，对于非anycast的负载均衡，此字段返回为空字符串
        :rtype: str
        """
        return self._AnycastZone

    @AnycastZone.setter
    def AnycastZone(self, AnycastZone):
        self._AnycastZone = AnycastZone

    @property
    def AddressIPVersion(self):
        r"""IP版本，ipv4 | ipv6
        :rtype: str
        """
        return self._AddressIPVersion

    @AddressIPVersion.setter
    def AddressIPVersion(self, AddressIPVersion):
        self._AddressIPVersion = AddressIPVersion

    @property
    def NumericalVpcId(self):
        r"""数值形式的私有网络 ID，可以通过[DescribeVpcs](https://cloud.tencent.com/document/product/215/15778)接口获取。
        :rtype: int
        """
        return self._NumericalVpcId

    @NumericalVpcId.setter
    def NumericalVpcId(self, NumericalVpcId):
        self._NumericalVpcId = NumericalVpcId

    @property
    def VipIsp(self):
        r"""负载均衡IP地址所属的运营商。

- BGP :  BGP（多线）
- CMCC：中国移动单线
- CTCC：中国电信单线
- CUCC：中国联通单线
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._VipIsp

    @VipIsp.setter
    def VipIsp(self, VipIsp):
        self._VipIsp = VipIsp

    @property
    def MasterZone(self):
        r"""主可用区
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.ZoneInfo`
        """
        return self._MasterZone

    @MasterZone.setter
    def MasterZone(self, MasterZone):
        self._MasterZone = MasterZone

    @property
    def BackupZoneSet(self):
        r"""备可用区
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: list of ZoneInfo
        """
        return self._BackupZoneSet

    @BackupZoneSet.setter
    def BackupZoneSet(self, BackupZoneSet):
        self._BackupZoneSet = BackupZoneSet

    @property
    def IsolatedTime(self):
        r"""负载均衡实例被隔离的时间。
格式：YYYY-MM-DD HH:mm:ss
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._IsolatedTime

    @IsolatedTime.setter
    def IsolatedTime(self, IsolatedTime):
        self._IsolatedTime = IsolatedTime

    @property
    def ExpireTime(self):
        r"""负载均衡实例的过期时间，仅对预付费负载均衡生效。
格式：YYYY-MM-DD HH:mm:ss
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ExpireTime

    @ExpireTime.setter
    def ExpireTime(self, ExpireTime):
        self._ExpireTime = ExpireTime

    @property
    def ChargeType(self):
        r"""负载均衡实例的计费类型，PREPAID：包年包月，POSTPAID_BY_HOUR：按量计费
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ChargeType

    @ChargeType.setter
    def ChargeType(self, ChargeType):
        self._ChargeType = ChargeType

    @property
    def NetworkAttributes(self):
        r"""负载均衡实例的网络属性
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.InternetAccessible`
        """
        return self._NetworkAttributes

    @NetworkAttributes.setter
    def NetworkAttributes(self, NetworkAttributes):
        self._NetworkAttributes = NetworkAttributes

    @property
    def PrepaidAttributes(self):
        r"""负载均衡实例的预付费相关属性，仅在 ChargeType=PREPAID 时显示。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.LBChargePrepaid`
        """
        return self._PrepaidAttributes

    @PrepaidAttributes.setter
    def PrepaidAttributes(self, PrepaidAttributes):
        self._PrepaidAttributes = PrepaidAttributes

    @property
    def LogSetId(self):
        r"""负载均衡日志服务(CLS)的日志集ID
        :rtype: str
        """
        return self._LogSetId

    @LogSetId.setter
    def LogSetId(self, LogSetId):
        self._LogSetId = LogSetId

    @property
    def LogTopicId(self):
        r"""负载均衡日志服务(CLS)的日志主题ID
        :rtype: str
        """
        return self._LogTopicId

    @LogTopicId.setter
    def LogTopicId(self, LogTopicId):
        self._LogTopicId = LogTopicId

    @property
    def AddressIPv6(self):
        r"""负载均衡实例的IPv6地址
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._AddressIPv6

    @AddressIPv6.setter
    def AddressIPv6(self, AddressIPv6):
        self._AddressIPv6 = AddressIPv6

    @property
    def ExtraInfo(self):
        r"""暂做保留，一般用户无需关注。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.ExtraInfo`
        """
        return self._ExtraInfo

    @ExtraInfo.setter
    def ExtraInfo(self, ExtraInfo):
        self._ExtraInfo = ExtraInfo

    @property
    def IsDDos(self):
        r"""是否可绑定高防包
        :rtype: bool
        """
        return self._IsDDos

    @IsDDos.setter
    def IsDDos(self, IsDDos):
        self._IsDDos = IsDDos

    @property
    def ConfigId(self):
        r"""负载均衡维度的个性化配置ID
        :rtype: str
        """
        return self._ConfigId

    @ConfigId.setter
    def ConfigId(self, ConfigId):
        self._ConfigId = ConfigId

    @property
    def LoadBalancerPassToTarget(self):
        r"""后端服务是否放通来自LB的流量
        :rtype: bool
        """
        return self._LoadBalancerPassToTarget

    @LoadBalancerPassToTarget.setter
    def LoadBalancerPassToTarget(self, LoadBalancerPassToTarget):
        self._LoadBalancerPassToTarget = LoadBalancerPassToTarget

    @property
    def ExclusiveCluster(self):
        r"""内网独占集群
        :rtype: :class:`tencentcloud.clb.v20180317.models.ExclusiveCluster`
        """
        return self._ExclusiveCluster

    @ExclusiveCluster.setter
    def ExclusiveCluster(self, ExclusiveCluster):
        self._ExclusiveCluster = ExclusiveCluster

    @property
    def IPv6Mode(self):
        r"""IP地址版本为ipv6时此字段有意义，IPv6Nat64 | IPv6FullChain。
IPv6Nat64: 基于 NAT64 IPv6 过渡技术实现的负载均衡器。
IPv6FullChain：基于 IPv6 单栈技术实现的负载均衡。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._IPv6Mode

    @IPv6Mode.setter
    def IPv6Mode(self, IPv6Mode):
        self._IPv6Mode = IPv6Mode

    @property
    def SnatPro(self):
        r"""是否开启SnatPro。
        :rtype: bool
        """
        return self._SnatPro

    @SnatPro.setter
    def SnatPro(self, SnatPro):
        self._SnatPro = SnatPro

    @property
    def SnatIps(self):
        r"""开启SnatPro负载均衡后，SnatIp列表。
        :rtype: list of SnatIp
        """
        return self._SnatIps

    @SnatIps.setter
    def SnatIps(self, SnatIps):
        self._SnatIps = SnatIps

    @property
    def SlaType(self):
        r"""性能容量型规格。<ul><li> clb.c1.small：简约型规格 </li><li> clb.c2.medium：标准型规格 </li><li> clb.c3.small：高阶型1规格 </li><li> clb.c3.medium：高阶型2规格 </li><li> clb.c4.small：超强型1规格 </li><li> clb.c4.medium：超强型2规格 </li><li> clb.c4.large：超强型3规格 </li><li> clb.c4.xlarge：超强型4规格 </li><li>""：非性能容量型实例</li></ul>
        :rtype: str
        """
        return self._SlaType

    @SlaType.setter
    def SlaType(self, SlaType):
        self._SlaType = SlaType

    @property
    def IsBlock(self):
        r"""vip是否被封堵
        :rtype: bool
        """
        return self._IsBlock

    @IsBlock.setter
    def IsBlock(self, IsBlock):
        self._IsBlock = IsBlock

    @property
    def IsBlockTime(self):
        r"""封堵或解封时间。
格式：YYYY-MM-DD HH:mm:ss。
        :rtype: str
        """
        return self._IsBlockTime

    @IsBlockTime.setter
    def IsBlockTime(self, IsBlockTime):
        self._IsBlockTime = IsBlockTime

    @property
    def LocalBgp(self):
        r"""IP类型是否是本地BGP
        :rtype: bool
        """
        return self._LocalBgp

    @LocalBgp.setter
    def LocalBgp(self, LocalBgp):
        self._LocalBgp = LocalBgp

    @property
    def ClusterTag(self):
        r"""7层独占标签。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ClusterTag

    @ClusterTag.setter
    def ClusterTag(self, ClusterTag):
        self._ClusterTag = ClusterTag

    @property
    def MixIpTarget(self):
        r"""开启IPv6FullChain负载均衡7层监听器支持混绑IPv4/IPv6目标功能。
        :rtype: bool
        """
        return self._MixIpTarget

    @MixIpTarget.setter
    def MixIpTarget(self, MixIpTarget):
        self._MixIpTarget = MixIpTarget

    @property
    def Zones(self):
        r"""私有网络内网负载均衡，就近接入模式下规则所落在的可用区
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: list of str
        """
        return self._Zones

    @Zones.setter
    def Zones(self, Zones):
        self._Zones = Zones

    @property
    def NfvInfo(self):
        r"""CLB是否为NFV，空：不是，l7nfv：七层是NFV。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._NfvInfo

    @NfvInfo.setter
    def NfvInfo(self, NfvInfo):
        self._NfvInfo = NfvInfo

    @property
    def HealthLogSetId(self):
        r"""负载均衡日志服务(CLS)的健康检查日志集ID
        :rtype: str
        """
        return self._HealthLogSetId

    @HealthLogSetId.setter
    def HealthLogSetId(self, HealthLogSetId):
        self._HealthLogSetId = HealthLogSetId

    @property
    def HealthLogTopicId(self):
        r"""负载均衡日志服务(CLS)的健康检查日志主题ID
        :rtype: str
        """
        return self._HealthLogTopicId

    @HealthLogTopicId.setter
    def HealthLogTopicId(self, HealthLogTopicId):
        self._HealthLogTopicId = HealthLogTopicId

    @property
    def ClusterIds(self):
        r"""集群ID
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: list of str
        """
        return self._ClusterIds

    @ClusterIds.setter
    def ClusterIds(self, ClusterIds):
        self._ClusterIds = ClusterIds

    @property
    def AttributeFlags(self):
        r"""负载均衡的属性，传入字符串数组来决定是否开启
DeleteProtect: 删除保护，开启后防止负载均衡被误删除。 
UserInVisible: 用户不可见，控制负载均衡对用户的可见性。 
BlockStatus: 阻塞状态，用于限制负载均衡的某些操作或流量。 
NoLBNat: 禁用负载均衡的NAT功能，用于特定场景下的流量直接转发。 
BanStatus: 封禁状态，用于暂停负载均衡服务或限制访问。 
ShiftupFlag: 升配标志，用于标识负载均衡需要升级配置或性能。 
Stop: 停止状态，开启后负载均衡暂停服务。 
NoVpcGw: 不使用VPC网关，用于绕过VPC网关直接处理流量。 
SgInTgw: 安全组在TGW（Transit Gateway）中，涉及网络安全策略配置。 
SharedLimitFlag: 共享限制标志，用于控制负载均衡的共享资源限制。 
WafFlag: Web应用防火墙（WAF）标志，开启后启用WAF保护。 
IsDomainCLB: 域名型负载均衡，标识负载均衡是否基于域名进行流量分发。 
IPv6Snat: IPv6源地址转换（SNAT），用于IPv6网络的源地址处理。 
HideDomain: 隐藏域名，用于隐私保护或特定场景下不暴露域名。 
JumboFrame: 巨型帧支持，开启后支持更大的数据帧以提高网络效率。 
NoLBNatL4IPdc: 四层IP直连无NAT，用于四层负载均衡直接转发IP流量。 
VpcGwL3Service: VPC网关三层服务，涉及三层网络服务的网关功能。 
Ipv62Flag: IPv6扩展标志，用于特定的IPv6功能支持。 
Ipv62ExclusiveFlag: IPv6独占标志，用于专属IPv6流量处理。 
BgpPro: BGP Pro 支持。 
ToaClean: TOA（TCP Option Address）清理，清除TCP选项中的地址信息。 

        :rtype: list of str
        """
        return self._AttributeFlags

    @AttributeFlags.setter
    def AttributeFlags(self, AttributeFlags):
        self._AttributeFlags = AttributeFlags

    @property
    def LoadBalancerDomain(self):
        r"""负载均衡实例的域名。
        :rtype: str
        """
        return self._LoadBalancerDomain

    @LoadBalancerDomain.setter
    def LoadBalancerDomain(self, LoadBalancerDomain):
        self._LoadBalancerDomain = LoadBalancerDomain

    @property
    def Egress(self):
        r"""网络出口
        :rtype: str
        """
        return self._Egress

    @Egress.setter
    def Egress(self, Egress):
        self._Egress = Egress

    @property
    def Exclusive(self):
        r"""实例类型是否为独占型。1：独占型实例。0：非独占型实例。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._Exclusive

    @Exclusive.setter
    def Exclusive(self, Exclusive):
        self._Exclusive = Exclusive

    @property
    def TargetCount(self):
        r"""已绑定的后端服务数量。
        :rtype: int
        """
        return self._TargetCount

    @TargetCount.setter
    def TargetCount(self, TargetCount):
        self._TargetCount = TargetCount

    @property
    def AssociateEndpoint(self):
        r"""负载均衡实例关联的Endpoint id。
        :rtype: str
        """
        return self._AssociateEndpoint

    @AssociateEndpoint.setter
    def AssociateEndpoint(self, AssociateEndpoint):
        self._AssociateEndpoint = AssociateEndpoint

    @property
    def AvailableZoneAffinityInfo(self):
        r"""可用区转发亲和信息
        :rtype: :class:`tencentcloud.clb.v20180317.models.AvailableZoneAffinityInfo`
        """
        return self._AvailableZoneAffinityInfo

    @AvailableZoneAffinityInfo.setter
    def AvailableZoneAffinityInfo(self, AvailableZoneAffinityInfo):
        self._AvailableZoneAffinityInfo = AvailableZoneAffinityInfo


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._LoadBalancerName = params.get("LoadBalancerName")
        self._LoadBalancerType = params.get("LoadBalancerType")
        self._Forward = params.get("Forward")
        self._Domain = params.get("Domain")
        self._LoadBalancerVips = params.get("LoadBalancerVips")
        self._Status = params.get("Status")
        self._CreateTime = params.get("CreateTime")
        self._StatusTime = params.get("StatusTime")
        self._ProjectId = params.get("ProjectId")
        self._VpcId = params.get("VpcId")
        self._OpenBgp = params.get("OpenBgp")
        self._Snat = params.get("Snat")
        self._Isolation = params.get("Isolation")
        self._Log = params.get("Log")
        self._SubnetId = params.get("SubnetId")
        if params.get("Tags") is not None:
            self._Tags = []
            for item in params.get("Tags"):
                obj = TagInfo()
                obj._deserialize(item)
                self._Tags.append(obj)
        self._SecureGroups = params.get("SecureGroups")
        if params.get("TargetRegionInfo") is not None:
            self._TargetRegionInfo = TargetRegionInfo()
            self._TargetRegionInfo._deserialize(params.get("TargetRegionInfo"))
        self._AnycastZone = params.get("AnycastZone")
        self._AddressIPVersion = params.get("AddressIPVersion")
        self._NumericalVpcId = params.get("NumericalVpcId")
        self._VipIsp = params.get("VipIsp")
        if params.get("MasterZone") is not None:
            self._MasterZone = ZoneInfo()
            self._MasterZone._deserialize(params.get("MasterZone"))
        if params.get("BackupZoneSet") is not None:
            self._BackupZoneSet = []
            for item in params.get("BackupZoneSet"):
                obj = ZoneInfo()
                obj._deserialize(item)
                self._BackupZoneSet.append(obj)
        self._IsolatedTime = params.get("IsolatedTime")
        self._ExpireTime = params.get("ExpireTime")
        self._ChargeType = params.get("ChargeType")
        if params.get("NetworkAttributes") is not None:
            self._NetworkAttributes = InternetAccessible()
            self._NetworkAttributes._deserialize(params.get("NetworkAttributes"))
        if params.get("PrepaidAttributes") is not None:
            self._PrepaidAttributes = LBChargePrepaid()
            self._PrepaidAttributes._deserialize(params.get("PrepaidAttributes"))
        self._LogSetId = params.get("LogSetId")
        self._LogTopicId = params.get("LogTopicId")
        self._AddressIPv6 = params.get("AddressIPv6")
        if params.get("ExtraInfo") is not None:
            self._ExtraInfo = ExtraInfo()
            self._ExtraInfo._deserialize(params.get("ExtraInfo"))
        self._IsDDos = params.get("IsDDos")
        self._ConfigId = params.get("ConfigId")
        self._LoadBalancerPassToTarget = params.get("LoadBalancerPassToTarget")
        if params.get("ExclusiveCluster") is not None:
            self._ExclusiveCluster = ExclusiveCluster()
            self._ExclusiveCluster._deserialize(params.get("ExclusiveCluster"))
        self._IPv6Mode = params.get("IPv6Mode")
        self._SnatPro = params.get("SnatPro")
        if params.get("SnatIps") is not None:
            self._SnatIps = []
            for item in params.get("SnatIps"):
                obj = SnatIp()
                obj._deserialize(item)
                self._SnatIps.append(obj)
        self._SlaType = params.get("SlaType")
        self._IsBlock = params.get("IsBlock")
        self._IsBlockTime = params.get("IsBlockTime")
        self._LocalBgp = params.get("LocalBgp")
        self._ClusterTag = params.get("ClusterTag")
        self._MixIpTarget = params.get("MixIpTarget")
        self._Zones = params.get("Zones")
        self._NfvInfo = params.get("NfvInfo")
        self._HealthLogSetId = params.get("HealthLogSetId")
        self._HealthLogTopicId = params.get("HealthLogTopicId")
        self._ClusterIds = params.get("ClusterIds")
        self._AttributeFlags = params.get("AttributeFlags")
        self._LoadBalancerDomain = params.get("LoadBalancerDomain")
        self._Egress = params.get("Egress")
        self._Exclusive = params.get("Exclusive")
        self._TargetCount = params.get("TargetCount")
        self._AssociateEndpoint = params.get("AssociateEndpoint")
        if params.get("AvailableZoneAffinityInfo") is not None:
            self._AvailableZoneAffinityInfo = AvailableZoneAffinityInfo()
            self._AvailableZoneAffinityInfo._deserialize(params.get("AvailableZoneAffinityInfo"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class LoadBalancerDetail(AbstractModel):
    r"""负载均衡详细信息

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例 ID。
        :type LoadBalancerId: str
        :param _LoadBalancerName: 负载均衡实例的名称。
        :type LoadBalancerName: str
        :param _LoadBalancerType: 负载均衡实例的网络类型：
Public：公网属性，Private：内网属性；对于内网属性的负载均衡，可通过绑定EIP出公网，具体可参考EIP文档。
注意：此字段可能返回 null，表示取不到有效值。
        :type LoadBalancerType: str
        :param _Status: 负载均衡实例的状态，包括
0：创建中，1：正常运行。
注意：此字段可能返回 null，表示取不到有效值。
        :type Status: int
        :param _Address: 负载均衡实例的 VIP 。
注意：此字段可能返回 null，表示取不到有效值。
        :type Address: str
        :param _AddressIPv6: 负载均衡实例 VIP 的IPv6地址。
注意：此字段可能返回 null，表示取不到有效值。
        :type AddressIPv6: str
        :param _AddressIPVersion: 负载均衡实例IP版本，IPv4 | IPv6。
注意：此字段可能返回 null，表示取不到有效值。
        :type AddressIPVersion: str
        :param _IPv6Mode: 负载均衡实例IPv6地址类型，IPv6Nat64 | IPv6FullChain。
注意：此字段可能返回 null，表示取不到有效值。
        :type IPv6Mode: str
        :param _Zone: 负载均衡实例所在可用区。
注意：此字段可能返回 null，表示取不到有效值。
        :type Zone: str
        :param _AddressIsp: 负载均衡实例IP地址所属的ISP。取值范围：BGP（多线）、CMCC（中国移动）、CUCC（中国联通）、CTCC（中国电信）、INTERNAL（内网）。
注意：此字段可能返回 null，表示取不到有效值。
        :type AddressIsp: str
        :param _VpcId: 负载均衡实例所属私有网络的 ID。
注意：此字段可能返回 null，表示取不到有效值。
        :type VpcId: str
        :param _ProjectId: 负载均衡实例所属的项目 ID， 0 表示默认项目。
注意：此字段可能返回 null，表示取不到有效值。
        :type ProjectId: int
        :param _CreateTime: 负载均衡实例的创建时间。
注意：此字段可能返回 null，表示取不到有效值。
        :type CreateTime: str
        :param _ChargeType: 负载均衡实例的计费类型。取值范围：PREPAID预付费、POSTPAID_BY_HOUR按量付费。
注意：此字段可能返回 null，表示取不到有效值。
        :type ChargeType: str
        :param _NetworkAttributes: 负载均衡实例的网络属性。
注意：此字段可能返回 null，表示取不到有效值。
        :type NetworkAttributes: :class:`tencentcloud.clb.v20180317.models.InternetAccessible`
        :param _PrepaidAttributes: 负载均衡实例的预付费相关属性。
注意：此字段可能返回 null，表示取不到有效值。
        :type PrepaidAttributes: :class:`tencentcloud.clb.v20180317.models.LBChargePrepaid`
        :param _ExtraInfo: 暂做保留，一般用户无需关注。
注意：此字段可能返回 null，表示取不到有效值。
        :type ExtraInfo: :class:`tencentcloud.clb.v20180317.models.ExtraInfo`
        :param _ConfigId: 负载均衡维度的个性化配置ID，多个配置用逗号隔开。
注意：此字段可能返回 null，表示取不到有效值。
        :type ConfigId: str
        :param _Tags: 负载均衡实例的标签信息。
注意：此字段可能返回 null，表示取不到有效值。
        :type Tags: list of TagInfo
        :param _ListenerId: 负载均衡监听器 ID。
注意：此字段可能返回 null，表示取不到有效值。
        :type ListenerId: str
        :param _Protocol: 监听器协议。
注意：此字段可能返回 null，表示取不到有效值。
        :type Protocol: str
        :param _Port: 监听器端口。
注意：此字段可能返回 null，表示取不到有效值。
        :type Port: int
        :param _LocationId: 转发规则的 ID。
注意：此字段可能返回 null，表示取不到有效值。
        :type LocationId: str
        :param _Domain: 转发规则的域名。
注意：此字段可能返回 null，表示取不到有效值。
        :type Domain: str
        :param _Url: 转发规则的路径。
注意：此字段可能返回 null，表示取不到有效值。
        :type Url: str
        :param _TargetId: 后端目标ID。
注意：此字段可能返回 null，表示取不到有效值。
        :type TargetId: str
        :param _TargetAddress: 后端目标的IP地址。
注意：此字段可能返回 null，表示取不到有效值。
        :type TargetAddress: str
        :param _TargetPort: 后端目标监听端口。
注意：此字段可能返回 null，表示取不到有效值。
        :type TargetPort: int
        :param _TargetWeight: 后端目标转发权重。
注意：此字段可能返回 null，表示取不到有效值。
        :type TargetWeight: int
        :param _Isolation: 0：表示未被隔离，1：表示被隔离。
注意：此字段可能返回 null，表示取不到有效值。
        :type Isolation: int
        :param _SecurityGroup: 负载均衡绑定的安全组列表。
注意：此字段可能返回 null，表示取不到有效值。
        :type SecurityGroup: list of str
        :param _LoadBalancerPassToTarget: 负载均衡安全组上移特性是否开启标识。取值范围：1表示开启、0表示未开启。
注意：此字段可能返回 null，表示取不到有效值。
        :type LoadBalancerPassToTarget: int
        :param _TargetHealth: 后端目标健康状态。
注意：此字段可能返回 null，表示取不到有效值。
        :type TargetHealth: str
        :param _Domains: 转发规则的域名列表。
注意：此字段可能返回 null，表示取不到有效值。
        :type Domains: str
        :param _SlaveZone: 多可用区负载均衡实例所选备区
注意：此字段可能返回 null，表示取不到有效值。
        :type SlaveZone: list of str
        :param _Zones: 内网负载均衡实例所在可用区，由白名单CLB_Internal_Zone控制
注意：此字段可能返回 null，表示取不到有效值。
        :type Zones: list of str
        :param _SniSwitch: 是否开启SNI特性，1：表示开启，0：表示不开启（本参数仅对于HTTPS监听器有意义）。
注意：此字段可能返回 null，表示取不到有效值。
        :type SniSwitch: int
        :param _LoadBalancerDomain: 负载均衡实例的域名。
        :type LoadBalancerDomain: str
        :param _Egress: 网络出口
        :type Egress: str
        :param _AttributeFlags: 负载均衡的属性
注意：此字段可能返回 null，表示取不到有效值。
        :type AttributeFlags: list of str
        :param _SlaType: 负载均衡实例的规格类型信息<ul><li> clb.c1.small：简约型规格 </li><li>clb.c2.medium：标准型规格 </li><li> clb.c3.small：高阶型1规格 </li><li> clb.c3.medium：高阶型2规格 </li><li> clb.c4.small：超强型1规格 </li><li> clb.c4.medium：超强型2规格 </li><li> clb.c4.large：超强型3规格 </li><li> clb.c4.xlarge：超强型4规格 </li><li>""：非性能容量型实例</li></ul>

注意：此字段可能返回 null，表示取不到有效值。
        :type SlaType: str
        :param _Exclusive: 0：表示非独占型实例，1：表示独占型态实例。
注意：此字段可能返回 null，表示取不到有效值。
        :type Exclusive: int
        :param _AvailableZoneAffinityInfo: 可用区转发亲和信息
注意：此字段可能返回 null，表示取不到有效值。
        :type AvailableZoneAffinityInfo: :class:`tencentcloud.clb.v20180317.models.AvailableZoneAffinityInfo`
        """
        self._LoadBalancerId = None
        self._LoadBalancerName = None
        self._LoadBalancerType = None
        self._Status = None
        self._Address = None
        self._AddressIPv6 = None
        self._AddressIPVersion = None
        self._IPv6Mode = None
        self._Zone = None
        self._AddressIsp = None
        self._VpcId = None
        self._ProjectId = None
        self._CreateTime = None
        self._ChargeType = None
        self._NetworkAttributes = None
        self._PrepaidAttributes = None
        self._ExtraInfo = None
        self._ConfigId = None
        self._Tags = None
        self._ListenerId = None
        self._Protocol = None
        self._Port = None
        self._LocationId = None
        self._Domain = None
        self._Url = None
        self._TargetId = None
        self._TargetAddress = None
        self._TargetPort = None
        self._TargetWeight = None
        self._Isolation = None
        self._SecurityGroup = None
        self._LoadBalancerPassToTarget = None
        self._TargetHealth = None
        self._Domains = None
        self._SlaveZone = None
        self._Zones = None
        self._SniSwitch = None
        self._LoadBalancerDomain = None
        self._Egress = None
        self._AttributeFlags = None
        self._SlaType = None
        self._Exclusive = None
        self._AvailableZoneAffinityInfo = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例 ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def LoadBalancerName(self):
        r"""负载均衡实例的名称。
        :rtype: str
        """
        return self._LoadBalancerName

    @LoadBalancerName.setter
    def LoadBalancerName(self, LoadBalancerName):
        self._LoadBalancerName = LoadBalancerName

    @property
    def LoadBalancerType(self):
        r"""负载均衡实例的网络类型：
Public：公网属性，Private：内网属性；对于内网属性的负载均衡，可通过绑定EIP出公网，具体可参考EIP文档。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._LoadBalancerType

    @LoadBalancerType.setter
    def LoadBalancerType(self, LoadBalancerType):
        self._LoadBalancerType = LoadBalancerType

    @property
    def Status(self):
        r"""负载均衡实例的状态，包括
0：创建中，1：正常运行。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status

    @property
    def Address(self):
        r"""负载均衡实例的 VIP 。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Address

    @Address.setter
    def Address(self, Address):
        self._Address = Address

    @property
    def AddressIPv6(self):
        r"""负载均衡实例 VIP 的IPv6地址。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._AddressIPv6

    @AddressIPv6.setter
    def AddressIPv6(self, AddressIPv6):
        self._AddressIPv6 = AddressIPv6

    @property
    def AddressIPVersion(self):
        r"""负载均衡实例IP版本，IPv4 | IPv6。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._AddressIPVersion

    @AddressIPVersion.setter
    def AddressIPVersion(self, AddressIPVersion):
        self._AddressIPVersion = AddressIPVersion

    @property
    def IPv6Mode(self):
        r"""负载均衡实例IPv6地址类型，IPv6Nat64 | IPv6FullChain。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._IPv6Mode

    @IPv6Mode.setter
    def IPv6Mode(self, IPv6Mode):
        self._IPv6Mode = IPv6Mode

    @property
    def Zone(self):
        r"""负载均衡实例所在可用区。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Zone

    @Zone.setter
    def Zone(self, Zone):
        self._Zone = Zone

    @property
    def AddressIsp(self):
        r"""负载均衡实例IP地址所属的ISP。取值范围：BGP（多线）、CMCC（中国移动）、CUCC（中国联通）、CTCC（中国电信）、INTERNAL（内网）。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._AddressIsp

    @AddressIsp.setter
    def AddressIsp(self, AddressIsp):
        self._AddressIsp = AddressIsp

    @property
    def VpcId(self):
        r"""负载均衡实例所属私有网络的 ID。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._VpcId

    @VpcId.setter
    def VpcId(self, VpcId):
        self._VpcId = VpcId

    @property
    def ProjectId(self):
        r"""负载均衡实例所属的项目 ID， 0 表示默认项目。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._ProjectId

    @ProjectId.setter
    def ProjectId(self, ProjectId):
        self._ProjectId = ProjectId

    @property
    def CreateTime(self):
        r"""负载均衡实例的创建时间。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._CreateTime

    @CreateTime.setter
    def CreateTime(self, CreateTime):
        self._CreateTime = CreateTime

    @property
    def ChargeType(self):
        r"""负载均衡实例的计费类型。取值范围：PREPAID预付费、POSTPAID_BY_HOUR按量付费。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ChargeType

    @ChargeType.setter
    def ChargeType(self, ChargeType):
        self._ChargeType = ChargeType

    @property
    def NetworkAttributes(self):
        r"""负载均衡实例的网络属性。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.InternetAccessible`
        """
        return self._NetworkAttributes

    @NetworkAttributes.setter
    def NetworkAttributes(self, NetworkAttributes):
        self._NetworkAttributes = NetworkAttributes

    @property
    def PrepaidAttributes(self):
        r"""负载均衡实例的预付费相关属性。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.LBChargePrepaid`
        """
        return self._PrepaidAttributes

    @PrepaidAttributes.setter
    def PrepaidAttributes(self, PrepaidAttributes):
        self._PrepaidAttributes = PrepaidAttributes

    @property
    def ExtraInfo(self):
        r"""暂做保留，一般用户无需关注。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.ExtraInfo`
        """
        return self._ExtraInfo

    @ExtraInfo.setter
    def ExtraInfo(self, ExtraInfo):
        self._ExtraInfo = ExtraInfo

    @property
    def ConfigId(self):
        r"""负载均衡维度的个性化配置ID，多个配置用逗号隔开。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ConfigId

    @ConfigId.setter
    def ConfigId(self, ConfigId):
        self._ConfigId = ConfigId

    @property
    def Tags(self):
        r"""负载均衡实例的标签信息。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: list of TagInfo
        """
        return self._Tags

    @Tags.setter
    def Tags(self, Tags):
        self._Tags = Tags

    @property
    def ListenerId(self):
        r"""负载均衡监听器 ID。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def Protocol(self):
        r"""监听器协议。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Protocol

    @Protocol.setter
    def Protocol(self, Protocol):
        self._Protocol = Protocol

    @property
    def Port(self):
        r"""监听器端口。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def LocationId(self):
        r"""转发规则的 ID。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._LocationId

    @LocationId.setter
    def LocationId(self, LocationId):
        self._LocationId = LocationId

    @property
    def Domain(self):
        r"""转发规则的域名。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def Url(self):
        r"""转发规则的路径。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Url

    @Url.setter
    def Url(self, Url):
        self._Url = Url

    @property
    def TargetId(self):
        r"""后端目标ID。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._TargetId

    @TargetId.setter
    def TargetId(self, TargetId):
        self._TargetId = TargetId

    @property
    def TargetAddress(self):
        r"""后端目标的IP地址。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._TargetAddress

    @TargetAddress.setter
    def TargetAddress(self, TargetAddress):
        self._TargetAddress = TargetAddress

    @property
    def TargetPort(self):
        r"""后端目标监听端口。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._TargetPort

    @TargetPort.setter
    def TargetPort(self, TargetPort):
        self._TargetPort = TargetPort

    @property
    def TargetWeight(self):
        r"""后端目标转发权重。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._TargetWeight

    @TargetWeight.setter
    def TargetWeight(self, TargetWeight):
        self._TargetWeight = TargetWeight

    @property
    def Isolation(self):
        r"""0：表示未被隔离，1：表示被隔离。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._Isolation

    @Isolation.setter
    def Isolation(self, Isolation):
        self._Isolation = Isolation

    @property
    def SecurityGroup(self):
        r"""负载均衡绑定的安全组列表。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: list of str
        """
        return self._SecurityGroup

    @SecurityGroup.setter
    def SecurityGroup(self, SecurityGroup):
        self._SecurityGroup = SecurityGroup

    @property
    def LoadBalancerPassToTarget(self):
        r"""负载均衡安全组上移特性是否开启标识。取值范围：1表示开启、0表示未开启。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._LoadBalancerPassToTarget

    @LoadBalancerPassToTarget.setter
    def LoadBalancerPassToTarget(self, LoadBalancerPassToTarget):
        self._LoadBalancerPassToTarget = LoadBalancerPassToTarget

    @property
    def TargetHealth(self):
        r"""后端目标健康状态。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._TargetHealth

    @TargetHealth.setter
    def TargetHealth(self, TargetHealth):
        self._TargetHealth = TargetHealth

    @property
    def Domains(self):
        r"""转发规则的域名列表。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Domains

    @Domains.setter
    def Domains(self, Domains):
        self._Domains = Domains

    @property
    def SlaveZone(self):
        r"""多可用区负载均衡实例所选备区
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: list of str
        """
        return self._SlaveZone

    @SlaveZone.setter
    def SlaveZone(self, SlaveZone):
        self._SlaveZone = SlaveZone

    @property
    def Zones(self):
        r"""内网负载均衡实例所在可用区，由白名单CLB_Internal_Zone控制
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: list of str
        """
        return self._Zones

    @Zones.setter
    def Zones(self, Zones):
        self._Zones = Zones

    @property
    def SniSwitch(self):
        r"""是否开启SNI特性，1：表示开启，0：表示不开启（本参数仅对于HTTPS监听器有意义）。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._SniSwitch

    @SniSwitch.setter
    def SniSwitch(self, SniSwitch):
        self._SniSwitch = SniSwitch

    @property
    def LoadBalancerDomain(self):
        r"""负载均衡实例的域名。
        :rtype: str
        """
        return self._LoadBalancerDomain

    @LoadBalancerDomain.setter
    def LoadBalancerDomain(self, LoadBalancerDomain):
        self._LoadBalancerDomain = LoadBalancerDomain

    @property
    def Egress(self):
        r"""网络出口
        :rtype: str
        """
        return self._Egress

    @Egress.setter
    def Egress(self, Egress):
        self._Egress = Egress

    @property
    def AttributeFlags(self):
        r"""负载均衡的属性
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: list of str
        """
        return self._AttributeFlags

    @AttributeFlags.setter
    def AttributeFlags(self, AttributeFlags):
        self._AttributeFlags = AttributeFlags

    @property
    def SlaType(self):
        r"""负载均衡实例的规格类型信息<ul><li> clb.c1.small：简约型规格 </li><li>clb.c2.medium：标准型规格 </li><li> clb.c3.small：高阶型1规格 </li><li> clb.c3.medium：高阶型2规格 </li><li> clb.c4.small：超强型1规格 </li><li> clb.c4.medium：超强型2规格 </li><li> clb.c4.large：超强型3规格 </li><li> clb.c4.xlarge：超强型4规格 </li><li>""：非性能容量型实例</li></ul>

注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._SlaType

    @SlaType.setter
    def SlaType(self, SlaType):
        self._SlaType = SlaType

    @property
    def Exclusive(self):
        r"""0：表示非独占型实例，1：表示独占型态实例。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._Exclusive

    @Exclusive.setter
    def Exclusive(self, Exclusive):
        self._Exclusive = Exclusive

    @property
    def AvailableZoneAffinityInfo(self):
        r"""可用区转发亲和信息
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.AvailableZoneAffinityInfo`
        """
        return self._AvailableZoneAffinityInfo

    @AvailableZoneAffinityInfo.setter
    def AvailableZoneAffinityInfo(self, AvailableZoneAffinityInfo):
        self._AvailableZoneAffinityInfo = AvailableZoneAffinityInfo


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._LoadBalancerName = params.get("LoadBalancerName")
        self._LoadBalancerType = params.get("LoadBalancerType")
        self._Status = params.get("Status")
        self._Address = params.get("Address")
        self._AddressIPv6 = params.get("AddressIPv6")
        self._AddressIPVersion = params.get("AddressIPVersion")
        self._IPv6Mode = params.get("IPv6Mode")
        self._Zone = params.get("Zone")
        self._AddressIsp = params.get("AddressIsp")
        self._VpcId = params.get("VpcId")
        self._ProjectId = params.get("ProjectId")
        self._CreateTime = params.get("CreateTime")
        self._ChargeType = params.get("ChargeType")
        if params.get("NetworkAttributes") is not None:
            self._NetworkAttributes = InternetAccessible()
            self._NetworkAttributes._deserialize(params.get("NetworkAttributes"))
        if params.get("PrepaidAttributes") is not None:
            self._PrepaidAttributes = LBChargePrepaid()
            self._PrepaidAttributes._deserialize(params.get("PrepaidAttributes"))
        if params.get("ExtraInfo") is not None:
            self._ExtraInfo = ExtraInfo()
            self._ExtraInfo._deserialize(params.get("ExtraInfo"))
        self._ConfigId = params.get("ConfigId")
        if params.get("Tags") is not None:
            self._Tags = []
            for item in params.get("Tags"):
                obj = TagInfo()
                obj._deserialize(item)
                self._Tags.append(obj)
        self._ListenerId = params.get("ListenerId")
        self._Protocol = params.get("Protocol")
        self._Port = params.get("Port")
        self._LocationId = params.get("LocationId")
        self._Domain = params.get("Domain")
        self._Url = params.get("Url")
        self._TargetId = params.get("TargetId")
        self._TargetAddress = params.get("TargetAddress")
        self._TargetPort = params.get("TargetPort")
        self._TargetWeight = params.get("TargetWeight")
        self._Isolation = params.get("Isolation")
        self._SecurityGroup = params.get("SecurityGroup")
        self._LoadBalancerPassToTarget = params.get("LoadBalancerPassToTarget")
        self._TargetHealth = params.get("TargetHealth")
        self._Domains = params.get("Domains")
        self._SlaveZone = params.get("SlaveZone")
        self._Zones = params.get("Zones")
        self._SniSwitch = params.get("SniSwitch")
        self._LoadBalancerDomain = params.get("LoadBalancerDomain")
        self._Egress = params.get("Egress")
        self._AttributeFlags = params.get("AttributeFlags")
        self._SlaType = params.get("SlaType")
        self._Exclusive = params.get("Exclusive")
        if params.get("AvailableZoneAffinityInfo") is not None:
            self._AvailableZoneAffinityInfo = AvailableZoneAffinityInfo()
            self._AvailableZoneAffinityInfo._deserialize(params.get("AvailableZoneAffinityInfo"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class LoadBalancerHealth(AbstractModel):
    r"""负载均衡实例的健康检查状态

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例ID
        :type LoadBalancerId: str
        :param _LoadBalancerName: 负载均衡实例名称
        :type LoadBalancerName: str
        :param _Listeners: 监听器列表
        :type Listeners: list of ListenerHealth
        """
        self._LoadBalancerId = None
        self._LoadBalancerName = None
        self._Listeners = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例ID
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def LoadBalancerName(self):
        r"""负载均衡实例名称
        :rtype: str
        """
        return self._LoadBalancerName

    @LoadBalancerName.setter
    def LoadBalancerName(self, LoadBalancerName):
        self._LoadBalancerName = LoadBalancerName

    @property
    def Listeners(self):
        r"""监听器列表
        :rtype: list of ListenerHealth
        """
        return self._Listeners

    @Listeners.setter
    def Listeners(self, Listeners):
        self._Listeners = Listeners


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._LoadBalancerName = params.get("LoadBalancerName")
        if params.get("Listeners") is not None:
            self._Listeners = []
            for item in params.get("Listeners"):
                obj = ListenerHealth()
                obj._deserialize(item)
                self._Listeners.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class LoadBalancerTraffic(AbstractModel):
    r"""负载均衡流量数据。

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡ID
        :type LoadBalancerId: str
        :param _LoadBalancerName: 负载均衡名字
        :type LoadBalancerName: str
        :param _Region: 负载均衡所在地域
        :type Region: str
        :param _Vip: 负载均衡的vip
        :type Vip: str
        :param _OutBandwidth: 最大出带宽，单位：Mbps
        :type OutBandwidth: float
        :param _Domain: CLB域名
        :type Domain: str
        """
        self._LoadBalancerId = None
        self._LoadBalancerName = None
        self._Region = None
        self._Vip = None
        self._OutBandwidth = None
        self._Domain = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡ID
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def LoadBalancerName(self):
        r"""负载均衡名字
        :rtype: str
        """
        return self._LoadBalancerName

    @LoadBalancerName.setter
    def LoadBalancerName(self, LoadBalancerName):
        self._LoadBalancerName = LoadBalancerName

    @property
    def Region(self):
        r"""负载均衡所在地域
        :rtype: str
        """
        return self._Region

    @Region.setter
    def Region(self, Region):
        self._Region = Region

    @property
    def Vip(self):
        r"""负载均衡的vip
        :rtype: str
        """
        return self._Vip

    @Vip.setter
    def Vip(self, Vip):
        self._Vip = Vip

    @property
    def OutBandwidth(self):
        r"""最大出带宽，单位：Mbps
        :rtype: float
        """
        return self._OutBandwidth

    @OutBandwidth.setter
    def OutBandwidth(self, OutBandwidth):
        self._OutBandwidth = OutBandwidth

    @property
    def Domain(self):
        r"""CLB域名
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._LoadBalancerName = params.get("LoadBalancerName")
        self._Region = params.get("Region")
        self._Vip = params.get("Vip")
        self._OutBandwidth = params.get("OutBandwidth")
        self._Domain = params.get("Domain")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ManualRewriteRequest(AbstractModel):
    r"""ManualRewrite请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例 ID。
        :type LoadBalancerId: str
        :param _SourceListenerId: 源监听器 ID。
        :type SourceListenerId: str
        :param _TargetListenerId: 目标监听器 ID。
        :type TargetListenerId: str
        :param _RewriteInfos: 转发规则之间的重定向关系。
        :type RewriteInfos: list of RewriteLocationMap
        """
        self._LoadBalancerId = None
        self._SourceListenerId = None
        self._TargetListenerId = None
        self._RewriteInfos = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例 ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def SourceListenerId(self):
        r"""源监听器 ID。
        :rtype: str
        """
        return self._SourceListenerId

    @SourceListenerId.setter
    def SourceListenerId(self, SourceListenerId):
        self._SourceListenerId = SourceListenerId

    @property
    def TargetListenerId(self):
        r"""目标监听器 ID。
        :rtype: str
        """
        return self._TargetListenerId

    @TargetListenerId.setter
    def TargetListenerId(self, TargetListenerId):
        self._TargetListenerId = TargetListenerId

    @property
    def RewriteInfos(self):
        r"""转发规则之间的重定向关系。
        :rtype: list of RewriteLocationMap
        """
        return self._RewriteInfos

    @RewriteInfos.setter
    def RewriteInfos(self, RewriteInfos):
        self._RewriteInfos = RewriteInfos


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._SourceListenerId = params.get("SourceListenerId")
        self._TargetListenerId = params.get("TargetListenerId")
        if params.get("RewriteInfos") is not None:
            self._RewriteInfos = []
            for item in params.get("RewriteInfos"):
                obj = RewriteLocationMap()
                obj._deserialize(item)
                self._RewriteInfos.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ManualRewriteResponse(AbstractModel):
    r"""ManualRewrite返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class MigrateClassicalLoadBalancersRequest(AbstractModel):
    r"""MigrateClassicalLoadBalancers请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerIds: 传统型负载均衡ID数组
        :type LoadBalancerIds: list of str
        :param _ExclusiveCluster: 独占集群信息
        :type ExclusiveCluster: :class:`tencentcloud.clb.v20180317.models.ExclusiveCluster`
        """
        self._LoadBalancerIds = None
        self._ExclusiveCluster = None

    @property
    def LoadBalancerIds(self):
        r"""传统型负载均衡ID数组
        :rtype: list of str
        """
        return self._LoadBalancerIds

    @LoadBalancerIds.setter
    def LoadBalancerIds(self, LoadBalancerIds):
        self._LoadBalancerIds = LoadBalancerIds

    @property
    def ExclusiveCluster(self):
        r"""独占集群信息
        :rtype: :class:`tencentcloud.clb.v20180317.models.ExclusiveCluster`
        """
        return self._ExclusiveCluster

    @ExclusiveCluster.setter
    def ExclusiveCluster(self, ExclusiveCluster):
        self._ExclusiveCluster = ExclusiveCluster


    def _deserialize(self, params):
        self._LoadBalancerIds = params.get("LoadBalancerIds")
        if params.get("ExclusiveCluster") is not None:
            self._ExclusiveCluster = ExclusiveCluster()
            self._ExclusiveCluster._deserialize(params.get("ExclusiveCluster"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class MigrateClassicalLoadBalancersResponse(AbstractModel):
    r"""MigrateClassicalLoadBalancers返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModalityProbeDetail(AbstractModel):
    r"""每个待探测模态的详细结果。

    """

    def __init__(self):
        r"""
        :param _Modality: <p>探测的模态</p>
        :type Modality: str
        :param _Status: <p>探测结果</p><p>枚举值：</p><ul><li>Supported： 模型支持该输入模态</li><li>Unsupported： 模型不支持该输入模态</li><li>Inconclusive： 模型未明确是否支持该模态，待重新探测</li></ul>
        :type Status: str
        :param _ErrorInfo: <p>探测该模态请求的报错详情</p>
        :type ErrorInfo: :class:`tencentcloud.clb.v20180317.models.ProviderTestConnectionErrorInfo`
        """
        self._Modality = None
        self._Status = None
        self._ErrorInfo = None

    @property
    def Modality(self):
        r"""<p>探测的模态</p>
        :rtype: str
        """
        return self._Modality

    @Modality.setter
    def Modality(self, Modality):
        self._Modality = Modality

    @property
    def Status(self):
        r"""<p>探测结果</p><p>枚举值：</p><ul><li>Supported： 模型支持该输入模态</li><li>Unsupported： 模型不支持该输入模态</li><li>Inconclusive： 模型未明确是否支持该模态，待重新探测</li></ul>
        :rtype: str
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status

    @property
    def ErrorInfo(self):
        r"""<p>探测该模态请求的报错详情</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.ProviderTestConnectionErrorInfo`
        """
        return self._ErrorInfo

    @ErrorInfo.setter
    def ErrorInfo(self, ErrorInfo):
        self._ErrorInfo = ErrorInfo


    def _deserialize(self, params):
        self._Modality = params.get("Modality")
        self._Status = params.get("Status")
        if params.get("ErrorInfo") is not None:
            self._ErrorInfo = ProviderTestConnectionErrorInfo()
            self._ErrorInfo._deserialize(params.get("ErrorInfo"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModelAlias(AbstractModel):
    r"""模型别名对象

    """

    def __init__(self):
        r"""
        :param _Coefficient: <p>模型积分系数配置，包含 <code>InputCoefficient</code>、<code>InputCachedCoefficient</code> 和 <code>OutputCoefficient</code>。</p><p>未配置时输入系数默认为 25，缓存命中输入系数默认为 3，输出系数默认为 100。</p>
        :type Coefficient: :class:`tencentcloud.clb.v20180317.models.Coefficient`
        :param _ModelAliasName: <p>模型别名名称。</p><p>若用户配置了模型别名，则为该别名；未配置时为原始模型名称。</p>
        :type ModelAliasName: str
        :param _ServiceProviderCoefficientSet: <p>该模型别名下各 BYOK 实例（ServiceProvider）的积分系数明细，体现 ModelAlias 与 ServiceProvider 的层级关系。</p><p>默认返回该别名引用的全部实例；某实例返回 <code>Coefficient</code> 表示其单独配置了 ServiceProvider 维度系数，否则继承顶层 ModelAlias 的 <code>Coefficient</code>。</p><p>该别名当前无有效 BYOK 引用时返回空数组。</p>
        :type ServiceProviderCoefficientSet: list of ServiceProviderCoefficient
        :param _Source: <p>模型来源。</p><p>枚举值：</p><ul><li>BYOK：用户 BYOK 配置的模型。</li></ul>
        :type Source: str
        :param _Status: <p>状态</p><p>枚举值：</p><ul><li>Active： 正常可用</li><li>Configuring： 变配中</li><li>ConfigureFailed： 变配失败</li></ul>
        :type Status: str
        """
        self._Coefficient = None
        self._ModelAliasName = None
        self._ServiceProviderCoefficientSet = None
        self._Source = None
        self._Status = None

    @property
    def Coefficient(self):
        r"""<p>模型积分系数配置，包含 <code>InputCoefficient</code>、<code>InputCachedCoefficient</code> 和 <code>OutputCoefficient</code>。</p><p>未配置时输入系数默认为 25，缓存命中输入系数默认为 3，输出系数默认为 100。</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.Coefficient`
        """
        return self._Coefficient

    @Coefficient.setter
    def Coefficient(self, Coefficient):
        self._Coefficient = Coefficient

    @property
    def ModelAliasName(self):
        r"""<p>模型别名名称。</p><p>若用户配置了模型别名，则为该别名；未配置时为原始模型名称。</p>
        :rtype: str
        """
        return self._ModelAliasName

    @ModelAliasName.setter
    def ModelAliasName(self, ModelAliasName):
        self._ModelAliasName = ModelAliasName

    @property
    def ServiceProviderCoefficientSet(self):
        r"""<p>该模型别名下各 BYOK 实例（ServiceProvider）的积分系数明细，体现 ModelAlias 与 ServiceProvider 的层级关系。</p><p>默认返回该别名引用的全部实例；某实例返回 <code>Coefficient</code> 表示其单独配置了 ServiceProvider 维度系数，否则继承顶层 ModelAlias 的 <code>Coefficient</code>。</p><p>该别名当前无有效 BYOK 引用时返回空数组。</p>
        :rtype: list of ServiceProviderCoefficient
        """
        return self._ServiceProviderCoefficientSet

    @ServiceProviderCoefficientSet.setter
    def ServiceProviderCoefficientSet(self, ServiceProviderCoefficientSet):
        self._ServiceProviderCoefficientSet = ServiceProviderCoefficientSet

    @property
    def Source(self):
        r"""<p>模型来源。</p><p>枚举值：</p><ul><li>BYOK：用户 BYOK 配置的模型。</li></ul>
        :rtype: str
        """
        return self._Source

    @Source.setter
    def Source(self, Source):
        self._Source = Source

    @property
    def Status(self):
        r"""<p>状态</p><p>枚举值：</p><ul><li>Active： 正常可用</li><li>Configuring： 变配中</li><li>ConfigureFailed： 变配失败</li></ul>
        :rtype: str
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status


    def _deserialize(self, params):
        if params.get("Coefficient") is not None:
            self._Coefficient = Coefficient()
            self._Coefficient._deserialize(params.get("Coefficient"))
        self._ModelAliasName = params.get("ModelAliasName")
        if params.get("ServiceProviderCoefficientSet") is not None:
            self._ServiceProviderCoefficientSet = []
            for item in params.get("ServiceProviderCoefficientSet"):
                obj = ServiceProviderCoefficient()
                obj._deserialize(item)
                self._ServiceProviderCoefficientSet.append(obj)
        self._Source = params.get("Source")
        self._Status = params.get("Status")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModelAssociation(AbstractModel):
    r"""模型关联信息

    """

    def __init__(self):
        r"""
        :param _InputModalitiesUnion: <p>该模型最大可支持的输入多模态能力列表</p><p>枚举值：</p><ul><li>text： 支持文本输入</li><li>image： 支持图像输入</li><li>file： 支持文件输入（当前仅支持pdf）</li></ul>
        :type InputModalitiesUnion: list of str
        :param _ModelName: <p>模型名称</p>
        :type ModelName: str
        :param _ServiceProviders: <p>BYOK列表</p>
        :type ServiceProviders: list of ServiceProvider
        :param _Type: <p>模型类型</p>
        :type Type: str
        """
        self._InputModalitiesUnion = None
        self._ModelName = None
        self._ServiceProviders = None
        self._Type = None

    @property
    def InputModalitiesUnion(self):
        r"""<p>该模型最大可支持的输入多模态能力列表</p><p>枚举值：</p><ul><li>text： 支持文本输入</li><li>image： 支持图像输入</li><li>file： 支持文件输入（当前仅支持pdf）</li></ul>
        :rtype: list of str
        """
        return self._InputModalitiesUnion

    @InputModalitiesUnion.setter
    def InputModalitiesUnion(self, InputModalitiesUnion):
        self._InputModalitiesUnion = InputModalitiesUnion

    @property
    def ModelName(self):
        r"""<p>模型名称</p>
        :rtype: str
        """
        return self._ModelName

    @ModelName.setter
    def ModelName(self, ModelName):
        self._ModelName = ModelName

    @property
    def ServiceProviders(self):
        r"""<p>BYOK列表</p>
        :rtype: list of ServiceProvider
        """
        return self._ServiceProviders

    @ServiceProviders.setter
    def ServiceProviders(self, ServiceProviders):
        self._ServiceProviders = ServiceProviders

    @property
    def Type(self):
        r"""<p>模型类型</p>
        :rtype: str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type


    def _deserialize(self, params):
        self._InputModalitiesUnion = params.get("InputModalitiesUnion")
        self._ModelName = params.get("ModelName")
        if params.get("ServiceProviders") is not None:
            self._ServiceProviders = []
            for item in params.get("ServiceProviders"):
                obj = ServiceProvider()
                obj._deserialize(item)
                self._ServiceProviders.append(obj)
        self._Type = params.get("Type")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModelAvailability(AbstractModel):
    r"""模型可用性

    """

    def __init__(self):
        r"""
        :param _InputModalities: <p>该模型所有健康BYOK实例下支持的输入多模态能力的并集。模型不健康时返回空列表。</p><p>枚举值：</p><ul><li>text： 支持文本输入</li><li>image： 支持图像输入</li><li>file： 支持文件输入（当前仅支持pdf）</li></ul>
        :type InputModalities: list of str
        :param _Model: <p>模型</p>
        :type Model: str
        :param _Status: <p>可用性状态</p><p>枚举值：</p><ul><li>Available： 可用</li><li>Unavailable： 不可用</li><li>Unknown： 未探测</li></ul>
        :type Status: str
        """
        self._InputModalities = None
        self._Model = None
        self._Status = None

    @property
    def InputModalities(self):
        r"""<p>该模型所有健康BYOK实例下支持的输入多模态能力的并集。模型不健康时返回空列表。</p><p>枚举值：</p><ul><li>text： 支持文本输入</li><li>image： 支持图像输入</li><li>file： 支持文件输入（当前仅支持pdf）</li></ul>
        :rtype: list of str
        """
        return self._InputModalities

    @InputModalities.setter
    def InputModalities(self, InputModalities):
        self._InputModalities = InputModalities

    @property
    def Model(self):
        r"""<p>模型</p>
        :rtype: str
        """
        return self._Model

    @Model.setter
    def Model(self, Model):
        self._Model = Model

    @property
    def Status(self):
        r"""<p>可用性状态</p><p>枚举值：</p><ul><li>Available： 可用</li><li>Unavailable： 不可用</li><li>Unknown： 未探测</li></ul>
        :rtype: str
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status


    def _deserialize(self, params):
        self._InputModalities = params.get("InputModalities")
        self._Model = params.get("Model")
        self._Status = params.get("Status")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModelHealthCheckResults(AbstractModel):
    r"""BYOK的健康检查结果

    """

    def __init__(self):
        r"""
        :param _ProviderKeyId: <p>BYOK的KeyID</p>
        :type ProviderKeyId: str
        :param _Model: <p>模型</p>
        :type Model: str
        :param _Status: <p>健康检查状态</p>
        :type Status: str
        """
        self._ProviderKeyId = None
        self._Model = None
        self._Status = None

    @property
    def ProviderKeyId(self):
        r"""<p>BYOK的KeyID</p>
        :rtype: str
        """
        return self._ProviderKeyId

    @ProviderKeyId.setter
    def ProviderKeyId(self, ProviderKeyId):
        self._ProviderKeyId = ProviderKeyId

    @property
    def Model(self):
        r"""<p>模型</p>
        :rtype: str
        """
        return self._Model

    @Model.setter
    def Model(self, Model):
        self._Model = Model

    @property
    def Status(self):
        r"""<p>健康检查状态</p>
        :rtype: str
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status


    def _deserialize(self, params):
        self._ProviderKeyId = params.get("ProviderKeyId")
        self._Model = params.get("Model")
        self._Status = params.get("Status")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModelItem(AbstractModel):
    r"""model 信息

    """

    def __init__(self):
        r"""
        :param _ModelId: <p>模型唯一标识, 用于实际访问</p>
        :type ModelId: str
        :param _InputModalities: <p>该模型当前支持的输入多模态能力列表</p><p>枚举值：</p><ul><li>text： 支持文本输入</li><li>image： 支持图像输入</li><li>file： 支持文件输入（当前仅支持pdf）</li></ul><p>默认值：text</p>
        :type InputModalities: list of str
        :param _ModelAlias: <p>模型别名, 可以用于实际访问</p>
        :type ModelAlias: str
        """
        self._ModelId = None
        self._InputModalities = None
        self._ModelAlias = None

    @property
    def ModelId(self):
        r"""<p>模型唯一标识, 用于实际访问</p>
        :rtype: str
        """
        return self._ModelId

    @ModelId.setter
    def ModelId(self, ModelId):
        self._ModelId = ModelId

    @property
    def InputModalities(self):
        r"""<p>该模型当前支持的输入多模态能力列表</p><p>枚举值：</p><ul><li>text： 支持文本输入</li><li>image： 支持图像输入</li><li>file： 支持文件输入（当前仅支持pdf）</li></ul><p>默认值：text</p>
        :rtype: list of str
        """
        return self._InputModalities

    @InputModalities.setter
    def InputModalities(self, InputModalities):
        self._InputModalities = InputModalities

    @property
    def ModelAlias(self):
        r"""<p>模型别名, 可以用于实际访问</p>
        :rtype: str
        """
        return self._ModelAlias

    @ModelAlias.setter
    def ModelAlias(self, ModelAlias):
        self._ModelAlias = ModelAlias


    def _deserialize(self, params):
        self._ModelId = params.get("ModelId")
        self._InputModalities = params.get("InputModalities")
        self._ModelAlias = params.get("ModelAlias")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModelKeyInfoItem(AbstractModel):
    r"""模型及其 Key 信息

    """

    def __init__(self):
        r"""
        :param _AccessType: <p>接入类型</p>
        :type AccessType: str
        :param _ApiBase: <p>API Base URL</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type ApiBase: str
        :param _CreatedAt: <p>模型创建时间（ISO 8601）</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type CreatedAt: str
        :param _HostHeader: <p>自定义host header</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type HostHeader: str
        :param _KeyCount: <p>Key 数量</p>
        :type KeyCount: int
        :param _Keys: <p>Key 详情列表</p>
        :type Keys: list of KeyDetailItem
        :param _ModelIdsWithAlias: <p>model信息</p>
        :type ModelIdsWithAlias: list of ServiceProviderModelItem
        :param _ModelProvider: <p>模型供应商</p>
        :type ModelProvider: str
        :param _Protocol: <p>模型协议</p>
        :type Protocol: str
        :param _ServiceIps: <p>内部通信占用IP</p>
        :type ServiceIps: list of str
        :param _ServiceProviderId: <p>服务提供商ID</p>
        :type ServiceProviderId: str
        :param _ServiceProviderName: <p>服务提供商自定义名称</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type ServiceProviderName: str
        :param _Status: <p>模型状态</p><p>枚举值：</p><ul><li>Active： 运行中</li><li>Provisioning： 创建中</li><li>Configuring： 变配中</li></ul>
        :type Status: str
        :param _SubnetId: <p>子网 ID</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type SubnetId: str
        :param _Tags: <p>标签信息</p>
        :type Tags: list of TagInfo
        :param _VerifySSL: <p>是否校验上游SSL</p>
        :type VerifySSL: bool
        :param _VpcId: <p>VPC 实例 ID</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type VpcId: str
        :param _HealthCheckConfig: <p>健康检查配置</p>
        :type HealthCheckConfig: :class:`tencentcloud.clb.v20180317.models.ServiceProviderHealthCheckConfigOutput`
        """
        self._AccessType = None
        self._ApiBase = None
        self._CreatedAt = None
        self._HostHeader = None
        self._KeyCount = None
        self._Keys = None
        self._ModelIdsWithAlias = None
        self._ModelProvider = None
        self._Protocol = None
        self._ServiceIps = None
        self._ServiceProviderId = None
        self._ServiceProviderName = None
        self._Status = None
        self._SubnetId = None
        self._Tags = None
        self._VerifySSL = None
        self._VpcId = None
        self._HealthCheckConfig = None

    @property
    def AccessType(self):
        r"""<p>接入类型</p>
        :rtype: str
        """
        return self._AccessType

    @AccessType.setter
    def AccessType(self, AccessType):
        self._AccessType = AccessType

    @property
    def ApiBase(self):
        r"""<p>API Base URL</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ApiBase

    @ApiBase.setter
    def ApiBase(self, ApiBase):
        self._ApiBase = ApiBase

    @property
    def CreatedAt(self):
        r"""<p>模型创建时间（ISO 8601）</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._CreatedAt

    @CreatedAt.setter
    def CreatedAt(self, CreatedAt):
        self._CreatedAt = CreatedAt

    @property
    def HostHeader(self):
        r"""<p>自定义host header</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._HostHeader

    @HostHeader.setter
    def HostHeader(self, HostHeader):
        self._HostHeader = HostHeader

    @property
    def KeyCount(self):
        r"""<p>Key 数量</p>
        :rtype: int
        """
        return self._KeyCount

    @KeyCount.setter
    def KeyCount(self, KeyCount):
        self._KeyCount = KeyCount

    @property
    def Keys(self):
        r"""<p>Key 详情列表</p>
        :rtype: list of KeyDetailItem
        """
        return self._Keys

    @Keys.setter
    def Keys(self, Keys):
        self._Keys = Keys

    @property
    def ModelIdsWithAlias(self):
        r"""<p>model信息</p>
        :rtype: list of ServiceProviderModelItem
        """
        return self._ModelIdsWithAlias

    @ModelIdsWithAlias.setter
    def ModelIdsWithAlias(self, ModelIdsWithAlias):
        self._ModelIdsWithAlias = ModelIdsWithAlias

    @property
    def ModelProvider(self):
        r"""<p>模型供应商</p>
        :rtype: str
        """
        return self._ModelProvider

    @ModelProvider.setter
    def ModelProvider(self, ModelProvider):
        self._ModelProvider = ModelProvider

    @property
    def Protocol(self):
        r"""<p>模型协议</p>
        :rtype: str
        """
        return self._Protocol

    @Protocol.setter
    def Protocol(self, Protocol):
        self._Protocol = Protocol

    @property
    def ServiceIps(self):
        r"""<p>内部通信占用IP</p>
        :rtype: list of str
        """
        return self._ServiceIps

    @ServiceIps.setter
    def ServiceIps(self, ServiceIps):
        self._ServiceIps = ServiceIps

    @property
    def ServiceProviderId(self):
        r"""<p>服务提供商ID</p>
        :rtype: str
        """
        return self._ServiceProviderId

    @ServiceProviderId.setter
    def ServiceProviderId(self, ServiceProviderId):
        self._ServiceProviderId = ServiceProviderId

    @property
    def ServiceProviderName(self):
        r"""<p>服务提供商自定义名称</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ServiceProviderName

    @ServiceProviderName.setter
    def ServiceProviderName(self, ServiceProviderName):
        self._ServiceProviderName = ServiceProviderName

    @property
    def Status(self):
        r"""<p>模型状态</p><p>枚举值：</p><ul><li>Active： 运行中</li><li>Provisioning： 创建中</li><li>Configuring： 变配中</li></ul>
        :rtype: str
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status

    @property
    def SubnetId(self):
        r"""<p>子网 ID</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._SubnetId

    @SubnetId.setter
    def SubnetId(self, SubnetId):
        self._SubnetId = SubnetId

    @property
    def Tags(self):
        r"""<p>标签信息</p>
        :rtype: list of TagInfo
        """
        return self._Tags

    @Tags.setter
    def Tags(self, Tags):
        self._Tags = Tags

    @property
    def VerifySSL(self):
        r"""<p>是否校验上游SSL</p>
        :rtype: bool
        """
        return self._VerifySSL

    @VerifySSL.setter
    def VerifySSL(self, VerifySSL):
        self._VerifySSL = VerifySSL

    @property
    def VpcId(self):
        r"""<p>VPC 实例 ID</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._VpcId

    @VpcId.setter
    def VpcId(self, VpcId):
        self._VpcId = VpcId

    @property
    def HealthCheckConfig(self):
        r"""<p>健康检查配置</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.ServiceProviderHealthCheckConfigOutput`
        """
        return self._HealthCheckConfig

    @HealthCheckConfig.setter
    def HealthCheckConfig(self, HealthCheckConfig):
        self._HealthCheckConfig = HealthCheckConfig


    def _deserialize(self, params):
        self._AccessType = params.get("AccessType")
        self._ApiBase = params.get("ApiBase")
        self._CreatedAt = params.get("CreatedAt")
        self._HostHeader = params.get("HostHeader")
        self._KeyCount = params.get("KeyCount")
        if params.get("Keys") is not None:
            self._Keys = []
            for item in params.get("Keys"):
                obj = KeyDetailItem()
                obj._deserialize(item)
                self._Keys.append(obj)
        if params.get("ModelIdsWithAlias") is not None:
            self._ModelIdsWithAlias = []
            for item in params.get("ModelIdsWithAlias"):
                obj = ServiceProviderModelItem()
                obj._deserialize(item)
                self._ModelIdsWithAlias.append(obj)
        self._ModelProvider = params.get("ModelProvider")
        self._Protocol = params.get("Protocol")
        self._ServiceIps = params.get("ServiceIps")
        self._ServiceProviderId = params.get("ServiceProviderId")
        self._ServiceProviderName = params.get("ServiceProviderName")
        self._Status = params.get("Status")
        self._SubnetId = params.get("SubnetId")
        if params.get("Tags") is not None:
            self._Tags = []
            for item in params.get("Tags"):
                obj = TagInfo()
                obj._deserialize(item)
                self._Tags.append(obj)
        self._VerifySSL = params.get("VerifySSL")
        self._VpcId = params.get("VpcId")
        if params.get("HealthCheckConfig") is not None:
            self._HealthCheckConfig = ServiceProviderHealthCheckConfigOutput()
            self._HealthCheckConfig._deserialize(params.get("HealthCheckConfig"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModelNameAggregatedItem(AbstractModel):
    r"""按模型标识聚合的信息

    """

    def __init__(self):
        r"""
        :param _ModelName: <p>模型标识显示名称（优先使用 model_alias，否则使用 model_name）</p>
        :type ModelName: str
        :param _ServiceProviders: <p>关联的服务商列表</p>
        :type ServiceProviders: list of ServiceProviderItem
        :param _InputModalitiesUnion: <p>该模型最大可支持的输入多模态能力列表。</p><p>枚举值：</p><ul><li>text： 支持文本输入</li><li>image： 支持图像输入</li><li>file： 支持文件输入（当前仅支持pdf）</li></ul>
        :type InputModalitiesUnion: list of str
        """
        self._ModelName = None
        self._ServiceProviders = None
        self._InputModalitiesUnion = None

    @property
    def ModelName(self):
        r"""<p>模型标识显示名称（优先使用 model_alias，否则使用 model_name）</p>
        :rtype: str
        """
        return self._ModelName

    @ModelName.setter
    def ModelName(self, ModelName):
        self._ModelName = ModelName

    @property
    def ServiceProviders(self):
        r"""<p>关联的服务商列表</p>
        :rtype: list of ServiceProviderItem
        """
        return self._ServiceProviders

    @ServiceProviders.setter
    def ServiceProviders(self, ServiceProviders):
        self._ServiceProviders = ServiceProviders

    @property
    def InputModalitiesUnion(self):
        r"""<p>该模型最大可支持的输入多模态能力列表。</p><p>枚举值：</p><ul><li>text： 支持文本输入</li><li>image： 支持图像输入</li><li>file： 支持文件输入（当前仅支持pdf）</li></ul>
        :rtype: list of str
        """
        return self._InputModalitiesUnion

    @InputModalitiesUnion.setter
    def InputModalitiesUnion(self, InputModalitiesUnion):
        self._InputModalitiesUnion = InputModalitiesUnion


    def _deserialize(self, params):
        self._ModelName = params.get("ModelName")
        if params.get("ServiceProviders") is not None:
            self._ServiceProviders = []
            for item in params.get("ServiceProviders"):
                obj = ServiceProviderItem()
                obj._deserialize(item)
                self._ServiceProviders.append(obj)
        self._InputModalitiesUnion = params.get("InputModalitiesUnion")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModelRouterBillingConfigInput(AbstractModel):
    r"""模型路由计费信息

    """

    def __init__(self):
        r"""
        :param _ChargeType: <p>模型路由计费模式</p><p>枚举值：</p><ul><li>POSTPAID_BY_HOUR： 按量计费</li><li>RESOURCE_PACKAGE： 按资源包抵扣</li></ul>
        :type ChargeType: str
        :param _SlaType: <p>实例规格</p><p>枚举值：</p><ul><li>t1.nano-01： 入门版</li><li>t1.nano-02： 轻量版</li><li>t1.nano-03： 轻量增强版</li><li>t1.micro-01： 微型版</li><li>t1.micro-02： 基础版</li><li>t1.small-01： 标准版</li><li>t1.small-02： 标准增强版</li><li>t1.medium-01： 进阶版</li><li>t1.medium-02： 进阶增强版</li><li>t1.large-01： 专业版</li><li>t1.large-02： 专业增强版</li><li>t1.xlarge-01： 旗舰版</li><li>t1.xlarge-02： 至尊版</li></ul>
        :type SlaType: str
        :param _AssociateResourcePackage: <p>是否关联资源包抵扣</p><p>枚举值：</p><ul><li>true： 关联</li><li>false： 不关联</li></ul>
        :type AssociateResourcePackage: bool
        """
        self._ChargeType = None
        self._SlaType = None
        self._AssociateResourcePackage = None

    @property
    def ChargeType(self):
        r"""<p>模型路由计费模式</p><p>枚举值：</p><ul><li>POSTPAID_BY_HOUR： 按量计费</li><li>RESOURCE_PACKAGE： 按资源包抵扣</li></ul>
        :rtype: str
        """
        return self._ChargeType

    @ChargeType.setter
    def ChargeType(self, ChargeType):
        self._ChargeType = ChargeType

    @property
    def SlaType(self):
        r"""<p>实例规格</p><p>枚举值：</p><ul><li>t1.nano-01： 入门版</li><li>t1.nano-02： 轻量版</li><li>t1.nano-03： 轻量增强版</li><li>t1.micro-01： 微型版</li><li>t1.micro-02： 基础版</li><li>t1.small-01： 标准版</li><li>t1.small-02： 标准增强版</li><li>t1.medium-01： 进阶版</li><li>t1.medium-02： 进阶增强版</li><li>t1.large-01： 专业版</li><li>t1.large-02： 专业增强版</li><li>t1.xlarge-01： 旗舰版</li><li>t1.xlarge-02： 至尊版</li></ul>
        :rtype: str
        """
        return self._SlaType

    @SlaType.setter
    def SlaType(self, SlaType):
        self._SlaType = SlaType

    @property
    def AssociateResourcePackage(self):
        r"""<p>是否关联资源包抵扣</p><p>枚举值：</p><ul><li>true： 关联</li><li>false： 不关联</li></ul>
        :rtype: bool
        """
        return self._AssociateResourcePackage

    @AssociateResourcePackage.setter
    def AssociateResourcePackage(self, AssociateResourcePackage):
        self._AssociateResourcePackage = AssociateResourcePackage


    def _deserialize(self, params):
        self._ChargeType = params.get("ChargeType")
        self._SlaType = params.get("SlaType")
        self._AssociateResourcePackage = params.get("AssociateResourcePackage")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModelRouterBillingConfigOutput(AbstractModel):
    r"""模型路由计费信息

    """

    def __init__(self):
        r"""
        :param _ChargeType: <p>模型路由计费模式</p><p>枚举值：</p><ul><li>POSTPAID_BY_HOUR： 按量计费</li><li>RESOURCE_PACKAGE： 按资源包抵扣</li></ul>
注意：此字段可能返回 null，表示取不到有效值。
        :type ChargeType: str
        :param _SlaType: <p>实例规格</p><p>枚举值：</p><ul><li>t1.nano-01： 入门版</li><li>t1.nano-02： 轻量版</li><li>t1.nano-03： 轻量增强版</li><li>t1.micro-01： 微型版</li><li>t1.micro-02： 基础版</li><li>t1.small-01： 标准版</li><li>t1.small-02： 标准增强版</li><li>t1.medium-01： 进阶版</li><li>t1.medium-02： 进阶增强版</li><li>t1.large-01： 专业版</li><li>t1.large-02： 专业增强版</li><li>t1.xlarge-01： 旗舰版</li><li>t1.xlarge-02： 至尊版</li></ul>
注意：此字段可能返回 null，表示取不到有效值。
        :type SlaType: str
        :param _AssociateResourcePackage: <p>是否关联资源包抵扣</p><p>枚举值：</p><ul><li>true： 关联</li><li>false： 不关联</li></ul>
注意：此字段可能返回 null，表示取不到有效值。
        :type AssociateResourcePackage: bool
        """
        self._ChargeType = None
        self._SlaType = None
        self._AssociateResourcePackage = None

    @property
    def ChargeType(self):
        r"""<p>模型路由计费模式</p><p>枚举值：</p><ul><li>POSTPAID_BY_HOUR： 按量计费</li><li>RESOURCE_PACKAGE： 按资源包抵扣</li></ul>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ChargeType

    @ChargeType.setter
    def ChargeType(self, ChargeType):
        self._ChargeType = ChargeType

    @property
    def SlaType(self):
        r"""<p>实例规格</p><p>枚举值：</p><ul><li>t1.nano-01： 入门版</li><li>t1.nano-02： 轻量版</li><li>t1.nano-03： 轻量增强版</li><li>t1.micro-01： 微型版</li><li>t1.micro-02： 基础版</li><li>t1.small-01： 标准版</li><li>t1.small-02： 标准增强版</li><li>t1.medium-01： 进阶版</li><li>t1.medium-02： 进阶增强版</li><li>t1.large-01： 专业版</li><li>t1.large-02： 专业增强版</li><li>t1.xlarge-01： 旗舰版</li><li>t1.xlarge-02： 至尊版</li></ul>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._SlaType

    @SlaType.setter
    def SlaType(self, SlaType):
        self._SlaType = SlaType

    @property
    def AssociateResourcePackage(self):
        r"""<p>是否关联资源包抵扣</p><p>枚举值：</p><ul><li>true： 关联</li><li>false： 不关联</li></ul>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: bool
        """
        return self._AssociateResourcePackage

    @AssociateResourcePackage.setter
    def AssociateResourcePackage(self, AssociateResourcePackage):
        self._AssociateResourcePackage = AssociateResourcePackage


    def _deserialize(self, params):
        self._ChargeType = params.get("ChargeType")
        self._SlaType = params.get("SlaType")
        self._AssociateResourcePackage = params.get("AssociateResourcePackage")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModelRouterDetail(AbstractModel):
    r"""查询单个实例详细信息

    """

    def __init__(self):
        r"""
        :param _BudgetId: <p>模型路由实例关联的Budget ID。</p><p>未关联Budget时返回空字符串。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type BudgetId: str
        :param _BudgetName: <p>模型路由实例关联的Budget名称。</p><p>未关联Budget时返回空字符串。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type BudgetName: str
        :param _ClusterInfo: <p>集群信息</p>
        :type ClusterInfo: :class:`tencentcloud.clb.v20180317.models.ClusterInfo`
        :param _CreatedTime: <p>创建时间</p>
        :type CreatedTime: str
        :param _CreditUsageSet: <p>模型路由实例按Budget刷新周期划分的Credit使用情况。</p><p>当关联Budget配置多个刷新周期时，按1d、7d、30d顺序返回各周期用量；未关联Budget时返回空数组。</p>
        :type CreditUsageSet: list of CreditUsage
        :param _Domain: <p>模型路由实例域名</p>
        :type Domain: str
        :param _ModelRouterId: <p>模型路由ID</p>
        :type ModelRouterId: str
        :param _ModelRouterName: <p>模型路由名称</p><p>默认值：-</p>
        :type ModelRouterName: str
        :param _ModelRouterType: <p>模型路由类型</p><p>枚举值：</p><ul><li>Shared： 共享型</li><li>Enterprise： 企业级</li></ul>
        :type ModelRouterType: str
        :param _ModifiedTime: <p>修改时间</p>
        :type ModifiedTime: str
        :param _NetworkType: <p>模型路由实例网络类型</p><p>枚举值：</p><ul><li>Internet： 公网</li><li>Intranet： 内网</li></ul>
        :type NetworkType: str
        :param _RateLimitConfig: <p>模型路由限速信息</p>
        :type RateLimitConfig: :class:`tencentcloud.clb.v20180317.models.RateLimitConfigForModelRouter`
        :param _RouterSetting: <p>模型路由的路由配置</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type RouterSetting: :class:`tencentcloud.clb.v20180317.models.RouterSettingWithFallBack`
        :param _SecurityGroups: <p>安全组ID列表</p>
        :type SecurityGroups: list of str
        :param _SecurityStatus: <p>模型路由实例的安全状态</p><p>枚举值：</p><ul><li>Normal： 正常</li><li>Banned： 已封禁</li><li>Frozen： 已冻结</li></ul>
        :type SecurityStatus: str
        :param _ServiceEndPoints: <p>模型路由网络配置列表</p>
        :type ServiceEndPoints: list of ServiceEndPoints
        :param _Status: <p>模型路由实例状态</p><p>枚举值：</p><ul><li>Active： 运行中</li><li>Provisioning： 创建中</li><li>Configuring： 变配中</li></ul>
        :type Status: str
        :param _SubnetId: <p>模型路由实例所属子网的ID</p>
        :type SubnetId: str
        :param _Tags: <p>标签</p>
        :type Tags: list of TagInfo
        :param _TradeStatus: <p>模型路由实例的计费状态</p><p>枚举值：</p><ul><li>Normal： 正常</li><li>Isolated： 已隔离</li></ul>
        :type TradeStatus: str
        :param _Vip: <p>模型路由实例VIP</p>
        :type Vip: str
        :param _VpcId: <p>模型路由实例所属VPC的ID</p>
        :type VpcId: str
        :param _Bandwidth: <p>带宽</p><p>单位：Mbps</p>
        :type Bandwidth: int
        :param _EipAddressId: <p>弹性公网IP的ID</p>
        :type EipAddressId: str
        :param _BillingConfig: <p>计费信息</p>
        :type BillingConfig: :class:`tencentcloud.clb.v20180317.models.ModelRouterBillingConfigOutput`
        """
        self._BudgetId = None
        self._BudgetName = None
        self._ClusterInfo = None
        self._CreatedTime = None
        self._CreditUsageSet = None
        self._Domain = None
        self._ModelRouterId = None
        self._ModelRouterName = None
        self._ModelRouterType = None
        self._ModifiedTime = None
        self._NetworkType = None
        self._RateLimitConfig = None
        self._RouterSetting = None
        self._SecurityGroups = None
        self._SecurityStatus = None
        self._ServiceEndPoints = None
        self._Status = None
        self._SubnetId = None
        self._Tags = None
        self._TradeStatus = None
        self._Vip = None
        self._VpcId = None
        self._Bandwidth = None
        self._EipAddressId = None
        self._BillingConfig = None

    @property
    def BudgetId(self):
        r"""<p>模型路由实例关联的Budget ID。</p><p>未关联Budget时返回空字符串。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._BudgetId

    @BudgetId.setter
    def BudgetId(self, BudgetId):
        self._BudgetId = BudgetId

    @property
    def BudgetName(self):
        r"""<p>模型路由实例关联的Budget名称。</p><p>未关联Budget时返回空字符串。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._BudgetName

    @BudgetName.setter
    def BudgetName(self, BudgetName):
        self._BudgetName = BudgetName

    @property
    def ClusterInfo(self):
        r"""<p>集群信息</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.ClusterInfo`
        """
        return self._ClusterInfo

    @ClusterInfo.setter
    def ClusterInfo(self, ClusterInfo):
        self._ClusterInfo = ClusterInfo

    @property
    def CreatedTime(self):
        r"""<p>创建时间</p>
        :rtype: str
        """
        return self._CreatedTime

    @CreatedTime.setter
    def CreatedTime(self, CreatedTime):
        self._CreatedTime = CreatedTime

    @property
    def CreditUsageSet(self):
        r"""<p>模型路由实例按Budget刷新周期划分的Credit使用情况。</p><p>当关联Budget配置多个刷新周期时，按1d、7d、30d顺序返回各周期用量；未关联Budget时返回空数组。</p>
        :rtype: list of CreditUsage
        """
        return self._CreditUsageSet

    @CreditUsageSet.setter
    def CreditUsageSet(self, CreditUsageSet):
        self._CreditUsageSet = CreditUsageSet

    @property
    def Domain(self):
        r"""<p>模型路由实例域名</p>
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def ModelRouterId(self):
        r"""<p>模型路由ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def ModelRouterName(self):
        r"""<p>模型路由名称</p><p>默认值：-</p>
        :rtype: str
        """
        return self._ModelRouterName

    @ModelRouterName.setter
    def ModelRouterName(self, ModelRouterName):
        self._ModelRouterName = ModelRouterName

    @property
    def ModelRouterType(self):
        r"""<p>模型路由类型</p><p>枚举值：</p><ul><li>Shared： 共享型</li><li>Enterprise： 企业级</li></ul>
        :rtype: str
        """
        return self._ModelRouterType

    @ModelRouterType.setter
    def ModelRouterType(self, ModelRouterType):
        self._ModelRouterType = ModelRouterType

    @property
    def ModifiedTime(self):
        r"""<p>修改时间</p>
        :rtype: str
        """
        return self._ModifiedTime

    @ModifiedTime.setter
    def ModifiedTime(self, ModifiedTime):
        self._ModifiedTime = ModifiedTime

    @property
    def NetworkType(self):
        r"""<p>模型路由实例网络类型</p><p>枚举值：</p><ul><li>Internet： 公网</li><li>Intranet： 内网</li></ul>
        :rtype: str
        """
        return self._NetworkType

    @NetworkType.setter
    def NetworkType(self, NetworkType):
        self._NetworkType = NetworkType

    @property
    def RateLimitConfig(self):
        r"""<p>模型路由限速信息</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.RateLimitConfigForModelRouter`
        """
        return self._RateLimitConfig

    @RateLimitConfig.setter
    def RateLimitConfig(self, RateLimitConfig):
        self._RateLimitConfig = RateLimitConfig

    @property
    def RouterSetting(self):
        r"""<p>模型路由的路由配置</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.RouterSettingWithFallBack`
        """
        return self._RouterSetting

    @RouterSetting.setter
    def RouterSetting(self, RouterSetting):
        self._RouterSetting = RouterSetting

    @property
    def SecurityGroups(self):
        r"""<p>安全组ID列表</p>
        :rtype: list of str
        """
        return self._SecurityGroups

    @SecurityGroups.setter
    def SecurityGroups(self, SecurityGroups):
        self._SecurityGroups = SecurityGroups

    @property
    def SecurityStatus(self):
        r"""<p>模型路由实例的安全状态</p><p>枚举值：</p><ul><li>Normal： 正常</li><li>Banned： 已封禁</li><li>Frozen： 已冻结</li></ul>
        :rtype: str
        """
        return self._SecurityStatus

    @SecurityStatus.setter
    def SecurityStatus(self, SecurityStatus):
        self._SecurityStatus = SecurityStatus

    @property
    def ServiceEndPoints(self):
        r"""<p>模型路由网络配置列表</p>
        :rtype: list of ServiceEndPoints
        """
        return self._ServiceEndPoints

    @ServiceEndPoints.setter
    def ServiceEndPoints(self, ServiceEndPoints):
        self._ServiceEndPoints = ServiceEndPoints

    @property
    def Status(self):
        r"""<p>模型路由实例状态</p><p>枚举值：</p><ul><li>Active： 运行中</li><li>Provisioning： 创建中</li><li>Configuring： 变配中</li></ul>
        :rtype: str
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status

    @property
    def SubnetId(self):
        r"""<p>模型路由实例所属子网的ID</p>
        :rtype: str
        """
        return self._SubnetId

    @SubnetId.setter
    def SubnetId(self, SubnetId):
        self._SubnetId = SubnetId

    @property
    def Tags(self):
        r"""<p>标签</p>
        :rtype: list of TagInfo
        """
        return self._Tags

    @Tags.setter
    def Tags(self, Tags):
        self._Tags = Tags

    @property
    def TradeStatus(self):
        r"""<p>模型路由实例的计费状态</p><p>枚举值：</p><ul><li>Normal： 正常</li><li>Isolated： 已隔离</li></ul>
        :rtype: str
        """
        return self._TradeStatus

    @TradeStatus.setter
    def TradeStatus(self, TradeStatus):
        self._TradeStatus = TradeStatus

    @property
    def Vip(self):
        r"""<p>模型路由实例VIP</p>
        :rtype: str
        """
        return self._Vip

    @Vip.setter
    def Vip(self, Vip):
        self._Vip = Vip

    @property
    def VpcId(self):
        r"""<p>模型路由实例所属VPC的ID</p>
        :rtype: str
        """
        return self._VpcId

    @VpcId.setter
    def VpcId(self, VpcId):
        self._VpcId = VpcId

    @property
    def Bandwidth(self):
        r"""<p>带宽</p><p>单位：Mbps</p>
        :rtype: int
        """
        return self._Bandwidth

    @Bandwidth.setter
    def Bandwidth(self, Bandwidth):
        self._Bandwidth = Bandwidth

    @property
    def EipAddressId(self):
        r"""<p>弹性公网IP的ID</p>
        :rtype: str
        """
        return self._EipAddressId

    @EipAddressId.setter
    def EipAddressId(self, EipAddressId):
        self._EipAddressId = EipAddressId

    @property
    def BillingConfig(self):
        r"""<p>计费信息</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.ModelRouterBillingConfigOutput`
        """
        return self._BillingConfig

    @BillingConfig.setter
    def BillingConfig(self, BillingConfig):
        self._BillingConfig = BillingConfig


    def _deserialize(self, params):
        self._BudgetId = params.get("BudgetId")
        self._BudgetName = params.get("BudgetName")
        if params.get("ClusterInfo") is not None:
            self._ClusterInfo = ClusterInfo()
            self._ClusterInfo._deserialize(params.get("ClusterInfo"))
        self._CreatedTime = params.get("CreatedTime")
        if params.get("CreditUsageSet") is not None:
            self._CreditUsageSet = []
            for item in params.get("CreditUsageSet"):
                obj = CreditUsage()
                obj._deserialize(item)
                self._CreditUsageSet.append(obj)
        self._Domain = params.get("Domain")
        self._ModelRouterId = params.get("ModelRouterId")
        self._ModelRouterName = params.get("ModelRouterName")
        self._ModelRouterType = params.get("ModelRouterType")
        self._ModifiedTime = params.get("ModifiedTime")
        self._NetworkType = params.get("NetworkType")
        if params.get("RateLimitConfig") is not None:
            self._RateLimitConfig = RateLimitConfigForModelRouter()
            self._RateLimitConfig._deserialize(params.get("RateLimitConfig"))
        if params.get("RouterSetting") is not None:
            self._RouterSetting = RouterSettingWithFallBack()
            self._RouterSetting._deserialize(params.get("RouterSetting"))
        self._SecurityGroups = params.get("SecurityGroups")
        self._SecurityStatus = params.get("SecurityStatus")
        if params.get("ServiceEndPoints") is not None:
            self._ServiceEndPoints = []
            for item in params.get("ServiceEndPoints"):
                obj = ServiceEndPoints()
                obj._deserialize(item)
                self._ServiceEndPoints.append(obj)
        self._Status = params.get("Status")
        self._SubnetId = params.get("SubnetId")
        if params.get("Tags") is not None:
            self._Tags = []
            for item in params.get("Tags"):
                obj = TagInfo()
                obj._deserialize(item)
                self._Tags.append(obj)
        self._TradeStatus = params.get("TradeStatus")
        self._Vip = params.get("Vip")
        self._VpcId = params.get("VpcId")
        self._Bandwidth = params.get("Bandwidth")
        self._EipAddressId = params.get("EipAddressId")
        if params.get("BillingConfig") is not None:
            self._BillingConfig = ModelRouterBillingConfigOutput()
            self._BillingConfig._deserialize(params.get("BillingConfig"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModelRouterLog(AbstractModel):
    r"""模型路由日志

    """

    def __init__(self):
        r"""
        :param _KeyId: <p>API Key的ID</p>
        :type KeyId: str
        :param _Model: <p>模型</p>
        :type Model: str
        :param _Provider: <p>所属厂商</p>
        :type Provider: str
        :param _Status: <p>请求状态</p><p>枚举值：</p><ul><li>failure： 失败</li><li>success： 成功</li></ul>
        :type Status: str
        :param _MaxRetries: <p>最大重试次数</p>
        :type MaxRetries: int
        :param _TotalTokens: <p>单次请求消耗的总Token数量</p>
        :type TotalTokens: int
        :param _InputTokens: <p>单次请求输入消耗的Token数量</p>
        :type InputTokens: int
        :param _OutputTokens: <p>单次请求输出消耗的Token数量</p>
        :type OutputTokens: int
        :param _RequestDuration: <p>请求耗时</p><p>单位：ms</p>
        :type RequestDuration: int
        :param _RequesterIp: <p>请求IP</p>
        :type RequesterIp: str
        :param _StartTime: <p>日志查询起始时间</p>
        :type StartTime: str
        :param _EndTime: <p>日志查询结束时间</p>
        :type EndTime: str
        """
        self._KeyId = None
        self._Model = None
        self._Provider = None
        self._Status = None
        self._MaxRetries = None
        self._TotalTokens = None
        self._InputTokens = None
        self._OutputTokens = None
        self._RequestDuration = None
        self._RequesterIp = None
        self._StartTime = None
        self._EndTime = None

    @property
    def KeyId(self):
        r"""<p>API Key的ID</p>
        :rtype: str
        """
        return self._KeyId

    @KeyId.setter
    def KeyId(self, KeyId):
        self._KeyId = KeyId

    @property
    def Model(self):
        r"""<p>模型</p>
        :rtype: str
        """
        return self._Model

    @Model.setter
    def Model(self, Model):
        self._Model = Model

    @property
    def Provider(self):
        r"""<p>所属厂商</p>
        :rtype: str
        """
        return self._Provider

    @Provider.setter
    def Provider(self, Provider):
        self._Provider = Provider

    @property
    def Status(self):
        r"""<p>请求状态</p><p>枚举值：</p><ul><li>failure： 失败</li><li>success： 成功</li></ul>
        :rtype: str
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status

    @property
    def MaxRetries(self):
        r"""<p>最大重试次数</p>
        :rtype: int
        """
        return self._MaxRetries

    @MaxRetries.setter
    def MaxRetries(self, MaxRetries):
        self._MaxRetries = MaxRetries

    @property
    def TotalTokens(self):
        r"""<p>单次请求消耗的总Token数量</p>
        :rtype: int
        """
        return self._TotalTokens

    @TotalTokens.setter
    def TotalTokens(self, TotalTokens):
        self._TotalTokens = TotalTokens

    @property
    def InputTokens(self):
        r"""<p>单次请求输入消耗的Token数量</p>
        :rtype: int
        """
        return self._InputTokens

    @InputTokens.setter
    def InputTokens(self, InputTokens):
        self._InputTokens = InputTokens

    @property
    def OutputTokens(self):
        r"""<p>单次请求输出消耗的Token数量</p>
        :rtype: int
        """
        return self._OutputTokens

    @OutputTokens.setter
    def OutputTokens(self, OutputTokens):
        self._OutputTokens = OutputTokens

    @property
    def RequestDuration(self):
        r"""<p>请求耗时</p><p>单位：ms</p>
        :rtype: int
        """
        return self._RequestDuration

    @RequestDuration.setter
    def RequestDuration(self, RequestDuration):
        self._RequestDuration = RequestDuration

    @property
    def RequesterIp(self):
        r"""<p>请求IP</p>
        :rtype: str
        """
        return self._RequesterIp

    @RequesterIp.setter
    def RequesterIp(self, RequesterIp):
        self._RequesterIp = RequesterIp

    @property
    def StartTime(self):
        r"""<p>日志查询起始时间</p>
        :rtype: str
        """
        return self._StartTime

    @StartTime.setter
    def StartTime(self, StartTime):
        self._StartTime = StartTime

    @property
    def EndTime(self):
        r"""<p>日志查询结束时间</p>
        :rtype: str
        """
        return self._EndTime

    @EndTime.setter
    def EndTime(self, EndTime):
        self._EndTime = EndTime


    def _deserialize(self, params):
        self._KeyId = params.get("KeyId")
        self._Model = params.get("Model")
        self._Provider = params.get("Provider")
        self._Status = params.get("Status")
        self._MaxRetries = params.get("MaxRetries")
        self._TotalTokens = params.get("TotalTokens")
        self._InputTokens = params.get("InputTokens")
        self._OutputTokens = params.get("OutputTokens")
        self._RequestDuration = params.get("RequestDuration")
        self._RequesterIp = params.get("RequesterIp")
        self._StartTime = params.get("StartTime")
        self._EndTime = params.get("EndTime")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModelRouterModel(AbstractModel):
    r"""模型路由关联的模型

    """

    def __init__(self):
        r"""
        :param _ModelName: <p>模型名称</p>
        :type ModelName: str
        :param _Provider: <p>所属厂商</p>
        :type Provider: str
        :param _Type: <p>模型类型。</p><p>枚举值：</p><ul><li>BYOK： BYOK类型</li><li>Platform： 平台类型</li></ul>
        :type Type: str
        :param _ServiceProviderId: <p>BYOK实例ID</p>
        :type ServiceProviderId: str
        :param _Order: <p>当前 CMR、当前绑定模型下该 BYOK实例的调度优先级。</p><p>取值范围：[0, 2]</p><p>默认值：0</p>
        :type Order: int
        :param _Weight: <p>当前CMR、当前绑定模型的同一有效Order层内，BYOK实例之间的相对选择权重。</p><p>取值范围：[0, 100]</p><p>默认值：10</p>
        :type Weight: int
        """
        self._ModelName = None
        self._Provider = None
        self._Type = None
        self._ServiceProviderId = None
        self._Order = None
        self._Weight = None

    @property
    def ModelName(self):
        r"""<p>模型名称</p>
        :rtype: str
        """
        return self._ModelName

    @ModelName.setter
    def ModelName(self, ModelName):
        self._ModelName = ModelName

    @property
    def Provider(self):
        r"""<p>所属厂商</p>
        :rtype: str
        """
        return self._Provider

    @Provider.setter
    def Provider(self, Provider):
        self._Provider = Provider

    @property
    def Type(self):
        r"""<p>模型类型。</p><p>枚举值：</p><ul><li>BYOK： BYOK类型</li><li>Platform： 平台类型</li></ul>
        :rtype: str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type

    @property
    def ServiceProviderId(self):
        r"""<p>BYOK实例ID</p>
        :rtype: str
        """
        return self._ServiceProviderId

    @ServiceProviderId.setter
    def ServiceProviderId(self, ServiceProviderId):
        self._ServiceProviderId = ServiceProviderId

    @property
    def Order(self):
        r"""<p>当前 CMR、当前绑定模型下该 BYOK实例的调度优先级。</p><p>取值范围：[0, 2]</p><p>默认值：0</p>
        :rtype: int
        """
        return self._Order

    @Order.setter
    def Order(self, Order):
        self._Order = Order

    @property
    def Weight(self):
        r"""<p>当前CMR、当前绑定模型的同一有效Order层内，BYOK实例之间的相对选择权重。</p><p>取值范围：[0, 100]</p><p>默认值：10</p>
        :rtype: int
        """
        return self._Weight

    @Weight.setter
    def Weight(self, Weight):
        self._Weight = Weight


    def _deserialize(self, params):
        self._ModelName = params.get("ModelName")
        self._Provider = params.get("Provider")
        self._Type = params.get("Type")
        self._ServiceProviderId = params.get("ServiceProviderId")
        self._Order = params.get("Order")
        self._Weight = params.get("Weight")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModelRouterModelToDisassociate(AbstractModel):
    r"""CMR实例待解绑的模型信息

    """

    def __init__(self):
        r"""
        :param _ModelName: <p>模型名称</p>
        :type ModelName: str
        :param _Provider: <p>所属厂商</p>
        :type Provider: str
        :param _Type: <p>模型类型。</p><p>枚举值：</p><ul><li>BYOK： BYOK类型</li><li>Platform： 平台类型</li></ul>
        :type Type: str
        :param _ServiceProviderId: <p>BYOK实例ID</p>
        :type ServiceProviderId: str
        """
        self._ModelName = None
        self._Provider = None
        self._Type = None
        self._ServiceProviderId = None

    @property
    def ModelName(self):
        r"""<p>模型名称</p>
        :rtype: str
        """
        return self._ModelName

    @ModelName.setter
    def ModelName(self, ModelName):
        self._ModelName = ModelName

    @property
    def Provider(self):
        r"""<p>所属厂商</p>
        :rtype: str
        """
        return self._Provider

    @Provider.setter
    def Provider(self, Provider):
        self._Provider = Provider

    @property
    def Type(self):
        r"""<p>模型类型。</p><p>枚举值：</p><ul><li>BYOK： BYOK类型</li><li>Platform： 平台类型</li></ul>
        :rtype: str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type

    @property
    def ServiceProviderId(self):
        r"""<p>BYOK实例ID</p>
        :rtype: str
        """
        return self._ServiceProviderId

    @ServiceProviderId.setter
    def ServiceProviderId(self, ServiceProviderId):
        self._ServiceProviderId = ServiceProviderId


    def _deserialize(self, params):
        self._ModelName = params.get("ModelName")
        self._Provider = params.get("Provider")
        self._Type = params.get("Type")
        self._ServiceProviderId = params.get("ServiceProviderId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModelRouterPackage(AbstractModel):
    r"""模型路由资源包

    """

    def __init__(self):
        r"""
        :param _CapacitySize: <p>模型路由资源包总容量</p>
        :type CapacitySize: str
        :param _CapacityRemain: <p>模型路由资源包总余量</p>
        :type CapacityRemain: str
        :param _CapacitySizePrecise: <p>模型路由资源包容量精确值</p>
        :type CapacitySizePrecise: str
        :param _CapacityRemainPrecise: <p>模型路由资源包总余量精确值</p>
        :type CapacityRemainPrecise: str
        :param _AutoPurchaseFlag: <p>模型路由资源包设置用尽续购标志位 0:未设置 1:用尽到期新购</p><p>取值范围：[0, 1]</p>
        :type AutoPurchaseFlag: int
        :param _ModelRouterResourcePackageId: <p>模型路由资源包Id</p>
        :type ModelRouterResourcePackageId: str
        :param _CreateTime: <p>模型路由资源包创建时间</p>
        :type CreateTime: str
        :param _DeductionStartTime: <p>模型路由资源包抵扣开始时间</p>
        :type DeductionStartTime: str
        :param _DeductionEndTime: <p>模型路由资源包抵扣截止时间</p>
        :type DeductionEndTime: str
        :param _ExpiredTime: <p>模型路由资源包失效时间</p>
        :type ExpiredTime: str
        :param _Status: <p>模型路由资源包状态</p><p>枚举值：</p><ul><li>0： 有效</li><li>1： 已退款</li><li>2： 已过期</li><li>3： 已用完</li></ul>
        :type Status: int
        """
        self._CapacitySize = None
        self._CapacityRemain = None
        self._CapacitySizePrecise = None
        self._CapacityRemainPrecise = None
        self._AutoPurchaseFlag = None
        self._ModelRouterResourcePackageId = None
        self._CreateTime = None
        self._DeductionStartTime = None
        self._DeductionEndTime = None
        self._ExpiredTime = None
        self._Status = None

    @property
    def CapacitySize(self):
        r"""<p>模型路由资源包总容量</p>
        :rtype: str
        """
        return self._CapacitySize

    @CapacitySize.setter
    def CapacitySize(self, CapacitySize):
        self._CapacitySize = CapacitySize

    @property
    def CapacityRemain(self):
        r"""<p>模型路由资源包总余量</p>
        :rtype: str
        """
        return self._CapacityRemain

    @CapacityRemain.setter
    def CapacityRemain(self, CapacityRemain):
        self._CapacityRemain = CapacityRemain

    @property
    def CapacitySizePrecise(self):
        r"""<p>模型路由资源包容量精确值</p>
        :rtype: str
        """
        return self._CapacitySizePrecise

    @CapacitySizePrecise.setter
    def CapacitySizePrecise(self, CapacitySizePrecise):
        self._CapacitySizePrecise = CapacitySizePrecise

    @property
    def CapacityRemainPrecise(self):
        r"""<p>模型路由资源包总余量精确值</p>
        :rtype: str
        """
        return self._CapacityRemainPrecise

    @CapacityRemainPrecise.setter
    def CapacityRemainPrecise(self, CapacityRemainPrecise):
        self._CapacityRemainPrecise = CapacityRemainPrecise

    @property
    def AutoPurchaseFlag(self):
        r"""<p>模型路由资源包设置用尽续购标志位 0:未设置 1:用尽到期新购</p><p>取值范围：[0, 1]</p>
        :rtype: int
        """
        return self._AutoPurchaseFlag

    @AutoPurchaseFlag.setter
    def AutoPurchaseFlag(self, AutoPurchaseFlag):
        self._AutoPurchaseFlag = AutoPurchaseFlag

    @property
    def ModelRouterResourcePackageId(self):
        r"""<p>模型路由资源包Id</p>
        :rtype: str
        """
        return self._ModelRouterResourcePackageId

    @ModelRouterResourcePackageId.setter
    def ModelRouterResourcePackageId(self, ModelRouterResourcePackageId):
        self._ModelRouterResourcePackageId = ModelRouterResourcePackageId

    @property
    def CreateTime(self):
        r"""<p>模型路由资源包创建时间</p>
        :rtype: str
        """
        return self._CreateTime

    @CreateTime.setter
    def CreateTime(self, CreateTime):
        self._CreateTime = CreateTime

    @property
    def DeductionStartTime(self):
        r"""<p>模型路由资源包抵扣开始时间</p>
        :rtype: str
        """
        return self._DeductionStartTime

    @DeductionStartTime.setter
    def DeductionStartTime(self, DeductionStartTime):
        self._DeductionStartTime = DeductionStartTime

    @property
    def DeductionEndTime(self):
        r"""<p>模型路由资源包抵扣截止时间</p>
        :rtype: str
        """
        return self._DeductionEndTime

    @DeductionEndTime.setter
    def DeductionEndTime(self, DeductionEndTime):
        self._DeductionEndTime = DeductionEndTime

    @property
    def ExpiredTime(self):
        r"""<p>模型路由资源包失效时间</p>
        :rtype: str
        """
        return self._ExpiredTime

    @ExpiredTime.setter
    def ExpiredTime(self, ExpiredTime):
        self._ExpiredTime = ExpiredTime

    @property
    def Status(self):
        r"""<p>模型路由资源包状态</p><p>枚举值：</p><ul><li>0： 有效</li><li>1： 已退款</li><li>2： 已过期</li><li>3： 已用完</li></ul>
        :rtype: int
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status


    def _deserialize(self, params):
        self._CapacitySize = params.get("CapacitySize")
        self._CapacityRemain = params.get("CapacityRemain")
        self._CapacitySizePrecise = params.get("CapacitySizePrecise")
        self._CapacityRemainPrecise = params.get("CapacityRemainPrecise")
        self._AutoPurchaseFlag = params.get("AutoPurchaseFlag")
        self._ModelRouterResourcePackageId = params.get("ModelRouterResourcePackageId")
        self._CreateTime = params.get("CreateTime")
        self._DeductionStartTime = params.get("DeductionStartTime")
        self._DeductionEndTime = params.get("DeductionEndTime")
        self._ExpiredTime = params.get("ExpiredTime")
        self._Status = params.get("Status")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModelRouterQuota(AbstractModel):
    r"""模型路由相关配额

    """

    def __init__(self):
        r"""
        :param _QuotaType: <p>配额名称</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type QuotaType: str
        :param _ResourceId: <p>资源ID</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type ResourceId: str
        :param _Limit: <p>配额上限</p><p>单位：个</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type Limit: int
        :param _Used: <p>已使用配额数量</p><p>单位：个</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type Used: int
        :param _Available: <p>剩余配额数量</p><p>单位：个</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type Available: int
        """
        self._QuotaType = None
        self._ResourceId = None
        self._Limit = None
        self._Used = None
        self._Available = None

    @property
    def QuotaType(self):
        r"""<p>配额名称</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._QuotaType

    @QuotaType.setter
    def QuotaType(self, QuotaType):
        self._QuotaType = QuotaType

    @property
    def ResourceId(self):
        r"""<p>资源ID</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ResourceId

    @ResourceId.setter
    def ResourceId(self, ResourceId):
        self._ResourceId = ResourceId

    @property
    def Limit(self):
        r"""<p>配额上限</p><p>单位：个</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._Limit

    @Limit.setter
    def Limit(self, Limit):
        self._Limit = Limit

    @property
    def Used(self):
        r"""<p>已使用配额数量</p><p>单位：个</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._Used

    @Used.setter
    def Used(self, Used):
        self._Used = Used

    @property
    def Available(self):
        r"""<p>剩余配额数量</p><p>单位：个</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._Available

    @Available.setter
    def Available(self, Available):
        self._Available = Available


    def _deserialize(self, params):
        self._QuotaType = params.get("QuotaType")
        self._ResourceId = params.get("ResourceId")
        self._Limit = params.get("Limit")
        self._Used = params.get("Used")
        self._Available = params.get("Available")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModelRouterResourcePackageDeduction(AbstractModel):
    r"""模型路由资源包抵扣信息

    """

    def __init__(self):
        r"""
        :param _ActualDosage: <p>实际抵扣量</p>
        :type ActualDosage: str
        :param _AfterDeductionRemain: <p>抵扣后包剩余量</p>
        :type AfterDeductionRemain: str
        :param _BeforeDeductionRemain: <p>抵扣前包剩余量</p>
        :type BeforeDeductionRemain: str
        :param _DeductionTime: <p>抵扣时间</p>
        :type DeductionTime: str
        :param _Dosage: <p>原始用量</p>
        :type Dosage: str
        :param _EndTime: <p>用量结束时间</p>
        :type EndTime: str
        :param _ModelRouterId: <p>产生用量的模型路由实例Id</p>
        :type ModelRouterId: str
        :param _ModelRouterResourcePackageId: <p>模型路由资源包Id</p>
        :type ModelRouterResourcePackageId: str
        :param _StartTime: <p>用量开始时间</p>
        :type StartTime: str
        """
        self._ActualDosage = None
        self._AfterDeductionRemain = None
        self._BeforeDeductionRemain = None
        self._DeductionTime = None
        self._Dosage = None
        self._EndTime = None
        self._ModelRouterId = None
        self._ModelRouterResourcePackageId = None
        self._StartTime = None

    @property
    def ActualDosage(self):
        r"""<p>实际抵扣量</p>
        :rtype: str
        """
        return self._ActualDosage

    @ActualDosage.setter
    def ActualDosage(self, ActualDosage):
        self._ActualDosage = ActualDosage

    @property
    def AfterDeductionRemain(self):
        r"""<p>抵扣后包剩余量</p>
        :rtype: str
        """
        return self._AfterDeductionRemain

    @AfterDeductionRemain.setter
    def AfterDeductionRemain(self, AfterDeductionRemain):
        self._AfterDeductionRemain = AfterDeductionRemain

    @property
    def BeforeDeductionRemain(self):
        r"""<p>抵扣前包剩余量</p>
        :rtype: str
        """
        return self._BeforeDeductionRemain

    @BeforeDeductionRemain.setter
    def BeforeDeductionRemain(self, BeforeDeductionRemain):
        self._BeforeDeductionRemain = BeforeDeductionRemain

    @property
    def DeductionTime(self):
        r"""<p>抵扣时间</p>
        :rtype: str
        """
        return self._DeductionTime

    @DeductionTime.setter
    def DeductionTime(self, DeductionTime):
        self._DeductionTime = DeductionTime

    @property
    def Dosage(self):
        r"""<p>原始用量</p>
        :rtype: str
        """
        return self._Dosage

    @Dosage.setter
    def Dosage(self, Dosage):
        self._Dosage = Dosage

    @property
    def EndTime(self):
        r"""<p>用量结束时间</p>
        :rtype: str
        """
        return self._EndTime

    @EndTime.setter
    def EndTime(self, EndTime):
        self._EndTime = EndTime

    @property
    def ModelRouterId(self):
        r"""<p>产生用量的模型路由实例Id</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def ModelRouterResourcePackageId(self):
        r"""<p>模型路由资源包Id</p>
        :rtype: str
        """
        return self._ModelRouterResourcePackageId

    @ModelRouterResourcePackageId.setter
    def ModelRouterResourcePackageId(self, ModelRouterResourcePackageId):
        self._ModelRouterResourcePackageId = ModelRouterResourcePackageId

    @property
    def StartTime(self):
        r"""<p>用量开始时间</p>
        :rtype: str
        """
        return self._StartTime

    @StartTime.setter
    def StartTime(self, StartTime):
        self._StartTime = StartTime


    def _deserialize(self, params):
        self._ActualDosage = params.get("ActualDosage")
        self._AfterDeductionRemain = params.get("AfterDeductionRemain")
        self._BeforeDeductionRemain = params.get("BeforeDeductionRemain")
        self._DeductionTime = params.get("DeductionTime")
        self._Dosage = params.get("Dosage")
        self._EndTime = params.get("EndTime")
        self._ModelRouterId = params.get("ModelRouterId")
        self._ModelRouterResourcePackageId = params.get("ModelRouterResourcePackageId")
        self._StartTime = params.get("StartTime")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModelRouterResourcePackageRefundPrice(AbstractModel):
    r"""模型路由资源包退款价格

    """

    def __init__(self):
        r"""
        :param _ModelRouterPackageId: <p>模型路由资源包Id</p>
        :type ModelRouterPackageId: str
        :param _Price: <p>可退还金额</p>
        :type Price: float
        """
        self._ModelRouterPackageId = None
        self._Price = None

    @property
    def ModelRouterPackageId(self):
        r"""<p>模型路由资源包Id</p>
        :rtype: str
        """
        return self._ModelRouterPackageId

    @ModelRouterPackageId.setter
    def ModelRouterPackageId(self, ModelRouterPackageId):
        self._ModelRouterPackageId = ModelRouterPackageId

    @property
    def Price(self):
        r"""<p>可退还金额</p>
        :rtype: float
        """
        return self._Price

    @Price.setter
    def Price(self, Price):
        self._Price = Price


    def _deserialize(self, params):
        self._ModelRouterPackageId = params.get("ModelRouterPackageId")
        self._Price = params.get("Price")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModelRouterSet(AbstractModel):
    r"""模型路由列表

    """

    def __init__(self):
        r"""
        :param _BudgetId: <p>模型路由实例关联的Budget ID。</p><p>未关联Budget时返回空字符串。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type BudgetId: str
        :param _BudgetName: <p>模型路由实例关联的Budget名称。</p><p>未关联Budget时返回空字符串。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type BudgetName: str
        :param _ClusterInfo: <p>集群信息</p>
        :type ClusterInfo: :class:`tencentcloud.clb.v20180317.models.ClusterInfo`
        :param _CreatedTime: <p>创建时间</p>
        :type CreatedTime: str
        :param _CreditUsageSet: <p>模型路由实例按Budget刷新周期划分的Credit使用情况。</p><p>当关联Budget配置多个刷新周期时，按1d、7d、30d顺序返回各周期用量；未关联Budget时返回空数组。</p>
        :type CreditUsageSet: list of CreditUsage
        :param _Domain: <p>模型路由实例域名</p>
        :type Domain: str
        :param _ModelRouterId: <p>模型路由ID</p>
        :type ModelRouterId: str
        :param _ModelRouterName: <p>模型路由名称</p><p>默认值：-</p>
        :type ModelRouterName: str
        :param _ModelRouterType: <p>模型路由类型</p><p>枚举值：</p><ul><li>Shared： 共享型</li><li>Enterprise： 企业级</li></ul>
        :type ModelRouterType: str
        :param _ModifiedTime: <p>修改时间</p>
        :type ModifiedTime: str
        :param _NetworkType: <p>模型路由实例网络类型</p><p>枚举值：</p><ul><li>Internet： 公网</li><li>Intranet： 内网</li></ul>
        :type NetworkType: str
        :param _SecurityStatus: <p>模型路由实例的安全状态</p><p>枚举值：</p><ul><li>Normal： 正常</li><li>Banned： 已封禁</li><li>Frozen： 已冻结</li></ul>
        :type SecurityStatus: str
        :param _Status: <p>模型路由实例状态</p><p>枚举值：</p><ul><li>Active： 运行中</li><li>Provisioning： 创建中</li><li>Configuring： 变配中</li></ul>
        :type Status: str
        :param _Tags: <p>标签</p>
        :type Tags: list of TagInfo
        :param _TradeStatus: <p>模型路由实例的计费状态</p><p>枚举值：</p><ul><li>Normal： 正常</li><li>Isolated： 已隔离</li></ul>
        :type TradeStatus: str
        :param _Vip: <p>模型路由实例VIP</p>
        :type Vip: str
        :param _VpcId: <p>模型路由实例所属VPC的ID</p>
        :type VpcId: str
        :param _Bandwidth: <p>带宽</p><p>单位：Mbps</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type Bandwidth: int
        :param _EipAddressId: <p>弹性公网IP的ID</p>
        :type EipAddressId: str
        :param _BillingConfig: <p>计费信息</p>
        :type BillingConfig: :class:`tencentcloud.clb.v20180317.models.ModelRouterBillingConfigOutput`
        """
        self._BudgetId = None
        self._BudgetName = None
        self._ClusterInfo = None
        self._CreatedTime = None
        self._CreditUsageSet = None
        self._Domain = None
        self._ModelRouterId = None
        self._ModelRouterName = None
        self._ModelRouterType = None
        self._ModifiedTime = None
        self._NetworkType = None
        self._SecurityStatus = None
        self._Status = None
        self._Tags = None
        self._TradeStatus = None
        self._Vip = None
        self._VpcId = None
        self._Bandwidth = None
        self._EipAddressId = None
        self._BillingConfig = None

    @property
    def BudgetId(self):
        r"""<p>模型路由实例关联的Budget ID。</p><p>未关联Budget时返回空字符串。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._BudgetId

    @BudgetId.setter
    def BudgetId(self, BudgetId):
        self._BudgetId = BudgetId

    @property
    def BudgetName(self):
        r"""<p>模型路由实例关联的Budget名称。</p><p>未关联Budget时返回空字符串。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._BudgetName

    @BudgetName.setter
    def BudgetName(self, BudgetName):
        self._BudgetName = BudgetName

    @property
    def ClusterInfo(self):
        r"""<p>集群信息</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.ClusterInfo`
        """
        return self._ClusterInfo

    @ClusterInfo.setter
    def ClusterInfo(self, ClusterInfo):
        self._ClusterInfo = ClusterInfo

    @property
    def CreatedTime(self):
        r"""<p>创建时间</p>
        :rtype: str
        """
        return self._CreatedTime

    @CreatedTime.setter
    def CreatedTime(self, CreatedTime):
        self._CreatedTime = CreatedTime

    @property
    def CreditUsageSet(self):
        r"""<p>模型路由实例按Budget刷新周期划分的Credit使用情况。</p><p>当关联Budget配置多个刷新周期时，按1d、7d、30d顺序返回各周期用量；未关联Budget时返回空数组。</p>
        :rtype: list of CreditUsage
        """
        return self._CreditUsageSet

    @CreditUsageSet.setter
    def CreditUsageSet(self, CreditUsageSet):
        self._CreditUsageSet = CreditUsageSet

    @property
    def Domain(self):
        r"""<p>模型路由实例域名</p>
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def ModelRouterId(self):
        r"""<p>模型路由ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def ModelRouterName(self):
        r"""<p>模型路由名称</p><p>默认值：-</p>
        :rtype: str
        """
        return self._ModelRouterName

    @ModelRouterName.setter
    def ModelRouterName(self, ModelRouterName):
        self._ModelRouterName = ModelRouterName

    @property
    def ModelRouterType(self):
        r"""<p>模型路由类型</p><p>枚举值：</p><ul><li>Shared： 共享型</li><li>Enterprise： 企业级</li></ul>
        :rtype: str
        """
        return self._ModelRouterType

    @ModelRouterType.setter
    def ModelRouterType(self, ModelRouterType):
        self._ModelRouterType = ModelRouterType

    @property
    def ModifiedTime(self):
        r"""<p>修改时间</p>
        :rtype: str
        """
        return self._ModifiedTime

    @ModifiedTime.setter
    def ModifiedTime(self, ModifiedTime):
        self._ModifiedTime = ModifiedTime

    @property
    def NetworkType(self):
        r"""<p>模型路由实例网络类型</p><p>枚举值：</p><ul><li>Internet： 公网</li><li>Intranet： 内网</li></ul>
        :rtype: str
        """
        return self._NetworkType

    @NetworkType.setter
    def NetworkType(self, NetworkType):
        self._NetworkType = NetworkType

    @property
    def SecurityStatus(self):
        r"""<p>模型路由实例的安全状态</p><p>枚举值：</p><ul><li>Normal： 正常</li><li>Banned： 已封禁</li><li>Frozen： 已冻结</li></ul>
        :rtype: str
        """
        return self._SecurityStatus

    @SecurityStatus.setter
    def SecurityStatus(self, SecurityStatus):
        self._SecurityStatus = SecurityStatus

    @property
    def Status(self):
        r"""<p>模型路由实例状态</p><p>枚举值：</p><ul><li>Active： 运行中</li><li>Provisioning： 创建中</li><li>Configuring： 变配中</li></ul>
        :rtype: str
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status

    @property
    def Tags(self):
        r"""<p>标签</p>
        :rtype: list of TagInfo
        """
        return self._Tags

    @Tags.setter
    def Tags(self, Tags):
        self._Tags = Tags

    @property
    def TradeStatus(self):
        r"""<p>模型路由实例的计费状态</p><p>枚举值：</p><ul><li>Normal： 正常</li><li>Isolated： 已隔离</li></ul>
        :rtype: str
        """
        return self._TradeStatus

    @TradeStatus.setter
    def TradeStatus(self, TradeStatus):
        self._TradeStatus = TradeStatus

    @property
    def Vip(self):
        r"""<p>模型路由实例VIP</p>
        :rtype: str
        """
        return self._Vip

    @Vip.setter
    def Vip(self, Vip):
        self._Vip = Vip

    @property
    def VpcId(self):
        r"""<p>模型路由实例所属VPC的ID</p>
        :rtype: str
        """
        return self._VpcId

    @VpcId.setter
    def VpcId(self, VpcId):
        self._VpcId = VpcId

    @property
    def Bandwidth(self):
        r"""<p>带宽</p><p>单位：Mbps</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._Bandwidth

    @Bandwidth.setter
    def Bandwidth(self, Bandwidth):
        self._Bandwidth = Bandwidth

    @property
    def EipAddressId(self):
        r"""<p>弹性公网IP的ID</p>
        :rtype: str
        """
        return self._EipAddressId

    @EipAddressId.setter
    def EipAddressId(self, EipAddressId):
        self._EipAddressId = EipAddressId

    @property
    def BillingConfig(self):
        r"""<p>计费信息</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.ModelRouterBillingConfigOutput`
        """
        return self._BillingConfig

    @BillingConfig.setter
    def BillingConfig(self, BillingConfig):
        self._BillingConfig = BillingConfig


    def _deserialize(self, params):
        self._BudgetId = params.get("BudgetId")
        self._BudgetName = params.get("BudgetName")
        if params.get("ClusterInfo") is not None:
            self._ClusterInfo = ClusterInfo()
            self._ClusterInfo._deserialize(params.get("ClusterInfo"))
        self._CreatedTime = params.get("CreatedTime")
        if params.get("CreditUsageSet") is not None:
            self._CreditUsageSet = []
            for item in params.get("CreditUsageSet"):
                obj = CreditUsage()
                obj._deserialize(item)
                self._CreditUsageSet.append(obj)
        self._Domain = params.get("Domain")
        self._ModelRouterId = params.get("ModelRouterId")
        self._ModelRouterName = params.get("ModelRouterName")
        self._ModelRouterType = params.get("ModelRouterType")
        self._ModifiedTime = params.get("ModifiedTime")
        self._NetworkType = params.get("NetworkType")
        self._SecurityStatus = params.get("SecurityStatus")
        self._Status = params.get("Status")
        if params.get("Tags") is not None:
            self._Tags = []
            for item in params.get("Tags"):
                obj = TagInfo()
                obj._deserialize(item)
                self._Tags.append(obj)
        self._TradeStatus = params.get("TradeStatus")
        self._Vip = params.get("Vip")
        self._VpcId = params.get("VpcId")
        self._Bandwidth = params.get("Bandwidth")
        self._EipAddressId = params.get("EipAddressId")
        if params.get("BillingConfig") is not None:
            self._BillingConfig = ModelRouterBillingConfigOutput()
            self._BillingConfig._deserialize(params.get("BillingConfig"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModelTestResult(AbstractModel):
    r"""BYOK健康探测结果

    """

    def __init__(self):
        r"""
        :param _Model: <p>模型</p>
        :type Model: str
        :param _Status: <p>健康状况</p><p>枚举值：</p><ul><li>Success： 健康</li><li>Error： 不健康</li></ul>
        :type Status: str
        :param _ErrorInfo: <p>错误信息</p>
        :type ErrorInfo: :class:`tencentcloud.clb.v20180317.models.ProviderTestConnectionErrorInfo`
        :param _TestConnectionRequest: <p>探测请求</p>
        :type TestConnectionRequest: :class:`tencentcloud.clb.v20180317.models.TestConnectionRequestInfo`
        """
        self._Model = None
        self._Status = None
        self._ErrorInfo = None
        self._TestConnectionRequest = None

    @property
    def Model(self):
        r"""<p>模型</p>
        :rtype: str
        """
        return self._Model

    @Model.setter
    def Model(self, Model):
        self._Model = Model

    @property
    def Status(self):
        r"""<p>健康状况</p><p>枚举值：</p><ul><li>Success： 健康</li><li>Error： 不健康</li></ul>
        :rtype: str
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status

    @property
    def ErrorInfo(self):
        r"""<p>错误信息</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.ProviderTestConnectionErrorInfo`
        """
        return self._ErrorInfo

    @ErrorInfo.setter
    def ErrorInfo(self, ErrorInfo):
        self._ErrorInfo = ErrorInfo

    @property
    def TestConnectionRequest(self):
        r"""<p>探测请求</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.TestConnectionRequestInfo`
        """
        return self._TestConnectionRequest

    @TestConnectionRequest.setter
    def TestConnectionRequest(self, TestConnectionRequest):
        self._TestConnectionRequest = TestConnectionRequest


    def _deserialize(self, params):
        self._Model = params.get("Model")
        self._Status = params.get("Status")
        if params.get("ErrorInfo") is not None:
            self._ErrorInfo = ProviderTestConnectionErrorInfo()
            self._ErrorInfo._deserialize(params.get("ErrorInfo"))
        if params.get("TestConnectionRequest") is not None:
            self._TestConnectionRequest = TestConnectionRequestInfo()
            self._TestConnectionRequest._deserialize(params.get("TestConnectionRequest"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyBlockIPListRequest(AbstractModel):
    r"""ModifyBlockIPList请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerIds: 负载均衡实例ID
        :type LoadBalancerIds: list of str
        :param _Type: 操作类型，可取：
<li> add_customized_field（首次设置header，开启黑名单功能）</li>
<li> set_customized_field（修改header）</li>
<li> del_customized_field（删除header）</li>
<li> add_blocked（添加黑名单）</li>
<li> del_blocked（删除黑名单）</li>
<li> flush_blocked（清空黑名单）</li>
        :type Type: str
        :param _ClientIPField: 客户端真实IP存放的header字段名
        :type ClientIPField: str
        :param _BlockIPList: 封禁IP列表，单次操作数组最大长度支持200000
        :type BlockIPList: list of str
        :param _ExpireTime: 过期时间，单位秒，默认值3600
        :type ExpireTime: int
        :param _AddStrategy: 添加IP的策略，可取：fifo（如果黑名单容量已满，新加入黑名单的IP采用先进先出策略）
        :type AddStrategy: str
        """
        self._LoadBalancerIds = None
        self._Type = None
        self._ClientIPField = None
        self._BlockIPList = None
        self._ExpireTime = None
        self._AddStrategy = None

    @property
    def LoadBalancerIds(self):
        r"""负载均衡实例ID
        :rtype: list of str
        """
        return self._LoadBalancerIds

    @LoadBalancerIds.setter
    def LoadBalancerIds(self, LoadBalancerIds):
        self._LoadBalancerIds = LoadBalancerIds

    @property
    def Type(self):
        r"""操作类型，可取：
<li> add_customized_field（首次设置header，开启黑名单功能）</li>
<li> set_customized_field（修改header）</li>
<li> del_customized_field（删除header）</li>
<li> add_blocked（添加黑名单）</li>
<li> del_blocked（删除黑名单）</li>
<li> flush_blocked（清空黑名单）</li>
        :rtype: str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type

    @property
    def ClientIPField(self):
        r"""客户端真实IP存放的header字段名
        :rtype: str
        """
        return self._ClientIPField

    @ClientIPField.setter
    def ClientIPField(self, ClientIPField):
        self._ClientIPField = ClientIPField

    @property
    def BlockIPList(self):
        r"""封禁IP列表，单次操作数组最大长度支持200000
        :rtype: list of str
        """
        return self._BlockIPList

    @BlockIPList.setter
    def BlockIPList(self, BlockIPList):
        self._BlockIPList = BlockIPList

    @property
    def ExpireTime(self):
        r"""过期时间，单位秒，默认值3600
        :rtype: int
        """
        return self._ExpireTime

    @ExpireTime.setter
    def ExpireTime(self, ExpireTime):
        self._ExpireTime = ExpireTime

    @property
    def AddStrategy(self):
        r"""添加IP的策略，可取：fifo（如果黑名单容量已满，新加入黑名单的IP采用先进先出策略）
        :rtype: str
        """
        return self._AddStrategy

    @AddStrategy.setter
    def AddStrategy(self, AddStrategy):
        self._AddStrategy = AddStrategy


    def _deserialize(self, params):
        self._LoadBalancerIds = params.get("LoadBalancerIds")
        self._Type = params.get("Type")
        self._ClientIPField = params.get("ClientIPField")
        self._BlockIPList = params.get("BlockIPList")
        self._ExpireTime = params.get("ExpireTime")
        self._AddStrategy = params.get("AddStrategy")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyBlockIPListResponse(AbstractModel):
    r"""ModifyBlockIPList返回参数结构体

    """

    def __init__(self):
        r"""
        :param _JodId: 异步任务的ID
        :type JodId: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._JodId = None
        self._RequestId = None

    @property
    def JodId(self):
        r"""异步任务的ID
        :rtype: str
        """
        return self._JodId

    @JodId.setter
    def JodId(self, JodId):
        self._JodId = JodId

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._JodId = params.get("JodId")
        self._RequestId = params.get("RequestId")


class ModifyBudgetAttributesRequest(AbstractModel):
    r"""ModifyBudgetAttributes请求参数结构体

    """

    def __init__(self):
        r"""
        :param _BudgetId: <p>Budget ID。</p>
        :type BudgetId: str
        :param _BudgetConfigs: <p>预算配置数组。</p><p>数组长度最大为3，最多可同时配置1d、7d、30d三个刷新周期，且每种刷新周期只能出现一次。BudgetResetAt不支持作为入参设置，系统会按配置的刷新周期自动维护刷新时间。</p>
        :type BudgetConfigs: list of BudgetConfigInput
        :param _BudgetName: <p>Budget名称。</p>
        :type BudgetName: str
        :param _RateLimitConfig: <p>Budget限速配置。</p>
        :type RateLimitConfig: :class:`tencentcloud.clb.v20180317.models.RateLimitConfigForBudget`
        """
        self._BudgetId = None
        self._BudgetConfigs = None
        self._BudgetName = None
        self._RateLimitConfig = None

    @property
    def BudgetId(self):
        r"""<p>Budget ID。</p>
        :rtype: str
        """
        return self._BudgetId

    @BudgetId.setter
    def BudgetId(self, BudgetId):
        self._BudgetId = BudgetId

    @property
    def BudgetConfigs(self):
        r"""<p>预算配置数组。</p><p>数组长度最大为3，最多可同时配置1d、7d、30d三个刷新周期，且每种刷新周期只能出现一次。BudgetResetAt不支持作为入参设置，系统会按配置的刷新周期自动维护刷新时间。</p>
        :rtype: list of BudgetConfigInput
        """
        return self._BudgetConfigs

    @BudgetConfigs.setter
    def BudgetConfigs(self, BudgetConfigs):
        self._BudgetConfigs = BudgetConfigs

    @property
    def BudgetName(self):
        r"""<p>Budget名称。</p>
        :rtype: str
        """
        return self._BudgetName

    @BudgetName.setter
    def BudgetName(self, BudgetName):
        self._BudgetName = BudgetName

    @property
    def RateLimitConfig(self):
        r"""<p>Budget限速配置。</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.RateLimitConfigForBudget`
        """
        return self._RateLimitConfig

    @RateLimitConfig.setter
    def RateLimitConfig(self, RateLimitConfig):
        self._RateLimitConfig = RateLimitConfig


    def _deserialize(self, params):
        self._BudgetId = params.get("BudgetId")
        if params.get("BudgetConfigs") is not None:
            self._BudgetConfigs = []
            for item in params.get("BudgetConfigs"):
                obj = BudgetConfigInput()
                obj._deserialize(item)
                self._BudgetConfigs.append(obj)
        self._BudgetName = params.get("BudgetName")
        if params.get("RateLimitConfig") is not None:
            self._RateLimitConfig = RateLimitConfigForBudget()
            self._RateLimitConfig._deserialize(params.get("RateLimitConfig"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyBudgetAttributesResponse(AbstractModel):
    r"""ModifyBudgetAttributes返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyDomainAttributesRequest(AbstractModel):
    r"""ModifyDomainAttributes请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口查询。
        :type LoadBalancerId: str
        :param _ListenerId: 负载均衡监听器ID，可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口查询。
        :type ListenerId: str
        :param _Domain: 域名（必须是已经创建的转发规则下的域名），如果是多域名，可以指定多域名列表中的任意一个，可以通过[DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口查询。
        :type Domain: str
        :param _NewDomain: 要修改的新域名。NewDomain和NewDomains只能传一个。
        :type NewDomain: str
        :param _Certificate: 域名相关的证书信息，注意，仅对启用SNI的监听器适用，不可和MultiCertInfo 同时传入。
        :type Certificate: :class:`tencentcloud.clb.v20180317.models.CertificateInput`
        :param _Http2: 是否开启HTTP2，注意，只有HTTPS域名才能开启HTTP2。
True: 开启HTTP2，Fasle: 不开启HTTP2。
        :type Http2: bool
        :param _DefaultServer: 是否设为默认域名，注意，一个监听器下只能设置一个默认域名。
True: 设为默认域名，Fasle: 不设置为默认域名。
        :type DefaultServer: bool
        :param _Quic: 是否开启 QUIC，注意，只有 HTTPS 域名才能开启 QUIC。
True: 开启 QUIC，False: 不开启QUIC。
        :type Quic: bool
        :param _NewDefaultServerDomain: 监听器下必须配置一个默认域名，若要关闭原默认域名，必须同时指定另一个域名作为新的默认域名，如果新的默认域名是多域名，可以指定多域名列表中的任意一个。
        :type NewDefaultServerDomain: str
        :param _NewDomains: 要修改的新域名列表。NewDomain和NewDomains只能传一个。
        :type NewDomains: list of str
        :param _MultiCertInfo: 域名相关的证书信息，注意，仅对启用SNI的监听器适用；支持同时传入多本算法类型不同的服务器证书，不可和Certificate 同时传入。
        :type MultiCertInfo: :class:`tencentcloud.clb.v20180317.models.MultiCertInfo`
        """
        self._LoadBalancerId = None
        self._ListenerId = None
        self._Domain = None
        self._NewDomain = None
        self._Certificate = None
        self._Http2 = None
        self._DefaultServer = None
        self._Quic = None
        self._NewDefaultServerDomain = None
        self._NewDomains = None
        self._MultiCertInfo = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口查询。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerId(self):
        r"""负载均衡监听器ID，可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口查询。
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def Domain(self):
        r"""域名（必须是已经创建的转发规则下的域名），如果是多域名，可以指定多域名列表中的任意一个，可以通过[DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口查询。
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def NewDomain(self):
        r"""要修改的新域名。NewDomain和NewDomains只能传一个。
        :rtype: str
        """
        return self._NewDomain

    @NewDomain.setter
    def NewDomain(self, NewDomain):
        self._NewDomain = NewDomain

    @property
    def Certificate(self):
        r"""域名相关的证书信息，注意，仅对启用SNI的监听器适用，不可和MultiCertInfo 同时传入。
        :rtype: :class:`tencentcloud.clb.v20180317.models.CertificateInput`
        """
        return self._Certificate

    @Certificate.setter
    def Certificate(self, Certificate):
        self._Certificate = Certificate

    @property
    def Http2(self):
        r"""是否开启HTTP2，注意，只有HTTPS域名才能开启HTTP2。
True: 开启HTTP2，Fasle: 不开启HTTP2。
        :rtype: bool
        """
        return self._Http2

    @Http2.setter
    def Http2(self, Http2):
        self._Http2 = Http2

    @property
    def DefaultServer(self):
        r"""是否设为默认域名，注意，一个监听器下只能设置一个默认域名。
True: 设为默认域名，Fasle: 不设置为默认域名。
        :rtype: bool
        """
        return self._DefaultServer

    @DefaultServer.setter
    def DefaultServer(self, DefaultServer):
        self._DefaultServer = DefaultServer

    @property
    def Quic(self):
        r"""是否开启 QUIC，注意，只有 HTTPS 域名才能开启 QUIC。
True: 开启 QUIC，False: 不开启QUIC。
        :rtype: bool
        """
        return self._Quic

    @Quic.setter
    def Quic(self, Quic):
        self._Quic = Quic

    @property
    def NewDefaultServerDomain(self):
        r"""监听器下必须配置一个默认域名，若要关闭原默认域名，必须同时指定另一个域名作为新的默认域名，如果新的默认域名是多域名，可以指定多域名列表中的任意一个。
        :rtype: str
        """
        return self._NewDefaultServerDomain

    @NewDefaultServerDomain.setter
    def NewDefaultServerDomain(self, NewDefaultServerDomain):
        self._NewDefaultServerDomain = NewDefaultServerDomain

    @property
    def NewDomains(self):
        r"""要修改的新域名列表。NewDomain和NewDomains只能传一个。
        :rtype: list of str
        """
        return self._NewDomains

    @NewDomains.setter
    def NewDomains(self, NewDomains):
        self._NewDomains = NewDomains

    @property
    def MultiCertInfo(self):
        r"""域名相关的证书信息，注意，仅对启用SNI的监听器适用；支持同时传入多本算法类型不同的服务器证书，不可和Certificate 同时传入。
        :rtype: :class:`tencentcloud.clb.v20180317.models.MultiCertInfo`
        """
        return self._MultiCertInfo

    @MultiCertInfo.setter
    def MultiCertInfo(self, MultiCertInfo):
        self._MultiCertInfo = MultiCertInfo


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerId = params.get("ListenerId")
        self._Domain = params.get("Domain")
        self._NewDomain = params.get("NewDomain")
        if params.get("Certificate") is not None:
            self._Certificate = CertificateInput()
            self._Certificate._deserialize(params.get("Certificate"))
        self._Http2 = params.get("Http2")
        self._DefaultServer = params.get("DefaultServer")
        self._Quic = params.get("Quic")
        self._NewDefaultServerDomain = params.get("NewDefaultServerDomain")
        self._NewDomains = params.get("NewDomains")
        if params.get("MultiCertInfo") is not None:
            self._MultiCertInfo = MultiCertInfo()
            self._MultiCertInfo._deserialize(params.get("MultiCertInfo"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyDomainAttributesResponse(AbstractModel):
    r"""ModifyDomainAttributes返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyDomainRequest(AbstractModel):
    r"""ModifyDomain请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例 ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口查询。
        :type LoadBalancerId: str
        :param _ListenerId: 负载均衡监听器 ID， 可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口查询。
        :type ListenerId: str
        :param _Domain: 监听器下的某个旧域名， 可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 查询。
        :type Domain: str
        :param _NewDomain: 新域名，	长度限制为：1-120。有三种使用格式：非正则表达式格式，通配符格式，正则表达式格式。非正则表达式格式只能使用字母、数字、‘-’、‘.’。通配符格式的使用 ‘*’ 只能在开头或者结尾。正则表达式以'~'开头。
        :type NewDomain: str
        """
        self._LoadBalancerId = None
        self._ListenerId = None
        self._Domain = None
        self._NewDomain = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例 ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口查询。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerId(self):
        r"""负载均衡监听器 ID， 可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口查询。
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def Domain(self):
        r"""监听器下的某个旧域名， 可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 查询。
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def NewDomain(self):
        r"""新域名，	长度限制为：1-120。有三种使用格式：非正则表达式格式，通配符格式，正则表达式格式。非正则表达式格式只能使用字母、数字、‘-’、‘.’。通配符格式的使用 ‘*’ 只能在开头或者结尾。正则表达式以'~'开头。
        :rtype: str
        """
        return self._NewDomain

    @NewDomain.setter
    def NewDomain(self, NewDomain):
        self._NewDomain = NewDomain


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerId = params.get("ListenerId")
        self._Domain = params.get("Domain")
        self._NewDomain = params.get("NewDomain")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyDomainResponse(AbstractModel):
    r"""ModifyDomain返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyFunctionTargetsRequest(AbstractModel):
    r"""ModifyFunctionTargets请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例ID。
        :type LoadBalancerId: str
        :param _ListenerId: 负载均衡监听器ID。
        :type ListenerId: str
        :param _FunctionTargets: 要修改的后端云函数服务列表，仅支持 Event 函数类型。
        :type FunctionTargets: list of FunctionTarget
        :param _LocationId: 转发规则的ID，当绑定机器到七层转发规则时，必须提供此参数或Domain+Url两者之一。
        :type LocationId: str
        :param _Domain: 目标规则的域名，提供LocationId参数时本参数不生效。
        :type Domain: str
        :param _Url: 目标规则的URL，提供LocationId参数时本参数不生效。
        :type Url: str
        """
        self._LoadBalancerId = None
        self._ListenerId = None
        self._FunctionTargets = None
        self._LocationId = None
        self._Domain = None
        self._Url = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerId(self):
        r"""负载均衡监听器ID。
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def FunctionTargets(self):
        r"""要修改的后端云函数服务列表，仅支持 Event 函数类型。
        :rtype: list of FunctionTarget
        """
        return self._FunctionTargets

    @FunctionTargets.setter
    def FunctionTargets(self, FunctionTargets):
        self._FunctionTargets = FunctionTargets

    @property
    def LocationId(self):
        r"""转发规则的ID，当绑定机器到七层转发规则时，必须提供此参数或Domain+Url两者之一。
        :rtype: str
        """
        return self._LocationId

    @LocationId.setter
    def LocationId(self, LocationId):
        self._LocationId = LocationId

    @property
    def Domain(self):
        r"""目标规则的域名，提供LocationId参数时本参数不生效。
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def Url(self):
        r"""目标规则的URL，提供LocationId参数时本参数不生效。
        :rtype: str
        """
        return self._Url

    @Url.setter
    def Url(self, Url):
        self._Url = Url


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerId = params.get("ListenerId")
        if params.get("FunctionTargets") is not None:
            self._FunctionTargets = []
            for item in params.get("FunctionTargets"):
                obj = FunctionTarget()
                obj._deserialize(item)
                self._FunctionTargets.append(obj)
        self._LocationId = params.get("LocationId")
        self._Domain = params.get("Domain")
        self._Url = params.get("Url")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyFunctionTargetsResponse(AbstractModel):
    r"""ModifyFunctionTargets返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyIntentRouterAttributeRequest(AbstractModel):
    r"""ModifyIntentRouterAttribute请求参数结构体

    """

    def __init__(self):
        r"""
        :param _IntentRouterId: <p>意图路由ID（ir-xxx格式）。</p>
        :type IntentRouterId: str
        :param _ModelRouterId: <p>模型路由实例ID。</p>
        :type ModelRouterId: str
        :param _RouteName: <p>新的路由名称。</p><p>选填；必须以"IntentRouter/"为前缀，后缀仅支持字母、数字、连字符和下划线，后缀长度1-128个字符。不传则不修改。</p>
        :type RouteName: str
        :param _RouterDescribe: <p>意图路由描述。</p>
        :type RouterDescribe: str
        :param _Tiers: <p>新的分层配置列表（全量替换）。</p><p>选填；不传则不修改。传入时必须为完整分层集合：复杂度分层须包含全部 4 个分层 SIMPLE/MEDIUM/COMPLEX/REASONING；语义分层须包含 default 及各语义 Tier（取决于实例所用协议，且不可跨协议变更）。每个分层至少包含一个模型，模型名称必须是已关联到该实例的模型。</p>
        :type Tiers: list of TierItem
        """
        self._IntentRouterId = None
        self._ModelRouterId = None
        self._RouteName = None
        self._RouterDescribe = None
        self._Tiers = None

    @property
    def IntentRouterId(self):
        r"""<p>意图路由ID（ir-xxx格式）。</p>
        :rtype: str
        """
        return self._IntentRouterId

    @IntentRouterId.setter
    def IntentRouterId(self, IntentRouterId):
        self._IntentRouterId = IntentRouterId

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID。</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def RouteName(self):
        r"""<p>新的路由名称。</p><p>选填；必须以"IntentRouter/"为前缀，后缀仅支持字母、数字、连字符和下划线，后缀长度1-128个字符。不传则不修改。</p>
        :rtype: str
        """
        return self._RouteName

    @RouteName.setter
    def RouteName(self, RouteName):
        self._RouteName = RouteName

    @property
    def RouterDescribe(self):
        r"""<p>意图路由描述。</p>
        :rtype: str
        """
        return self._RouterDescribe

    @RouterDescribe.setter
    def RouterDescribe(self, RouterDescribe):
        self._RouterDescribe = RouterDescribe

    @property
    def Tiers(self):
        r"""<p>新的分层配置列表（全量替换）。</p><p>选填；不传则不修改。传入时必须为完整分层集合：复杂度分层须包含全部 4 个分层 SIMPLE/MEDIUM/COMPLEX/REASONING；语义分层须包含 default 及各语义 Tier（取决于实例所用协议，且不可跨协议变更）。每个分层至少包含一个模型，模型名称必须是已关联到该实例的模型。</p>
        :rtype: list of TierItem
        """
        return self._Tiers

    @Tiers.setter
    def Tiers(self, Tiers):
        self._Tiers = Tiers


    def _deserialize(self, params):
        self._IntentRouterId = params.get("IntentRouterId")
        self._ModelRouterId = params.get("ModelRouterId")
        self._RouteName = params.get("RouteName")
        self._RouterDescribe = params.get("RouterDescribe")
        if params.get("Tiers") is not None:
            self._Tiers = []
            for item in params.get("Tiers"):
                obj = TierItem()
                obj._deserialize(item)
                self._Tiers.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyIntentRouterAttributeResponse(AbstractModel):
    r"""ModifyIntentRouterAttribute返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyKeyAttributesRequest(AbstractModel):
    r"""ModifyKeyAttributes请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID</p>
        :type ModelRouterId: str
        :param _KeyId: <p>API Key的ID</p>
        :type KeyId: str
        :param _KeyName: <p>Key的名称</p>
        :type KeyName: str
        :param _RateLimitConfig: <p>限速配置</p>
        :type RateLimitConfig: :class:`tencentcloud.clb.v20180317.models.RateLimitConfigForKey`
        """
        self._ModelRouterId = None
        self._KeyId = None
        self._KeyName = None
        self._RateLimitConfig = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def KeyId(self):
        r"""<p>API Key的ID</p>
        :rtype: str
        """
        return self._KeyId

    @KeyId.setter
    def KeyId(self, KeyId):
        self._KeyId = KeyId

    @property
    def KeyName(self):
        r"""<p>Key的名称</p>
        :rtype: str
        """
        return self._KeyName

    @KeyName.setter
    def KeyName(self, KeyName):
        self._KeyName = KeyName

    @property
    def RateLimitConfig(self):
        r"""<p>限速配置</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.RateLimitConfigForKey`
        """
        return self._RateLimitConfig

    @RateLimitConfig.setter
    def RateLimitConfig(self, RateLimitConfig):
        self._RateLimitConfig = RateLimitConfig


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._KeyId = params.get("KeyId")
        self._KeyName = params.get("KeyName")
        if params.get("RateLimitConfig") is not None:
            self._RateLimitConfig = RateLimitConfigForKey()
            self._RateLimitConfig._deserialize(params.get("RateLimitConfig"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyKeyAttributesResponse(AbstractModel):
    r"""ModifyKeyAttributes返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyKeysBlockStatusRequest(AbstractModel):
    r"""ModifyKeysBlockStatus请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID</p>
        :type ModelRouterId: str
        :param _Blocked: <p>是否停止使用</p>
        :type Blocked: bool
        :param _KeyIds: <p>需要修改的Key的ID列表</p>
        :type KeyIds: list of str
        """
        self._ModelRouterId = None
        self._Blocked = None
        self._KeyIds = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def Blocked(self):
        r"""<p>是否停止使用</p>
        :rtype: bool
        """
        return self._Blocked

    @Blocked.setter
    def Blocked(self, Blocked):
        self._Blocked = Blocked

    @property
    def KeyIds(self):
        r"""<p>需要修改的Key的ID列表</p>
        :rtype: list of str
        """
        return self._KeyIds

    @KeyIds.setter
    def KeyIds(self, KeyIds):
        self._KeyIds = KeyIds


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._Blocked = params.get("Blocked")
        self._KeyIds = params.get("KeyIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyKeysBlockStatusResponse(AbstractModel):
    r"""ModifyKeysBlockStatus返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyKeysUserGroupRequest(AbstractModel):
    r"""ModifyKeysUserGroup请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID。</p>
        :type ModelRouterId: str
        :param _UserGroupId: <p>目标归属用户组ID。传真实用户组ID表示批量入组或跨组移动（Key 已属其它组则改为目标组）；传 ugrp-ungrouped 表示批量移出到未分组。</p>
        :type UserGroupId: str
        :param _KeyIds: <p>待变更归属的 Key ID 列表，单次1-100个。</p>
        :type KeyIds: list of str
        """
        self._ModelRouterId = None
        self._UserGroupId = None
        self._KeyIds = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID。</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def UserGroupId(self):
        r"""<p>目标归属用户组ID。传真实用户组ID表示批量入组或跨组移动（Key 已属其它组则改为目标组）；传 ugrp-ungrouped 表示批量移出到未分组。</p>
        :rtype: str
        """
        return self._UserGroupId

    @UserGroupId.setter
    def UserGroupId(self, UserGroupId):
        self._UserGroupId = UserGroupId

    @property
    def KeyIds(self):
        r"""<p>待变更归属的 Key ID 列表，单次1-100个。</p>
        :rtype: list of str
        """
        return self._KeyIds

    @KeyIds.setter
    def KeyIds(self, KeyIds):
        self._KeyIds = KeyIds


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._UserGroupId = params.get("UserGroupId")
        self._KeyIds = params.get("KeyIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyKeysUserGroupResponse(AbstractModel):
    r"""ModifyKeysUserGroup返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyListenerRequest(AbstractModel):
    r"""ModifyListener请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: <p>负载均衡实例ID，可以通过 <a href="https://cloud.tencent.com/document/product/214/30685">DescribeLoadBalancers</a> 接口查询。</p>
        :type LoadBalancerId: str
        :param _ListenerId: <p>负载均衡监听器ID，可以通过 <a href="https://cloud.tencent.com/document/product/214/30686">DescribeListeners</a> 接口查询。</p>
        :type ListenerId: str
        :param _ListenerName: <p>新的监听器名称。命名规则：1-80 个英文字母、汉字等国际通用语言字符，数字，连接线“-”、下划线“_”等常见字符（禁止Unicode补充字符，如emoji表情、生僻汉字等）。</p>
        :type ListenerName: str
        :param _SessionExpireTime: <p>会话保持时间，单位：秒。可选值：30~3600，默认 0，表示不开启。此参数仅适用于TCP/UDP监听器。</p>
        :type SessionExpireTime: int
        :param _HealthCheck: <p>健康检查相关参数，此参数仅适用于TCP/UDP/TCP_SSL/QUIC监听器。</p>
        :type HealthCheck: :class:`tencentcloud.clb.v20180317.models.HealthCheck`
        :param _Certificate: <p>证书相关信息，此参数仅适用于HTTPS/TCP_SSL/QUIC监听器；此参数和MultiCertInfo不能同时传入。</p>
        :type Certificate: :class:`tencentcloud.clb.v20180317.models.CertificateInput`
        :param _Scheduler: <p>监听器转发的方式。可选值：WRR（按权重轮询）、LEAST_CONN（按最小连接数）、IP_HASH（按 IP 地址哈希）<br>分别表示按权重轮询、最小连接数， 默认为 WRR。<br>使用场景：适用于TCP/UDP/TCP_SSL/QUIC监听器。七层监听器的均衡方式应在转发规则中修改。</p>
        :type Scheduler: str
        :param _SniSwitch: <p>是否开启SNI特性，此参数仅适用于HTTPS监听器。默认0，表示不开启，1表示开启。注意：未开启SNI的监听器可以开启SNI；已开启SNI的监听器不能关闭SNI。</p>
        :type SniSwitch: int
        :param _TargetType: <p>后端目标类型，NODE表示绑定普通节点，TARGETGROUP表示绑定目标组。</p>
        :type TargetType: str
        :param _KeepaliveEnable: <p>是否开启长连接，此参数仅适用于HTTP/HTTPS监听器。<br>默认值0表示不开启，1表示开启。<br>若后端服务对连接数上限有限制，则建议谨慎开启。此功能目前处于内测中，如需使用，请提交 <a href="https://cloud.tencent.com/apply/p/tsodp6qm21">内测申请</a>。</p>
        :type KeepaliveEnable: int
        :param _DeregisterTargetRst: <p>重新调度功能，解绑后端服务开关，打开此开关，当解绑后端服务时触发重新调度。仅TCP/UDP监听器支持。</p>
        :type DeregisterTargetRst: bool
        :param _SessionType: <p>会话保持类型。NORMAL表示默认会话保持类型。QUIC_CID表示根据Quic Connection ID做会话保持。QUIC_CID只支持UDP协议。<br>使用场景：适用于TCP/UDP/TCP_SSL/QUIC监听器。<br>默认为 NORMAL。</p>
        :type SessionType: str
        :param _MultiCertInfo: <p>证书信息，支持同时传入不同算法类型的多本服务端证书；此参数仅适用于未开启SNI特性的HTTPS监听器。此参数和Certificate不能同时传入。</p>
        :type MultiCertInfo: :class:`tencentcloud.clb.v20180317.models.MultiCertInfo`
        :param _MaxConn: <p>监听器粒度并发连接数上限，当前仅性能容量型实例且仅TCP/UDP/TCP_SSL/QUIC监听器支持。取值范围：1-实例规格并发连接上限，其中-1表示关闭监听器粒度并发连接数限速。基础网络实例不支持该参数。<br>默认为 -1，表示不限速。</p>
        :type MaxConn: int
        :param _MaxCps: <p>监听器粒度新建连接数上限，当前仅性能容量型实例且仅TCP/UDP/TCP_SSL/QUIC监听器支持。取值范围：1-实例规格新建连接上限，其中-1表示关闭监听器粒度新建连接数限速。基础网络实例不支持该参数。<br>默认为 -1 表示不限速。</p>
        :type MaxCps: int
        :param _IdleConnectTimeout: <p>空闲连接超时时间，此参数仅适用于TCP/UDP监听器。如需设置超过1980s，请通过 <a href="https://console.cloud.tencent.com/workorder/category">工单申请</a>,最大可设置到3600s。</p><p>取值范围：[10, 1980]</p><p>单位：秒</p><p>默认值：900</p><p>TCP监听器默认值：900，UDP监听器默认值：300s。取值范围：共享型实例和独占型实例支持：10～900，性能容量型实例支持：10~1980。</p>
        :type IdleConnectTimeout: int
        :param _ProxyProtocol: <p>TCP_SSL和QUIC是否支持PP</p>
        :type ProxyProtocol: bool
        :param _SnatEnable: <p>是否开启SNAT（源IP替换），True（开启）、False（关闭）。默认为关闭。注意：SnatEnable开启时会替换客户端源IP，此时<code>透传客户端源IP</code>选项关闭，反之亦然。</p>
        :type SnatEnable: bool
        :param _DataCompressMode: <p>数据压缩模式</p><p>枚举值：</p><ul><li>transparent： 透明模式（默认值）</li><li>compatibility： 兼容模式（开启 gzip 兼容压缩配置）</li></ul>
        :type DataCompressMode: str
        :param _RescheduleTargetZeroWeight: <p>重新调度功能，权重调为0开关，打开此开关，后端服务器权重调为0时触发重新调度。仅TCP/UDP监听器支持。</p>
        :type RescheduleTargetZeroWeight: bool
        :param _RescheduleUnhealthy: <p>重新调度功能，健康检查异常开关，打开此开关，后端服务器健康检查异常时触发重新调度。仅TCP/UDP监听器支持。</p>
        :type RescheduleUnhealthy: bool
        :param _RescheduleExpandTarget: <p>重新调度功能，扩容后端服务开关，打开此开关，后端服务器增加或者减少时触发重新调度。仅TCP/UDP监听器支持。</p>
        :type RescheduleExpandTarget: bool
        :param _RescheduleStartTime: <p>重新调度触发开始时间，取值0~3600s。仅TCP/UDP监听器支持。</p>
        :type RescheduleStartTime: int
        :param _RescheduleInterval: <p>重新调度触发持续时间，取值0~3600s。仅TCP/UDP监听器支持。</p>
        :type RescheduleInterval: int
        """
        self._LoadBalancerId = None
        self._ListenerId = None
        self._ListenerName = None
        self._SessionExpireTime = None
        self._HealthCheck = None
        self._Certificate = None
        self._Scheduler = None
        self._SniSwitch = None
        self._TargetType = None
        self._KeepaliveEnable = None
        self._DeregisterTargetRst = None
        self._SessionType = None
        self._MultiCertInfo = None
        self._MaxConn = None
        self._MaxCps = None
        self._IdleConnectTimeout = None
        self._ProxyProtocol = None
        self._SnatEnable = None
        self._DataCompressMode = None
        self._RescheduleTargetZeroWeight = None
        self._RescheduleUnhealthy = None
        self._RescheduleExpandTarget = None
        self._RescheduleStartTime = None
        self._RescheduleInterval = None

    @property
    def LoadBalancerId(self):
        r"""<p>负载均衡实例ID，可以通过 <a href="https://cloud.tencent.com/document/product/214/30685">DescribeLoadBalancers</a> 接口查询。</p>
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerId(self):
        r"""<p>负载均衡监听器ID，可以通过 <a href="https://cloud.tencent.com/document/product/214/30686">DescribeListeners</a> 接口查询。</p>
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def ListenerName(self):
        r"""<p>新的监听器名称。命名规则：1-80 个英文字母、汉字等国际通用语言字符，数字，连接线“-”、下划线“_”等常见字符（禁止Unicode补充字符，如emoji表情、生僻汉字等）。</p>
        :rtype: str
        """
        return self._ListenerName

    @ListenerName.setter
    def ListenerName(self, ListenerName):
        self._ListenerName = ListenerName

    @property
    def SessionExpireTime(self):
        r"""<p>会话保持时间，单位：秒。可选值：30~3600，默认 0，表示不开启。此参数仅适用于TCP/UDP监听器。</p>
        :rtype: int
        """
        return self._SessionExpireTime

    @SessionExpireTime.setter
    def SessionExpireTime(self, SessionExpireTime):
        self._SessionExpireTime = SessionExpireTime

    @property
    def HealthCheck(self):
        r"""<p>健康检查相关参数，此参数仅适用于TCP/UDP/TCP_SSL/QUIC监听器。</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.HealthCheck`
        """
        return self._HealthCheck

    @HealthCheck.setter
    def HealthCheck(self, HealthCheck):
        self._HealthCheck = HealthCheck

    @property
    def Certificate(self):
        r"""<p>证书相关信息，此参数仅适用于HTTPS/TCP_SSL/QUIC监听器；此参数和MultiCertInfo不能同时传入。</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.CertificateInput`
        """
        return self._Certificate

    @Certificate.setter
    def Certificate(self, Certificate):
        self._Certificate = Certificate

    @property
    def Scheduler(self):
        r"""<p>监听器转发的方式。可选值：WRR（按权重轮询）、LEAST_CONN（按最小连接数）、IP_HASH（按 IP 地址哈希）<br>分别表示按权重轮询、最小连接数， 默认为 WRR。<br>使用场景：适用于TCP/UDP/TCP_SSL/QUIC监听器。七层监听器的均衡方式应在转发规则中修改。</p>
        :rtype: str
        """
        return self._Scheduler

    @Scheduler.setter
    def Scheduler(self, Scheduler):
        self._Scheduler = Scheduler

    @property
    def SniSwitch(self):
        r"""<p>是否开启SNI特性，此参数仅适用于HTTPS监听器。默认0，表示不开启，1表示开启。注意：未开启SNI的监听器可以开启SNI；已开启SNI的监听器不能关闭SNI。</p>
        :rtype: int
        """
        return self._SniSwitch

    @SniSwitch.setter
    def SniSwitch(self, SniSwitch):
        self._SniSwitch = SniSwitch

    @property
    def TargetType(self):
        r"""<p>后端目标类型，NODE表示绑定普通节点，TARGETGROUP表示绑定目标组。</p>
        :rtype: str
        """
        return self._TargetType

    @TargetType.setter
    def TargetType(self, TargetType):
        self._TargetType = TargetType

    @property
    def KeepaliveEnable(self):
        r"""<p>是否开启长连接，此参数仅适用于HTTP/HTTPS监听器。<br>默认值0表示不开启，1表示开启。<br>若后端服务对连接数上限有限制，则建议谨慎开启。此功能目前处于内测中，如需使用，请提交 <a href="https://cloud.tencent.com/apply/p/tsodp6qm21">内测申请</a>。</p>
        :rtype: int
        """
        return self._KeepaliveEnable

    @KeepaliveEnable.setter
    def KeepaliveEnable(self, KeepaliveEnable):
        self._KeepaliveEnable = KeepaliveEnable

    @property
    def DeregisterTargetRst(self):
        r"""<p>重新调度功能，解绑后端服务开关，打开此开关，当解绑后端服务时触发重新调度。仅TCP/UDP监听器支持。</p>
        :rtype: bool
        """
        return self._DeregisterTargetRst

    @DeregisterTargetRst.setter
    def DeregisterTargetRst(self, DeregisterTargetRst):
        self._DeregisterTargetRst = DeregisterTargetRst

    @property
    def SessionType(self):
        r"""<p>会话保持类型。NORMAL表示默认会话保持类型。QUIC_CID表示根据Quic Connection ID做会话保持。QUIC_CID只支持UDP协议。<br>使用场景：适用于TCP/UDP/TCP_SSL/QUIC监听器。<br>默认为 NORMAL。</p>
        :rtype: str
        """
        return self._SessionType

    @SessionType.setter
    def SessionType(self, SessionType):
        self._SessionType = SessionType

    @property
    def MultiCertInfo(self):
        r"""<p>证书信息，支持同时传入不同算法类型的多本服务端证书；此参数仅适用于未开启SNI特性的HTTPS监听器。此参数和Certificate不能同时传入。</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.MultiCertInfo`
        """
        return self._MultiCertInfo

    @MultiCertInfo.setter
    def MultiCertInfo(self, MultiCertInfo):
        self._MultiCertInfo = MultiCertInfo

    @property
    def MaxConn(self):
        r"""<p>监听器粒度并发连接数上限，当前仅性能容量型实例且仅TCP/UDP/TCP_SSL/QUIC监听器支持。取值范围：1-实例规格并发连接上限，其中-1表示关闭监听器粒度并发连接数限速。基础网络实例不支持该参数。<br>默认为 -1，表示不限速。</p>
        :rtype: int
        """
        return self._MaxConn

    @MaxConn.setter
    def MaxConn(self, MaxConn):
        self._MaxConn = MaxConn

    @property
    def MaxCps(self):
        r"""<p>监听器粒度新建连接数上限，当前仅性能容量型实例且仅TCP/UDP/TCP_SSL/QUIC监听器支持。取值范围：1-实例规格新建连接上限，其中-1表示关闭监听器粒度新建连接数限速。基础网络实例不支持该参数。<br>默认为 -1 表示不限速。</p>
        :rtype: int
        """
        return self._MaxCps

    @MaxCps.setter
    def MaxCps(self, MaxCps):
        self._MaxCps = MaxCps

    @property
    def IdleConnectTimeout(self):
        r"""<p>空闲连接超时时间，此参数仅适用于TCP/UDP监听器。如需设置超过1980s，请通过 <a href="https://console.cloud.tencent.com/workorder/category">工单申请</a>,最大可设置到3600s。</p><p>取值范围：[10, 1980]</p><p>单位：秒</p><p>默认值：900</p><p>TCP监听器默认值：900，UDP监听器默认值：300s。取值范围：共享型实例和独占型实例支持：10～900，性能容量型实例支持：10~1980。</p>
        :rtype: int
        """
        return self._IdleConnectTimeout

    @IdleConnectTimeout.setter
    def IdleConnectTimeout(self, IdleConnectTimeout):
        self._IdleConnectTimeout = IdleConnectTimeout

    @property
    def ProxyProtocol(self):
        r"""<p>TCP_SSL和QUIC是否支持PP</p>
        :rtype: bool
        """
        return self._ProxyProtocol

    @ProxyProtocol.setter
    def ProxyProtocol(self, ProxyProtocol):
        self._ProxyProtocol = ProxyProtocol

    @property
    def SnatEnable(self):
        r"""<p>是否开启SNAT（源IP替换），True（开启）、False（关闭）。默认为关闭。注意：SnatEnable开启时会替换客户端源IP，此时<code>透传客户端源IP</code>选项关闭，反之亦然。</p>
        :rtype: bool
        """
        return self._SnatEnable

    @SnatEnable.setter
    def SnatEnable(self, SnatEnable):
        self._SnatEnable = SnatEnable

    @property
    def DataCompressMode(self):
        r"""<p>数据压缩模式</p><p>枚举值：</p><ul><li>transparent： 透明模式（默认值）</li><li>compatibility： 兼容模式（开启 gzip 兼容压缩配置）</li></ul>
        :rtype: str
        """
        return self._DataCompressMode

    @DataCompressMode.setter
    def DataCompressMode(self, DataCompressMode):
        self._DataCompressMode = DataCompressMode

    @property
    def RescheduleTargetZeroWeight(self):
        r"""<p>重新调度功能，权重调为0开关，打开此开关，后端服务器权重调为0时触发重新调度。仅TCP/UDP监听器支持。</p>
        :rtype: bool
        """
        return self._RescheduleTargetZeroWeight

    @RescheduleTargetZeroWeight.setter
    def RescheduleTargetZeroWeight(self, RescheduleTargetZeroWeight):
        self._RescheduleTargetZeroWeight = RescheduleTargetZeroWeight

    @property
    def RescheduleUnhealthy(self):
        r"""<p>重新调度功能，健康检查异常开关，打开此开关，后端服务器健康检查异常时触发重新调度。仅TCP/UDP监听器支持。</p>
        :rtype: bool
        """
        return self._RescheduleUnhealthy

    @RescheduleUnhealthy.setter
    def RescheduleUnhealthy(self, RescheduleUnhealthy):
        self._RescheduleUnhealthy = RescheduleUnhealthy

    @property
    def RescheduleExpandTarget(self):
        r"""<p>重新调度功能，扩容后端服务开关，打开此开关，后端服务器增加或者减少时触发重新调度。仅TCP/UDP监听器支持。</p>
        :rtype: bool
        """
        return self._RescheduleExpandTarget

    @RescheduleExpandTarget.setter
    def RescheduleExpandTarget(self, RescheduleExpandTarget):
        self._RescheduleExpandTarget = RescheduleExpandTarget

    @property
    def RescheduleStartTime(self):
        r"""<p>重新调度触发开始时间，取值0~3600s。仅TCP/UDP监听器支持。</p>
        :rtype: int
        """
        return self._RescheduleStartTime

    @RescheduleStartTime.setter
    def RescheduleStartTime(self, RescheduleStartTime):
        self._RescheduleStartTime = RescheduleStartTime

    @property
    def RescheduleInterval(self):
        r"""<p>重新调度触发持续时间，取值0~3600s。仅TCP/UDP监听器支持。</p>
        :rtype: int
        """
        return self._RescheduleInterval

    @RescheduleInterval.setter
    def RescheduleInterval(self, RescheduleInterval):
        self._RescheduleInterval = RescheduleInterval


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerId = params.get("ListenerId")
        self._ListenerName = params.get("ListenerName")
        self._SessionExpireTime = params.get("SessionExpireTime")
        if params.get("HealthCheck") is not None:
            self._HealthCheck = HealthCheck()
            self._HealthCheck._deserialize(params.get("HealthCheck"))
        if params.get("Certificate") is not None:
            self._Certificate = CertificateInput()
            self._Certificate._deserialize(params.get("Certificate"))
        self._Scheduler = params.get("Scheduler")
        self._SniSwitch = params.get("SniSwitch")
        self._TargetType = params.get("TargetType")
        self._KeepaliveEnable = params.get("KeepaliveEnable")
        self._DeregisterTargetRst = params.get("DeregisterTargetRst")
        self._SessionType = params.get("SessionType")
        if params.get("MultiCertInfo") is not None:
            self._MultiCertInfo = MultiCertInfo()
            self._MultiCertInfo._deserialize(params.get("MultiCertInfo"))
        self._MaxConn = params.get("MaxConn")
        self._MaxCps = params.get("MaxCps")
        self._IdleConnectTimeout = params.get("IdleConnectTimeout")
        self._ProxyProtocol = params.get("ProxyProtocol")
        self._SnatEnable = params.get("SnatEnable")
        self._DataCompressMode = params.get("DataCompressMode")
        self._RescheduleTargetZeroWeight = params.get("RescheduleTargetZeroWeight")
        self._RescheduleUnhealthy = params.get("RescheduleUnhealthy")
        self._RescheduleExpandTarget = params.get("RescheduleExpandTarget")
        self._RescheduleStartTime = params.get("RescheduleStartTime")
        self._RescheduleInterval = params.get("RescheduleInterval")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyListenerResponse(AbstractModel):
    r"""ModifyListener返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyLoadBalancerAttributesRequest(AbstractModel):
    r"""ModifyLoadBalancerAttributes请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: <p>负载均衡的唯一ID，可以通过 <a href="https://cloud.tencent.com/document/product/214/30685">DescribeLoadBalancers</a> 接口获取。</p>
        :type LoadBalancerId: str
        :param _LoadBalancerName: <p>负载均衡实例名称，规则：1-80 个英文字母、汉字等国际通用语言字符，数字，连接线“-”、下划线“_”等常见字符（禁止Unicode补充字符，如emoji表情、生僻汉字等）。</p>
        :type LoadBalancerName: str
        :param _TargetRegionInfo: <p>设置负载均衡跨地域绑定1.0的后端服务信息</p>
        :type TargetRegionInfo: :class:`tencentcloud.clb.v20180317.models.TargetRegionInfo`
        :param _InternetChargeInfo: <p>网络计费相关参数</p>
        :type InternetChargeInfo: :class:`tencentcloud.clb.v20180317.models.InternetAccessible`
        :param _LoadBalancerPassToTarget: <p>Target是否放通来自CLB的流量。<br>开启放通（true）：只验证CLB上的安全组；<br>不开启放通（false）：需同时验证CLB和后端实例上的安全组。<br>不填则不修改。</p>
        :type LoadBalancerPassToTarget: bool
        :param _SwitchFlag: <p>不同计费模式之间的切换：0表示不切换，1表示预付费和后付费切换，2表示后付费之间切换。默认值：0</p>
        :type SwitchFlag: int
        :param _SnatPro: <p>是否开启跨地域绑定2.0功能。不填则不修改。</p>
        :type SnatPro: bool
        :param _DeleteProtect: <p>是否开启删除保护，不填则不修改。</p>
        :type DeleteProtect: bool
        :param _ModifyClassicDomain: <p>将负载均衡二级域名由mycloud.com改为tencentclb.com，子域名也会变换，修改后mycloud.com域名将失效。不填则不修改。</p>
        :type ModifyClassicDomain: bool
        :param _AssociateEndpoint: <p>关联的终端节点Id，可通过<a href="https://cloud.tencent.com/document/product/215/54679">DescribeVpcEndPoint</a>接口查询。传空字符串代表解除关联。</p>
        :type AssociateEndpoint: str
        """
        self._LoadBalancerId = None
        self._LoadBalancerName = None
        self._TargetRegionInfo = None
        self._InternetChargeInfo = None
        self._LoadBalancerPassToTarget = None
        self._SwitchFlag = None
        self._SnatPro = None
        self._DeleteProtect = None
        self._ModifyClassicDomain = None
        self._AssociateEndpoint = None

    @property
    def LoadBalancerId(self):
        r"""<p>负载均衡的唯一ID，可以通过 <a href="https://cloud.tencent.com/document/product/214/30685">DescribeLoadBalancers</a> 接口获取。</p>
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def LoadBalancerName(self):
        r"""<p>负载均衡实例名称，规则：1-80 个英文字母、汉字等国际通用语言字符，数字，连接线“-”、下划线“_”等常见字符（禁止Unicode补充字符，如emoji表情、生僻汉字等）。</p>
        :rtype: str
        """
        return self._LoadBalancerName

    @LoadBalancerName.setter
    def LoadBalancerName(self, LoadBalancerName):
        self._LoadBalancerName = LoadBalancerName

    @property
    def TargetRegionInfo(self):
        r"""<p>设置负载均衡跨地域绑定1.0的后端服务信息</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.TargetRegionInfo`
        """
        return self._TargetRegionInfo

    @TargetRegionInfo.setter
    def TargetRegionInfo(self, TargetRegionInfo):
        self._TargetRegionInfo = TargetRegionInfo

    @property
    def InternetChargeInfo(self):
        r"""<p>网络计费相关参数</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.InternetAccessible`
        """
        return self._InternetChargeInfo

    @InternetChargeInfo.setter
    def InternetChargeInfo(self, InternetChargeInfo):
        self._InternetChargeInfo = InternetChargeInfo

    @property
    def LoadBalancerPassToTarget(self):
        r"""<p>Target是否放通来自CLB的流量。<br>开启放通（true）：只验证CLB上的安全组；<br>不开启放通（false）：需同时验证CLB和后端实例上的安全组。<br>不填则不修改。</p>
        :rtype: bool
        """
        return self._LoadBalancerPassToTarget

    @LoadBalancerPassToTarget.setter
    def LoadBalancerPassToTarget(self, LoadBalancerPassToTarget):
        self._LoadBalancerPassToTarget = LoadBalancerPassToTarget

    @property
    def SwitchFlag(self):
        r"""<p>不同计费模式之间的切换：0表示不切换，1表示预付费和后付费切换，2表示后付费之间切换。默认值：0</p>
        :rtype: int
        """
        return self._SwitchFlag

    @SwitchFlag.setter
    def SwitchFlag(self, SwitchFlag):
        self._SwitchFlag = SwitchFlag

    @property
    def SnatPro(self):
        r"""<p>是否开启跨地域绑定2.0功能。不填则不修改。</p>
        :rtype: bool
        """
        return self._SnatPro

    @SnatPro.setter
    def SnatPro(self, SnatPro):
        self._SnatPro = SnatPro

    @property
    def DeleteProtect(self):
        r"""<p>是否开启删除保护，不填则不修改。</p>
        :rtype: bool
        """
        return self._DeleteProtect

    @DeleteProtect.setter
    def DeleteProtect(self, DeleteProtect):
        self._DeleteProtect = DeleteProtect

    @property
    def ModifyClassicDomain(self):
        r"""<p>将负载均衡二级域名由mycloud.com改为tencentclb.com，子域名也会变换，修改后mycloud.com域名将失效。不填则不修改。</p>
        :rtype: bool
        """
        return self._ModifyClassicDomain

    @ModifyClassicDomain.setter
    def ModifyClassicDomain(self, ModifyClassicDomain):
        self._ModifyClassicDomain = ModifyClassicDomain

    @property
    def AssociateEndpoint(self):
        r"""<p>关联的终端节点Id，可通过<a href="https://cloud.tencent.com/document/product/215/54679">DescribeVpcEndPoint</a>接口查询。传空字符串代表解除关联。</p>
        :rtype: str
        """
        return self._AssociateEndpoint

    @AssociateEndpoint.setter
    def AssociateEndpoint(self, AssociateEndpoint):
        self._AssociateEndpoint = AssociateEndpoint


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._LoadBalancerName = params.get("LoadBalancerName")
        if params.get("TargetRegionInfo") is not None:
            self._TargetRegionInfo = TargetRegionInfo()
            self._TargetRegionInfo._deserialize(params.get("TargetRegionInfo"))
        if params.get("InternetChargeInfo") is not None:
            self._InternetChargeInfo = InternetAccessible()
            self._InternetChargeInfo._deserialize(params.get("InternetChargeInfo"))
        self._LoadBalancerPassToTarget = params.get("LoadBalancerPassToTarget")
        self._SwitchFlag = params.get("SwitchFlag")
        self._SnatPro = params.get("SnatPro")
        self._DeleteProtect = params.get("DeleteProtect")
        self._ModifyClassicDomain = params.get("ModifyClassicDomain")
        self._AssociateEndpoint = params.get("AssociateEndpoint")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyLoadBalancerAttributesResponse(AbstractModel):
    r"""ModifyLoadBalancerAttributes返回参数结构体

    """

    def __init__(self):
        r"""
        :param _DealName: <p>切换负载均衡计费方式时，可用此参数查询切换任务是否成功。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type DealName: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._DealName = None
        self._RequestId = None

    @property
    def DealName(self):
        r"""<p>切换负载均衡计费方式时，可用此参数查询切换任务是否成功。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._DealName

    @DealName.setter
    def DealName(self, DealName):
        self._DealName = DealName

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._DealName = params.get("DealName")
        self._RequestId = params.get("RequestId")


class ModifyLoadBalancerMixIpTargetRequest(AbstractModel):
    r"""ModifyLoadBalancerMixIpTarget请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerIds: 负载均衡实例ID数组，默认支持20个负载均衡实例ID。
可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
        :type LoadBalancerIds: list of str
        :param _MixIpTarget: 开启/关闭IPv6FullChain负载均衡7层监听器支持混绑IPv4/IPv6目标特性。
        :type MixIpTarget: bool
        """
        self._LoadBalancerIds = None
        self._MixIpTarget = None

    @property
    def LoadBalancerIds(self):
        r"""负载均衡实例ID数组，默认支持20个负载均衡实例ID。
可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
        :rtype: list of str
        """
        return self._LoadBalancerIds

    @LoadBalancerIds.setter
    def LoadBalancerIds(self, LoadBalancerIds):
        self._LoadBalancerIds = LoadBalancerIds

    @property
    def MixIpTarget(self):
        r"""开启/关闭IPv6FullChain负载均衡7层监听器支持混绑IPv4/IPv6目标特性。
        :rtype: bool
        """
        return self._MixIpTarget

    @MixIpTarget.setter
    def MixIpTarget(self, MixIpTarget):
        self._MixIpTarget = MixIpTarget


    def _deserialize(self, params):
        self._LoadBalancerIds = params.get("LoadBalancerIds")
        self._MixIpTarget = params.get("MixIpTarget")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyLoadBalancerMixIpTargetResponse(AbstractModel):
    r"""ModifyLoadBalancerMixIpTarget返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyLoadBalancerSlaRequest(AbstractModel):
    r"""ModifyLoadBalancerSla请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerSla: 负载均衡实例信息。
        :type LoadBalancerSla: list of SlaUpdateParam
        :param _Force: 是否强制升级，默认否。
        :type Force: bool
        """
        self._LoadBalancerSla = None
        self._Force = None

    @property
    def LoadBalancerSla(self):
        r"""负载均衡实例信息。
        :rtype: list of SlaUpdateParam
        """
        return self._LoadBalancerSla

    @LoadBalancerSla.setter
    def LoadBalancerSla(self, LoadBalancerSla):
        self._LoadBalancerSla = LoadBalancerSla

    @property
    def Force(self):
        r"""是否强制升级，默认否。
        :rtype: bool
        """
        return self._Force

    @Force.setter
    def Force(self, Force):
        self._Force = Force


    def _deserialize(self, params):
        if params.get("LoadBalancerSla") is not None:
            self._LoadBalancerSla = []
            for item in params.get("LoadBalancerSla"):
                obj = SlaUpdateParam()
                obj._deserialize(item)
                self._LoadBalancerSla.append(obj)
        self._Force = params.get("Force")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyLoadBalancerSlaResponse(AbstractModel):
    r"""ModifyLoadBalancerSla返回参数结构体

    """

    def __init__(self):
        r"""
        :param _DealName: 订单号。
        :type DealName: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._DealName = None
        self._RequestId = None

    @property
    def DealName(self):
        r"""订单号。
        :rtype: str
        """
        return self._DealName

    @DealName.setter
    def DealName(self, DealName):
        self._DealName = DealName

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._DealName = params.get("DealName")
        self._RequestId = params.get("RequestId")


class ModifyLoadBalancersProjectRequest(AbstractModel):
    r"""ModifyLoadBalancersProject请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerIds: 一个或多个待操作的负载均衡实例ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
列表支持最大长度为20。
        :type LoadBalancerIds: list of str
        :param _ProjectId: 项目ID。可以通过 [DescribeProject](https://cloud.tencent.com/document/api/651/78725) 接口获取。
        :type ProjectId: int
        """
        self._LoadBalancerIds = None
        self._ProjectId = None

    @property
    def LoadBalancerIds(self):
        r"""一个或多个待操作的负载均衡实例ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
列表支持最大长度为20。
        :rtype: list of str
        """
        return self._LoadBalancerIds

    @LoadBalancerIds.setter
    def LoadBalancerIds(self, LoadBalancerIds):
        self._LoadBalancerIds = LoadBalancerIds

    @property
    def ProjectId(self):
        r"""项目ID。可以通过 [DescribeProject](https://cloud.tencent.com/document/api/651/78725) 接口获取。
        :rtype: int
        """
        return self._ProjectId

    @ProjectId.setter
    def ProjectId(self, ProjectId):
        self._ProjectId = ProjectId


    def _deserialize(self, params):
        self._LoadBalancerIds = params.get("LoadBalancerIds")
        self._ProjectId = params.get("ProjectId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyLoadBalancersProjectResponse(AbstractModel):
    r"""ModifyLoadBalancersProject返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyModelAliasAttributesRequest(AbstractModel):
    r"""ModifyModelAliasAttributes请求参数结构体

    """

    def __init__(self):
        r"""
        :param _Coefficient: <p>模型积分系数配置。</p><p>必填，至少包含 <code>InputCoefficient</code>、<code>InputCachedCoefficient</code>、<code>OutputCoefficient</code> 中的一个字段，未传字段保持原值。</p><p><code>InputCoefficient</code> 为非缓存命中输入积分系数。</p><p><code>InputCachedCoefficient</code> 为缓存命中输入积分系数，用于 provider prompt cache 命中的输入 token。</p><p><code>OutputCoefficient</code> 为输出积分系数。</p><p>各字段取值范围：[0, 5000]，仅支持整数，0 表示该类 token 不计积分。</p>
        :type Coefficient: :class:`tencentcloud.clb.v20180317.models.Coefficient`
        :param _ModelAliasNames: <p>模型别名列表。</p><p>不传 <code>ServiceProviderIds</code>（按 ModelAlias 账号维度修改）时支持数组批量，同一份 Coefficient 应用到多个别名。</p><p>传入 <code>ServiceProviderIds</code>（按 ServiceProvider 维度修改）时只能传 1 个别名，锁定唯一 model 别名；去重后不等于 1 个将返回 InvalidParameter。</p>
        :type ModelAliasNames: list of str
        :param _ServiceProviderIds: <p>BYOK 实例（ServiceProvider）ID 列表。</p><p>可选，数组。传入时按 ServiceProvider 维度修改：把同一份 Coefficient 批量应用到数组内每一个实例（覆盖配置，仅作用于这些实例），此时 <code>ModelAliasNames</code> 只能传 1 个别名（即 1 别名 × N ServiceProvider）；数组需去重、非空、上限 100，任一实例不归属/不存在/该实例下无该别名将整批返回错误。不传时按 ModelAlias（账号）维度修改，作用于该别名下未单独配置覆盖的全部实例。</p>
        :type ServiceProviderIds: list of str
        """
        self._Coefficient = None
        self._ModelAliasNames = None
        self._ServiceProviderIds = None

    @property
    def Coefficient(self):
        r"""<p>模型积分系数配置。</p><p>必填，至少包含 <code>InputCoefficient</code>、<code>InputCachedCoefficient</code>、<code>OutputCoefficient</code> 中的一个字段，未传字段保持原值。</p><p><code>InputCoefficient</code> 为非缓存命中输入积分系数。</p><p><code>InputCachedCoefficient</code> 为缓存命中输入积分系数，用于 provider prompt cache 命中的输入 token。</p><p><code>OutputCoefficient</code> 为输出积分系数。</p><p>各字段取值范围：[0, 5000]，仅支持整数，0 表示该类 token 不计积分。</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.Coefficient`
        """
        return self._Coefficient

    @Coefficient.setter
    def Coefficient(self, Coefficient):
        self._Coefficient = Coefficient

    @property
    def ModelAliasNames(self):
        r"""<p>模型别名列表。</p><p>不传 <code>ServiceProviderIds</code>（按 ModelAlias 账号维度修改）时支持数组批量，同一份 Coefficient 应用到多个别名。</p><p>传入 <code>ServiceProviderIds</code>（按 ServiceProvider 维度修改）时只能传 1 个别名，锁定唯一 model 别名；去重后不等于 1 个将返回 InvalidParameter。</p>
        :rtype: list of str
        """
        return self._ModelAliasNames

    @ModelAliasNames.setter
    def ModelAliasNames(self, ModelAliasNames):
        self._ModelAliasNames = ModelAliasNames

    @property
    def ServiceProviderIds(self):
        r"""<p>BYOK 实例（ServiceProvider）ID 列表。</p><p>可选，数组。传入时按 ServiceProvider 维度修改：把同一份 Coefficient 批量应用到数组内每一个实例（覆盖配置，仅作用于这些实例），此时 <code>ModelAliasNames</code> 只能传 1 个别名（即 1 别名 × N ServiceProvider）；数组需去重、非空、上限 100，任一实例不归属/不存在/该实例下无该别名将整批返回错误。不传时按 ModelAlias（账号）维度修改，作用于该别名下未单独配置覆盖的全部实例。</p>
        :rtype: list of str
        """
        return self._ServiceProviderIds

    @ServiceProviderIds.setter
    def ServiceProviderIds(self, ServiceProviderIds):
        self._ServiceProviderIds = ServiceProviderIds


    def _deserialize(self, params):
        if params.get("Coefficient") is not None:
            self._Coefficient = Coefficient()
            self._Coefficient._deserialize(params.get("Coefficient"))
        self._ModelAliasNames = params.get("ModelAliasNames")
        self._ServiceProviderIds = params.get("ServiceProviderIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyModelAliasAttributesResponse(AbstractModel):
    r"""ModifyModelAliasAttributes返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyModelAttributesRequest(AbstractModel):
    r"""ModifyModelAttributes请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ServiceProviderId: <p>BYOK的ID</p><p>参数格式：byok-kot39u7j</p>
        :type ServiceProviderId: str
        :param _ServiceProviderName: <p>BYOK的自定义名字</p><p>入参限制：1～256个字符</p>
        :type ServiceProviderName: str
        """
        self._ServiceProviderId = None
        self._ServiceProviderName = None

    @property
    def ServiceProviderId(self):
        r"""<p>BYOK的ID</p><p>参数格式：byok-kot39u7j</p>
        :rtype: str
        """
        return self._ServiceProviderId

    @ServiceProviderId.setter
    def ServiceProviderId(self, ServiceProviderId):
        self._ServiceProviderId = ServiceProviderId

    @property
    def ServiceProviderName(self):
        r"""<p>BYOK的自定义名字</p><p>入参限制：1～256个字符</p>
        :rtype: str
        """
        return self._ServiceProviderName

    @ServiceProviderName.setter
    def ServiceProviderName(self, ServiceProviderName):
        self._ServiceProviderName = ServiceProviderName


    def _deserialize(self, params):
        self._ServiceProviderId = params.get("ServiceProviderId")
        self._ServiceProviderName = params.get("ServiceProviderName")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyModelAttributesResponse(AbstractModel):
    r"""ModifyModelAttributes返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyModelRouterAttributesRequest(AbstractModel):
    r"""ModifyModelRouterAttributes请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由ID</p>
        :type ModelRouterId: str
        :param _CertId: <p>新的 HTTPS 证书ID，用于替换实例 HTTPS 服务端点当前绑定的证书。常用于证书到期前的更换场景。</p><p>使用限制：</p><ul><li>仅企业型（Enterprise）且服务端点协议为 HTTPS 的实例支持修改证书。</li><li>证书须为 SSL 证书控制台中状态为“已签发”（可用）且未过期的服务器证书（SVR 类型）。可在 <a href="https://console.cloud.tencent.com/ssl">SSL 证书控制台</a> 查看证书ID。</li><li>替换后新证书立即生效，过程中不会中断业务流量。</li><li>若传入的证书与当前绑定的证书相同，接口直接返回成功，不做任何变更。</li></ul><p>不传则证书保持不变。可通过 <code>DescribeModelRouterDetail</code> 接口的 <code>ServiceEndPoints.CertId</code> 字段查询当前绑定的证书。</p>
        :type CertId: str
        :param _ModelRouterName: <p>模型路由名称</p>
        :type ModelRouterName: str
        :param _RateLimitConfig: <p>限速配置</p>
        :type RateLimitConfig: :class:`tencentcloud.clb.v20180317.models.RateLimitConfigForModelRouter`
        :param _RouterSetting: <p>路由配置</p>
        :type RouterSetting: :class:`tencentcloud.clb.v20180317.models.RouterSettingWithFallBack`
        :param _Bandwidth: <p>带宽</p><p>取值范围：[1, 2048]</p><p>单位：Mbps</p>
        :type Bandwidth: int
        """
        self._ModelRouterId = None
        self._CertId = None
        self._ModelRouterName = None
        self._RateLimitConfig = None
        self._RouterSetting = None
        self._Bandwidth = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def CertId(self):
        r"""<p>新的 HTTPS 证书ID，用于替换实例 HTTPS 服务端点当前绑定的证书。常用于证书到期前的更换场景。</p><p>使用限制：</p><ul><li>仅企业型（Enterprise）且服务端点协议为 HTTPS 的实例支持修改证书。</li><li>证书须为 SSL 证书控制台中状态为“已签发”（可用）且未过期的服务器证书（SVR 类型）。可在 <a href="https://console.cloud.tencent.com/ssl">SSL 证书控制台</a> 查看证书ID。</li><li>替换后新证书立即生效，过程中不会中断业务流量。</li><li>若传入的证书与当前绑定的证书相同，接口直接返回成功，不做任何变更。</li></ul><p>不传则证书保持不变。可通过 <code>DescribeModelRouterDetail</code> 接口的 <code>ServiceEndPoints.CertId</code> 字段查询当前绑定的证书。</p>
        :rtype: str
        """
        return self._CertId

    @CertId.setter
    def CertId(self, CertId):
        self._CertId = CertId

    @property
    def ModelRouterName(self):
        r"""<p>模型路由名称</p>
        :rtype: str
        """
        return self._ModelRouterName

    @ModelRouterName.setter
    def ModelRouterName(self, ModelRouterName):
        self._ModelRouterName = ModelRouterName

    @property
    def RateLimitConfig(self):
        r"""<p>限速配置</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.RateLimitConfigForModelRouter`
        """
        return self._RateLimitConfig

    @RateLimitConfig.setter
    def RateLimitConfig(self, RateLimitConfig):
        self._RateLimitConfig = RateLimitConfig

    @property
    def RouterSetting(self):
        r"""<p>路由配置</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.RouterSettingWithFallBack`
        """
        return self._RouterSetting

    @RouterSetting.setter
    def RouterSetting(self, RouterSetting):
        self._RouterSetting = RouterSetting

    @property
    def Bandwidth(self):
        r"""<p>带宽</p><p>取值范围：[1, 2048]</p><p>单位：Mbps</p>
        :rtype: int
        """
        return self._Bandwidth

    @Bandwidth.setter
    def Bandwidth(self, Bandwidth):
        self._Bandwidth = Bandwidth


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._CertId = params.get("CertId")
        self._ModelRouterName = params.get("ModelRouterName")
        if params.get("RateLimitConfig") is not None:
            self._RateLimitConfig = RateLimitConfigForModelRouter()
            self._RateLimitConfig._deserialize(params.get("RateLimitConfig"))
        if params.get("RouterSetting") is not None:
            self._RouterSetting = RouterSettingWithFallBack()
            self._RouterSetting._deserialize(params.get("RouterSetting"))
        self._Bandwidth = params.get("Bandwidth")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyModelRouterAttributesResponse(AbstractModel):
    r"""ModifyModelRouterAttributes返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyModelRouterGuardrailsRequest(AbstractModel):
    r"""ModifyModelRouterGuardrails请求参数结构体

    """

    def __init__(self):
        r"""
        :param _Guardrails: <p>待修改的 Guardrail 防护配置列表。</p><p>当前最多支持 1 个元素。每个元素必须填写 GuardrailId；当 Type 为 WAF 或未传按 WAF 处理时，InstanceId 和 ServiceId 必填；InputCheckDepth 为选填，不传时沿用当前已关联 Guardrail 的取值。</p>
        :type Guardrails: list of GuardrailConfig
        :param _ModelRouterId: <p>模型路由实例 ID。</p>
        :type ModelRouterId: str
        """
        self._Guardrails = None
        self._ModelRouterId = None

    @property
    def Guardrails(self):
        r"""<p>待修改的 Guardrail 防护配置列表。</p><p>当前最多支持 1 个元素。每个元素必须填写 GuardrailId；当 Type 为 WAF 或未传按 WAF 处理时，InstanceId 和 ServiceId 必填；InputCheckDepth 为选填，不传时沿用当前已关联 Guardrail 的取值。</p>
        :rtype: list of GuardrailConfig
        """
        return self._Guardrails

    @Guardrails.setter
    def Guardrails(self, Guardrails):
        self._Guardrails = Guardrails

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例 ID。</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId


    def _deserialize(self, params):
        if params.get("Guardrails") is not None:
            self._Guardrails = []
            for item in params.get("Guardrails"):
                obj = GuardrailConfig()
                obj._deserialize(item)
                self._Guardrails.append(obj)
        self._ModelRouterId = params.get("ModelRouterId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyModelRouterGuardrailsResponse(AbstractModel):
    r"""ModifyModelRouterGuardrails返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyModelRouterSecurityGroupsRequest(AbstractModel):
    r"""ModifyModelRouterSecurityGroups请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID</p>
        :type ModelRouterId: str
        :param _SecurityGroups: <p>需要绑定的安全组ID列表</p>
        :type SecurityGroups: list of str
        """
        self._ModelRouterId = None
        self._SecurityGroups = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def SecurityGroups(self):
        r"""<p>需要绑定的安全组ID列表</p>
        :rtype: list of str
        """
        return self._SecurityGroups

    @SecurityGroups.setter
    def SecurityGroups(self, SecurityGroups):
        self._SecurityGroups = SecurityGroups


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._SecurityGroups = params.get("SecurityGroups")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyModelRouterSecurityGroupsResponse(AbstractModel):
    r"""ModifyModelRouterSecurityGroups返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyRuleRequest(AbstractModel):
    r"""ModifyRule请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例 ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口获取。
        :type LoadBalancerId: str
        :param _ListenerId: 负载均衡监听器 ID，可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口获取。
        :type ListenerId: str
        :param _LocationId: 要修改的转发规则的 ID， 可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口获取。
        :type LocationId: str
        :param _Url: 转发规则的新的转发路径，如不需修改Url，则不需提供此参数。
        :type Url: str
        :param _HealthCheck: 健康检查信息。
        :type HealthCheck: :class:`tencentcloud.clb.v20180317.models.HealthCheck`
        :param _Scheduler: 规则的请求转发方式，可选值：WRR、LEAST_CONN、IP_HASH
分别表示按权重轮询、最小连接数、按IP哈希， 默认为 WRR。
        :type Scheduler: str
        :param _SessionExpireTime: 会话保持时间。取值范围0或30-86400（单位：秒）。
默认为0。
        :type SessionExpireTime: int
        :param _ForwardType: 负载均衡实例与后端服务之间的转发协议，默认HTTP，可取值：HTTP、HTTPS、GRPC。仅HTTPS监听器该参数有效。
        :type ForwardType: str
        :param _TrpcCallee: TRPC被调服务器路由，ForwardType为TRPC时必填。目前暂未对外开放。
        :type TrpcCallee: str
        :param _TrpcFunc: TRPC调用服务接口，ForwardType为TRPC时必填。目前暂未对外开放。
        :type TrpcFunc: str
        :param _OAuth: OAuth配置信息。
        :type OAuth: :class:`tencentcloud.clb.v20180317.models.OAuth`
        :param _CookieName: 自定义cookie名
        :type CookieName: str
        """
        self._LoadBalancerId = None
        self._ListenerId = None
        self._LocationId = None
        self._Url = None
        self._HealthCheck = None
        self._Scheduler = None
        self._SessionExpireTime = None
        self._ForwardType = None
        self._TrpcCallee = None
        self._TrpcFunc = None
        self._OAuth = None
        self._CookieName = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例 ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/214/30685) 接口获取。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerId(self):
        r"""负载均衡监听器 ID，可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口获取。
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def LocationId(self):
        r"""要修改的转发规则的 ID， 可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口获取。
        :rtype: str
        """
        return self._LocationId

    @LocationId.setter
    def LocationId(self, LocationId):
        self._LocationId = LocationId

    @property
    def Url(self):
        r"""转发规则的新的转发路径，如不需修改Url，则不需提供此参数。
        :rtype: str
        """
        return self._Url

    @Url.setter
    def Url(self, Url):
        self._Url = Url

    @property
    def HealthCheck(self):
        r"""健康检查信息。
        :rtype: :class:`tencentcloud.clb.v20180317.models.HealthCheck`
        """
        return self._HealthCheck

    @HealthCheck.setter
    def HealthCheck(self, HealthCheck):
        self._HealthCheck = HealthCheck

    @property
    def Scheduler(self):
        r"""规则的请求转发方式，可选值：WRR、LEAST_CONN、IP_HASH
分别表示按权重轮询、最小连接数、按IP哈希， 默认为 WRR。
        :rtype: str
        """
        return self._Scheduler

    @Scheduler.setter
    def Scheduler(self, Scheduler):
        self._Scheduler = Scheduler

    @property
    def SessionExpireTime(self):
        r"""会话保持时间。取值范围0或30-86400（单位：秒）。
默认为0。
        :rtype: int
        """
        return self._SessionExpireTime

    @SessionExpireTime.setter
    def SessionExpireTime(self, SessionExpireTime):
        self._SessionExpireTime = SessionExpireTime

    @property
    def ForwardType(self):
        r"""负载均衡实例与后端服务之间的转发协议，默认HTTP，可取值：HTTP、HTTPS、GRPC。仅HTTPS监听器该参数有效。
        :rtype: str
        """
        return self._ForwardType

    @ForwardType.setter
    def ForwardType(self, ForwardType):
        self._ForwardType = ForwardType

    @property
    def TrpcCallee(self):
        r"""TRPC被调服务器路由，ForwardType为TRPC时必填。目前暂未对外开放。
        :rtype: str
        """
        return self._TrpcCallee

    @TrpcCallee.setter
    def TrpcCallee(self, TrpcCallee):
        self._TrpcCallee = TrpcCallee

    @property
    def TrpcFunc(self):
        r"""TRPC调用服务接口，ForwardType为TRPC时必填。目前暂未对外开放。
        :rtype: str
        """
        return self._TrpcFunc

    @TrpcFunc.setter
    def TrpcFunc(self, TrpcFunc):
        self._TrpcFunc = TrpcFunc

    @property
    def OAuth(self):
        r"""OAuth配置信息。
        :rtype: :class:`tencentcloud.clb.v20180317.models.OAuth`
        """
        return self._OAuth

    @OAuth.setter
    def OAuth(self, OAuth):
        self._OAuth = OAuth

    @property
    def CookieName(self):
        r"""自定义cookie名
        :rtype: str
        """
        return self._CookieName

    @CookieName.setter
    def CookieName(self, CookieName):
        self._CookieName = CookieName


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerId = params.get("ListenerId")
        self._LocationId = params.get("LocationId")
        self._Url = params.get("Url")
        if params.get("HealthCheck") is not None:
            self._HealthCheck = HealthCheck()
            self._HealthCheck._deserialize(params.get("HealthCheck"))
        self._Scheduler = params.get("Scheduler")
        self._SessionExpireTime = params.get("SessionExpireTime")
        self._ForwardType = params.get("ForwardType")
        self._TrpcCallee = params.get("TrpcCallee")
        self._TrpcFunc = params.get("TrpcFunc")
        if params.get("OAuth") is not None:
            self._OAuth = OAuth()
            self._OAuth._deserialize(params.get("OAuth"))
        self._CookieName = params.get("CookieName")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyRuleResponse(AbstractModel):
    r"""ModifyRule返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyServiceProviderModelAttributesRequest(AbstractModel):
    r"""ModifyServiceProviderModelAttributes请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ServiceProviderId: <p>BYOK 实例 ID</p>
        :type ServiceProviderId: str
        :param _ModelName: <p>待修改的模型的名称（原始模型名称）</p>
        :type ModelName: str
        :param _InputModalities: <p>该模型支持的输入多模态能力列表</p><p>枚举值：</p><ul><li>text： 支持文本输入</li><li>image： 支持图像输入</li><li>file： 支持文件输入（当前仅支持pdf）</li></ul>
        :type InputModalities: list of str
        """
        self._ServiceProviderId = None
        self._ModelName = None
        self._InputModalities = None

    @property
    def ServiceProviderId(self):
        r"""<p>BYOK 实例 ID</p>
        :rtype: str
        """
        return self._ServiceProviderId

    @ServiceProviderId.setter
    def ServiceProviderId(self, ServiceProviderId):
        self._ServiceProviderId = ServiceProviderId

    @property
    def ModelName(self):
        r"""<p>待修改的模型的名称（原始模型名称）</p>
        :rtype: str
        """
        return self._ModelName

    @ModelName.setter
    def ModelName(self, ModelName):
        self._ModelName = ModelName

    @property
    def InputModalities(self):
        r"""<p>该模型支持的输入多模态能力列表</p><p>枚举值：</p><ul><li>text： 支持文本输入</li><li>image： 支持图像输入</li><li>file： 支持文件输入（当前仅支持pdf）</li></ul>
        :rtype: list of str
        """
        return self._InputModalities

    @InputModalities.setter
    def InputModalities(self, InputModalities):
        self._InputModalities = InputModalities


    def _deserialize(self, params):
        self._ServiceProviderId = params.get("ServiceProviderId")
        self._ModelName = params.get("ModelName")
        self._InputModalities = params.get("InputModalities")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyServiceProviderModelAttributesResponse(AbstractModel):
    r"""ModifyServiceProviderModelAttributes返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyTargetGroupAttributeRequest(AbstractModel):
    r"""ModifyTargetGroupAttribute请求参数结构体

    """

    def __init__(self):
        r"""
        :param _TargetGroupId: <p>目标组的ID。</p>
        :type TargetGroupId: str
        :param _TargetGroupName: <p>目标组的新名称。命名规则：1-80 个英文字母、汉字等国际通用语言字符，数字，连接线“-”、下划线“_”等常见字符（禁止Unicode补充字符，如emoji表情、生僻汉字等）。</p>
        :type TargetGroupName: str
        :param _Port: <p>目标组的新默认端口。全监听目标组不支持此参数。</p>
        :type Port: int
        :param _ScheduleAlgorithm: <p>调度算法，仅V2新版目标组，且后端转发协议为(HTTP|HTTPS|GRPC)时该参数有效。可选值：<br>&lt;ur&gt;<li>WRR:按权重轮询。</li><li>LEAST_CONN:最小连接数。</li><li>IP_HASH:按IP哈希。</li><li>默认为 WRR。</li>&lt;ur&gt;</p>
        :type ScheduleAlgorithm: str
        :param _HealthCheck: <p>健康检查详情。</p>
        :type HealthCheck: :class:`tencentcloud.clb.v20180317.models.TargetGroupHealthCheck`
        :param _Weight: <p>后端服务默认权重, 其中：<ul><li>取值范围[0, 100]</li><li>设置该值后，添加后端服务到目标组时， 若后端服务不单独设置权重， 则使用这里的默认权重。 </li><li>v1目标组类型不支持设置Weight参数。</li> </ul></p>
        :type Weight: int
        :param _KeepaliveEnable: <p>是否开启长连接，此参数仅适用于HTTP/HTTPS目标组，true:关闭；false:开启， 默认关闭。</p>
        :type KeepaliveEnable: bool
        :param _SessionExpireTime: <p>会话保持时间，单位：秒。可选值：30~3600，默认 0，表示不开启。TCP/UDP目标组不支持该参数。</p>
        :type SessionExpireTime: int
        :param _SnatEnable: <p>是否开启SNAT（源IP替换），True（开启）、False（关闭）。默认为关闭。注意：SnatEnable开启时会替换客户端源IP，此时<code>透传客户端源IP</code>选项关闭，反之亦然。</p>
        :type SnatEnable: bool
        """
        self._TargetGroupId = None
        self._TargetGroupName = None
        self._Port = None
        self._ScheduleAlgorithm = None
        self._HealthCheck = None
        self._Weight = None
        self._KeepaliveEnable = None
        self._SessionExpireTime = None
        self._SnatEnable = None

    @property
    def TargetGroupId(self):
        r"""<p>目标组的ID。</p>
        :rtype: str
        """
        return self._TargetGroupId

    @TargetGroupId.setter
    def TargetGroupId(self, TargetGroupId):
        self._TargetGroupId = TargetGroupId

    @property
    def TargetGroupName(self):
        r"""<p>目标组的新名称。命名规则：1-80 个英文字母、汉字等国际通用语言字符，数字，连接线“-”、下划线“_”等常见字符（禁止Unicode补充字符，如emoji表情、生僻汉字等）。</p>
        :rtype: str
        """
        return self._TargetGroupName

    @TargetGroupName.setter
    def TargetGroupName(self, TargetGroupName):
        self._TargetGroupName = TargetGroupName

    @property
    def Port(self):
        r"""<p>目标组的新默认端口。全监听目标组不支持此参数。</p>
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def ScheduleAlgorithm(self):
        r"""<p>调度算法，仅V2新版目标组，且后端转发协议为(HTTP|HTTPS|GRPC)时该参数有效。可选值：<br>&lt;ur&gt;<li>WRR:按权重轮询。</li><li>LEAST_CONN:最小连接数。</li><li>IP_HASH:按IP哈希。</li><li>默认为 WRR。</li>&lt;ur&gt;</p>
        :rtype: str
        """
        return self._ScheduleAlgorithm

    @ScheduleAlgorithm.setter
    def ScheduleAlgorithm(self, ScheduleAlgorithm):
        self._ScheduleAlgorithm = ScheduleAlgorithm

    @property
    def HealthCheck(self):
        r"""<p>健康检查详情。</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.TargetGroupHealthCheck`
        """
        return self._HealthCheck

    @HealthCheck.setter
    def HealthCheck(self, HealthCheck):
        self._HealthCheck = HealthCheck

    @property
    def Weight(self):
        r"""<p>后端服务默认权重, 其中：<ul><li>取值范围[0, 100]</li><li>设置该值后，添加后端服务到目标组时， 若后端服务不单独设置权重， 则使用这里的默认权重。 </li><li>v1目标组类型不支持设置Weight参数。</li> </ul></p>
        :rtype: int
        """
        return self._Weight

    @Weight.setter
    def Weight(self, Weight):
        self._Weight = Weight

    @property
    def KeepaliveEnable(self):
        r"""<p>是否开启长连接，此参数仅适用于HTTP/HTTPS目标组，true:关闭；false:开启， 默认关闭。</p>
        :rtype: bool
        """
        return self._KeepaliveEnable

    @KeepaliveEnable.setter
    def KeepaliveEnable(self, KeepaliveEnable):
        self._KeepaliveEnable = KeepaliveEnable

    @property
    def SessionExpireTime(self):
        r"""<p>会话保持时间，单位：秒。可选值：30~3600，默认 0，表示不开启。TCP/UDP目标组不支持该参数。</p>
        :rtype: int
        """
        return self._SessionExpireTime

    @SessionExpireTime.setter
    def SessionExpireTime(self, SessionExpireTime):
        self._SessionExpireTime = SessionExpireTime

    @property
    def SnatEnable(self):
        r"""<p>是否开启SNAT（源IP替换），True（开启）、False（关闭）。默认为关闭。注意：SnatEnable开启时会替换客户端源IP，此时<code>透传客户端源IP</code>选项关闭，反之亦然。</p>
        :rtype: bool
        """
        return self._SnatEnable

    @SnatEnable.setter
    def SnatEnable(self, SnatEnable):
        self._SnatEnable = SnatEnable


    def _deserialize(self, params):
        self._TargetGroupId = params.get("TargetGroupId")
        self._TargetGroupName = params.get("TargetGroupName")
        self._Port = params.get("Port")
        self._ScheduleAlgorithm = params.get("ScheduleAlgorithm")
        if params.get("HealthCheck") is not None:
            self._HealthCheck = TargetGroupHealthCheck()
            self._HealthCheck._deserialize(params.get("HealthCheck"))
        self._Weight = params.get("Weight")
        self._KeepaliveEnable = params.get("KeepaliveEnable")
        self._SessionExpireTime = params.get("SessionExpireTime")
        self._SnatEnable = params.get("SnatEnable")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyTargetGroupAttributeResponse(AbstractModel):
    r"""ModifyTargetGroupAttribute返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyTargetGroupInstancesPortRequest(AbstractModel):
    r"""ModifyTargetGroupInstancesPort请求参数结构体

    """

    def __init__(self):
        r"""
        :param _TargetGroupId: 目标组ID。
        :type TargetGroupId: str
        :param _TargetGroupInstances: 待修改端口的服务器数组，在这个接口 NewPort 和 Port 为必填项。
        :type TargetGroupInstances: list of TargetGroupInstance
        """
        self._TargetGroupId = None
        self._TargetGroupInstances = None

    @property
    def TargetGroupId(self):
        r"""目标组ID。
        :rtype: str
        """
        return self._TargetGroupId

    @TargetGroupId.setter
    def TargetGroupId(self, TargetGroupId):
        self._TargetGroupId = TargetGroupId

    @property
    def TargetGroupInstances(self):
        r"""待修改端口的服务器数组，在这个接口 NewPort 和 Port 为必填项。
        :rtype: list of TargetGroupInstance
        """
        return self._TargetGroupInstances

    @TargetGroupInstances.setter
    def TargetGroupInstances(self, TargetGroupInstances):
        self._TargetGroupInstances = TargetGroupInstances


    def _deserialize(self, params):
        self._TargetGroupId = params.get("TargetGroupId")
        if params.get("TargetGroupInstances") is not None:
            self._TargetGroupInstances = []
            for item in params.get("TargetGroupInstances"):
                obj = TargetGroupInstance()
                obj._deserialize(item)
                self._TargetGroupInstances.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyTargetGroupInstancesPortResponse(AbstractModel):
    r"""ModifyTargetGroupInstancesPort返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyTargetGroupInstancesWeightRequest(AbstractModel):
    r"""ModifyTargetGroupInstancesWeight请求参数结构体

    """

    def __init__(self):
        r"""
        :param _TargetGroupId: 目标组ID。
        :type TargetGroupId: str
        :param _TargetGroupInstances: 待修改权重的服务器数组，在这个接口 Port 为必填项。
        :type TargetGroupInstances: list of TargetGroupInstance
        """
        self._TargetGroupId = None
        self._TargetGroupInstances = None

    @property
    def TargetGroupId(self):
        r"""目标组ID。
        :rtype: str
        """
        return self._TargetGroupId

    @TargetGroupId.setter
    def TargetGroupId(self, TargetGroupId):
        self._TargetGroupId = TargetGroupId

    @property
    def TargetGroupInstances(self):
        r"""待修改权重的服务器数组，在这个接口 Port 为必填项。
        :rtype: list of TargetGroupInstance
        """
        return self._TargetGroupInstances

    @TargetGroupInstances.setter
    def TargetGroupInstances(self, TargetGroupInstances):
        self._TargetGroupInstances = TargetGroupInstances


    def _deserialize(self, params):
        self._TargetGroupId = params.get("TargetGroupId")
        if params.get("TargetGroupInstances") is not None:
            self._TargetGroupInstances = []
            for item in params.get("TargetGroupInstances"):
                obj = TargetGroupInstance()
                obj._deserialize(item)
                self._TargetGroupInstances.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyTargetGroupInstancesWeightResponse(AbstractModel):
    r"""ModifyTargetGroupInstancesWeight返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyTargetPortRequest(AbstractModel):
    r"""ModifyTargetPort请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例ID。
        :type LoadBalancerId: str
        :param _ListenerId: 负载均衡监听器ID。
        :type ListenerId: str
        :param _Targets: 要修改端口的后端服务列表。
        :type Targets: list of Target
        :param _NewPort: 后端服务绑定到监听器或转发规则的新端口。
        :type NewPort: int
        :param _LocationId: 转发规则的ID，当后端服务绑定到七层转发规则时，必须提供此参数或Domain+Url两者之一。
        :type LocationId: str
        :param _Domain: 目标规则的域名，提供LocationId参数时本参数不生效。
        :type Domain: str
        :param _Url: 目标规则的URL，提供LocationId参数时本参数不生效。
        :type Url: str
        """
        self._LoadBalancerId = None
        self._ListenerId = None
        self._Targets = None
        self._NewPort = None
        self._LocationId = None
        self._Domain = None
        self._Url = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerId(self):
        r"""负载均衡监听器ID。
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def Targets(self):
        r"""要修改端口的后端服务列表。
        :rtype: list of Target
        """
        return self._Targets

    @Targets.setter
    def Targets(self, Targets):
        self._Targets = Targets

    @property
    def NewPort(self):
        r"""后端服务绑定到监听器或转发规则的新端口。
        :rtype: int
        """
        return self._NewPort

    @NewPort.setter
    def NewPort(self, NewPort):
        self._NewPort = NewPort

    @property
    def LocationId(self):
        r"""转发规则的ID，当后端服务绑定到七层转发规则时，必须提供此参数或Domain+Url两者之一。
        :rtype: str
        """
        return self._LocationId

    @LocationId.setter
    def LocationId(self, LocationId):
        self._LocationId = LocationId

    @property
    def Domain(self):
        r"""目标规则的域名，提供LocationId参数时本参数不生效。
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def Url(self):
        r"""目标规则的URL，提供LocationId参数时本参数不生效。
        :rtype: str
        """
        return self._Url

    @Url.setter
    def Url(self, Url):
        self._Url = Url


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerId = params.get("ListenerId")
        if params.get("Targets") is not None:
            self._Targets = []
            for item in params.get("Targets"):
                obj = Target()
                obj._deserialize(item)
                self._Targets.append(obj)
        self._NewPort = params.get("NewPort")
        self._LocationId = params.get("LocationId")
        self._Domain = params.get("Domain")
        self._Url = params.get("Url")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyTargetPortResponse(AbstractModel):
    r"""ModifyTargetPort返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyTargetWeightRequest(AbstractModel):
    r"""ModifyTargetWeight请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例ID。
        :type LoadBalancerId: str
        :param _ListenerId: 负载均衡监听器ID。
        :type ListenerId: str
        :param _Targets: 要修改权重的后端服务列表。
        :type Targets: list of Target
        :param _LocationId: 转发规则的ID，当绑定机器到七层转发规则时，必须提供此参数或Domain+Url两者之一。
        :type LocationId: str
        :param _Domain: 目标规则的域名，提供LocationId参数时本参数不生效。
        :type Domain: str
        :param _Url: 目标规则的URL，提供LocationId参数时本参数不生效。
        :type Url: str
        :param _Weight: 后端服务新的转发权重，取值范围：0~100，默认值10。如果设置了 Targets.Weight 参数，则此参数不生效。
        :type Weight: int
        """
        self._LoadBalancerId = None
        self._ListenerId = None
        self._Targets = None
        self._LocationId = None
        self._Domain = None
        self._Url = None
        self._Weight = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerId(self):
        r"""负载均衡监听器ID。
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def Targets(self):
        r"""要修改权重的后端服务列表。
        :rtype: list of Target
        """
        return self._Targets

    @Targets.setter
    def Targets(self, Targets):
        self._Targets = Targets

    @property
    def LocationId(self):
        r"""转发规则的ID，当绑定机器到七层转发规则时，必须提供此参数或Domain+Url两者之一。
        :rtype: str
        """
        return self._LocationId

    @LocationId.setter
    def LocationId(self, LocationId):
        self._LocationId = LocationId

    @property
    def Domain(self):
        r"""目标规则的域名，提供LocationId参数时本参数不生效。
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def Url(self):
        r"""目标规则的URL，提供LocationId参数时本参数不生效。
        :rtype: str
        """
        return self._Url

    @Url.setter
    def Url(self, Url):
        self._Url = Url

    @property
    def Weight(self):
        r"""后端服务新的转发权重，取值范围：0~100，默认值10。如果设置了 Targets.Weight 参数，则此参数不生效。
        :rtype: int
        """
        return self._Weight

    @Weight.setter
    def Weight(self, Weight):
        self._Weight = Weight


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerId = params.get("ListenerId")
        if params.get("Targets") is not None:
            self._Targets = []
            for item in params.get("Targets"):
                obj = Target()
                obj._deserialize(item)
                self._Targets.append(obj)
        self._LocationId = params.get("LocationId")
        self._Domain = params.get("Domain")
        self._Url = params.get("Url")
        self._Weight = params.get("Weight")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyTargetWeightResponse(AbstractModel):
    r"""ModifyTargetWeight返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class ModifyUserGroupAttributesRequest(AbstractModel):
    r"""ModifyUserGroupAttributes请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID。</p>
        :type ModelRouterId: str
        :param _UserGroupId: <p>待修改的用户组ID。不可为「未分组」虚拟分组 ugrp-ungrouped。</p>
        :type UserGroupId: str
        :param _BudgetId: <p>用户组关联的预算ID。不传则不修改预算关联；传入有效 budget-xxx 则将该用户组关联到此预算（若已关联其它预算则替换为本预算）。仅支持关联/替换，不支持解绑——解绑请用 DisassociateBudget。预算与组内 Key、所属实例的预算各自独立判定。</p>
        :type BudgetId: str
        :param _IntentRouters: <p>用户组意图路由白名单（ir-xxx）。每一项须为该实例已创建的意图路由名。不传则不修改；传入即整体覆盖。</p>
        :type IntentRouters: list of str
        :param _Models: <p>用户组真实模型白名单。每一项须为该实例已关联的模型名。不传则不修改；传入即整体覆盖。</p>
        :type Models: list of str
        :param _UserGroupName: <p>用户组名称。不传则不修改；传入时长度不超过255个字符、同实例下唯一。</p>
        :type UserGroupName: str
        """
        self._ModelRouterId = None
        self._UserGroupId = None
        self._BudgetId = None
        self._IntentRouters = None
        self._Models = None
        self._UserGroupName = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID。</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def UserGroupId(self):
        r"""<p>待修改的用户组ID。不可为「未分组」虚拟分组 ugrp-ungrouped。</p>
        :rtype: str
        """
        return self._UserGroupId

    @UserGroupId.setter
    def UserGroupId(self, UserGroupId):
        self._UserGroupId = UserGroupId

    @property
    def BudgetId(self):
        r"""<p>用户组关联的预算ID。不传则不修改预算关联；传入有效 budget-xxx 则将该用户组关联到此预算（若已关联其它预算则替换为本预算）。仅支持关联/替换，不支持解绑——解绑请用 DisassociateBudget。预算与组内 Key、所属实例的预算各自独立判定。</p>
        :rtype: str
        """
        return self._BudgetId

    @BudgetId.setter
    def BudgetId(self, BudgetId):
        self._BudgetId = BudgetId

    @property
    def IntentRouters(self):
        r"""<p>用户组意图路由白名单（ir-xxx）。每一项须为该实例已创建的意图路由名。不传则不修改；传入即整体覆盖。</p>
        :rtype: list of str
        """
        return self._IntentRouters

    @IntentRouters.setter
    def IntentRouters(self, IntentRouters):
        self._IntentRouters = IntentRouters

    @property
    def Models(self):
        r"""<p>用户组真实模型白名单。每一项须为该实例已关联的模型名。不传则不修改；传入即整体覆盖。</p>
        :rtype: list of str
        """
        return self._Models

    @Models.setter
    def Models(self, Models):
        self._Models = Models

    @property
    def UserGroupName(self):
        r"""<p>用户组名称。不传则不修改；传入时长度不超过255个字符、同实例下唯一。</p>
        :rtype: str
        """
        return self._UserGroupName

    @UserGroupName.setter
    def UserGroupName(self, UserGroupName):
        self._UserGroupName = UserGroupName


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._UserGroupId = params.get("UserGroupId")
        self._BudgetId = params.get("BudgetId")
        self._IntentRouters = params.get("IntentRouters")
        self._Models = params.get("Models")
        self._UserGroupName = params.get("UserGroupName")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ModifyUserGroupAttributesResponse(AbstractModel):
    r"""ModifyUserGroupAttributes返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class MultiCertInfo(AbstractModel):
    r"""CLB监听器或规则绑定的多证书信息

    """

    def __init__(self):
        r"""
        :param _SSLMode: 认证类型，UNIDIRECTIONAL：单向认证，MUTUAL：双向认证
        :type SSLMode: str
        :param _CertList: 监听器或规则证书列表，单双向认证，多本服务端证书算法类型不能重复;若SSLMode为双向认证，证书列表必须包含一本ca证书。
        :type CertList: list of CertInfo
        :param _SSLVerifyClient: 双向认证时，是否开启客户端认证，ON:开启，OPTIONAL:自适应，默认ON
        :type SSLVerifyClient: str
        """
        self._SSLMode = None
        self._CertList = None
        self._SSLVerifyClient = None

    @property
    def SSLMode(self):
        r"""认证类型，UNIDIRECTIONAL：单向认证，MUTUAL：双向认证
        :rtype: str
        """
        return self._SSLMode

    @SSLMode.setter
    def SSLMode(self, SSLMode):
        self._SSLMode = SSLMode

    @property
    def CertList(self):
        r"""监听器或规则证书列表，单双向认证，多本服务端证书算法类型不能重复;若SSLMode为双向认证，证书列表必须包含一本ca证书。
        :rtype: list of CertInfo
        """
        return self._CertList

    @CertList.setter
    def CertList(self, CertList):
        self._CertList = CertList

    @property
    def SSLVerifyClient(self):
        r"""双向认证时，是否开启客户端认证，ON:开启，OPTIONAL:自适应，默认ON
        :rtype: str
        """
        return self._SSLVerifyClient

    @SSLVerifyClient.setter
    def SSLVerifyClient(self, SSLVerifyClient):
        self._SSLVerifyClient = SSLVerifyClient


    def _deserialize(self, params):
        self._SSLMode = params.get("SSLMode")
        if params.get("CertList") is not None:
            self._CertList = []
            for item in params.get("CertList"):
                obj = CertInfo()
                obj._deserialize(item)
                self._CertList.append(obj)
        self._SSLVerifyClient = params.get("SSLVerifyClient")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class MultiModalityAttachments(AbstractModel):
    r"""聊天测试接口多模态附件

    """

    def __init__(self):
        r"""
        :param _Data: <p>base64 url编码的文件内容</p>
        :type Data: str
        :param _Type: <p>附件类型</p><p>枚举值：</p><ul><li>image： 图像</li><li>pdf： pdf（文件）</li></ul>
        :type Type: str
        """
        self._Data = None
        self._Type = None

    @property
    def Data(self):
        r"""<p>base64 url编码的文件内容</p>
        :rtype: str
        """
        return self._Data

    @Data.setter
    def Data(self, Data):
        self._Data = Data

    @property
    def Type(self):
        r"""<p>附件类型</p><p>枚举值：</p><ul><li>image： 图像</li><li>pdf： pdf（文件）</li></ul>
        :rtype: str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type


    def _deserialize(self, params):
        self._Data = params.get("Data")
        self._Type = params.get("Type")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class OAuth(AbstractModel):
    r"""OAuth配置信息。

    """

    def __init__(self):
        r"""
        :param _OAuthEnable: 开启或关闭鉴权。
True: 开启;
False: 关闭
默认为关闭。
        :type OAuthEnable: bool
        :param _OAuthFailureStatus: IAP全部故障后，拒绝请求还是放行。
BYPASS: 通过
REJECT: 拒绝
默认为 BYPASS
        :type OAuthFailureStatus: str
        """
        self._OAuthEnable = None
        self._OAuthFailureStatus = None

    @property
    def OAuthEnable(self):
        r"""开启或关闭鉴权。
True: 开启;
False: 关闭
默认为关闭。
        :rtype: bool
        """
        return self._OAuthEnable

    @OAuthEnable.setter
    def OAuthEnable(self, OAuthEnable):
        self._OAuthEnable = OAuthEnable

    @property
    def OAuthFailureStatus(self):
        r"""IAP全部故障后，拒绝请求还是放行。
BYPASS: 通过
REJECT: 拒绝
默认为 BYPASS
        :rtype: str
        """
        return self._OAuthFailureStatus

    @OAuthFailureStatus.setter
    def OAuthFailureStatus(self, OAuthFailureStatus):
        self._OAuthFailureStatus = OAuthFailureStatus


    def _deserialize(self, params):
        self._OAuthEnable = params.get("OAuthEnable")
        self._OAuthFailureStatus = params.get("OAuthFailureStatus")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class Price(AbstractModel):
    r"""表示负载均衡的价格

    """

    def __init__(self):
        r"""
        :param _InstancePrice: 描述了实例价格。
        :type InstancePrice: :class:`tencentcloud.clb.v20180317.models.ItemPrice`
        :param _BandwidthPrice: 描述了网络价格。
注意：此字段可能返回 null，表示取不到有效值。
        :type BandwidthPrice: :class:`tencentcloud.clb.v20180317.models.ItemPrice`
        :param _LcuPrice: 描述了lcu价格。
注意：此字段可能返回 null，表示取不到有效值。
        :type LcuPrice: :class:`tencentcloud.clb.v20180317.models.ItemPrice`
        """
        self._InstancePrice = None
        self._BandwidthPrice = None
        self._LcuPrice = None

    @property
    def InstancePrice(self):
        r"""描述了实例价格。
        :rtype: :class:`tencentcloud.clb.v20180317.models.ItemPrice`
        """
        return self._InstancePrice

    @InstancePrice.setter
    def InstancePrice(self, InstancePrice):
        self._InstancePrice = InstancePrice

    @property
    def BandwidthPrice(self):
        r"""描述了网络价格。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.ItemPrice`
        """
        return self._BandwidthPrice

    @BandwidthPrice.setter
    def BandwidthPrice(self, BandwidthPrice):
        self._BandwidthPrice = BandwidthPrice

    @property
    def LcuPrice(self):
        r"""描述了lcu价格。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.ItemPrice`
        """
        return self._LcuPrice

    @LcuPrice.setter
    def LcuPrice(self, LcuPrice):
        self._LcuPrice = LcuPrice


    def _deserialize(self, params):
        if params.get("InstancePrice") is not None:
            self._InstancePrice = ItemPrice()
            self._InstancePrice._deserialize(params.get("InstancePrice"))
        if params.get("BandwidthPrice") is not None:
            self._BandwidthPrice = ItemPrice()
            self._BandwidthPrice._deserialize(params.get("BandwidthPrice"))
        if params.get("LcuPrice") is not None:
            self._LcuPrice = ItemPrice()
            self._LcuPrice._deserialize(params.get("LcuPrice"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ProviderItem(AbstractModel):
    r"""Provider 信息

    """

    def __init__(self):
        r"""
        :param _Provider: <p>Provider 标识（如 openai）</p>
        :type Provider: str
        :param _DisplayName: <p>显示名称（如 OpenAI）</p>
        :type DisplayName: str
        :param _Protocols: <p>模型协议列表</p>
        :type Protocols: list of str
        :param _EnglishDisplayName: <p>英文显示名称</p>
        :type EnglishDisplayName: str
        """
        self._Provider = None
        self._DisplayName = None
        self._Protocols = None
        self._EnglishDisplayName = None

    @property
    def Provider(self):
        r"""<p>Provider 标识（如 openai）</p>
        :rtype: str
        """
        return self._Provider

    @Provider.setter
    def Provider(self, Provider):
        self._Provider = Provider

    @property
    def DisplayName(self):
        r"""<p>显示名称（如 OpenAI）</p>
        :rtype: str
        """
        return self._DisplayName

    @DisplayName.setter
    def DisplayName(self, DisplayName):
        self._DisplayName = DisplayName

    @property
    def Protocols(self):
        r"""<p>模型协议列表</p>
        :rtype: list of str
        """
        return self._Protocols

    @Protocols.setter
    def Protocols(self, Protocols):
        self._Protocols = Protocols

    @property
    def EnglishDisplayName(self):
        r"""<p>英文显示名称</p>
        :rtype: str
        """
        return self._EnglishDisplayName

    @EnglishDisplayName.setter
    def EnglishDisplayName(self, EnglishDisplayName):
        self._EnglishDisplayName = EnglishDisplayName


    def _deserialize(self, params):
        self._Provider = params.get("Provider")
        self._DisplayName = params.get("DisplayName")
        self._Protocols = params.get("Protocols")
        self._EnglishDisplayName = params.get("EnglishDisplayName")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ProviderTestConnectionErrorInfo(AbstractModel):
    r"""BYOK健康检查错误信息

    """

    def __init__(self):
        r"""
        :param _HttpCode: <p>上游模型侧返回的HTTP状态码</p>
        :type HttpCode: int
        :param _ErrorStatus: <p>错误状态码</p>
        :type ErrorStatus: str
        :param _OriginalMessage: <p>探测请求错误信息</p>
        :type OriginalMessage: str
        """
        self._HttpCode = None
        self._ErrorStatus = None
        self._OriginalMessage = None

    @property
    def HttpCode(self):
        r"""<p>上游模型侧返回的HTTP状态码</p>
        :rtype: int
        """
        return self._HttpCode

    @HttpCode.setter
    def HttpCode(self, HttpCode):
        self._HttpCode = HttpCode

    @property
    def ErrorStatus(self):
        r"""<p>错误状态码</p>
        :rtype: str
        """
        return self._ErrorStatus

    @ErrorStatus.setter
    def ErrorStatus(self, ErrorStatus):
        self._ErrorStatus = ErrorStatus

    @property
    def OriginalMessage(self):
        r"""<p>探测请求错误信息</p>
        :rtype: str
        """
        return self._OriginalMessage

    @OriginalMessage.setter
    def OriginalMessage(self, OriginalMessage):
        self._OriginalMessage = OriginalMessage


    def _deserialize(self, params):
        self._HttpCode = params.get("HttpCode")
        self._ErrorStatus = params.get("ErrorStatus")
        self._OriginalMessage = params.get("OriginalMessage")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class Quota(AbstractModel):
    r"""描述配额信息，所有配额均指当前地域下的配额。

    """

    def __init__(self):
        r"""
        :param _QuotaId: 配额名称，取值范围：
<li> TOTAL_OPEN_CLB_QUOTA：用户当前地域下的公网CLB配额 </li>
<li> TOTAL_INTERNAL_CLB_QUOTA：用户当前地域下的内网CLB配额 </li>
<li> TOTAL_LISTENER_QUOTA：一个CLB下的监听器配额 </li>
<li> TOTAL_LISTENER_RULE_QUOTA：一个监听器下的转发规则配额 </li>
<li> TOTAL_TARGET_BIND_QUOTA：一条转发规则下可绑定设备的配额 </li>
<li> TOTAL_SNAT_IP_QUOTA： 一个CLB实例下跨地域2.0的SNAT IP配额 </li>
<li>TOTAL_ISP_CLB_QUOTA：用户当前地域下的三网CLB配额 </li>
<li>TOTAL_FULL_PORT_RANGE_LISTENER_QUOTA：一个CLB实例下的单个协议全端口段监听器配额</li>
        :type QuotaId: str
        :param _QuotaCurrent: 当前使用数量，为 null 时表示无意义。
注意：此字段可能返回 null，表示取不到有效值。
        :type QuotaCurrent: int
        :param _QuotaLimit: 配额数量。
        :type QuotaLimit: int
        """
        self._QuotaId = None
        self._QuotaCurrent = None
        self._QuotaLimit = None

    @property
    def QuotaId(self):
        r"""配额名称，取值范围：
<li> TOTAL_OPEN_CLB_QUOTA：用户当前地域下的公网CLB配额 </li>
<li> TOTAL_INTERNAL_CLB_QUOTA：用户当前地域下的内网CLB配额 </li>
<li> TOTAL_LISTENER_QUOTA：一个CLB下的监听器配额 </li>
<li> TOTAL_LISTENER_RULE_QUOTA：一个监听器下的转发规则配额 </li>
<li> TOTAL_TARGET_BIND_QUOTA：一条转发规则下可绑定设备的配额 </li>
<li> TOTAL_SNAT_IP_QUOTA： 一个CLB实例下跨地域2.0的SNAT IP配额 </li>
<li>TOTAL_ISP_CLB_QUOTA：用户当前地域下的三网CLB配额 </li>
<li>TOTAL_FULL_PORT_RANGE_LISTENER_QUOTA：一个CLB实例下的单个协议全端口段监听器配额</li>
        :rtype: str
        """
        return self._QuotaId

    @QuotaId.setter
    def QuotaId(self, QuotaId):
        self._QuotaId = QuotaId

    @property
    def QuotaCurrent(self):
        r"""当前使用数量，为 null 时表示无意义。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._QuotaCurrent

    @QuotaCurrent.setter
    def QuotaCurrent(self, QuotaCurrent):
        self._QuotaCurrent = QuotaCurrent

    @property
    def QuotaLimit(self):
        r"""配额数量。
        :rtype: int
        """
        return self._QuotaLimit

    @QuotaLimit.setter
    def QuotaLimit(self, QuotaLimit):
        self._QuotaLimit = QuotaLimit


    def _deserialize(self, params):
        self._QuotaId = params.get("QuotaId")
        self._QuotaCurrent = params.get("QuotaCurrent")
        self._QuotaLimit = params.get("QuotaLimit")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RateLimitConfigForBudget(AbstractModel):
    r"""Budget限速配置

    """

    def __init__(self):
        r"""
        :param _RPM: <p>每分钟限制的请求数量。</p><p>单位：次/分钟。</p>
        :type RPM: int
        :param _TPM: <p>每分钟限制的Token数量。</p><p>单位：个/分钟。</p>
        :type TPM: int
        """
        self._RPM = None
        self._TPM = None

    @property
    def RPM(self):
        r"""<p>每分钟限制的请求数量。</p><p>单位：次/分钟。</p>
        :rtype: int
        """
        return self._RPM

    @RPM.setter
    def RPM(self, RPM):
        self._RPM = RPM

    @property
    def TPM(self):
        r"""<p>每分钟限制的Token数量。</p><p>单位：个/分钟。</p>
        :rtype: int
        """
        return self._TPM

    @TPM.setter
    def TPM(self, TPM):
        self._TPM = TPM


    def _deserialize(self, params):
        self._RPM = params.get("RPM")
        self._TPM = params.get("TPM")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RateLimitConfigForKey(AbstractModel):
    r"""限速配置

    """

    def __init__(self):
        r"""
        :param _MaxParallelRequest: <p>最大并发请求数量</p><p>单位：次</p>
        :type MaxParallelRequest: int
        :param _RPM: <p>每分钟限制的请求数量</p><p>单位：次/分钟</p>
        :type RPM: int
        :param _TPM: <p>每分钟限制的Token数量</p><p>单位：个/分钟</p>
        :type TPM: int
        """
        self._MaxParallelRequest = None
        self._RPM = None
        self._TPM = None

    @property
    def MaxParallelRequest(self):
        r"""<p>最大并发请求数量</p><p>单位：次</p>
        :rtype: int
        """
        return self._MaxParallelRequest

    @MaxParallelRequest.setter
    def MaxParallelRequest(self, MaxParallelRequest):
        self._MaxParallelRequest = MaxParallelRequest

    @property
    def RPM(self):
        r"""<p>每分钟限制的请求数量</p><p>单位：次/分钟</p>
        :rtype: int
        """
        return self._RPM

    @RPM.setter
    def RPM(self, RPM):
        self._RPM = RPM

    @property
    def TPM(self):
        r"""<p>每分钟限制的Token数量</p><p>单位：个/分钟</p>
        :rtype: int
        """
        return self._TPM

    @TPM.setter
    def TPM(self, TPM):
        self._TPM = TPM


    def _deserialize(self, params):
        self._MaxParallelRequest = params.get("MaxParallelRequest")
        self._RPM = params.get("RPM")
        self._TPM = params.get("TPM")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RateLimitConfigForModelRouter(AbstractModel):
    r"""限速配置

    """

    def __init__(self):
        r"""
        :param _RPM: <p>每分钟限制的请求数量</p><p>单位：次/分钟</p>
        :type RPM: int
        :param _TPM: <p>每分钟限制的Token数量</p><p>单位：个/分钟</p>
        :type TPM: int
        """
        self._RPM = None
        self._TPM = None

    @property
    def RPM(self):
        r"""<p>每分钟限制的请求数量</p><p>单位：次/分钟</p>
        :rtype: int
        """
        return self._RPM

    @RPM.setter
    def RPM(self, RPM):
        self._RPM = RPM

    @property
    def TPM(self):
        r"""<p>每分钟限制的Token数量</p><p>单位：个/分钟</p>
        :rtype: int
        """
        return self._TPM

    @TPM.setter
    def TPM(self, TPM):
        self._TPM = TPM


    def _deserialize(self, params):
        self._RPM = params.get("RPM")
        self._TPM = params.get("TPM")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RefundModelRouterResourcePackageRequest(AbstractModel):
    r"""RefundModelRouterResourcePackage请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterResourcePackageIds: <p>待退还的模型路由资源包Id</p><p>非有效状态或者设置了自动续订且自动续订已生效的资源包不允许退款。</p>
        :type ModelRouterResourcePackageIds: list of str
        """
        self._ModelRouterResourcePackageIds = None

    @property
    def ModelRouterResourcePackageIds(self):
        r"""<p>待退还的模型路由资源包Id</p><p>非有效状态或者设置了自动续订且自动续订已生效的资源包不允许退款。</p>
        :rtype: list of str
        """
        return self._ModelRouterResourcePackageIds

    @ModelRouterResourcePackageIds.setter
    def ModelRouterResourcePackageIds(self, ModelRouterResourcePackageIds):
        self._ModelRouterResourcePackageIds = ModelRouterResourcePackageIds


    def _deserialize(self, params):
        self._ModelRouterResourcePackageIds = params.get("ModelRouterResourcePackageIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RefundModelRouterResourcePackageResponse(AbstractModel):
    r"""RefundModelRouterResourcePackage返回参数结构体

    """

    def __init__(self):
        r"""
        :param _DealNames: <p>退还模型路由资源包的订单号</p>
        :type DealNames: list of str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._DealNames = None
        self._RequestId = None

    @property
    def DealNames(self):
        r"""<p>退还模型路由资源包的订单号</p>
        :rtype: list of str
        """
        return self._DealNames

    @DealNames.setter
    def DealNames(self, DealNames):
        self._DealNames = DealNames

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._DealNames = params.get("DealNames")
        self._RequestId = params.get("RequestId")


class RegenerateKeysRequest(AbstractModel):
    r"""RegenerateKeys请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例ID</p>
        :type ModelRouterId: str
        :param _KeyIds: <p>Key的ID列表</p>
        :type KeyIds: list of str
        """
        self._ModelRouterId = None
        self._KeyIds = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例ID</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def KeyIds(self):
        r"""<p>Key的ID列表</p>
        :rtype: list of str
        """
        return self._KeyIds

    @KeyIds.setter
    def KeyIds(self, KeyIds):
        self._KeyIds = KeyIds


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._KeyIds = params.get("KeyIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RegenerateKeysResponse(AbstractModel):
    r"""RegenerateKeys返回参数结构体

    """

    def __init__(self):
        r"""
        :param _FailedKeyIds: <p>重新生成失败的Key的ID列表</p>
        :type FailedKeyIds: list of str
        :param _RegeneratedKeys: <p>重新生成后的Key的信息</p>
        :type RegeneratedKeys: list of RegeneratedKey
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._FailedKeyIds = None
        self._RegeneratedKeys = None
        self._RequestId = None

    @property
    def FailedKeyIds(self):
        r"""<p>重新生成失败的Key的ID列表</p>
        :rtype: list of str
        """
        return self._FailedKeyIds

    @FailedKeyIds.setter
    def FailedKeyIds(self, FailedKeyIds):
        self._FailedKeyIds = FailedKeyIds

    @property
    def RegeneratedKeys(self):
        r"""<p>重新生成后的Key的信息</p>
        :rtype: list of RegeneratedKey
        """
        return self._RegeneratedKeys

    @RegeneratedKeys.setter
    def RegeneratedKeys(self, RegeneratedKeys):
        self._RegeneratedKeys = RegeneratedKeys

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._FailedKeyIds = params.get("FailedKeyIds")
        if params.get("RegeneratedKeys") is not None:
            self._RegeneratedKeys = []
            for item in params.get("RegeneratedKeys"):
                obj = RegeneratedKey()
                obj._deserialize(item)
                self._RegeneratedKeys.append(obj)
        self._RequestId = params.get("RequestId")


class RegeneratedKey(AbstractModel):
    r"""重新生成的Key信息

    """

    def __init__(self):
        r"""
        :param _Key: <p>重新生成的明文Key</p>
        :type Key: str
        :param _KeyId: <p>Key的ID</p>
        :type KeyId: str
        """
        self._Key = None
        self._KeyId = None

    @property
    def Key(self):
        r"""<p>重新生成的明文Key</p>
        :rtype: str
        """
        return self._Key

    @Key.setter
    def Key(self, Key):
        self._Key = Key

    @property
    def KeyId(self):
        r"""<p>Key的ID</p>
        :rtype: str
        """
        return self._KeyId

    @KeyId.setter
    def KeyId(self, KeyId):
        self._KeyId = KeyId


    def _deserialize(self, params):
        self._Key = params.get("Key")
        self._KeyId = params.get("KeyId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RegisterFunctionTargetsRequest(AbstractModel):
    r"""RegisterFunctionTargets请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例 ID。
        :type LoadBalancerId: str
        :param _ListenerId: 负载均衡监听器 ID。
        :type ListenerId: str
        :param _FunctionTargets: 待绑定的云函数列表。
        :type FunctionTargets: list of FunctionTarget
        :param _LocationId: 目标转发规则的 ID，当将云函数绑定到七层转发规则时，必须输入此参数或 Domain+Url 参数。
        :type LocationId: str
        :param _Domain: 目标转发规则的域名，若已经输入 LocationId 参数，则本参数不生效。
        :type Domain: str
        :param _Url: 目标转发规则的 URL，若已经输入 LocationId 参数，则本参数不生效。
        :type Url: str
        """
        self._LoadBalancerId = None
        self._ListenerId = None
        self._FunctionTargets = None
        self._LocationId = None
        self._Domain = None
        self._Url = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例 ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerId(self):
        r"""负载均衡监听器 ID。
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def FunctionTargets(self):
        r"""待绑定的云函数列表。
        :rtype: list of FunctionTarget
        """
        return self._FunctionTargets

    @FunctionTargets.setter
    def FunctionTargets(self, FunctionTargets):
        self._FunctionTargets = FunctionTargets

    @property
    def LocationId(self):
        r"""目标转发规则的 ID，当将云函数绑定到七层转发规则时，必须输入此参数或 Domain+Url 参数。
        :rtype: str
        """
        return self._LocationId

    @LocationId.setter
    def LocationId(self, LocationId):
        self._LocationId = LocationId

    @property
    def Domain(self):
        r"""目标转发规则的域名，若已经输入 LocationId 参数，则本参数不生效。
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def Url(self):
        r"""目标转发规则的 URL，若已经输入 LocationId 参数，则本参数不生效。
        :rtype: str
        """
        return self._Url

    @Url.setter
    def Url(self, Url):
        self._Url = Url


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerId = params.get("ListenerId")
        if params.get("FunctionTargets") is not None:
            self._FunctionTargets = []
            for item in params.get("FunctionTargets"):
                obj = FunctionTarget()
                obj._deserialize(item)
                self._FunctionTargets.append(obj)
        self._LocationId = params.get("LocationId")
        self._Domain = params.get("Domain")
        self._Url = params.get("Url")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RegisterFunctionTargetsResponse(AbstractModel):
    r"""RegisterFunctionTargets返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class RegisterModelsToServiceProviderRequest(AbstractModel):
    r"""RegisterModelsToServiceProvider请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ServiceProviderId: <p>BYOK的ID</p>
        :type ServiceProviderId: str
        :param _Models: <p>需要关联的模型信息</p>
        :type Models: list of ModelItem
        """
        self._ServiceProviderId = None
        self._Models = None

    @property
    def ServiceProviderId(self):
        r"""<p>BYOK的ID</p>
        :rtype: str
        """
        return self._ServiceProviderId

    @ServiceProviderId.setter
    def ServiceProviderId(self, ServiceProviderId):
        self._ServiceProviderId = ServiceProviderId

    @property
    def Models(self):
        r"""<p>需要关联的模型信息</p>
        :rtype: list of ModelItem
        """
        return self._Models

    @Models.setter
    def Models(self, Models):
        self._Models = Models


    def _deserialize(self, params):
        self._ServiceProviderId = params.get("ServiceProviderId")
        if params.get("Models") is not None:
            self._Models = []
            for item in params.get("Models"):
                obj = ModelItem()
                obj._deserialize(item)
                self._Models.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RegisterModelsToServiceProviderResponse(AbstractModel):
    r"""RegisterModelsToServiceProvider返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class RegisterTargetGroupInstancesRequest(AbstractModel):
    r"""RegisterTargetGroupInstances请求参数结构体

    """

    def __init__(self):
        r"""
        :param _TargetGroupId: 目标组ID
        :type TargetGroupId: str
        :param _TargetGroupInstances: 服务器实例数组，服务器和目标组的 VPC 需相同。
        :type TargetGroupInstances: list of TargetGroupInstance
        """
        self._TargetGroupId = None
        self._TargetGroupInstances = None

    @property
    def TargetGroupId(self):
        r"""目标组ID
        :rtype: str
        """
        return self._TargetGroupId

    @TargetGroupId.setter
    def TargetGroupId(self, TargetGroupId):
        self._TargetGroupId = TargetGroupId

    @property
    def TargetGroupInstances(self):
        r"""服务器实例数组，服务器和目标组的 VPC 需相同。
        :rtype: list of TargetGroupInstance
        """
        return self._TargetGroupInstances

    @TargetGroupInstances.setter
    def TargetGroupInstances(self, TargetGroupInstances):
        self._TargetGroupInstances = TargetGroupInstances


    def _deserialize(self, params):
        self._TargetGroupId = params.get("TargetGroupId")
        if params.get("TargetGroupInstances") is not None:
            self._TargetGroupInstances = []
            for item in params.get("TargetGroupInstances"):
                obj = TargetGroupInstance()
                obj._deserialize(item)
                self._TargetGroupInstances.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RegisterTargetGroupInstancesResponse(AbstractModel):
    r"""RegisterTargetGroupInstances返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class RegisterTargetsRequest(AbstractModel):
    r"""RegisterTargets请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例ID。
        :type LoadBalancerId: str
        :param _ListenerId: 负载均衡监听器ID。
        :type ListenerId: str
        :param _Targets: 待绑定的后端服务列表，数组长度最大支持20。
        :type Targets: list of Target
        :param _LocationId: 转发规则的ID，可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口获取，当绑定后端服务到七层转发规则时，必须提供此参数或Domain+Url两者之一。
        :type LocationId: str
        :param _Domain: 目标转发规则的域名，提供LocationId参数时本参数不生效。
        :type Domain: str
        :param _Url: 目标转发规则的URL，提供LocationId参数时本参数不生效。
        :type Url: str
        """
        self._LoadBalancerId = None
        self._ListenerId = None
        self._Targets = None
        self._LocationId = None
        self._Domain = None
        self._Url = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerId(self):
        r"""负载均衡监听器ID。
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def Targets(self):
        r"""待绑定的后端服务列表，数组长度最大支持20。
        :rtype: list of Target
        """
        return self._Targets

    @Targets.setter
    def Targets(self, Targets):
        self._Targets = Targets

    @property
    def LocationId(self):
        r"""转发规则的ID，可以通过 [DescribeListeners](https://cloud.tencent.com/document/product/214/30686) 接口获取，当绑定后端服务到七层转发规则时，必须提供此参数或Domain+Url两者之一。
        :rtype: str
        """
        return self._LocationId

    @LocationId.setter
    def LocationId(self, LocationId):
        self._LocationId = LocationId

    @property
    def Domain(self):
        r"""目标转发规则的域名，提供LocationId参数时本参数不生效。
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def Url(self):
        r"""目标转发规则的URL，提供LocationId参数时本参数不生效。
        :rtype: str
        """
        return self._Url

    @Url.setter
    def Url(self, Url):
        self._Url = Url


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerId = params.get("ListenerId")
        if params.get("Targets") is not None:
            self._Targets = []
            for item in params.get("Targets"):
                obj = Target()
                obj._deserialize(item)
                self._Targets.append(obj)
        self._LocationId = params.get("LocationId")
        self._Domain = params.get("Domain")
        self._Url = params.get("Url")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RegisterTargetsResponse(AbstractModel):
    r"""RegisterTargets返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class RegisterTargetsWithClassicalLBRequest(AbstractModel):
    r"""RegisterTargetsWithClassicalLB请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例ID。
        :type LoadBalancerId: str
        :param _Targets: 后端服务信息。
        :type Targets: list of ClassicalTargetInfo
        """
        self._LoadBalancerId = None
        self._Targets = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例ID。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def Targets(self):
        r"""后端服务信息。
        :rtype: list of ClassicalTargetInfo
        """
        return self._Targets

    @Targets.setter
    def Targets(self, Targets):
        self._Targets = Targets


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        if params.get("Targets") is not None:
            self._Targets = []
            for item in params.get("Targets"):
                obj = ClassicalTargetInfo()
                obj._deserialize(item)
                self._Targets.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RegisterTargetsWithClassicalLBResponse(AbstractModel):
    r"""RegisterTargetsWithClassicalLB返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class RemoveModelKeyRequest(AbstractModel):
    r"""RemoveModelKey请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ServiceProviderId: <p>服务提供商ID</p>
        :type ServiceProviderId: str
        :param _KeyIds: <p>Key 业务 ID 列表，至少 1 个，最多 10 个</p>
        :type KeyIds: list of str
        """
        self._ServiceProviderId = None
        self._KeyIds = None

    @property
    def ServiceProviderId(self):
        r"""<p>服务提供商ID</p>
        :rtype: str
        """
        return self._ServiceProviderId

    @ServiceProviderId.setter
    def ServiceProviderId(self, ServiceProviderId):
        self._ServiceProviderId = ServiceProviderId

    @property
    def KeyIds(self):
        r"""<p>Key 业务 ID 列表，至少 1 个，最多 10 个</p>
        :rtype: list of str
        """
        return self._KeyIds

    @KeyIds.setter
    def KeyIds(self, KeyIds):
        self._KeyIds = KeyIds


    def _deserialize(self, params):
        self._ServiceProviderId = params.get("ServiceProviderId")
        self._KeyIds = params.get("KeyIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RemoveModelKeyResponse(AbstractModel):
    r"""RemoveModelKey返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class RemoveModelRewriteRequest(AbstractModel):
    r"""RemoveModelRewrite请求参数结构体

    """

    def __init__(self):
        r"""
        :param _ModelRouterId: <p>模型路由实例 ID。</p>
        :type ModelRouterId: str
        :param _SourceModel: <p>要删除的源模型名（重写规则的 key）。</p><p>长度 1-255 字符；支持特殊值 <code>default</code> 表示删除兜底规则。</p><p>当指定的 SourceModel 当前不存在重写规则时，请求幂等成功。</p>
        :type SourceModel: str
        """
        self._ModelRouterId = None
        self._SourceModel = None

    @property
    def ModelRouterId(self):
        r"""<p>模型路由实例 ID。</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def SourceModel(self):
        r"""<p>要删除的源模型名（重写规则的 key）。</p><p>长度 1-255 字符；支持特殊值 <code>default</code> 表示删除兜底规则。</p><p>当指定的 SourceModel 当前不存在重写规则时，请求幂等成功。</p>
        :rtype: str
        """
        return self._SourceModel

    @SourceModel.setter
    def SourceModel(self, SourceModel):
        self._SourceModel = SourceModel


    def _deserialize(self, params):
        self._ModelRouterId = params.get("ModelRouterId")
        self._SourceModel = params.get("SourceModel")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RemoveModelRewriteResponse(AbstractModel):
    r"""RemoveModelRewrite返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class RenewLoadBalancersRequest(AbstractModel):
    r"""RenewLoadBalancers请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerIds: 负载均衡实例唯一ID数组，最多支持20个。
        :type LoadBalancerIds: list of str
        :param _LBChargePrepaid: 负载均衡实例的预付费相关属性。
        :type LBChargePrepaid: :class:`tencentcloud.clb.v20180317.models.LBChargePrepaid`
        """
        self._LoadBalancerIds = None
        self._LBChargePrepaid = None

    @property
    def LoadBalancerIds(self):
        r"""负载均衡实例唯一ID数组，最多支持20个。
        :rtype: list of str
        """
        return self._LoadBalancerIds

    @LoadBalancerIds.setter
    def LoadBalancerIds(self, LoadBalancerIds):
        self._LoadBalancerIds = LoadBalancerIds

    @property
    def LBChargePrepaid(self):
        r"""负载均衡实例的预付费相关属性。
        :rtype: :class:`tencentcloud.clb.v20180317.models.LBChargePrepaid`
        """
        return self._LBChargePrepaid

    @LBChargePrepaid.setter
    def LBChargePrepaid(self, LBChargePrepaid):
        self._LBChargePrepaid = LBChargePrepaid


    def _deserialize(self, params):
        self._LoadBalancerIds = params.get("LoadBalancerIds")
        if params.get("LBChargePrepaid") is not None:
            self._LBChargePrepaid = LBChargePrepaid()
            self._LBChargePrepaid._deserialize(params.get("LBChargePrepaid"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RenewLoadBalancersResponse(AbstractModel):
    r"""RenewLoadBalancers返回参数结构体

    """

    def __init__(self):
        r"""
        :param _DealName: 订单号。
        :type DealName: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._DealName = None
        self._RequestId = None

    @property
    def DealName(self):
        r"""订单号。
        :rtype: str
        """
        return self._DealName

    @DealName.setter
    def DealName(self, DealName):
        self._DealName = DealName

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._DealName = params.get("DealName")
        self._RequestId = params.get("RequestId")


class ReplaceCertForLoadBalancersRequest(AbstractModel):
    r"""ReplaceCertForLoadBalancers请求参数结构体

    """

    def __init__(self):
        r"""
        :param _OldCertificateId: 需要被替换的证书的ID，可以是服务端证书或客户端证书
        :type OldCertificateId: str
        :param _Certificate: 新证书的内容等相关信息
        :type Certificate: :class:`tencentcloud.clb.v20180317.models.CertificateInput`
        """
        self._OldCertificateId = None
        self._Certificate = None

    @property
    def OldCertificateId(self):
        r"""需要被替换的证书的ID，可以是服务端证书或客户端证书
        :rtype: str
        """
        return self._OldCertificateId

    @OldCertificateId.setter
    def OldCertificateId(self, OldCertificateId):
        self._OldCertificateId = OldCertificateId

    @property
    def Certificate(self):
        r"""新证书的内容等相关信息
        :rtype: :class:`tencentcloud.clb.v20180317.models.CertificateInput`
        """
        return self._Certificate

    @Certificate.setter
    def Certificate(self, Certificate):
        self._Certificate = Certificate


    def _deserialize(self, params):
        self._OldCertificateId = params.get("OldCertificateId")
        if params.get("Certificate") is not None:
            self._Certificate = CertificateInput()
            self._Certificate._deserialize(params.get("Certificate"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ReplaceCertForLoadBalancersResponse(AbstractModel):
    r"""ReplaceCertForLoadBalancers返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class Resource(AbstractModel):
    r"""资源详细信息

    """

    def __init__(self):
        r"""
        :param _Type: 运营商内具体资源信息，如"CMCC", "CUCC", "CTCC", "BGP", "INTERNAL"。
        :type Type: list of str
        :param _Isp: 运营商信息，如"CMCC", "CUCC", "CTCC", "BGP", "INTERNAL"。
        :type Isp: str
        :param _AvailabilitySet: 可用资源。
        :type AvailabilitySet: list of ResourceAvailability
        :param _TypeSet: 运营商类型信息
        :type TypeSet: list of TypeInfo
        """
        self._Type = None
        self._Isp = None
        self._AvailabilitySet = None
        self._TypeSet = None

    @property
    def Type(self):
        r"""运营商内具体资源信息，如"CMCC", "CUCC", "CTCC", "BGP", "INTERNAL"。
        :rtype: list of str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type

    @property
    def Isp(self):
        r"""运营商信息，如"CMCC", "CUCC", "CTCC", "BGP", "INTERNAL"。
        :rtype: str
        """
        return self._Isp

    @Isp.setter
    def Isp(self, Isp):
        self._Isp = Isp

    @property
    def AvailabilitySet(self):
        r"""可用资源。
        :rtype: list of ResourceAvailability
        """
        return self._AvailabilitySet

    @AvailabilitySet.setter
    def AvailabilitySet(self, AvailabilitySet):
        self._AvailabilitySet = AvailabilitySet

    @property
    def TypeSet(self):
        r"""运营商类型信息
        :rtype: list of TypeInfo
        """
        return self._TypeSet

    @TypeSet.setter
    def TypeSet(self, TypeSet):
        self._TypeSet = TypeSet


    def _deserialize(self, params):
        self._Type = params.get("Type")
        self._Isp = params.get("Isp")
        if params.get("AvailabilitySet") is not None:
            self._AvailabilitySet = []
            for item in params.get("AvailabilitySet"):
                obj = ResourceAvailability()
                obj._deserialize(item)
                self._AvailabilitySet.append(obj)
        if params.get("TypeSet") is not None:
            self._TypeSet = []
            for item in params.get("TypeSet"):
                obj = TypeInfo()
                obj._deserialize(item)
                self._TypeSet.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ResourceAvailability(AbstractModel):
    r"""资源可用性

    """

    def __init__(self):
        r"""
        :param _Type: 运营商内具体资源信息，如"CMCC", "CUCC", "CTCC", "BGP"。
        :type Type: str
        :param _Availability: 资源可用性，"Available"：可用，"Unavailable"：不可用
        :type Availability: str
        """
        self._Type = None
        self._Availability = None

    @property
    def Type(self):
        r"""运营商内具体资源信息，如"CMCC", "CUCC", "CTCC", "BGP"。
        :rtype: str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type

    @property
    def Availability(self):
        r"""资源可用性，"Available"：可用，"Unavailable"：不可用
        :rtype: str
        """
        return self._Availability

    @Availability.setter
    def Availability(self, Availability):
        self._Availability = Availability


    def _deserialize(self, params):
        self._Type = params.get("Type")
        self._Availability = params.get("Availability")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RewriteItem(AbstractModel):
    r"""单条模型重写规则。

    """

    def __init__(self):
        r"""
        :param _SourceModel: <p>源模型名（重写规则的 key）。</p><p>特殊值 <code>default</code> 表示兜底规则（命中所有未显式列出的源模型）。</p>
        :type SourceModel: str
        :param _TargetModel: <p>目标模型名（重写规则的 value）。</p>
        :type TargetModel: str
        """
        self._SourceModel = None
        self._TargetModel = None

    @property
    def SourceModel(self):
        r"""<p>源模型名（重写规则的 key）。</p><p>特殊值 <code>default</code> 表示兜底规则（命中所有未显式列出的源模型）。</p>
        :rtype: str
        """
        return self._SourceModel

    @SourceModel.setter
    def SourceModel(self, SourceModel):
        self._SourceModel = SourceModel

    @property
    def TargetModel(self):
        r"""<p>目标模型名（重写规则的 value）。</p>
        :rtype: str
        """
        return self._TargetModel

    @TargetModel.setter
    def TargetModel(self, TargetModel):
        self._TargetModel = TargetModel


    def _deserialize(self, params):
        self._SourceModel = params.get("SourceModel")
        self._TargetModel = params.get("TargetModel")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RewriteLocationMap(AbstractModel):
    r"""转发规则之间的重定向关系

    """

    def __init__(self):
        r"""
        :param _SourceLocationId: 源转发规则ID
        :type SourceLocationId: str
        :param _TargetLocationId: 重定向目标转发规则的ID
        :type TargetLocationId: str
        :param _RewriteCode: 重定向状态码，可取值301,302,307
        :type RewriteCode: int
        :param _TakeUrl: 重定向是否携带匹配的url，配置RewriteCode时必填
        :type TakeUrl: bool
        :param _SourceDomain: 源转发的域名，必须是SourceLocationId对应的域名，配置RewriteCode时必填
        :type SourceDomain: str
        """
        self._SourceLocationId = None
        self._TargetLocationId = None
        self._RewriteCode = None
        self._TakeUrl = None
        self._SourceDomain = None

    @property
    def SourceLocationId(self):
        r"""源转发规则ID
        :rtype: str
        """
        return self._SourceLocationId

    @SourceLocationId.setter
    def SourceLocationId(self, SourceLocationId):
        self._SourceLocationId = SourceLocationId

    @property
    def TargetLocationId(self):
        r"""重定向目标转发规则的ID
        :rtype: str
        """
        return self._TargetLocationId

    @TargetLocationId.setter
    def TargetLocationId(self, TargetLocationId):
        self._TargetLocationId = TargetLocationId

    @property
    def RewriteCode(self):
        r"""重定向状态码，可取值301,302,307
        :rtype: int
        """
        return self._RewriteCode

    @RewriteCode.setter
    def RewriteCode(self, RewriteCode):
        self._RewriteCode = RewriteCode

    @property
    def TakeUrl(self):
        r"""重定向是否携带匹配的url，配置RewriteCode时必填
        :rtype: bool
        """
        return self._TakeUrl

    @TakeUrl.setter
    def TakeUrl(self, TakeUrl):
        self._TakeUrl = TakeUrl

    @property
    def SourceDomain(self):
        r"""源转发的域名，必须是SourceLocationId对应的域名，配置RewriteCode时必填
        :rtype: str
        """
        return self._SourceDomain

    @SourceDomain.setter
    def SourceDomain(self, SourceDomain):
        self._SourceDomain = SourceDomain


    def _deserialize(self, params):
        self._SourceLocationId = params.get("SourceLocationId")
        self._TargetLocationId = params.get("TargetLocationId")
        self._RewriteCode = params.get("RewriteCode")
        self._TakeUrl = params.get("TakeUrl")
        self._SourceDomain = params.get("SourceDomain")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RewriteTarget(AbstractModel):
    r"""重定向目标的信息

    """

    def __init__(self):
        r"""
        :param _TargetListenerId: 重定向目标的监听器ID，该字段仅配置了重定向时有效。
注意：此字段可能返回 null，表示取不到有效值。
        :type TargetListenerId: str
        :param _TargetLocationId: 重定向目标的转发规则ID，该字段仅配置了重定向时有效。
注意：此字段可能返回 null，表示取不到有效值。
        :type TargetLocationId: str
        :param _RewriteCode: 重定向状态码
        :type RewriteCode: int
        :param _TakeUrl: 重定向是否携带匹配的url
        :type TakeUrl: bool
        :param _RewriteType: 重定向类型，Manual: 手动重定向，Auto:  自动重定向
        :type RewriteType: str
        """
        self._TargetListenerId = None
        self._TargetLocationId = None
        self._RewriteCode = None
        self._TakeUrl = None
        self._RewriteType = None

    @property
    def TargetListenerId(self):
        r"""重定向目标的监听器ID，该字段仅配置了重定向时有效。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._TargetListenerId

    @TargetListenerId.setter
    def TargetListenerId(self, TargetListenerId):
        self._TargetListenerId = TargetListenerId

    @property
    def TargetLocationId(self):
        r"""重定向目标的转发规则ID，该字段仅配置了重定向时有效。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._TargetLocationId

    @TargetLocationId.setter
    def TargetLocationId(self, TargetLocationId):
        self._TargetLocationId = TargetLocationId

    @property
    def RewriteCode(self):
        r"""重定向状态码
        :rtype: int
        """
        return self._RewriteCode

    @RewriteCode.setter
    def RewriteCode(self, RewriteCode):
        self._RewriteCode = RewriteCode

    @property
    def TakeUrl(self):
        r"""重定向是否携带匹配的url
        :rtype: bool
        """
        return self._TakeUrl

    @TakeUrl.setter
    def TakeUrl(self, TakeUrl):
        self._TakeUrl = TakeUrl

    @property
    def RewriteType(self):
        r"""重定向类型，Manual: 手动重定向，Auto:  自动重定向
        :rtype: str
        """
        return self._RewriteType

    @RewriteType.setter
    def RewriteType(self, RewriteType):
        self._RewriteType = RewriteType


    def _deserialize(self, params):
        self._TargetListenerId = params.get("TargetListenerId")
        self._TargetLocationId = params.get("TargetLocationId")
        self._RewriteCode = params.get("RewriteCode")
        self._TakeUrl = params.get("TakeUrl")
        self._RewriteType = params.get("RewriteType")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RouterSettingWithFallBack(AbstractModel):
    r"""路由设置

    """

    def __init__(self):
        r"""
        :param _CrossModelGroupRoutingStrategy: <p>模型间路由策略。</p><p>枚举值：</p><ul><li>SimpleShuffle： 简单随机路由</li><li>CostBasedRouting： 最低积分路由</li></ul>
注意：此字段可能返回 null，表示取不到有效值。
        :type CrossModelGroupRoutingStrategy: str
        :param _FallBack: <p>回退策略</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type FallBack: :class:`tencentcloud.clb.v20180317.models.FallBackItem`
        :param _RoutingStrategy: <p>模型内路由策略</p><p>枚举值：</p><ul><li>SimpleShuffle： 简单随机路由</li><li>LeastBusy： 最低繁忙路由</li><li>LatencyBasedRouting： 最低延迟路由</li><li>UsageBasedRouting： 用量均衡路由</li><li>CostBasedRouting： 最低积分路由</li></ul>
注意：此字段可能返回 null，表示取不到有效值。
        :type RoutingStrategy: str
        :param _NumRetries: <p>CMR实例级别请求组内重试次数</p><p>取值范围：[0, 5]</p><p>默认值：2</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type NumRetries: int
        :param _RoutingStrategyArgs: <p>L2模型组内路由调度算法参数</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type RoutingStrategyArgs: :class:`tencentcloud.clb.v20180317.models.RoutingStrategyArgs`
        :param _StickyConfig: <p>粘连配置参数</p>
        :type StickyConfig: :class:`tencentcloud.clb.v20180317.models.StickyConfig`
        """
        self._CrossModelGroupRoutingStrategy = None
        self._FallBack = None
        self._RoutingStrategy = None
        self._NumRetries = None
        self._RoutingStrategyArgs = None
        self._StickyConfig = None

    @property
    def CrossModelGroupRoutingStrategy(self):
        r"""<p>模型间路由策略。</p><p>枚举值：</p><ul><li>SimpleShuffle： 简单随机路由</li><li>CostBasedRouting： 最低积分路由</li></ul>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._CrossModelGroupRoutingStrategy

    @CrossModelGroupRoutingStrategy.setter
    def CrossModelGroupRoutingStrategy(self, CrossModelGroupRoutingStrategy):
        self._CrossModelGroupRoutingStrategy = CrossModelGroupRoutingStrategy

    @property
    def FallBack(self):
        r"""<p>回退策略</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.FallBackItem`
        """
        return self._FallBack

    @FallBack.setter
    def FallBack(self, FallBack):
        self._FallBack = FallBack

    @property
    def RoutingStrategy(self):
        r"""<p>模型内路由策略</p><p>枚举值：</p><ul><li>SimpleShuffle： 简单随机路由</li><li>LeastBusy： 最低繁忙路由</li><li>LatencyBasedRouting： 最低延迟路由</li><li>UsageBasedRouting： 用量均衡路由</li><li>CostBasedRouting： 最低积分路由</li></ul>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._RoutingStrategy

    @RoutingStrategy.setter
    def RoutingStrategy(self, RoutingStrategy):
        self._RoutingStrategy = RoutingStrategy

    @property
    def NumRetries(self):
        r"""<p>CMR实例级别请求组内重试次数</p><p>取值范围：[0, 5]</p><p>默认值：2</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._NumRetries

    @NumRetries.setter
    def NumRetries(self, NumRetries):
        self._NumRetries = NumRetries

    @property
    def RoutingStrategyArgs(self):
        r"""<p>L2模型组内路由调度算法参数</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.RoutingStrategyArgs`
        """
        return self._RoutingStrategyArgs

    @RoutingStrategyArgs.setter
    def RoutingStrategyArgs(self, RoutingStrategyArgs):
        self._RoutingStrategyArgs = RoutingStrategyArgs

    @property
    def StickyConfig(self):
        r"""<p>粘连配置参数</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.StickyConfig`
        """
        return self._StickyConfig

    @StickyConfig.setter
    def StickyConfig(self, StickyConfig):
        self._StickyConfig = StickyConfig


    def _deserialize(self, params):
        self._CrossModelGroupRoutingStrategy = params.get("CrossModelGroupRoutingStrategy")
        if params.get("FallBack") is not None:
            self._FallBack = FallBackItem()
            self._FallBack._deserialize(params.get("FallBack"))
        self._RoutingStrategy = params.get("RoutingStrategy")
        self._NumRetries = params.get("NumRetries")
        if params.get("RoutingStrategyArgs") is not None:
            self._RoutingStrategyArgs = RoutingStrategyArgs()
            self._RoutingStrategyArgs._deserialize(params.get("RoutingStrategyArgs"))
        if params.get("StickyConfig") is not None:
            self._StickyConfig = StickyConfig()
            self._StickyConfig._deserialize(params.get("StickyConfig"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RouterSettingWithoutFallBack(AbstractModel):
    r"""路由设置

    """

    def __init__(self):
        r"""
        :param _RoutingStrategy: <p>路由策略</p><p>枚举值：</p><ul><li>SimpleShuffle： 简单随机路由</li><li>LeastBusy： 最低繁忙路由</li><li>LatencyBasedRouting： 最低延迟路由</li><li>UsageBasedRouting： 用量均衡路由</li><li>CostBasedRouting： 最低积分路由</li></ul>
        :type RoutingStrategy: str
        :param _CrossModelGroupRoutingStrategy: <p>模型间路由策略。</p><p>枚举值：</p><ul><li>SimpleShuffle： 简单随机路由</li><li>CostBasedRouting： 最低积分路由</li></ul>
        :type CrossModelGroupRoutingStrategy: str
        :param _RoutingStrategyArgs: <p>L2模型组内路由调度算法参数</p>
        :type RoutingStrategyArgs: :class:`tencentcloud.clb.v20180317.models.RoutingStrategyArgs`
        :param _NumRetries: <p>CMR实例级别请求组内重试次数</p><p>取值范围：[0, 5]</p><p>默认值：2</p>
        :type NumRetries: int
        :param _StickyConfig: <p>粘连路由配置参数</p>
        :type StickyConfig: :class:`tencentcloud.clb.v20180317.models.StickyConfig`
        """
        self._RoutingStrategy = None
        self._CrossModelGroupRoutingStrategy = None
        self._RoutingStrategyArgs = None
        self._NumRetries = None
        self._StickyConfig = None

    @property
    def RoutingStrategy(self):
        r"""<p>路由策略</p><p>枚举值：</p><ul><li>SimpleShuffle： 简单随机路由</li><li>LeastBusy： 最低繁忙路由</li><li>LatencyBasedRouting： 最低延迟路由</li><li>UsageBasedRouting： 用量均衡路由</li><li>CostBasedRouting： 最低积分路由</li></ul>
        :rtype: str
        """
        return self._RoutingStrategy

    @RoutingStrategy.setter
    def RoutingStrategy(self, RoutingStrategy):
        self._RoutingStrategy = RoutingStrategy

    @property
    def CrossModelGroupRoutingStrategy(self):
        r"""<p>模型间路由策略。</p><p>枚举值：</p><ul><li>SimpleShuffle： 简单随机路由</li><li>CostBasedRouting： 最低积分路由</li></ul>
        :rtype: str
        """
        return self._CrossModelGroupRoutingStrategy

    @CrossModelGroupRoutingStrategy.setter
    def CrossModelGroupRoutingStrategy(self, CrossModelGroupRoutingStrategy):
        self._CrossModelGroupRoutingStrategy = CrossModelGroupRoutingStrategy

    @property
    def RoutingStrategyArgs(self):
        r"""<p>L2模型组内路由调度算法参数</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.RoutingStrategyArgs`
        """
        return self._RoutingStrategyArgs

    @RoutingStrategyArgs.setter
    def RoutingStrategyArgs(self, RoutingStrategyArgs):
        self._RoutingStrategyArgs = RoutingStrategyArgs

    @property
    def NumRetries(self):
        r"""<p>CMR实例级别请求组内重试次数</p><p>取值范围：[0, 5]</p><p>默认值：2</p>
        :rtype: int
        """
        return self._NumRetries

    @NumRetries.setter
    def NumRetries(self, NumRetries):
        self._NumRetries = NumRetries

    @property
    def StickyConfig(self):
        r"""<p>粘连路由配置参数</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.StickyConfig`
        """
        return self._StickyConfig

    @StickyConfig.setter
    def StickyConfig(self, StickyConfig):
        self._StickyConfig = StickyConfig


    def _deserialize(self, params):
        self._RoutingStrategy = params.get("RoutingStrategy")
        self._CrossModelGroupRoutingStrategy = params.get("CrossModelGroupRoutingStrategy")
        if params.get("RoutingStrategyArgs") is not None:
            self._RoutingStrategyArgs = RoutingStrategyArgs()
            self._RoutingStrategyArgs._deserialize(params.get("RoutingStrategyArgs"))
        self._NumRetries = params.get("NumRetries")
        if params.get("StickyConfig") is not None:
            self._StickyConfig = StickyConfig()
            self._StickyConfig._deserialize(params.get("StickyConfig"))
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RoutingStrategyArgs(AbstractModel):
    r"""L2模型内路由算法策略参数

    """

    def __init__(self):
        r"""
        :param _LeastBusyBuffer: <p>最低繁忙路由算法相对近优容差。</p><p>取值范围：[0, 100]</p><p>默认值：0</p><p>仅最低繁忙路由算法生效。0 表示请求仅会路由到在途数最小的上游大模型部署，0.10 表示请求路由到的上游大模型部署在途请求数最多比最小在途数高10%，依次类推。</p>
        :type LeastBusyBuffer: float
        :param _UsageBasedBuffer: <p>用量均衡路由算法相对近优容差</p><p>取值范围：[0, 100]</p><p>默认值：0</p><p>仅用量均衡路由算法生效。0 表示请求仅会路由到TPM最低的上游大模型部署；0.10 表示请求最多会路由到比TPM最小值高10%的上游大模型部署，依次类推。</p>
        :type UsageBasedBuffer: float
        :param _LowestLatencyBuffer: <p>最低延迟路由算法相对近优容差</p><p>取值范围：[0, 100]</p><p>默认值：0</p><p>仅最低延迟路由算法生效。0 表示请求仅会路由到延迟最低的上游大模型部署；0.10 表示请求最多会路由到比延迟最小值高10%的上游大模型部署，依次类推。</p>
        :type LowestLatencyBuffer: float
        :param _LowestCostBuffer: <p>最低积分系数路由算法相对近优容差</p><p>取值范围：[0, 100]</p><p>默认值：0</p><p>仅最低积分系数路由算法生效。0 表示请求仅会路由到积分系数最低的上游大模型部署；0.10 表示请求最多会路由到比积分系数最小值高10%的上游大模型部署，依次类推。</p>
        :type LowestCostBuffer: float
        """
        self._LeastBusyBuffer = None
        self._UsageBasedBuffer = None
        self._LowestLatencyBuffer = None
        self._LowestCostBuffer = None

    @property
    def LeastBusyBuffer(self):
        r"""<p>最低繁忙路由算法相对近优容差。</p><p>取值范围：[0, 100]</p><p>默认值：0</p><p>仅最低繁忙路由算法生效。0 表示请求仅会路由到在途数最小的上游大模型部署，0.10 表示请求路由到的上游大模型部署在途请求数最多比最小在途数高10%，依次类推。</p>
        :rtype: float
        """
        return self._LeastBusyBuffer

    @LeastBusyBuffer.setter
    def LeastBusyBuffer(self, LeastBusyBuffer):
        self._LeastBusyBuffer = LeastBusyBuffer

    @property
    def UsageBasedBuffer(self):
        r"""<p>用量均衡路由算法相对近优容差</p><p>取值范围：[0, 100]</p><p>默认值：0</p><p>仅用量均衡路由算法生效。0 表示请求仅会路由到TPM最低的上游大模型部署；0.10 表示请求最多会路由到比TPM最小值高10%的上游大模型部署，依次类推。</p>
        :rtype: float
        """
        return self._UsageBasedBuffer

    @UsageBasedBuffer.setter
    def UsageBasedBuffer(self, UsageBasedBuffer):
        self._UsageBasedBuffer = UsageBasedBuffer

    @property
    def LowestLatencyBuffer(self):
        r"""<p>最低延迟路由算法相对近优容差</p><p>取值范围：[0, 100]</p><p>默认值：0</p><p>仅最低延迟路由算法生效。0 表示请求仅会路由到延迟最低的上游大模型部署；0.10 表示请求最多会路由到比延迟最小值高10%的上游大模型部署，依次类推。</p>
        :rtype: float
        """
        return self._LowestLatencyBuffer

    @LowestLatencyBuffer.setter
    def LowestLatencyBuffer(self, LowestLatencyBuffer):
        self._LowestLatencyBuffer = LowestLatencyBuffer

    @property
    def LowestCostBuffer(self):
        r"""<p>最低积分系数路由算法相对近优容差</p><p>取值范围：[0, 100]</p><p>默认值：0</p><p>仅最低积分系数路由算法生效。0 表示请求仅会路由到积分系数最低的上游大模型部署；0.10 表示请求最多会路由到比积分系数最小值高10%的上游大模型部署，依次类推。</p>
        :rtype: float
        """
        return self._LowestCostBuffer

    @LowestCostBuffer.setter
    def LowestCostBuffer(self, LowestCostBuffer):
        self._LowestCostBuffer = LowestCostBuffer


    def _deserialize(self, params):
        self._LeastBusyBuffer = params.get("LeastBusyBuffer")
        self._UsageBasedBuffer = params.get("UsageBasedBuffer")
        self._LowestLatencyBuffer = params.get("LowestLatencyBuffer")
        self._LowestCostBuffer = params.get("LowestCostBuffer")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RsTagRule(AbstractModel):
    r"""修改节点标签的数据类型

    """

    def __init__(self):
        r"""
        :param _ListenerId: <p>负载均衡监听器 ID。</p>
        :type ListenerId: str
        :param _Targets: <p>要修改标签的后端机器列表。</p>
        :type Targets: list of Target
        :param _LocationId: <p>转发规则的ID，七层规则时需要此参数，4层规则不需要。</p>
        :type LocationId: str
        :param _Tag: <p>后端服务修改后的标签。此参数的优先级低于前述<a href="https://cloud.tencent.com/document/api/214/30694#Target">Target</a>中的Tag参数，即最终的标签以Target中的Tag参数值为准，仅当Target中的Tag参数为空时，才以RsTagRule中的Tag参数为准。</p>
        :type Tag: str
        """
        self._ListenerId = None
        self._Targets = None
        self._LocationId = None
        self._Tag = None

    @property
    def ListenerId(self):
        r"""<p>负载均衡监听器 ID。</p>
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def Targets(self):
        r"""<p>要修改标签的后端机器列表。</p>
        :rtype: list of Target
        """
        return self._Targets

    @Targets.setter
    def Targets(self, Targets):
        self._Targets = Targets

    @property
    def LocationId(self):
        r"""<p>转发规则的ID，七层规则时需要此参数，4层规则不需要。</p>
        :rtype: str
        """
        return self._LocationId

    @LocationId.setter
    def LocationId(self, LocationId):
        self._LocationId = LocationId

    @property
    def Tag(self):
        r"""<p>后端服务修改后的标签。此参数的优先级低于前述<a href="https://cloud.tencent.com/document/api/214/30694#Target">Target</a>中的Tag参数，即最终的标签以Target中的Tag参数值为准，仅当Target中的Tag参数为空时，才以RsTagRule中的Tag参数为准。</p>
        :rtype: str
        """
        return self._Tag

    @Tag.setter
    def Tag(self, Tag):
        self._Tag = Tag


    def _deserialize(self, params):
        self._ListenerId = params.get("ListenerId")
        if params.get("Targets") is not None:
            self._Targets = []
            for item in params.get("Targets"):
                obj = Target()
                obj._deserialize(item)
                self._Targets.append(obj)
        self._LocationId = params.get("LocationId")
        self._Tag = params.get("Tag")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RsWeightRule(AbstractModel):
    r"""修改节点权重的数据类型

    """

    def __init__(self):
        r"""
        :param _ListenerId: 负载均衡监听器 ID。
        :type ListenerId: str
        :param _Targets: 要修改权重的后端机器列表。
        :type Targets: list of Target
        :param _LocationId: 转发规则的ID，七层规则时需要此参数，4层规则不需要。
        :type LocationId: str
        :param _Domain: 目标规则的域名，提供LocationId参数时本参数不生效。
        :type Domain: str
        :param _Url: 目标规则的URL，提供LocationId参数时本参数不生效。
        :type Url: str
        :param _Weight: 后端服务修改后的转发权重，取值范围：[0，100]。此参数的优先级低于前述[Target](https://cloud.tencent.com/document/api/214/30694#Target)中的Weight参数，即最终的权重值以Target中的Weight参数值为准，仅当Target中的Weight参数为空时，才以RsWeightRule中的Weight参数为准。
        :type Weight: int
        """
        self._ListenerId = None
        self._Targets = None
        self._LocationId = None
        self._Domain = None
        self._Url = None
        self._Weight = None

    @property
    def ListenerId(self):
        r"""负载均衡监听器 ID。
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def Targets(self):
        r"""要修改权重的后端机器列表。
        :rtype: list of Target
        """
        return self._Targets

    @Targets.setter
    def Targets(self, Targets):
        self._Targets = Targets

    @property
    def LocationId(self):
        r"""转发规则的ID，七层规则时需要此参数，4层规则不需要。
        :rtype: str
        """
        return self._LocationId

    @LocationId.setter
    def LocationId(self, LocationId):
        self._LocationId = LocationId

    @property
    def Domain(self):
        warnings.warn("parameter `Domain` is deprecated", DeprecationWarning) 

        r"""目标规则的域名，提供LocationId参数时本参数不生效。
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        warnings.warn("parameter `Domain` is deprecated", DeprecationWarning) 

        self._Domain = Domain

    @property
    def Url(self):
        warnings.warn("parameter `Url` is deprecated", DeprecationWarning) 

        r"""目标规则的URL，提供LocationId参数时本参数不生效。
        :rtype: str
        """
        return self._Url

    @Url.setter
    def Url(self, Url):
        warnings.warn("parameter `Url` is deprecated", DeprecationWarning) 

        self._Url = Url

    @property
    def Weight(self):
        r"""后端服务修改后的转发权重，取值范围：[0，100]。此参数的优先级低于前述[Target](https://cloud.tencent.com/document/api/214/30694#Target)中的Weight参数，即最终的权重值以Target中的Weight参数值为准，仅当Target中的Weight参数为空时，才以RsWeightRule中的Weight参数为准。
        :rtype: int
        """
        return self._Weight

    @Weight.setter
    def Weight(self, Weight):
        self._Weight = Weight


    def _deserialize(self, params):
        self._ListenerId = params.get("ListenerId")
        if params.get("Targets") is not None:
            self._Targets = []
            for item in params.get("Targets"):
                obj = Target()
                obj._deserialize(item)
                self._Targets.append(obj)
        self._LocationId = params.get("LocationId")
        self._Domain = params.get("Domain")
        self._Url = params.get("Url")
        self._Weight = params.get("Weight")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RuleHealth(AbstractModel):
    r"""一条转发规则的健康检查状态

    """

    def __init__(self):
        r"""
        :param _LocationId: 转发规则ID
        :type LocationId: str
        :param _Domain: 转发规则的域名
注意：此字段可能返回 null，表示取不到有效值。
        :type Domain: str
        :param _Url: 转发规则的Url
注意：此字段可能返回 null，表示取不到有效值。
        :type Url: str
        :param _RuleId: 高级路由规则ID
        :type RuleId: str
        :param _Targets: 本规则上绑定的后端服务的健康检查状态
        :type Targets: list of TargetHealth
        """
        self._LocationId = None
        self._Domain = None
        self._Url = None
        self._RuleId = None
        self._Targets = None

    @property
    def LocationId(self):
        r"""转发规则ID
        :rtype: str
        """
        return self._LocationId

    @LocationId.setter
    def LocationId(self, LocationId):
        self._LocationId = LocationId

    @property
    def Domain(self):
        r"""转发规则的域名
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def Url(self):
        r"""转发规则的Url
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Url

    @Url.setter
    def Url(self, Url):
        self._Url = Url

    @property
    def RuleId(self):
        r"""高级路由规则ID
        :rtype: str
        """
        return self._RuleId

    @RuleId.setter
    def RuleId(self, RuleId):
        self._RuleId = RuleId

    @property
    def Targets(self):
        r"""本规则上绑定的后端服务的健康检查状态
        :rtype: list of TargetHealth
        """
        return self._Targets

    @Targets.setter
    def Targets(self, Targets):
        self._Targets = Targets


    def _deserialize(self, params):
        self._LocationId = params.get("LocationId")
        self._Domain = params.get("Domain")
        self._Url = params.get("Url")
        self._RuleId = params.get("RuleId")
        if params.get("Targets") is not None:
            self._Targets = []
            for item in params.get("Targets"):
                obj = TargetHealth()
                obj._deserialize(item)
                self._Targets.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RuleInput(AbstractModel):
    r"""HTTP/HTTPS转发规则（输入）

    """

    def __init__(self):
        r"""
        :param _Url: <p>转发规则的路径。长度限制为：1~200。</p>
        :type Url: str
        :param _Domain: <p>转发规则的域名。长度限制为：1~80。Domain和Domains只需要传一个，单域名规则传Domain，多域名规则传Domains。</p>
        :type Domain: str
        :param _SessionExpireTime: <p>会话保持时间。设置为0表示关闭会话保持，开启会话保持可取值30~86400，单位：秒。</p>
        :type SessionExpireTime: int
        :param _HealthCheck: <p>健康检查信息。详情请参见：<a href="https://cloud.tencent.com/document/product/214/6097">健康检查</a></p>
        :type HealthCheck: :class:`tencentcloud.clb.v20180317.models.HealthCheck`
        :param _Certificate: <p>证书信息；此参数和MultiCertInfo不能同时传入。</p>
        :type Certificate: :class:`tencentcloud.clb.v20180317.models.CertificateInput`
        :param _Scheduler: <p>规则的请求转发方式，可选值：WRR、LEAST_CONN、IP_HASH<br>分别表示按权重轮询、最小连接数、按IP哈希， 默认为 WRR。</p>
        :type Scheduler: str
        :param _ForwardType: <p>负载均衡与后端服务之间的转发协议，目前支持 HTTP/HTTPS/GRPC/GRPCS/TRPC，TRPC暂未对外开放，默认HTTP。</p>
        :type ForwardType: str
        :param _DefaultServer: <p>是否将该域名设为默认域名，注意，一个监听器下只能设置一个默认域名。</p>
        :type DefaultServer: bool
        :param _Http2: <p>是否开启Http2，注意，只有HTTPS域名才能开启Http2。</p>
        :type Http2: bool
        :param _TargetType: <p>后端目标类型，NODE表示绑定普通节点，TARGETGROUP表示绑定目标组</p><p>枚举值：</p><ul><li>NODE： 绑定普通节点</li><li>TARGETGROUP： 绑定目标组 v1</li><li>TARGETGROUP-V2： 绑定目标组 v2</li></ul>
        :type TargetType: str
        :param _TrpcCallee: <p>TRPC被调服务器路由，ForwardType为TRPC时必填。目前暂未对外开放。</p>
        :type TrpcCallee: str
        :param _TrpcFunc: <p>TRPC调用服务接口，ForwardType为TRPC时必填。目前暂未对外开放</p>
        :type TrpcFunc: str
        :param _Quic: <p>是否开启QUIC，注意，只有HTTPS域名才能开启QUIC</p>
        :type Quic: bool
        :param _Domains: <p>转发规则的域名列表。每个域名的长度限制为：1~80。Domain和Domains只需要传一个，单域名规则传Domain，多域名规则传Domains。</p>
        :type Domains: list of str
        :param _MultiCertInfo: <p>证书信息，支持同时传入不同算法类型的多本服务端证书；此参数和Certificate不能同时传入。</p>
        :type MultiCertInfo: :class:`tencentcloud.clb.v20180317.models.MultiCertInfo`
        :param _CookieName: <p>自定义cookie名</p>
        :type CookieName: str
        """
        self._Url = None
        self._Domain = None
        self._SessionExpireTime = None
        self._HealthCheck = None
        self._Certificate = None
        self._Scheduler = None
        self._ForwardType = None
        self._DefaultServer = None
        self._Http2 = None
        self._TargetType = None
        self._TrpcCallee = None
        self._TrpcFunc = None
        self._Quic = None
        self._Domains = None
        self._MultiCertInfo = None
        self._CookieName = None

    @property
    def Url(self):
        r"""<p>转发规则的路径。长度限制为：1~200。</p>
        :rtype: str
        """
        return self._Url

    @Url.setter
    def Url(self, Url):
        self._Url = Url

    @property
    def Domain(self):
        r"""<p>转发规则的域名。长度限制为：1~80。Domain和Domains只需要传一个，单域名规则传Domain，多域名规则传Domains。</p>
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def SessionExpireTime(self):
        r"""<p>会话保持时间。设置为0表示关闭会话保持，开启会话保持可取值30~86400，单位：秒。</p>
        :rtype: int
        """
        return self._SessionExpireTime

    @SessionExpireTime.setter
    def SessionExpireTime(self, SessionExpireTime):
        self._SessionExpireTime = SessionExpireTime

    @property
    def HealthCheck(self):
        r"""<p>健康检查信息。详情请参见：<a href="https://cloud.tencent.com/document/product/214/6097">健康检查</a></p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.HealthCheck`
        """
        return self._HealthCheck

    @HealthCheck.setter
    def HealthCheck(self, HealthCheck):
        self._HealthCheck = HealthCheck

    @property
    def Certificate(self):
        r"""<p>证书信息；此参数和MultiCertInfo不能同时传入。</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.CertificateInput`
        """
        return self._Certificate

    @Certificate.setter
    def Certificate(self, Certificate):
        self._Certificate = Certificate

    @property
    def Scheduler(self):
        r"""<p>规则的请求转发方式，可选值：WRR、LEAST_CONN、IP_HASH<br>分别表示按权重轮询、最小连接数、按IP哈希， 默认为 WRR。</p>
        :rtype: str
        """
        return self._Scheduler

    @Scheduler.setter
    def Scheduler(self, Scheduler):
        self._Scheduler = Scheduler

    @property
    def ForwardType(self):
        r"""<p>负载均衡与后端服务之间的转发协议，目前支持 HTTP/HTTPS/GRPC/GRPCS/TRPC，TRPC暂未对外开放，默认HTTP。</p>
        :rtype: str
        """
        return self._ForwardType

    @ForwardType.setter
    def ForwardType(self, ForwardType):
        self._ForwardType = ForwardType

    @property
    def DefaultServer(self):
        r"""<p>是否将该域名设为默认域名，注意，一个监听器下只能设置一个默认域名。</p>
        :rtype: bool
        """
        return self._DefaultServer

    @DefaultServer.setter
    def DefaultServer(self, DefaultServer):
        self._DefaultServer = DefaultServer

    @property
    def Http2(self):
        r"""<p>是否开启Http2，注意，只有HTTPS域名才能开启Http2。</p>
        :rtype: bool
        """
        return self._Http2

    @Http2.setter
    def Http2(self, Http2):
        self._Http2 = Http2

    @property
    def TargetType(self):
        r"""<p>后端目标类型，NODE表示绑定普通节点，TARGETGROUP表示绑定目标组</p><p>枚举值：</p><ul><li>NODE： 绑定普通节点</li><li>TARGETGROUP： 绑定目标组 v1</li><li>TARGETGROUP-V2： 绑定目标组 v2</li></ul>
        :rtype: str
        """
        return self._TargetType

    @TargetType.setter
    def TargetType(self, TargetType):
        self._TargetType = TargetType

    @property
    def TrpcCallee(self):
        r"""<p>TRPC被调服务器路由，ForwardType为TRPC时必填。目前暂未对外开放。</p>
        :rtype: str
        """
        return self._TrpcCallee

    @TrpcCallee.setter
    def TrpcCallee(self, TrpcCallee):
        self._TrpcCallee = TrpcCallee

    @property
    def TrpcFunc(self):
        r"""<p>TRPC调用服务接口，ForwardType为TRPC时必填。目前暂未对外开放</p>
        :rtype: str
        """
        return self._TrpcFunc

    @TrpcFunc.setter
    def TrpcFunc(self, TrpcFunc):
        self._TrpcFunc = TrpcFunc

    @property
    def Quic(self):
        r"""<p>是否开启QUIC，注意，只有HTTPS域名才能开启QUIC</p>
        :rtype: bool
        """
        return self._Quic

    @Quic.setter
    def Quic(self, Quic):
        self._Quic = Quic

    @property
    def Domains(self):
        r"""<p>转发规则的域名列表。每个域名的长度限制为：1~80。Domain和Domains只需要传一个，单域名规则传Domain，多域名规则传Domains。</p>
        :rtype: list of str
        """
        return self._Domains

    @Domains.setter
    def Domains(self, Domains):
        self._Domains = Domains

    @property
    def MultiCertInfo(self):
        r"""<p>证书信息，支持同时传入不同算法类型的多本服务端证书；此参数和Certificate不能同时传入。</p>
        :rtype: :class:`tencentcloud.clb.v20180317.models.MultiCertInfo`
        """
        return self._MultiCertInfo

    @MultiCertInfo.setter
    def MultiCertInfo(self, MultiCertInfo):
        self._MultiCertInfo = MultiCertInfo

    @property
    def CookieName(self):
        r"""<p>自定义cookie名</p>
        :rtype: str
        """
        return self._CookieName

    @CookieName.setter
    def CookieName(self, CookieName):
        self._CookieName = CookieName


    def _deserialize(self, params):
        self._Url = params.get("Url")
        self._Domain = params.get("Domain")
        self._SessionExpireTime = params.get("SessionExpireTime")
        if params.get("HealthCheck") is not None:
            self._HealthCheck = HealthCheck()
            self._HealthCheck._deserialize(params.get("HealthCheck"))
        if params.get("Certificate") is not None:
            self._Certificate = CertificateInput()
            self._Certificate._deserialize(params.get("Certificate"))
        self._Scheduler = params.get("Scheduler")
        self._ForwardType = params.get("ForwardType")
        self._DefaultServer = params.get("DefaultServer")
        self._Http2 = params.get("Http2")
        self._TargetType = params.get("TargetType")
        self._TrpcCallee = params.get("TrpcCallee")
        self._TrpcFunc = params.get("TrpcFunc")
        self._Quic = params.get("Quic")
        self._Domains = params.get("Domains")
        if params.get("MultiCertInfo") is not None:
            self._MultiCertInfo = MultiCertInfo()
            self._MultiCertInfo._deserialize(params.get("MultiCertInfo"))
        self._CookieName = params.get("CookieName")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RuleOutput(AbstractModel):
    r"""HTTP/HTTPS监听器的转发规则（输出）

    """

    def __init__(self):
        r"""
        :param _LocationId: 转发规则的 ID
        :type LocationId: str
        :param _Domain: 转发规则的域名。
        :type Domain: str
        :param _Url: 转发规则的路径。
        :type Url: str
        :param _SessionExpireTime: 会话保持时间
        :type SessionExpireTime: int
        :param _HealthCheck: 健康检查信息
        :type HealthCheck: :class:`tencentcloud.clb.v20180317.models.HealthCheck`
        :param _Certificate: 证书信息
注意：此字段可能返回 null，表示取不到有效值。
        :type Certificate: :class:`tencentcloud.clb.v20180317.models.CertificateOutput`
        :param _Scheduler: 规则的请求转发方式。
WRR、LEAST_CONN、IP_HASH分别表示按权重轮询、最小连接数、IP Hash。
        :type Scheduler: str
        :param _ListenerId: 转发规则所属的监听器 ID
        :type ListenerId: str
        :param _RewriteTarget: 转发规则的重定向目标信息
        :type RewriteTarget: :class:`tencentcloud.clb.v20180317.models.RewriteTarget`
        :param _HttpGzip: 是否开启gzip
        :type HttpGzip: bool
        :param _BeAutoCreated: 转发规则是否为自动创建
        :type BeAutoCreated: bool
        :param _DefaultServer: 是否作为默认域名
        :type DefaultServer: bool
        :param _Http2: 是否开启Http2
        :type Http2: bool
        :param _ForwardType: 负载均衡与后端服务之间的转发协议
        :type ForwardType: str
        :param _CreateTime: 转发规则的创建时间
        :type CreateTime: str
        :param _TargetType: 后端服务器类型。NODE表示绑定普通节点，TARGETGROUP表示绑定目标组。
        :type TargetType: str
        :param _TargetGroup: 绑定的目标组基本信息；当规则绑定目标组时，会返回该字段
注意：此字段可能返回 null，表示取不到有效值。
        :type TargetGroup: :class:`tencentcloud.clb.v20180317.models.BasicTargetGroupInfo`
        :param _WafDomainId: WAF实例ID
        :type WafDomainId: str
        :param _TrpcCallee: TRPC被调服务器路由，ForwardType为TRPC时有效。目前暂未对外开放。
        :type TrpcCallee: str
        :param _TrpcFunc: TRPC调用服务接口，ForwardType为TRPC时有效。目前暂未对外开放。
        :type TrpcFunc: str
        :param _QuicStatus: QUIC状态。QUIC_ACTIVE表示开启，QUIC_INACTIVE表示未开启。注意，只有HTTPS域名才能开启QUIC。
        :type QuicStatus: str
        :param _Domains: 转发规则的域名列表。
        :type Domains: list of str
        :param _TargetGroupList: 绑定的目标组列表
注意：此字段可能返回 null，表示取不到有效值。
        :type TargetGroupList: list of BasicTargetGroupInfo
        :param _OAuth: OAuth配置状态信息。
        :type OAuth: :class:`tencentcloud.clb.v20180317.models.OAuth`
        :param _CookieName: 自定义cookie名。
        :type CookieName: str
        """
        self._LocationId = None
        self._Domain = None
        self._Url = None
        self._SessionExpireTime = None
        self._HealthCheck = None
        self._Certificate = None
        self._Scheduler = None
        self._ListenerId = None
        self._RewriteTarget = None
        self._HttpGzip = None
        self._BeAutoCreated = None
        self._DefaultServer = None
        self._Http2 = None
        self._ForwardType = None
        self._CreateTime = None
        self._TargetType = None
        self._TargetGroup = None
        self._WafDomainId = None
        self._TrpcCallee = None
        self._TrpcFunc = None
        self._QuicStatus = None
        self._Domains = None
        self._TargetGroupList = None
        self._OAuth = None
        self._CookieName = None

    @property
    def LocationId(self):
        r"""转发规则的 ID
        :rtype: str
        """
        return self._LocationId

    @LocationId.setter
    def LocationId(self, LocationId):
        self._LocationId = LocationId

    @property
    def Domain(self):
        r"""转发规则的域名。
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def Url(self):
        r"""转发规则的路径。
        :rtype: str
        """
        return self._Url

    @Url.setter
    def Url(self, Url):
        self._Url = Url

    @property
    def SessionExpireTime(self):
        r"""会话保持时间
        :rtype: int
        """
        return self._SessionExpireTime

    @SessionExpireTime.setter
    def SessionExpireTime(self, SessionExpireTime):
        self._SessionExpireTime = SessionExpireTime

    @property
    def HealthCheck(self):
        r"""健康检查信息
        :rtype: :class:`tencentcloud.clb.v20180317.models.HealthCheck`
        """
        return self._HealthCheck

    @HealthCheck.setter
    def HealthCheck(self, HealthCheck):
        self._HealthCheck = HealthCheck

    @property
    def Certificate(self):
        r"""证书信息
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.CertificateOutput`
        """
        return self._Certificate

    @Certificate.setter
    def Certificate(self, Certificate):
        self._Certificate = Certificate

    @property
    def Scheduler(self):
        r"""规则的请求转发方式。
WRR、LEAST_CONN、IP_HASH分别表示按权重轮询、最小连接数、IP Hash。
        :rtype: str
        """
        return self._Scheduler

    @Scheduler.setter
    def Scheduler(self, Scheduler):
        self._Scheduler = Scheduler

    @property
    def ListenerId(self):
        r"""转发规则所属的监听器 ID
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def RewriteTarget(self):
        r"""转发规则的重定向目标信息
        :rtype: :class:`tencentcloud.clb.v20180317.models.RewriteTarget`
        """
        return self._RewriteTarget

    @RewriteTarget.setter
    def RewriteTarget(self, RewriteTarget):
        self._RewriteTarget = RewriteTarget

    @property
    def HttpGzip(self):
        r"""是否开启gzip
        :rtype: bool
        """
        return self._HttpGzip

    @HttpGzip.setter
    def HttpGzip(self, HttpGzip):
        self._HttpGzip = HttpGzip

    @property
    def BeAutoCreated(self):
        r"""转发规则是否为自动创建
        :rtype: bool
        """
        return self._BeAutoCreated

    @BeAutoCreated.setter
    def BeAutoCreated(self, BeAutoCreated):
        self._BeAutoCreated = BeAutoCreated

    @property
    def DefaultServer(self):
        r"""是否作为默认域名
        :rtype: bool
        """
        return self._DefaultServer

    @DefaultServer.setter
    def DefaultServer(self, DefaultServer):
        self._DefaultServer = DefaultServer

    @property
    def Http2(self):
        r"""是否开启Http2
        :rtype: bool
        """
        return self._Http2

    @Http2.setter
    def Http2(self, Http2):
        self._Http2 = Http2

    @property
    def ForwardType(self):
        r"""负载均衡与后端服务之间的转发协议
        :rtype: str
        """
        return self._ForwardType

    @ForwardType.setter
    def ForwardType(self, ForwardType):
        self._ForwardType = ForwardType

    @property
    def CreateTime(self):
        r"""转发规则的创建时间
        :rtype: str
        """
        return self._CreateTime

    @CreateTime.setter
    def CreateTime(self, CreateTime):
        self._CreateTime = CreateTime

    @property
    def TargetType(self):
        r"""后端服务器类型。NODE表示绑定普通节点，TARGETGROUP表示绑定目标组。
        :rtype: str
        """
        return self._TargetType

    @TargetType.setter
    def TargetType(self, TargetType):
        self._TargetType = TargetType

    @property
    def TargetGroup(self):
        r"""绑定的目标组基本信息；当规则绑定目标组时，会返回该字段
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.BasicTargetGroupInfo`
        """
        return self._TargetGroup

    @TargetGroup.setter
    def TargetGroup(self, TargetGroup):
        self._TargetGroup = TargetGroup

    @property
    def WafDomainId(self):
        r"""WAF实例ID
        :rtype: str
        """
        return self._WafDomainId

    @WafDomainId.setter
    def WafDomainId(self, WafDomainId):
        self._WafDomainId = WafDomainId

    @property
    def TrpcCallee(self):
        r"""TRPC被调服务器路由，ForwardType为TRPC时有效。目前暂未对外开放。
        :rtype: str
        """
        return self._TrpcCallee

    @TrpcCallee.setter
    def TrpcCallee(self, TrpcCallee):
        self._TrpcCallee = TrpcCallee

    @property
    def TrpcFunc(self):
        r"""TRPC调用服务接口，ForwardType为TRPC时有效。目前暂未对外开放。
        :rtype: str
        """
        return self._TrpcFunc

    @TrpcFunc.setter
    def TrpcFunc(self, TrpcFunc):
        self._TrpcFunc = TrpcFunc

    @property
    def QuicStatus(self):
        r"""QUIC状态。QUIC_ACTIVE表示开启，QUIC_INACTIVE表示未开启。注意，只有HTTPS域名才能开启QUIC。
        :rtype: str
        """
        return self._QuicStatus

    @QuicStatus.setter
    def QuicStatus(self, QuicStatus):
        self._QuicStatus = QuicStatus

    @property
    def Domains(self):
        r"""转发规则的域名列表。
        :rtype: list of str
        """
        return self._Domains

    @Domains.setter
    def Domains(self, Domains):
        self._Domains = Domains

    @property
    def TargetGroupList(self):
        r"""绑定的目标组列表
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: list of BasicTargetGroupInfo
        """
        return self._TargetGroupList

    @TargetGroupList.setter
    def TargetGroupList(self, TargetGroupList):
        self._TargetGroupList = TargetGroupList

    @property
    def OAuth(self):
        r"""OAuth配置状态信息。
        :rtype: :class:`tencentcloud.clb.v20180317.models.OAuth`
        """
        return self._OAuth

    @OAuth.setter
    def OAuth(self, OAuth):
        self._OAuth = OAuth

    @property
    def CookieName(self):
        r"""自定义cookie名。
        :rtype: str
        """
        return self._CookieName

    @CookieName.setter
    def CookieName(self, CookieName):
        self._CookieName = CookieName


    def _deserialize(self, params):
        self._LocationId = params.get("LocationId")
        self._Domain = params.get("Domain")
        self._Url = params.get("Url")
        self._SessionExpireTime = params.get("SessionExpireTime")
        if params.get("HealthCheck") is not None:
            self._HealthCheck = HealthCheck()
            self._HealthCheck._deserialize(params.get("HealthCheck"))
        if params.get("Certificate") is not None:
            self._Certificate = CertificateOutput()
            self._Certificate._deserialize(params.get("Certificate"))
        self._Scheduler = params.get("Scheduler")
        self._ListenerId = params.get("ListenerId")
        if params.get("RewriteTarget") is not None:
            self._RewriteTarget = RewriteTarget()
            self._RewriteTarget._deserialize(params.get("RewriteTarget"))
        self._HttpGzip = params.get("HttpGzip")
        self._BeAutoCreated = params.get("BeAutoCreated")
        self._DefaultServer = params.get("DefaultServer")
        self._Http2 = params.get("Http2")
        self._ForwardType = params.get("ForwardType")
        self._CreateTime = params.get("CreateTime")
        self._TargetType = params.get("TargetType")
        if params.get("TargetGroup") is not None:
            self._TargetGroup = BasicTargetGroupInfo()
            self._TargetGroup._deserialize(params.get("TargetGroup"))
        self._WafDomainId = params.get("WafDomainId")
        self._TrpcCallee = params.get("TrpcCallee")
        self._TrpcFunc = params.get("TrpcFunc")
        self._QuicStatus = params.get("QuicStatus")
        self._Domains = params.get("Domains")
        if params.get("TargetGroupList") is not None:
            self._TargetGroupList = []
            for item in params.get("TargetGroupList"):
                obj = BasicTargetGroupInfo()
                obj._deserialize(item)
                self._TargetGroupList.append(obj)
        if params.get("OAuth") is not None:
            self._OAuth = OAuth()
            self._OAuth._deserialize(params.get("OAuth"))
        self._CookieName = params.get("CookieName")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RuleTargets(AbstractModel):
    r"""HTTP/HTTPS监听器下的转发规则绑定的后端服务信息

    """

    def __init__(self):
        r"""
        :param _LocationId: 转发规则的 ID
        :type LocationId: str
        :param _Domain: 转发规则的域名
        :type Domain: str
        :param _Url: 转发规则的路径。
        :type Url: str
        :param _Targets: 后端服务的信息
        :type Targets: list of Backend
        :param _FunctionTargets: 后端云函数的信息
        :type FunctionTargets: list of FunctionTarget
        """
        self._LocationId = None
        self._Domain = None
        self._Url = None
        self._Targets = None
        self._FunctionTargets = None

    @property
    def LocationId(self):
        r"""转发规则的 ID
        :rtype: str
        """
        return self._LocationId

    @LocationId.setter
    def LocationId(self, LocationId):
        self._LocationId = LocationId

    @property
    def Domain(self):
        r"""转发规则的域名
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def Url(self):
        r"""转发规则的路径。
        :rtype: str
        """
        return self._Url

    @Url.setter
    def Url(self, Url):
        self._Url = Url

    @property
    def Targets(self):
        r"""后端服务的信息
        :rtype: list of Backend
        """
        return self._Targets

    @Targets.setter
    def Targets(self, Targets):
        self._Targets = Targets

    @property
    def FunctionTargets(self):
        r"""后端云函数的信息
        :rtype: list of FunctionTarget
        """
        return self._FunctionTargets

    @FunctionTargets.setter
    def FunctionTargets(self, FunctionTargets):
        self._FunctionTargets = FunctionTargets


    def _deserialize(self, params):
        self._LocationId = params.get("LocationId")
        self._Domain = params.get("Domain")
        self._Url = params.get("Url")
        if params.get("Targets") is not None:
            self._Targets = []
            for item in params.get("Targets"):
                obj = Backend()
                obj._deserialize(item)
                self._Targets.append(obj)
        if params.get("FunctionTargets") is not None:
            self._FunctionTargets = []
            for item in params.get("FunctionTargets"):
                obj = FunctionTarget()
                obj._deserialize(item)
                self._FunctionTargets.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class RulesItems(AbstractModel):
    r"""七层规则对象

    """

    def __init__(self):
        r"""
        :param _LocationId: 规则id
        :type LocationId: str
        :param _Domain: 域名
        :type Domain: str
        :param _Url: uri
        :type Url: str
        :param _Targets: 绑定的后端对象
        :type Targets: list of LbRsTargets
        """
        self._LocationId = None
        self._Domain = None
        self._Url = None
        self._Targets = None

    @property
    def LocationId(self):
        r"""规则id
        :rtype: str
        """
        return self._LocationId

    @LocationId.setter
    def LocationId(self, LocationId):
        self._LocationId = LocationId

    @property
    def Domain(self):
        r"""域名
        :rtype: str
        """
        return self._Domain

    @Domain.setter
    def Domain(self, Domain):
        self._Domain = Domain

    @property
    def Url(self):
        r"""uri
        :rtype: str
        """
        return self._Url

    @Url.setter
    def Url(self, Url):
        self._Url = Url

    @property
    def Targets(self):
        r"""绑定的后端对象
        :rtype: list of LbRsTargets
        """
        return self._Targets

    @Targets.setter
    def Targets(self, Targets):
        self._Targets = Targets


    def _deserialize(self, params):
        self._LocationId = params.get("LocationId")
        self._Domain = params.get("Domain")
        self._Url = params.get("Url")
        if params.get("Targets") is not None:
            self._Targets = []
            for item in params.get("Targets"):
                obj = LbRsTargets()
                obj._deserialize(item)
                self._Targets.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ServiceEndPoints(AbstractModel):
    r"""模型路由网络服务信息

    """

    def __init__(self):
        r"""
        :param _CertId: <p>证书ID</p>
        :type CertId: str
        :param _Port: <p>监听端口</p>
        :type Port: int
        :param _Schema: <p>网络协议</p>
        :type Schema: str
        """
        self._CertId = None
        self._Port = None
        self._Schema = None

    @property
    def CertId(self):
        r"""<p>证书ID</p>
        :rtype: str
        """
        return self._CertId

    @CertId.setter
    def CertId(self, CertId):
        self._CertId = CertId

    @property
    def Port(self):
        r"""<p>监听端口</p>
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def Schema(self):
        r"""<p>网络协议</p>
        :rtype: str
        """
        return self._Schema

    @Schema.setter
    def Schema(self, Schema):
        self._Schema = Schema


    def _deserialize(self, params):
        self._CertId = params.get("CertId")
        self._Port = params.get("Port")
        self._Schema = params.get("Schema")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ServiceProvider(AbstractModel):
    r"""BYOK信息

    """

    def __init__(self):
        r"""
        :param _AccessType: <p>BYOK类型</p>
        :type AccessType: str
        :param _InputModalities: <p>单个byok实例下该模型可支持的输入多模态能力列表。</p><p>枚举值：</p><ul><li>text： 支持文本输入</li><li>file： 支持文件输入（当前仅支持pdf）</li><li>image： 支持图像输入</li></ul>
        :type InputModalities: list of str
        :param _Protocol: <p>模型协议</p>
        :type Protocol: str
        :param _Provider: <p>BYOK的所属厂商</p>
        :type Provider: str
        :param _ServiceProviderId: <p>BYOK实例ID</p>
        :type ServiceProviderId: str
        :param _ServiceProviderName: <p>BYOK名称</p>
        :type ServiceProviderName: str
        :param _Order: <p>绑定的指定模型组内BYOK实例的调度优先级</p><p>取值范围[0,2]，优先级随数值增大而降低。</p>
        :type Order: int
        :param _Weight: <p>绑定的指定模型组Order相同层级内BYOK实例的调度权重</p>
        :type Weight: int
        :param _AssociationStatus: <p>CMR实例-BYOK实例的模型调度绑定关系状态</p><p>枚举值：</p><ul><li>Configuring： 变配中</li><li>ConfigureFailed： 变配失败</li><li>Deleting： 删除中</li><li>Provisioning： 创建中</li><li>Active： 正常可用</li><li>ProvisionFailed： 创建失败</li><li>DeletionFailed： 删除失败</li></ul>
        :type AssociationStatus: str
        """
        self._AccessType = None
        self._InputModalities = None
        self._Protocol = None
        self._Provider = None
        self._ServiceProviderId = None
        self._ServiceProviderName = None
        self._Order = None
        self._Weight = None
        self._AssociationStatus = None

    @property
    def AccessType(self):
        r"""<p>BYOK类型</p>
        :rtype: str
        """
        return self._AccessType

    @AccessType.setter
    def AccessType(self, AccessType):
        self._AccessType = AccessType

    @property
    def InputModalities(self):
        r"""<p>单个byok实例下该模型可支持的输入多模态能力列表。</p><p>枚举值：</p><ul><li>text： 支持文本输入</li><li>file： 支持文件输入（当前仅支持pdf）</li><li>image： 支持图像输入</li></ul>
        :rtype: list of str
        """
        return self._InputModalities

    @InputModalities.setter
    def InputModalities(self, InputModalities):
        self._InputModalities = InputModalities

    @property
    def Protocol(self):
        r"""<p>模型协议</p>
        :rtype: str
        """
        return self._Protocol

    @Protocol.setter
    def Protocol(self, Protocol):
        self._Protocol = Protocol

    @property
    def Provider(self):
        r"""<p>BYOK的所属厂商</p>
        :rtype: str
        """
        return self._Provider

    @Provider.setter
    def Provider(self, Provider):
        self._Provider = Provider

    @property
    def ServiceProviderId(self):
        r"""<p>BYOK实例ID</p>
        :rtype: str
        """
        return self._ServiceProviderId

    @ServiceProviderId.setter
    def ServiceProviderId(self, ServiceProviderId):
        self._ServiceProviderId = ServiceProviderId

    @property
    def ServiceProviderName(self):
        r"""<p>BYOK名称</p>
        :rtype: str
        """
        return self._ServiceProviderName

    @ServiceProviderName.setter
    def ServiceProviderName(self, ServiceProviderName):
        self._ServiceProviderName = ServiceProviderName

    @property
    def Order(self):
        r"""<p>绑定的指定模型组内BYOK实例的调度优先级</p><p>取值范围[0,2]，优先级随数值增大而降低。</p>
        :rtype: int
        """
        return self._Order

    @Order.setter
    def Order(self, Order):
        self._Order = Order

    @property
    def Weight(self):
        r"""<p>绑定的指定模型组Order相同层级内BYOK实例的调度权重</p>
        :rtype: int
        """
        return self._Weight

    @Weight.setter
    def Weight(self, Weight):
        self._Weight = Weight

    @property
    def AssociationStatus(self):
        r"""<p>CMR实例-BYOK实例的模型调度绑定关系状态</p><p>枚举值：</p><ul><li>Configuring： 变配中</li><li>ConfigureFailed： 变配失败</li><li>Deleting： 删除中</li><li>Provisioning： 创建中</li><li>Active： 正常可用</li><li>ProvisionFailed： 创建失败</li><li>DeletionFailed： 删除失败</li></ul>
        :rtype: str
        """
        return self._AssociationStatus

    @AssociationStatus.setter
    def AssociationStatus(self, AssociationStatus):
        self._AssociationStatus = AssociationStatus


    def _deserialize(self, params):
        self._AccessType = params.get("AccessType")
        self._InputModalities = params.get("InputModalities")
        self._Protocol = params.get("Protocol")
        self._Provider = params.get("Provider")
        self._ServiceProviderId = params.get("ServiceProviderId")
        self._ServiceProviderName = params.get("ServiceProviderName")
        self._Order = params.get("Order")
        self._Weight = params.get("Weight")
        self._AssociationStatus = params.get("AssociationStatus")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ServiceProviderCoefficient(AbstractModel):
    r"""BYOK 实例（ServiceProvider）维度积分系数明细

    """

    def __init__(self):
        r"""
        :param _Coefficient: <p>该 BYOK 实例（ServiceProvider）维度的积分系数。</p><p>可选字段：仅当该实例单独配置了 ServiceProvider 维度系数时返回，返回值即该实例的生效系数；未返回时表示该实例继承所属 ModelAlias 的 <code>Coefficient</code>。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type Coefficient: :class:`tencentcloud.clb.v20180317.models.Coefficient`
        :param _ServiceProviderId: <p>BYOK 实例（ServiceProvider）ID。</p>
        :type ServiceProviderId: str
        :param _ServiceProviderName: <p>BYOK 实例（ServiceProvider）名称。</p>
        :type ServiceProviderName: str
        """
        self._Coefficient = None
        self._ServiceProviderId = None
        self._ServiceProviderName = None

    @property
    def Coefficient(self):
        r"""<p>该 BYOK 实例（ServiceProvider）维度的积分系数。</p><p>可选字段：仅当该实例单独配置了 ServiceProvider 维度系数时返回，返回值即该实例的生效系数；未返回时表示该实例继承所属 ModelAlias 的 <code>Coefficient</code>。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.Coefficient`
        """
        return self._Coefficient

    @Coefficient.setter
    def Coefficient(self, Coefficient):
        self._Coefficient = Coefficient

    @property
    def ServiceProviderId(self):
        r"""<p>BYOK 实例（ServiceProvider）ID。</p>
        :rtype: str
        """
        return self._ServiceProviderId

    @ServiceProviderId.setter
    def ServiceProviderId(self, ServiceProviderId):
        self._ServiceProviderId = ServiceProviderId

    @property
    def ServiceProviderName(self):
        r"""<p>BYOK 实例（ServiceProvider）名称。</p>
        :rtype: str
        """
        return self._ServiceProviderName

    @ServiceProviderName.setter
    def ServiceProviderName(self, ServiceProviderName):
        self._ServiceProviderName = ServiceProviderName


    def _deserialize(self, params):
        if params.get("Coefficient") is not None:
            self._Coefficient = Coefficient()
            self._Coefficient._deserialize(params.get("Coefficient"))
        self._ServiceProviderId = params.get("ServiceProviderId")
        self._ServiceProviderName = params.get("ServiceProviderName")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ServiceProviderHealthCheckConfigInput(AbstractModel):
    r"""健康检查配置

    """

    def __init__(self):
        r"""
        :param _HealthCheckEnabled: <p>是否开启健康检查</p><p>枚举值：</p><ul><li>true： 是</li><li>false： 否</li></ul>
        :type HealthCheckEnabled: bool
        """
        self._HealthCheckEnabled = None

    @property
    def HealthCheckEnabled(self):
        r"""<p>是否开启健康检查</p><p>枚举值：</p><ul><li>true： 是</li><li>false： 否</li></ul>
        :rtype: bool
        """
        return self._HealthCheckEnabled

    @HealthCheckEnabled.setter
    def HealthCheckEnabled(self, HealthCheckEnabled):
        self._HealthCheckEnabled = HealthCheckEnabled


    def _deserialize(self, params):
        self._HealthCheckEnabled = params.get("HealthCheckEnabled")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ServiceProviderHealthCheckConfigOutput(AbstractModel):
    r"""健康检查配置

    """

    def __init__(self):
        r"""
        :param _HealthCheckEnabled: <p>是否开启健康检查</p><p>枚举值：</p><ul><li>true： 是</li><li>false： 否</li></ul>
        :type HealthCheckEnabled: bool
        """
        self._HealthCheckEnabled = None

    @property
    def HealthCheckEnabled(self):
        r"""<p>是否开启健康检查</p><p>枚举值：</p><ul><li>true： 是</li><li>false： 否</li></ul>
        :rtype: bool
        """
        return self._HealthCheckEnabled

    @HealthCheckEnabled.setter
    def HealthCheckEnabled(self, HealthCheckEnabled):
        self._HealthCheckEnabled = HealthCheckEnabled


    def _deserialize(self, params):
        self._HealthCheckEnabled = params.get("HealthCheckEnabled")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ServiceProviderItem(AbstractModel):
    r"""服务商详情

    """

    def __init__(self):
        r"""
        :param _ServiceProviderId: <p>服务提供商 ID</p>
        :type ServiceProviderId: str
        :param _ServiceProviderName: <p>用户自定义服务提供商名称</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type ServiceProviderName: str
        :param _ModelProvider: <p>模型供应商</p>
        :type ModelProvider: str
        :param _InputModalities: <p>该byok实例下该模型可支持的输入多模态能力列表。</p><p>枚举值：</p><ul><li>text： 支持文本输入</li><li>file： 支持文件输入（当前仅支持pdf）</li><li>image： 支持图像输入</li></ul>
        :type InputModalities: list of str
        """
        self._ServiceProviderId = None
        self._ServiceProviderName = None
        self._ModelProvider = None
        self._InputModalities = None

    @property
    def ServiceProviderId(self):
        r"""<p>服务提供商 ID</p>
        :rtype: str
        """
        return self._ServiceProviderId

    @ServiceProviderId.setter
    def ServiceProviderId(self, ServiceProviderId):
        self._ServiceProviderId = ServiceProviderId

    @property
    def ServiceProviderName(self):
        r"""<p>用户自定义服务提供商名称</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ServiceProviderName

    @ServiceProviderName.setter
    def ServiceProviderName(self, ServiceProviderName):
        self._ServiceProviderName = ServiceProviderName

    @property
    def ModelProvider(self):
        r"""<p>模型供应商</p>
        :rtype: str
        """
        return self._ModelProvider

    @ModelProvider.setter
    def ModelProvider(self, ModelProvider):
        self._ModelProvider = ModelProvider

    @property
    def InputModalities(self):
        r"""<p>该byok实例下该模型可支持的输入多模态能力列表。</p><p>枚举值：</p><ul><li>text： 支持文本输入</li><li>file： 支持文件输入（当前仅支持pdf）</li><li>image： 支持图像输入</li></ul>
        :rtype: list of str
        """
        return self._InputModalities

    @InputModalities.setter
    def InputModalities(self, InputModalities):
        self._InputModalities = InputModalities


    def _deserialize(self, params):
        self._ServiceProviderId = params.get("ServiceProviderId")
        self._ServiceProviderName = params.get("ServiceProviderName")
        self._ModelProvider = params.get("ModelProvider")
        self._InputModalities = params.get("InputModalities")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ServiceProviderModelItem(AbstractModel):
    r"""model 信息

    """

    def __init__(self):
        r"""
        :param _AssociatedModelRouters: <p>关联的模型路由实例列表</p>
        :type AssociatedModelRouters: list of AssociatedModelRouterItem
        :param _InputModalities: <p>该模型当前支持的输入多模态能力列表</p><p>枚举值：</p><ul><li>text： 支持文本输入</li><li>image： 支持图像输入</li><li>file： 支持文件输入（当前仅支持pdf）</li></ul><p>默认值：text</p>
        :type InputModalities: list of str
        :param _ModelAlias: <p>模型别名, 可以用于实际访问</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type ModelAlias: str
        :param _ModelId: <p>模型唯一标识, 原始模型名称</p>
        :type ModelId: str
        :param _ProbedInputModalities: <p>该模型经探测最多支持的输入多模态能力列表</p><p>枚举值：</p><ul><li>text： 支持文本输入</li><li>file： 支持文件输入（当前仅支持pdf）</li><li>image： 支持图像输入</li></ul><p>模型不健康时列表为空</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type ProbedInputModalities: list of str
        """
        self._AssociatedModelRouters = None
        self._InputModalities = None
        self._ModelAlias = None
        self._ModelId = None
        self._ProbedInputModalities = None

    @property
    def AssociatedModelRouters(self):
        r"""<p>关联的模型路由实例列表</p>
        :rtype: list of AssociatedModelRouterItem
        """
        return self._AssociatedModelRouters

    @AssociatedModelRouters.setter
    def AssociatedModelRouters(self, AssociatedModelRouters):
        self._AssociatedModelRouters = AssociatedModelRouters

    @property
    def InputModalities(self):
        r"""<p>该模型当前支持的输入多模态能力列表</p><p>枚举值：</p><ul><li>text： 支持文本输入</li><li>image： 支持图像输入</li><li>file： 支持文件输入（当前仅支持pdf）</li></ul><p>默认值：text</p>
        :rtype: list of str
        """
        return self._InputModalities

    @InputModalities.setter
    def InputModalities(self, InputModalities):
        self._InputModalities = InputModalities

    @property
    def ModelAlias(self):
        r"""<p>模型别名, 可以用于实际访问</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ModelAlias

    @ModelAlias.setter
    def ModelAlias(self, ModelAlias):
        self._ModelAlias = ModelAlias

    @property
    def ModelId(self):
        r"""<p>模型唯一标识, 原始模型名称</p>
        :rtype: str
        """
        return self._ModelId

    @ModelId.setter
    def ModelId(self, ModelId):
        self._ModelId = ModelId

    @property
    def ProbedInputModalities(self):
        r"""<p>该模型经探测最多支持的输入多模态能力列表</p><p>枚举值：</p><ul><li>text： 支持文本输入</li><li>file： 支持文件输入（当前仅支持pdf）</li><li>image： 支持图像输入</li></ul><p>模型不健康时列表为空</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: list of str
        """
        return self._ProbedInputModalities

    @ProbedInputModalities.setter
    def ProbedInputModalities(self, ProbedInputModalities):
        self._ProbedInputModalities = ProbedInputModalities


    def _deserialize(self, params):
        if params.get("AssociatedModelRouters") is not None:
            self._AssociatedModelRouters = []
            for item in params.get("AssociatedModelRouters"):
                obj = AssociatedModelRouterItem()
                obj._deserialize(item)
                self._AssociatedModelRouters.append(obj)
        self._InputModalities = params.get("InputModalities")
        self._ModelAlias = params.get("ModelAlias")
        self._ModelId = params.get("ModelId")
        self._ProbedInputModalities = params.get("ProbedInputModalities")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class SetCustomizedConfigForLoadBalancerRequest(AbstractModel):
    r"""SetCustomizedConfigForLoadBalancer请求参数结构体

    """

    def __init__(self):
        r"""
        :param _OperationType: 操作类型。
- ADD：创建
- DELETE：删除
- UPDATE：修改
- BIND：绑定
- UNBIND：解绑
        :type OperationType: str
        :param _UconfigId: 个性化配置ID。除了创建个性化配置外，必传此字段，如：pz-1234abcd
        :type UconfigId: str
        :param _ConfigContent: 个性化配置内容。创建个性化配置或修改个性化配置的内容时，必传此字段。
具体限制查看 [七层个性化配置](https://cloud.tencent.com/document/product/214/15171)
        :type ConfigContent: str
        :param _ConfigName: 个性化配置名称。创建个性化配置或修改个性化配置的名字时，必传此字段。
        :type ConfigName: str
        :param _LoadBalancerIds: 负载均衡实例ID。绑定解绑时，必传此字段。
可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
        :type LoadBalancerIds: list of str
        :param _Tags: 标签
        :type Tags: list of TagInfo
        """
        self._OperationType = None
        self._UconfigId = None
        self._ConfigContent = None
        self._ConfigName = None
        self._LoadBalancerIds = None
        self._Tags = None

    @property
    def OperationType(self):
        r"""操作类型。
- ADD：创建
- DELETE：删除
- UPDATE：修改
- BIND：绑定
- UNBIND：解绑
        :rtype: str
        """
        return self._OperationType

    @OperationType.setter
    def OperationType(self, OperationType):
        self._OperationType = OperationType

    @property
    def UconfigId(self):
        r"""个性化配置ID。除了创建个性化配置外，必传此字段，如：pz-1234abcd
        :rtype: str
        """
        return self._UconfigId

    @UconfigId.setter
    def UconfigId(self, UconfigId):
        self._UconfigId = UconfigId

    @property
    def ConfigContent(self):
        r"""个性化配置内容。创建个性化配置或修改个性化配置的内容时，必传此字段。
具体限制查看 [七层个性化配置](https://cloud.tencent.com/document/product/214/15171)
        :rtype: str
        """
        return self._ConfigContent

    @ConfigContent.setter
    def ConfigContent(self, ConfigContent):
        self._ConfigContent = ConfigContent

    @property
    def ConfigName(self):
        r"""个性化配置名称。创建个性化配置或修改个性化配置的名字时，必传此字段。
        :rtype: str
        """
        return self._ConfigName

    @ConfigName.setter
    def ConfigName(self, ConfigName):
        self._ConfigName = ConfigName

    @property
    def LoadBalancerIds(self):
        r"""负载均衡实例ID。绑定解绑时，必传此字段。
可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
        :rtype: list of str
        """
        return self._LoadBalancerIds

    @LoadBalancerIds.setter
    def LoadBalancerIds(self, LoadBalancerIds):
        self._LoadBalancerIds = LoadBalancerIds

    @property
    def Tags(self):
        r"""标签
        :rtype: list of TagInfo
        """
        return self._Tags

    @Tags.setter
    def Tags(self, Tags):
        self._Tags = Tags


    def _deserialize(self, params):
        self._OperationType = params.get("OperationType")
        self._UconfigId = params.get("UconfigId")
        self._ConfigContent = params.get("ConfigContent")
        self._ConfigName = params.get("ConfigName")
        self._LoadBalancerIds = params.get("LoadBalancerIds")
        if params.get("Tags") is not None:
            self._Tags = []
            for item in params.get("Tags"):
                obj = TagInfo()
                obj._deserialize(item)
                self._Tags.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class SetCustomizedConfigForLoadBalancerResponse(AbstractModel):
    r"""SetCustomizedConfigForLoadBalancer返回参数结构体

    """

    def __init__(self):
        r"""
        :param _ConfigId: 个性化配置ID，如：pz-1234abcd
        :type ConfigId: str
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._ConfigId = None
        self._RequestId = None

    @property
    def ConfigId(self):
        r"""个性化配置ID，如：pz-1234abcd
        :rtype: str
        """
        return self._ConfigId

    @ConfigId.setter
    def ConfigId(self, ConfigId):
        self._ConfigId = ConfigId

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._ConfigId = params.get("ConfigId")
        self._RequestId = params.get("RequestId")


class SetLoadBalancerClsLogRequest(AbstractModel):
    r"""SetLoadBalancerClsLog请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例 ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
        :type LoadBalancerId: str
        :param _LogSetId: 日志服务(CLS)的日志集 ID。
<li>增加和更新日志主题时可调用 [DescribeLogsets](https://cloud.tencent.com/document/product/614/58624) 接口获取日志集 ID。</li>
<li>删除日志主题时，此参数填写为**空字符串**即可。</li>
        :type LogSetId: str
        :param _LogTopicId: 日志服务(CLS)的日志主题 ID。
<li>增加和更新日志主题时可调用 [DescribeTopics](https://cloud.tencent.com/document/product/614/56454) 接口获取日志主题 ID。</li>
<li>删除日志主题时，此参数填写为**空字符串**即可。</li>
        :type LogTopicId: str
        :param _LogType: 日志类型：
<li>ACCESS：访问日志</li>
<li>HEALTH：健康检查日志</li>
默认为ACCESS。
        :type LogType: str
        """
        self._LoadBalancerId = None
        self._LogSetId = None
        self._LogTopicId = None
        self._LogType = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例 ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def LogSetId(self):
        r"""日志服务(CLS)的日志集 ID。
<li>增加和更新日志主题时可调用 [DescribeLogsets](https://cloud.tencent.com/document/product/614/58624) 接口获取日志集 ID。</li>
<li>删除日志主题时，此参数填写为**空字符串**即可。</li>
        :rtype: str
        """
        return self._LogSetId

    @LogSetId.setter
    def LogSetId(self, LogSetId):
        self._LogSetId = LogSetId

    @property
    def LogTopicId(self):
        r"""日志服务(CLS)的日志主题 ID。
<li>增加和更新日志主题时可调用 [DescribeTopics](https://cloud.tencent.com/document/product/614/56454) 接口获取日志主题 ID。</li>
<li>删除日志主题时，此参数填写为**空字符串**即可。</li>
        :rtype: str
        """
        return self._LogTopicId

    @LogTopicId.setter
    def LogTopicId(self, LogTopicId):
        self._LogTopicId = LogTopicId

    @property
    def LogType(self):
        r"""日志类型：
<li>ACCESS：访问日志</li>
<li>HEALTH：健康检查日志</li>
默认为ACCESS。
        :rtype: str
        """
        return self._LogType

    @LogType.setter
    def LogType(self, LogType):
        self._LogType = LogType


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._LogSetId = params.get("LogSetId")
        self._LogTopicId = params.get("LogTopicId")
        self._LogType = params.get("LogType")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class SetLoadBalancerClsLogResponse(AbstractModel):
    r"""SetLoadBalancerClsLog返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class SetLoadBalancerSecurityGroupsRequest(AbstractModel):
    r"""SetLoadBalancerSecurityGroups请求参数结构体

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例 ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
        :type LoadBalancerId: str
        :param _SecurityGroups: 安全组ID构成的数组，一个负载均衡实例最多可绑定50个安全组，如果要解绑所有安全组，可不传此参数。
可以通过 [DescribeSecurityGroups](https://cloud.tencent.com/document/product/215/15808) 接口查询。
        :type SecurityGroups: list of str
        """
        self._LoadBalancerId = None
        self._SecurityGroups = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例 ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def SecurityGroups(self):
        r"""安全组ID构成的数组，一个负载均衡实例最多可绑定50个安全组，如果要解绑所有安全组，可不传此参数。
可以通过 [DescribeSecurityGroups](https://cloud.tencent.com/document/product/215/15808) 接口查询。
        :rtype: list of str
        """
        return self._SecurityGroups

    @SecurityGroups.setter
    def SecurityGroups(self, SecurityGroups):
        self._SecurityGroups = SecurityGroups


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._SecurityGroups = params.get("SecurityGroups")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class SetLoadBalancerSecurityGroupsResponse(AbstractModel):
    r"""SetLoadBalancerSecurityGroups返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class SetLoadBalancerStartStatusRequest(AbstractModel):
    r"""SetLoadBalancerStartStatus请求参数结构体

    """

    def __init__(self):
        r"""
        :param _OperationType: 操作类型。Start：启动实例，Stop：停止实例。
        :type OperationType: str
        :param _LoadBalancerId: 负载均衡实例ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
        :type LoadBalancerId: str
        :param _ListenerIds: 监听器ID。如果该字段为空，则表示操作负载均衡实例，如果不为空，则表示操作监听器。
        :type ListenerIds: list of str
        """
        self._OperationType = None
        self._LoadBalancerId = None
        self._ListenerIds = None

    @property
    def OperationType(self):
        r"""操作类型。Start：启动实例，Stop：停止实例。
        :rtype: str
        """
        return self._OperationType

    @OperationType.setter
    def OperationType(self, OperationType):
        self._OperationType = OperationType

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例ID，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def ListenerIds(self):
        r"""监听器ID。如果该字段为空，则表示操作负载均衡实例，如果不为空，则表示操作监听器。
        :rtype: list of str
        """
        return self._ListenerIds

    @ListenerIds.setter
    def ListenerIds(self, ListenerIds):
        self._ListenerIds = ListenerIds


    def _deserialize(self, params):
        self._OperationType = params.get("OperationType")
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._ListenerIds = params.get("ListenerIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class SetLoadBalancerStartStatusResponse(AbstractModel):
    r"""SetLoadBalancerStartStatus返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class SetSecurityGroupForLoadbalancersRequest(AbstractModel):
    r"""SetSecurityGroupForLoadbalancers请求参数结构体

    """

    def __init__(self):
        r"""
        :param _SecurityGroup: 安全组ID，如 sg-12345678。可以通过 [DescribeSecurityGroups](https://cloud.tencent.com/document/product/215/15808) 接口获取。
        :type SecurityGroup: str
        :param _OperationType: ADD 绑定安全组；
DEL 解绑安全组
        :type OperationType: str
        :param _LoadBalancerIds: 负载均衡实例ID数组，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
列表支持的最大长度为20。
        :type LoadBalancerIds: list of str
        """
        self._SecurityGroup = None
        self._OperationType = None
        self._LoadBalancerIds = None

    @property
    def SecurityGroup(self):
        r"""安全组ID，如 sg-12345678。可以通过 [DescribeSecurityGroups](https://cloud.tencent.com/document/product/215/15808) 接口获取。
        :rtype: str
        """
        return self._SecurityGroup

    @SecurityGroup.setter
    def SecurityGroup(self, SecurityGroup):
        self._SecurityGroup = SecurityGroup

    @property
    def OperationType(self):
        r"""ADD 绑定安全组；
DEL 解绑安全组
        :rtype: str
        """
        return self._OperationType

    @OperationType.setter
    def OperationType(self, OperationType):
        self._OperationType = OperationType

    @property
    def LoadBalancerIds(self):
        r"""负载均衡实例ID数组，可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
列表支持的最大长度为20。
        :rtype: list of str
        """
        return self._LoadBalancerIds

    @LoadBalancerIds.setter
    def LoadBalancerIds(self, LoadBalancerIds):
        self._LoadBalancerIds = LoadBalancerIds


    def _deserialize(self, params):
        self._SecurityGroup = params.get("SecurityGroup")
        self._OperationType = params.get("OperationType")
        self._LoadBalancerIds = params.get("LoadBalancerIds")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class SetSecurityGroupForLoadbalancersResponse(AbstractModel):
    r"""SetSecurityGroupForLoadbalancers返回参数结构体

    """

    def __init__(self):
        r"""
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._RequestId = None

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._RequestId = params.get("RequestId")


class SlaUpdateParam(AbstractModel):
    r"""升级为性能容量型参数

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡实例 ID。
可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
        :type LoadBalancerId: str
        :param _SlaType: 性能容量型规格，取值范围：
<li> clb.c2.medium：标准型规格 </li>
<li> clb.c3.small：高阶型1规格 </li>
<li> clb.c3.medium：高阶型2规格 </li>
<li> clb.c4.small：超强型1规格 </li>
<li> clb.c4.medium：超强型2规格 </li>
<li> clb.c4.large：超强型3规格 </li>
<li> clb.c4.xlarge：超强型4规格 </li>如需了解规格详情，请参见[实例规格对比](https://cloud.tencent.com/document/product/214/84689)
        :type SlaType: str
        """
        self._LoadBalancerId = None
        self._SlaType = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡实例 ID。
可以通过 [DescribeLoadBalancers](https://cloud.tencent.com/document/product/1108/48459) 接口查询。
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def SlaType(self):
        r"""性能容量型规格，取值范围：
<li> clb.c2.medium：标准型规格 </li>
<li> clb.c3.small：高阶型1规格 </li>
<li> clb.c3.medium：高阶型2规格 </li>
<li> clb.c4.small：超强型1规格 </li>
<li> clb.c4.medium：超强型2规格 </li>
<li> clb.c4.large：超强型3规格 </li>
<li> clb.c4.xlarge：超强型4规格 </li>如需了解规格详情，请参见[实例规格对比](https://cloud.tencent.com/document/product/214/84689)
        :rtype: str
        """
        return self._SlaType

    @SlaType.setter
    def SlaType(self, SlaType):
        self._SlaType = SlaType


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._SlaType = params.get("SlaType")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class SnatIp(AbstractModel):
    r"""SnatIp的信息结构

    """

    def __init__(self):
        r"""
        :param _SubnetId: 私有网络子网的唯一性id，如subnet-12345678
        :type SubnetId: str
        :param _Ip: IP地址，如192.168.0.1
        :type Ip: str
        """
        self._SubnetId = None
        self._Ip = None

    @property
    def SubnetId(self):
        r"""私有网络子网的唯一性id，如subnet-12345678
        :rtype: str
        """
        return self._SubnetId

    @SubnetId.setter
    def SubnetId(self, SubnetId):
        self._SubnetId = SubnetId

    @property
    def Ip(self):
        r"""IP地址，如192.168.0.1
        :rtype: str
        """
        return self._Ip

    @Ip.setter
    def Ip(self, Ip):
        self._Ip = Ip


    def _deserialize(self, params):
        self._SubnetId = params.get("SubnetId")
        self._Ip = params.get("Ip")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class Sort(AbstractModel):
    r"""排序条件

    """

    def __init__(self):
        r"""
        :param _Field: <p>排序的字段</p>
        :type Field: str
        :param _Order: <p>排序方式，支持ASC、DESC</p>
        :type Order: str
        """
        self._Field = None
        self._Order = None

    @property
    def Field(self):
        r"""<p>排序的字段</p>
        :rtype: str
        """
        return self._Field

    @Field.setter
    def Field(self, Field):
        self._Field = Field

    @property
    def Order(self):
        r"""<p>排序方式，支持ASC、DESC</p>
        :rtype: str
        """
        return self._Order

    @Order.setter
    def Order(self, Order):
        self._Order = Order


    def _deserialize(self, params):
        self._Field = params.get("Field")
        self._Order = params.get("Order")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class SpecAvailability(AbstractModel):
    r"""规格可用性

    """

    def __init__(self):
        r"""
        :param _SpecType: 规格类型。
<li>clb.c2.medium（标准型）</li><li>clb.c3.small（高阶型1）</li><li>clb.c3.medium（高阶型2）</li>
<li>clb.c4.small（超强型1）</li><li>clb.c4.medium（超强型2）</li><li>clb.c4.large（超强型3）</li><li>clb.c4.xlarge（超强型4）</li><li>shared（共享型）</li>

        :type SpecType: str
        :param _Availability: 规格可用性。资源可用性，"Available"：可用，"Unavailable"：不可用
        :type Availability: str
        """
        self._SpecType = None
        self._Availability = None

    @property
    def SpecType(self):
        r"""规格类型。
<li>clb.c2.medium（标准型）</li><li>clb.c3.small（高阶型1）</li><li>clb.c3.medium（高阶型2）</li>
<li>clb.c4.small（超强型1）</li><li>clb.c4.medium（超强型2）</li><li>clb.c4.large（超强型3）</li><li>clb.c4.xlarge（超强型4）</li><li>shared（共享型）</li>

        :rtype: str
        """
        return self._SpecType

    @SpecType.setter
    def SpecType(self, SpecType):
        self._SpecType = SpecType

    @property
    def Availability(self):
        r"""规格可用性。资源可用性，"Available"：可用，"Unavailable"：不可用
        :rtype: str
        """
        return self._Availability

    @Availability.setter
    def Availability(self, Availability):
        self._Availability = Availability


    def _deserialize(self, params):
        self._SpecType = params.get("SpecType")
        self._Availability = params.get("Availability")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class StickyConfig(AbstractModel):
    r"""粘连路由配置

    """

    def __init__(self):
        r"""
        :param _Enabled: <p>是否开启粘连路由</p>
        :type Enabled: bool
        """
        self._Enabled = None

    @property
    def Enabled(self):
        r"""<p>是否开启粘连路由</p>
        :rtype: bool
        """
        return self._Enabled

    @Enabled.setter
    def Enabled(self, Enabled):
        self._Enabled = Enabled


    def _deserialize(self, params):
        self._Enabled = params.get("Enabled")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class TagInfo(AbstractModel):
    r"""模型路由实例的标签信息

    """

    def __init__(self):
        r"""
        :param _TagKey: 标签的键
        :type TagKey: str
        :param _TagValue: 标签的值
        :type TagValue: str
        """
        self._TagKey = None
        self._TagValue = None

    @property
    def TagKey(self):
        r"""标签的键
        :rtype: str
        """
        return self._TagKey

    @TagKey.setter
    def TagKey(self, TagKey):
        self._TagKey = TagKey

    @property
    def TagValue(self):
        r"""标签的值
        :rtype: str
        """
        return self._TagValue

    @TagValue.setter
    def TagValue(self, TagValue):
        self._TagValue = TagValue


    def _deserialize(self, params):
        self._TagKey = params.get("TagKey")
        self._TagValue = params.get("TagValue")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class Target(AbstractModel):
    r"""转发目标，即绑定在负载均衡上的后端服务

    """

    def __init__(self):
        r"""
        :param _Port: 后端服务的监听端口。
注意：绑定CVM（云服务器）或ENI（弹性网卡）时必传此参数
        :type Port: int
        :param _Type: 后端服务的类型，可取：CVM（云服务器）、ENI（弹性网卡）；作为入参时，目前本参数暂不生效。
        :type Type: str
        :param _InstanceId: 绑定CVM时需要传入此参数，代表CVM的唯一 ID，可通过 DescribeInstances 接口返回字段中的 InstanceId 字段获取。表示绑定主网卡主IPv4地址；以下场景都不支持指定InstanceId：绑定非CVM，绑定CVM上的辅助网卡IP，通过跨域2.0绑定CVM，以及绑定CVM的IPv6地址等。
注意：参数 InstanceId、EniIp 有且只能传入其中一个参数。
        :type InstanceId: str
        :param _Weight: 后端服务修改后的转发权重，取值范围：[0, 100]，默认为 10。此参数的优先级高于[RsWeightRule](https://cloud.tencent.com/document/api/214/30694#RsWeightRule)中的Weight参数，即最终的权重值以此Weight参数值为准，仅当此Weight参数为空时，才以RsWeightRule中的Weight参数为准。
        :type Weight: int
        :param _EniIp: 绑定IP时需要传入此参数，支持弹性网卡的IP和其他内网IP，如果是弹性网卡则必须先绑定至CVM，然后才能绑定到负载均衡实例。
注意：参数 InstanceId、EniIp 有且只能传入其中一个参数。如果绑定双栈IPV6子机，则必须传该参数。如果是跨地域绑定，则必须传该参数，不支持传InstanceId参数。
        :type EniIp: str
        :param _Tag: 标签。
        :type Tag: str
        """
        self._Port = None
        self._Type = None
        self._InstanceId = None
        self._Weight = None
        self._EniIp = None
        self._Tag = None

    @property
    def Port(self):
        r"""后端服务的监听端口。
注意：绑定CVM（云服务器）或ENI（弹性网卡）时必传此参数
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def Type(self):
        r"""后端服务的类型，可取：CVM（云服务器）、ENI（弹性网卡）；作为入参时，目前本参数暂不生效。
        :rtype: str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type

    @property
    def InstanceId(self):
        r"""绑定CVM时需要传入此参数，代表CVM的唯一 ID，可通过 DescribeInstances 接口返回字段中的 InstanceId 字段获取。表示绑定主网卡主IPv4地址；以下场景都不支持指定InstanceId：绑定非CVM，绑定CVM上的辅助网卡IP，通过跨域2.0绑定CVM，以及绑定CVM的IPv6地址等。
注意：参数 InstanceId、EniIp 有且只能传入其中一个参数。
        :rtype: str
        """
        return self._InstanceId

    @InstanceId.setter
    def InstanceId(self, InstanceId):
        self._InstanceId = InstanceId

    @property
    def Weight(self):
        r"""后端服务修改后的转发权重，取值范围：[0, 100]，默认为 10。此参数的优先级高于[RsWeightRule](https://cloud.tencent.com/document/api/214/30694#RsWeightRule)中的Weight参数，即最终的权重值以此Weight参数值为准，仅当此Weight参数为空时，才以RsWeightRule中的Weight参数为准。
        :rtype: int
        """
        return self._Weight

    @Weight.setter
    def Weight(self, Weight):
        self._Weight = Weight

    @property
    def EniIp(self):
        r"""绑定IP时需要传入此参数，支持弹性网卡的IP和其他内网IP，如果是弹性网卡则必须先绑定至CVM，然后才能绑定到负载均衡实例。
注意：参数 InstanceId、EniIp 有且只能传入其中一个参数。如果绑定双栈IPV6子机，则必须传该参数。如果是跨地域绑定，则必须传该参数，不支持传InstanceId参数。
        :rtype: str
        """
        return self._EniIp

    @EniIp.setter
    def EniIp(self, EniIp):
        self._EniIp = EniIp

    @property
    def Tag(self):
        r"""标签。
        :rtype: str
        """
        return self._Tag

    @Tag.setter
    def Tag(self, Tag):
        self._Tag = Tag


    def _deserialize(self, params):
        self._Port = params.get("Port")
        self._Type = params.get("Type")
        self._InstanceId = params.get("InstanceId")
        self._Weight = params.get("Weight")
        self._EniIp = params.get("EniIp")
        self._Tag = params.get("Tag")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class TargetGroupAssociation(AbstractModel):
    r"""规则与目标组的关联关系

    """

    def __init__(self):
        r"""
        :param _LoadBalancerId: 负载均衡ID
        :type LoadBalancerId: str
        :param _TargetGroupId: 目标组ID
        :type TargetGroupId: str
        :param _ListenerId: 监听器ID。访问AssociateTargetGroups和DisassociateTargetGroups接口时必传此参数。
        :type ListenerId: str
        :param _LocationId: 转发规则ID
        :type LocationId: str
        :param _Weight: 目标组权重，范围[0, 100]。仅绑定v2目标组时生效，如果不存在，则默认为10。
        :type Weight: int
        """
        self._LoadBalancerId = None
        self._TargetGroupId = None
        self._ListenerId = None
        self._LocationId = None
        self._Weight = None

    @property
    def LoadBalancerId(self):
        r"""负载均衡ID
        :rtype: str
        """
        return self._LoadBalancerId

    @LoadBalancerId.setter
    def LoadBalancerId(self, LoadBalancerId):
        self._LoadBalancerId = LoadBalancerId

    @property
    def TargetGroupId(self):
        r"""目标组ID
        :rtype: str
        """
        return self._TargetGroupId

    @TargetGroupId.setter
    def TargetGroupId(self, TargetGroupId):
        self._TargetGroupId = TargetGroupId

    @property
    def ListenerId(self):
        r"""监听器ID。访问AssociateTargetGroups和DisassociateTargetGroups接口时必传此参数。
        :rtype: str
        """
        return self._ListenerId

    @ListenerId.setter
    def ListenerId(self, ListenerId):
        self._ListenerId = ListenerId

    @property
    def LocationId(self):
        r"""转发规则ID
        :rtype: str
        """
        return self._LocationId

    @LocationId.setter
    def LocationId(self, LocationId):
        self._LocationId = LocationId

    @property
    def Weight(self):
        r"""目标组权重，范围[0, 100]。仅绑定v2目标组时生效，如果不存在，则默认为10。
        :rtype: int
        """
        return self._Weight

    @Weight.setter
    def Weight(self, Weight):
        self._Weight = Weight


    def _deserialize(self, params):
        self._LoadBalancerId = params.get("LoadBalancerId")
        self._TargetGroupId = params.get("TargetGroupId")
        self._ListenerId = params.get("ListenerId")
        self._LocationId = params.get("LocationId")
        self._Weight = params.get("Weight")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class TargetGroupBackend(AbstractModel):
    r"""目标组绑定的后端服务器

    """

    def __init__(self):
        r"""
        :param _TargetGroupId: 目标组ID
        :type TargetGroupId: str
        :param _Type: 后端服务的类型，可取：CVM、ENI（即将支持）
        :type Type: str
        :param _InstanceId: 后端服务的唯一 ID
        :type InstanceId: str
        :param _Port: 后端服务的监听端口，全端口段监听器此字段返回0，代表无效端口，即不支持设置。
        :type Port: int
        :param _Weight: 后端服务的转发权重，取值范围：[0, 100]，默认为 10。
        :type Weight: int
        :param _PublicIpAddresses: 后端服务的外网 IP
        :type PublicIpAddresses: list of str
        :param _PrivateIpAddresses: 后端服务的内网 IP
        :type PrivateIpAddresses: list of str
        :param _InstanceName: 后端服务的实例名称
        :type InstanceName: str
        :param _RegisteredTime: 后端服务被绑定的时间
注意：此字段可能返回 null，表示取不到有效值。
        :type RegisteredTime: str
        :param _EniId: 弹性网卡唯一ID
        :type EniId: str
        :param _ZoneId: 后端服务的可用区ID
        :type ZoneId: int
        """
        self._TargetGroupId = None
        self._Type = None
        self._InstanceId = None
        self._Port = None
        self._Weight = None
        self._PublicIpAddresses = None
        self._PrivateIpAddresses = None
        self._InstanceName = None
        self._RegisteredTime = None
        self._EniId = None
        self._ZoneId = None

    @property
    def TargetGroupId(self):
        r"""目标组ID
        :rtype: str
        """
        return self._TargetGroupId

    @TargetGroupId.setter
    def TargetGroupId(self, TargetGroupId):
        self._TargetGroupId = TargetGroupId

    @property
    def Type(self):
        r"""后端服务的类型，可取：CVM、ENI（即将支持）
        :rtype: str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type

    @property
    def InstanceId(self):
        r"""后端服务的唯一 ID
        :rtype: str
        """
        return self._InstanceId

    @InstanceId.setter
    def InstanceId(self, InstanceId):
        self._InstanceId = InstanceId

    @property
    def Port(self):
        r"""后端服务的监听端口，全端口段监听器此字段返回0，代表无效端口，即不支持设置。
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def Weight(self):
        r"""后端服务的转发权重，取值范围：[0, 100]，默认为 10。
        :rtype: int
        """
        return self._Weight

    @Weight.setter
    def Weight(self, Weight):
        self._Weight = Weight

    @property
    def PublicIpAddresses(self):
        r"""后端服务的外网 IP
        :rtype: list of str
        """
        return self._PublicIpAddresses

    @PublicIpAddresses.setter
    def PublicIpAddresses(self, PublicIpAddresses):
        self._PublicIpAddresses = PublicIpAddresses

    @property
    def PrivateIpAddresses(self):
        r"""后端服务的内网 IP
        :rtype: list of str
        """
        return self._PrivateIpAddresses

    @PrivateIpAddresses.setter
    def PrivateIpAddresses(self, PrivateIpAddresses):
        self._PrivateIpAddresses = PrivateIpAddresses

    @property
    def InstanceName(self):
        r"""后端服务的实例名称
        :rtype: str
        """
        return self._InstanceName

    @InstanceName.setter
    def InstanceName(self, InstanceName):
        self._InstanceName = InstanceName

    @property
    def RegisteredTime(self):
        r"""后端服务被绑定的时间
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._RegisteredTime

    @RegisteredTime.setter
    def RegisteredTime(self, RegisteredTime):
        self._RegisteredTime = RegisteredTime

    @property
    def EniId(self):
        r"""弹性网卡唯一ID
        :rtype: str
        """
        return self._EniId

    @EniId.setter
    def EniId(self, EniId):
        self._EniId = EniId

    @property
    def ZoneId(self):
        r"""后端服务的可用区ID
        :rtype: int
        """
        return self._ZoneId

    @ZoneId.setter
    def ZoneId(self, ZoneId):
        self._ZoneId = ZoneId


    def _deserialize(self, params):
        self._TargetGroupId = params.get("TargetGroupId")
        self._Type = params.get("Type")
        self._InstanceId = params.get("InstanceId")
        self._Port = params.get("Port")
        self._Weight = params.get("Weight")
        self._PublicIpAddresses = params.get("PublicIpAddresses")
        self._PrivateIpAddresses = params.get("PrivateIpAddresses")
        self._InstanceName = params.get("InstanceName")
        self._RegisteredTime = params.get("RegisteredTime")
        self._EniId = params.get("EniId")
        self._ZoneId = params.get("ZoneId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class TargetGroupHealthCheck(AbstractModel):
    r"""目标组健康检查详情

    """

    def __init__(self):
        r"""
        :param _HealthSwitch: 是否开启健康检查。
        :type HealthSwitch: bool
        :param _Protocol: 健康检查方式， 其中仅V2新版目标组类型支持该参数， 支持取值 TCP | HTTP | HTTPS | PING | CUSTOM，其中:
<ur><li>当目标组后端转发协议为TCP时， 健康检查方式支持 TCP/HTTP/CUSTOM， 默认为TCP。</li><li>当目标组后端转发协议为UDP时， 健康检查方式支持 PING/CUSTOM，默认为PING。</li><li>当目标组后端转发协议为HTTP时， 健康检查方式支持 HTTP/TCP， 默认为HTTP。</li><li>当目标组后端转发协议为HTTPS时， 健康检查方式支持 HTTPS/TCP， 默认为HTTPS。</li><li>当目标组后端转发协议为GRPC时， 健康检查方式支持GRPC/TCP， 默认为GRPC。</li></ur>
        :type Protocol: str
        :param _Port: 自定义探测相关参数。健康检查端口，默认为后端服务的端口，除非您希望指定特定端口，否则建议留空。（仅适用于TCP/UDP目标组）。

        :type Port: int
        :param _Timeout: 健康检查超时时间。 默认为2秒。 可配置范围：2 - 30秒。
        :type Timeout: int
        :param _GapTime: 检测间隔时间。 默认为5秒。 可配置范围：2 - 300秒。
        :type GapTime: int
        :param _GoodLimit: 检测健康阈值。 默认为3秒。 可配置范围：2 - 10次。
        :type GoodLimit: int
        :param _BadLimit: 检测不健康阈值。 默认为3秒。 可配置范围：2 - 10次。
        :type BadLimit: int
        :param _JumboFrame: 目标组下的所有rs的探测包是否开启巨帧。默认开启。仅GWLB类型目标组支持该参数。
        :type JumboFrame: bool
        :param _HttpCode: 健康检查状态码（仅适用于HTTP/HTTPS目标组、TCP目标组的HTTP健康检查方式）。可选值：1~31，默认 31，其中：<url> <li>1 表示探测后返回值 1xx 代表健康。</li><li>2 表示返回 2xx 代表健康。</li><li>4 表示返回 3xx 代表健康。</li><li>8 表示返回 4xx 代表健康。</li><li>16 表示返回 5xx 代表健康。</li></url>若希望多种返回码都可代表健康，则将相应的值相加。
注意：此字段可能返回 null，表示取不到有效值。
        :type HttpCode: int
        :param _HttpCheckDomain: 健康检查域名， 其中：<ur><li>仅适用于HTTP/HTTPS目标组和TCP目标组的HTTP健康检查方式。</li><li>针对HTTP/HTTPS目标组，当使用HTTP健康检查方式时，该参数为必填项。</li></ur>
注意：此字段可能返回 null，表示取不到有效值。
        :type HttpCheckDomain: str
        :param _HttpCheckPath: 健康检查路径（仅适用于HTTP/HTTPS转发规则、TCP监听器的HTTP健康检查方式）。
注意：此字段可能返回 null，表示取不到有效值。
        :type HttpCheckPath: str
        :param _HttpCheckMethod: 健康检查方法（仅适用于HTTP/HTTPS转发规则、TCP监听器的HTTP健康检查方式），默认值：HEAD，可选值HEAD或GET。
注意：此字段可能返回 null，表示取不到有效值。
        :type HttpCheckMethod: str
        :param _ContextType: 健康检查的输入格式，健康检查方式取CUSTOM时，必填此字段，可取值：HEX或TEXT，其中：<ur><li>TEXT：文本格式。</li><li>HEX：十六进制格式， SendContext和RecvContext的字符只能在0123456789ABCDEF中选取且长度必须是偶数位。</li><li>仅适用于TCP/UDP目标组。</li></ur>
注意：此字段可能返回 null，表示取不到有效值。
        :type ContextType: str
        :param _SendContext: 自定义探测相关参数。健康检查协议CheckType的值取CUSTOM时，必填此字段，代表健康检查发送的请求内容，只允许ASCII可见字符，最大长度限制500。（仅适用于TCP/UDP目标组）。
注意：此字段可能返回 null，表示取不到有效值。
        :type SendContext: str
        :param _RecvContext: 自定义探测相关参数。健康检查协议CheckType的值取CUSTOM时，必填此字段，代表健康检查返回的结果，只允许ASCII可见字符，最大长度限制500。（仅适用于TCP/UDP目标组）。
注意：此字段可能返回 null，表示取不到有效值。
        :type RecvContext: str
        :param _HttpVersion: HTTP版本, 其中：<ur><li>健康检查协议CheckType的值取HTTP时，必传此字段。</li><li>支持配置选项：HTTP/1.0, HTTP/1.1。</li><li>仅适用于TCP目标组。</li></ur>
注意：此字段可能返回 null，表示取不到有效值。
        :type HttpVersion: str
        :param _ExtendedCode: GRPC健康检查状态码（仅适用于后端转发协议为GRPC的目标组）。默认值为 12，可输入值为数值、多个数值、或者范围，例如 20 或 20,25 或 0-99。
注意：此字段可能返回 null，表示取不到有效值。
        :type ExtendedCode: str
        """
        self._HealthSwitch = None
        self._Protocol = None
        self._Port = None
        self._Timeout = None
        self._GapTime = None
        self._GoodLimit = None
        self._BadLimit = None
        self._JumboFrame = None
        self._HttpCode = None
        self._HttpCheckDomain = None
        self._HttpCheckPath = None
        self._HttpCheckMethod = None
        self._ContextType = None
        self._SendContext = None
        self._RecvContext = None
        self._HttpVersion = None
        self._ExtendedCode = None

    @property
    def HealthSwitch(self):
        r"""是否开启健康检查。
        :rtype: bool
        """
        return self._HealthSwitch

    @HealthSwitch.setter
    def HealthSwitch(self, HealthSwitch):
        self._HealthSwitch = HealthSwitch

    @property
    def Protocol(self):
        r"""健康检查方式， 其中仅V2新版目标组类型支持该参数， 支持取值 TCP | HTTP | HTTPS | PING | CUSTOM，其中:
<ur><li>当目标组后端转发协议为TCP时， 健康检查方式支持 TCP/HTTP/CUSTOM， 默认为TCP。</li><li>当目标组后端转发协议为UDP时， 健康检查方式支持 PING/CUSTOM，默认为PING。</li><li>当目标组后端转发协议为HTTP时， 健康检查方式支持 HTTP/TCP， 默认为HTTP。</li><li>当目标组后端转发协议为HTTPS时， 健康检查方式支持 HTTPS/TCP， 默认为HTTPS。</li><li>当目标组后端转发协议为GRPC时， 健康检查方式支持GRPC/TCP， 默认为GRPC。</li></ur>
        :rtype: str
        """
        return self._Protocol

    @Protocol.setter
    def Protocol(self, Protocol):
        self._Protocol = Protocol

    @property
    def Port(self):
        r"""自定义探测相关参数。健康检查端口，默认为后端服务的端口，除非您希望指定特定端口，否则建议留空。（仅适用于TCP/UDP目标组）。

        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def Timeout(self):
        r"""健康检查超时时间。 默认为2秒。 可配置范围：2 - 30秒。
        :rtype: int
        """
        return self._Timeout

    @Timeout.setter
    def Timeout(self, Timeout):
        self._Timeout = Timeout

    @property
    def GapTime(self):
        r"""检测间隔时间。 默认为5秒。 可配置范围：2 - 300秒。
        :rtype: int
        """
        return self._GapTime

    @GapTime.setter
    def GapTime(self, GapTime):
        self._GapTime = GapTime

    @property
    def GoodLimit(self):
        r"""检测健康阈值。 默认为3秒。 可配置范围：2 - 10次。
        :rtype: int
        """
        return self._GoodLimit

    @GoodLimit.setter
    def GoodLimit(self, GoodLimit):
        self._GoodLimit = GoodLimit

    @property
    def BadLimit(self):
        r"""检测不健康阈值。 默认为3秒。 可配置范围：2 - 10次。
        :rtype: int
        """
        return self._BadLimit

    @BadLimit.setter
    def BadLimit(self, BadLimit):
        self._BadLimit = BadLimit

    @property
    def JumboFrame(self):
        r"""目标组下的所有rs的探测包是否开启巨帧。默认开启。仅GWLB类型目标组支持该参数。
        :rtype: bool
        """
        return self._JumboFrame

    @JumboFrame.setter
    def JumboFrame(self, JumboFrame):
        self._JumboFrame = JumboFrame

    @property
    def HttpCode(self):
        r"""健康检查状态码（仅适用于HTTP/HTTPS目标组、TCP目标组的HTTP健康检查方式）。可选值：1~31，默认 31，其中：<url> <li>1 表示探测后返回值 1xx 代表健康。</li><li>2 表示返回 2xx 代表健康。</li><li>4 表示返回 3xx 代表健康。</li><li>8 表示返回 4xx 代表健康。</li><li>16 表示返回 5xx 代表健康。</li></url>若希望多种返回码都可代表健康，则将相应的值相加。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._HttpCode

    @HttpCode.setter
    def HttpCode(self, HttpCode):
        self._HttpCode = HttpCode

    @property
    def HttpCheckDomain(self):
        r"""健康检查域名， 其中：<ur><li>仅适用于HTTP/HTTPS目标组和TCP目标组的HTTP健康检查方式。</li><li>针对HTTP/HTTPS目标组，当使用HTTP健康检查方式时，该参数为必填项。</li></ur>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._HttpCheckDomain

    @HttpCheckDomain.setter
    def HttpCheckDomain(self, HttpCheckDomain):
        self._HttpCheckDomain = HttpCheckDomain

    @property
    def HttpCheckPath(self):
        r"""健康检查路径（仅适用于HTTP/HTTPS转发规则、TCP监听器的HTTP健康检查方式）。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._HttpCheckPath

    @HttpCheckPath.setter
    def HttpCheckPath(self, HttpCheckPath):
        self._HttpCheckPath = HttpCheckPath

    @property
    def HttpCheckMethod(self):
        r"""健康检查方法（仅适用于HTTP/HTTPS转发规则、TCP监听器的HTTP健康检查方式），默认值：HEAD，可选值HEAD或GET。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._HttpCheckMethod

    @HttpCheckMethod.setter
    def HttpCheckMethod(self, HttpCheckMethod):
        self._HttpCheckMethod = HttpCheckMethod

    @property
    def ContextType(self):
        r"""健康检查的输入格式，健康检查方式取CUSTOM时，必填此字段，可取值：HEX或TEXT，其中：<ur><li>TEXT：文本格式。</li><li>HEX：十六进制格式， SendContext和RecvContext的字符只能在0123456789ABCDEF中选取且长度必须是偶数位。</li><li>仅适用于TCP/UDP目标组。</li></ur>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ContextType

    @ContextType.setter
    def ContextType(self, ContextType):
        self._ContextType = ContextType

    @property
    def SendContext(self):
        r"""自定义探测相关参数。健康检查协议CheckType的值取CUSTOM时，必填此字段，代表健康检查发送的请求内容，只允许ASCII可见字符，最大长度限制500。（仅适用于TCP/UDP目标组）。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._SendContext

    @SendContext.setter
    def SendContext(self, SendContext):
        self._SendContext = SendContext

    @property
    def RecvContext(self):
        r"""自定义探测相关参数。健康检查协议CheckType的值取CUSTOM时，必填此字段，代表健康检查返回的结果，只允许ASCII可见字符，最大长度限制500。（仅适用于TCP/UDP目标组）。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._RecvContext

    @RecvContext.setter
    def RecvContext(self, RecvContext):
        self._RecvContext = RecvContext

    @property
    def HttpVersion(self):
        r"""HTTP版本, 其中：<ur><li>健康检查协议CheckType的值取HTTP时，必传此字段。</li><li>支持配置选项：HTTP/1.0, HTTP/1.1。</li><li>仅适用于TCP目标组。</li></ur>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._HttpVersion

    @HttpVersion.setter
    def HttpVersion(self, HttpVersion):
        self._HttpVersion = HttpVersion

    @property
    def ExtendedCode(self):
        r"""GRPC健康检查状态码（仅适用于后端转发协议为GRPC的目标组）。默认值为 12，可输入值为数值、多个数值、或者范围，例如 20 或 20,25 或 0-99。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ExtendedCode

    @ExtendedCode.setter
    def ExtendedCode(self, ExtendedCode):
        self._ExtendedCode = ExtendedCode


    def _deserialize(self, params):
        self._HealthSwitch = params.get("HealthSwitch")
        self._Protocol = params.get("Protocol")
        self._Port = params.get("Port")
        self._Timeout = params.get("Timeout")
        self._GapTime = params.get("GapTime")
        self._GoodLimit = params.get("GoodLimit")
        self._BadLimit = params.get("BadLimit")
        self._JumboFrame = params.get("JumboFrame")
        self._HttpCode = params.get("HttpCode")
        self._HttpCheckDomain = params.get("HttpCheckDomain")
        self._HttpCheckPath = params.get("HttpCheckPath")
        self._HttpCheckMethod = params.get("HttpCheckMethod")
        self._ContextType = params.get("ContextType")
        self._SendContext = params.get("SendContext")
        self._RecvContext = params.get("RecvContext")
        self._HttpVersion = params.get("HttpVersion")
        self._ExtendedCode = params.get("ExtendedCode")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class TargetGroupInfo(AbstractModel):
    r"""目标组信息

    """

    def __init__(self):
        r"""
        :param _TargetGroupId: <p>目标组ID</p>
        :type TargetGroupId: str
        :param _VpcId: <p>目标组的vpcid</p>
        :type VpcId: str
        :param _TargetGroupName: <p>目标组的名字</p>
        :type TargetGroupName: str
        :param _Port: <p>目标组的默认端口，全监听目标组此字段返回0，表示无效端口。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type Port: int
        :param _CreatedTime: <p>目标组的创建时间</p>
        :type CreatedTime: str
        :param _UpdatedTime: <p>目标组的修改时间</p>
        :type UpdatedTime: str
        :param _AssociatedRule: <p>关联到的规则数组。在DescribeTargetGroupList接口调用时无法获取到该参数。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type AssociatedRule: list of AssociationItem
        :param _Protocol: <p>目标组后端转发协议, 仅v2新版目标组返回有效值。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type Protocol: str
        :param _ScheduleAlgorithm: <p>调度算法，仅后端转发协议为(HTTP、HTTPS、GRPC)的目标组返回有效值， 可选值：<br><ur></p><li>WRR:按权重轮询。</li><li>LEAST_CONN:最小连接数。</li><li>IP_HASH:按IP哈希。</li></ur>
注意：此字段可能返回 null，表示取不到有效值。
        :type ScheduleAlgorithm: str
        :param _HealthCheck: <p>健康检查详情。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type HealthCheck: :class:`tencentcloud.clb.v20180317.models.TargetGroupHealthCheck`
        :param _TargetGroupType: <p>目标组类型，当前支持v1(旧版目标组), v2(新版目标组)。默认为v1旧版目标组。</p>
        :type TargetGroupType: str
        :param _AssociatedRuleCount: <p>目标组已关联的规则数。</p>
        :type AssociatedRuleCount: int
        :param _RegisteredInstancesCount: <p>目标组内的实例数量。</p>
        :type RegisteredInstancesCount: int
        :param _Tag: <p>标签。</p>
        :type Tag: list of TagInfo
        :param _Weight: <p>默认权重。只有v2类型目标组返回该字段。当返回为NULL时， 表示未设置默认权重。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type Weight: int
        :param _FullListenSwitch: <p>是否全监听目标组。</p>
        :type FullListenSwitch: bool
        :param _KeepaliveEnable: <p>是否开启长连接,  仅后端转发协议为HTTP/HTTPS/GRPC目标组返回有效值。</p>
        :type KeepaliveEnable: bool
        :param _SessionExpireTime: <p>会话保持时间，仅后端转发协议为HTTP/HTTPS/GRPC目标组返回有效值。</p>
        :type SessionExpireTime: int
        :param _IpVersion: <p>IP版本。</p>
        :type IpVersion: str
        :param _SnatEnable: <p>是否开启SNAT</p>
        :type SnatEnable: bool
        """
        self._TargetGroupId = None
        self._VpcId = None
        self._TargetGroupName = None
        self._Port = None
        self._CreatedTime = None
        self._UpdatedTime = None
        self._AssociatedRule = None
        self._Protocol = None
        self._ScheduleAlgorithm = None
        self._HealthCheck = None
        self._TargetGroupType = None
        self._AssociatedRuleCount = None
        self._RegisteredInstancesCount = None
        self._Tag = None
        self._Weight = None
        self._FullListenSwitch = None
        self._KeepaliveEnable = None
        self._SessionExpireTime = None
        self._IpVersion = None
        self._SnatEnable = None

    @property
    def TargetGroupId(self):
        r"""<p>目标组ID</p>
        :rtype: str
        """
        return self._TargetGroupId

    @TargetGroupId.setter
    def TargetGroupId(self, TargetGroupId):
        self._TargetGroupId = TargetGroupId

    @property
    def VpcId(self):
        r"""<p>目标组的vpcid</p>
        :rtype: str
        """
        return self._VpcId

    @VpcId.setter
    def VpcId(self, VpcId):
        self._VpcId = VpcId

    @property
    def TargetGroupName(self):
        r"""<p>目标组的名字</p>
        :rtype: str
        """
        return self._TargetGroupName

    @TargetGroupName.setter
    def TargetGroupName(self, TargetGroupName):
        self._TargetGroupName = TargetGroupName

    @property
    def Port(self):
        r"""<p>目标组的默认端口，全监听目标组此字段返回0，表示无效端口。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def CreatedTime(self):
        r"""<p>目标组的创建时间</p>
        :rtype: str
        """
        return self._CreatedTime

    @CreatedTime.setter
    def CreatedTime(self, CreatedTime):
        self._CreatedTime = CreatedTime

    @property
    def UpdatedTime(self):
        r"""<p>目标组的修改时间</p>
        :rtype: str
        """
        return self._UpdatedTime

    @UpdatedTime.setter
    def UpdatedTime(self, UpdatedTime):
        self._UpdatedTime = UpdatedTime

    @property
    def AssociatedRule(self):
        r"""<p>关联到的规则数组。在DescribeTargetGroupList接口调用时无法获取到该参数。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: list of AssociationItem
        """
        return self._AssociatedRule

    @AssociatedRule.setter
    def AssociatedRule(self, AssociatedRule):
        self._AssociatedRule = AssociatedRule

    @property
    def Protocol(self):
        r"""<p>目标组后端转发协议, 仅v2新版目标组返回有效值。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._Protocol

    @Protocol.setter
    def Protocol(self, Protocol):
        self._Protocol = Protocol

    @property
    def ScheduleAlgorithm(self):
        r"""<p>调度算法，仅后端转发协议为(HTTP、HTTPS、GRPC)的目标组返回有效值， 可选值：<br><ur></p><li>WRR:按权重轮询。</li><li>LEAST_CONN:最小连接数。</li><li>IP_HASH:按IP哈希。</li></ur>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._ScheduleAlgorithm

    @ScheduleAlgorithm.setter
    def ScheduleAlgorithm(self, ScheduleAlgorithm):
        self._ScheduleAlgorithm = ScheduleAlgorithm

    @property
    def HealthCheck(self):
        r"""<p>健康检查详情。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: :class:`tencentcloud.clb.v20180317.models.TargetGroupHealthCheck`
        """
        return self._HealthCheck

    @HealthCheck.setter
    def HealthCheck(self, HealthCheck):
        self._HealthCheck = HealthCheck

    @property
    def TargetGroupType(self):
        r"""<p>目标组类型，当前支持v1(旧版目标组), v2(新版目标组)。默认为v1旧版目标组。</p>
        :rtype: str
        """
        return self._TargetGroupType

    @TargetGroupType.setter
    def TargetGroupType(self, TargetGroupType):
        self._TargetGroupType = TargetGroupType

    @property
    def AssociatedRuleCount(self):
        r"""<p>目标组已关联的规则数。</p>
        :rtype: int
        """
        return self._AssociatedRuleCount

    @AssociatedRuleCount.setter
    def AssociatedRuleCount(self, AssociatedRuleCount):
        self._AssociatedRuleCount = AssociatedRuleCount

    @property
    def RegisteredInstancesCount(self):
        r"""<p>目标组内的实例数量。</p>
        :rtype: int
        """
        return self._RegisteredInstancesCount

    @RegisteredInstancesCount.setter
    def RegisteredInstancesCount(self, RegisteredInstancesCount):
        self._RegisteredInstancesCount = RegisteredInstancesCount

    @property
    def Tag(self):
        r"""<p>标签。</p>
        :rtype: list of TagInfo
        """
        return self._Tag

    @Tag.setter
    def Tag(self, Tag):
        self._Tag = Tag

    @property
    def Weight(self):
        r"""<p>默认权重。只有v2类型目标组返回该字段。当返回为NULL时， 表示未设置默认权重。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: int
        """
        return self._Weight

    @Weight.setter
    def Weight(self, Weight):
        self._Weight = Weight

    @property
    def FullListenSwitch(self):
        r"""<p>是否全监听目标组。</p>
        :rtype: bool
        """
        return self._FullListenSwitch

    @FullListenSwitch.setter
    def FullListenSwitch(self, FullListenSwitch):
        self._FullListenSwitch = FullListenSwitch

    @property
    def KeepaliveEnable(self):
        r"""<p>是否开启长连接,  仅后端转发协议为HTTP/HTTPS/GRPC目标组返回有效值。</p>
        :rtype: bool
        """
        return self._KeepaliveEnable

    @KeepaliveEnable.setter
    def KeepaliveEnable(self, KeepaliveEnable):
        self._KeepaliveEnable = KeepaliveEnable

    @property
    def SessionExpireTime(self):
        r"""<p>会话保持时间，仅后端转发协议为HTTP/HTTPS/GRPC目标组返回有效值。</p>
        :rtype: int
        """
        return self._SessionExpireTime

    @SessionExpireTime.setter
    def SessionExpireTime(self, SessionExpireTime):
        self._SessionExpireTime = SessionExpireTime

    @property
    def IpVersion(self):
        r"""<p>IP版本。</p>
        :rtype: str
        """
        return self._IpVersion

    @IpVersion.setter
    def IpVersion(self, IpVersion):
        self._IpVersion = IpVersion

    @property
    def SnatEnable(self):
        r"""<p>是否开启SNAT</p>
        :rtype: bool
        """
        return self._SnatEnable

    @SnatEnable.setter
    def SnatEnable(self, SnatEnable):
        self._SnatEnable = SnatEnable


    def _deserialize(self, params):
        self._TargetGroupId = params.get("TargetGroupId")
        self._VpcId = params.get("VpcId")
        self._TargetGroupName = params.get("TargetGroupName")
        self._Port = params.get("Port")
        self._CreatedTime = params.get("CreatedTime")
        self._UpdatedTime = params.get("UpdatedTime")
        if params.get("AssociatedRule") is not None:
            self._AssociatedRule = []
            for item in params.get("AssociatedRule"):
                obj = AssociationItem()
                obj._deserialize(item)
                self._AssociatedRule.append(obj)
        self._Protocol = params.get("Protocol")
        self._ScheduleAlgorithm = params.get("ScheduleAlgorithm")
        if params.get("HealthCheck") is not None:
            self._HealthCheck = TargetGroupHealthCheck()
            self._HealthCheck._deserialize(params.get("HealthCheck"))
        self._TargetGroupType = params.get("TargetGroupType")
        self._AssociatedRuleCount = params.get("AssociatedRuleCount")
        self._RegisteredInstancesCount = params.get("RegisteredInstancesCount")
        if params.get("Tag") is not None:
            self._Tag = []
            for item in params.get("Tag"):
                obj = TagInfo()
                obj._deserialize(item)
                self._Tag.append(obj)
        self._Weight = params.get("Weight")
        self._FullListenSwitch = params.get("FullListenSwitch")
        self._KeepaliveEnable = params.get("KeepaliveEnable")
        self._SessionExpireTime = params.get("SessionExpireTime")
        self._IpVersion = params.get("IpVersion")
        self._SnatEnable = params.get("SnatEnable")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class TargetGroupInstance(AbstractModel):
    r"""目标组实例

    """

    def __init__(self):
        r"""
        :param _BindIP: 目标组实例的内网IP
        :type BindIP: str
        :param _Port: 目标组实例的端口，全监听目标组不支持传此字段。
        :type Port: int
        :param _Weight: 目标组实例的权重
v2目标组需要配置权重，调用CreateTargetGroup接口创建目标组时该参数与创建接口中的Weight参数必填其一。
取值范围：0-100
        :type Weight: int
        :param _NewPort: 目标组实例的新端口，全监听目标组不支持传此字段。
        :type NewPort: int
        """
        self._BindIP = None
        self._Port = None
        self._Weight = None
        self._NewPort = None

    @property
    def BindIP(self):
        r"""目标组实例的内网IP
        :rtype: str
        """
        return self._BindIP

    @BindIP.setter
    def BindIP(self, BindIP):
        self._BindIP = BindIP

    @property
    def Port(self):
        r"""目标组实例的端口，全监听目标组不支持传此字段。
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def Weight(self):
        r"""目标组实例的权重
v2目标组需要配置权重，调用CreateTargetGroup接口创建目标组时该参数与创建接口中的Weight参数必填其一。
取值范围：0-100
        :rtype: int
        """
        return self._Weight

    @Weight.setter
    def Weight(self, Weight):
        self._Weight = Weight

    @property
    def NewPort(self):
        r"""目标组实例的新端口，全监听目标组不支持传此字段。
        :rtype: int
        """
        return self._NewPort

    @NewPort.setter
    def NewPort(self, NewPort):
        self._NewPort = NewPort


    def _deserialize(self, params):
        self._BindIP = params.get("BindIP")
        self._Port = params.get("Port")
        self._Weight = params.get("Weight")
        self._NewPort = params.get("NewPort")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class TargetGroupInstanceStatus(AbstractModel):
    r"""用于目标组后端rs健康检查状态。

    """

    def __init__(self):
        r"""
        :param _InstanceIp: 后端rs的IP
        :type InstanceIp: str
        :param _Status: 健康检查状态，参数值及含义如下：
● on：表示探测中。
● off：表示健康检查关闭。
● health：表示健康。
● unhealth：表示异常。
        :type Status: str
        :param _InstanceId: 实例ID
        :type InstanceId: str
        :param _Port: 端口
        :type Port: int
        :param _EniId: 网卡ID
注意：此字段可能返回 null，表示取不到有效值。
        :type EniId: str
        """
        self._InstanceIp = None
        self._Status = None
        self._InstanceId = None
        self._Port = None
        self._EniId = None

    @property
    def InstanceIp(self):
        r"""后端rs的IP
        :rtype: str
        """
        return self._InstanceIp

    @InstanceIp.setter
    def InstanceIp(self, InstanceIp):
        self._InstanceIp = InstanceIp

    @property
    def Status(self):
        r"""健康检查状态，参数值及含义如下：
● on：表示探测中。
● off：表示健康检查关闭。
● health：表示健康。
● unhealth：表示异常。
        :rtype: str
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status

    @property
    def InstanceId(self):
        r"""实例ID
        :rtype: str
        """
        return self._InstanceId

    @InstanceId.setter
    def InstanceId(self, InstanceId):
        self._InstanceId = InstanceId

    @property
    def Port(self):
        r"""端口
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def EniId(self):
        r"""网卡ID
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._EniId

    @EniId.setter
    def EniId(self, EniId):
        self._EniId = EniId


    def _deserialize(self, params):
        self._InstanceIp = params.get("InstanceIp")
        self._Status = params.get("Status")
        self._InstanceId = params.get("InstanceId")
        self._Port = params.get("Port")
        self._EniId = params.get("EniId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class TargetHealth(AbstractModel):
    r"""描述一个Target的健康信息

    """

    def __init__(self):
        r"""
        :param _IP: Target的内网IP
        :type IP: str
        :param _Port: Target绑定的端口
        :type Port: int
        :param _HealthStatus: 当前健康状态，true：健康，false：不健康（包括尚未开始探测、探测中、状态异常等几种状态）。只有处于健康状态（且权重大于0），负载均衡才会向其转发流量。
        :type HealthStatus: bool
        :param _TargetId: Target的实例ID，如 ins-12345678
        :type TargetId: str
        :param _HealthStatusDetail: 当前健康状态的详细信息。如：Alive、Dead、Unknown、Close。Alive状态为健康，Dead状态为异常，Unknown状态包括尚未开始探测、探测中、状态未知，Close表示健康检查关闭或监听器状态停止。
        :type HealthStatusDetail: str
        :param _HealthStatusDetial: (**该参数对象即将下线，不推荐使用，请使用HealthStatusDetail获取健康详情**) 当前健康状态的详细信息。如：Alive、Dead、Unknown。Alive状态为健康，Dead状态为异常，Unknown状态包括尚未开始探测、探测中、状态未知。
        :type HealthStatusDetial: str
        :param _TargetGroupId: 目标组唯一ID。
        :type TargetGroupId: str
        :param _Weight: Target的权重。
        :type Weight: int
        """
        self._IP = None
        self._Port = None
        self._HealthStatus = None
        self._TargetId = None
        self._HealthStatusDetail = None
        self._HealthStatusDetial = None
        self._TargetGroupId = None
        self._Weight = None

    @property
    def IP(self):
        r"""Target的内网IP
        :rtype: str
        """
        return self._IP

    @IP.setter
    def IP(self, IP):
        self._IP = IP

    @property
    def Port(self):
        r"""Target绑定的端口
        :rtype: int
        """
        return self._Port

    @Port.setter
    def Port(self, Port):
        self._Port = Port

    @property
    def HealthStatus(self):
        r"""当前健康状态，true：健康，false：不健康（包括尚未开始探测、探测中、状态异常等几种状态）。只有处于健康状态（且权重大于0），负载均衡才会向其转发流量。
        :rtype: bool
        """
        return self._HealthStatus

    @HealthStatus.setter
    def HealthStatus(self, HealthStatus):
        self._HealthStatus = HealthStatus

    @property
    def TargetId(self):
        r"""Target的实例ID，如 ins-12345678
        :rtype: str
        """
        return self._TargetId

    @TargetId.setter
    def TargetId(self, TargetId):
        self._TargetId = TargetId

    @property
    def HealthStatusDetail(self):
        r"""当前健康状态的详细信息。如：Alive、Dead、Unknown、Close。Alive状态为健康，Dead状态为异常，Unknown状态包括尚未开始探测、探测中、状态未知，Close表示健康检查关闭或监听器状态停止。
        :rtype: str
        """
        return self._HealthStatusDetail

    @HealthStatusDetail.setter
    def HealthStatusDetail(self, HealthStatusDetail):
        self._HealthStatusDetail = HealthStatusDetail

    @property
    def HealthStatusDetial(self):
        warnings.warn("parameter `HealthStatusDetial` is deprecated", DeprecationWarning) 

        r"""(**该参数对象即将下线，不推荐使用，请使用HealthStatusDetail获取健康详情**) 当前健康状态的详细信息。如：Alive、Dead、Unknown。Alive状态为健康，Dead状态为异常，Unknown状态包括尚未开始探测、探测中、状态未知。
        :rtype: str
        """
        return self._HealthStatusDetial

    @HealthStatusDetial.setter
    def HealthStatusDetial(self, HealthStatusDetial):
        warnings.warn("parameter `HealthStatusDetial` is deprecated", DeprecationWarning) 

        self._HealthStatusDetial = HealthStatusDetial

    @property
    def TargetGroupId(self):
        r"""目标组唯一ID。
        :rtype: str
        """
        return self._TargetGroupId

    @TargetGroupId.setter
    def TargetGroupId(self, TargetGroupId):
        self._TargetGroupId = TargetGroupId

    @property
    def Weight(self):
        r"""Target的权重。
        :rtype: int
        """
        return self._Weight

    @Weight.setter
    def Weight(self, Weight):
        self._Weight = Weight


    def _deserialize(self, params):
        self._IP = params.get("IP")
        self._Port = params.get("Port")
        self._HealthStatus = params.get("HealthStatus")
        self._TargetId = params.get("TargetId")
        self._HealthStatusDetail = params.get("HealthStatusDetail")
        self._HealthStatusDetial = params.get("HealthStatusDetial")
        self._TargetGroupId = params.get("TargetGroupId")
        self._Weight = params.get("Weight")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class TargetRegionInfo(AbstractModel):
    r"""负载均衡实例所绑定的后端服务的信息，包括所属地域、所属网络。

    """

    def __init__(self):
        r"""
        :param _Region: Target所属地域，如 ap-guangzhou
        :type Region: str
        :param _VpcId: Target所属网络，私有网络格式如 vpc-abcd1234，如果是基础网络，则为"0"
        :type VpcId: str
        :param _NumericalVpcId: Target所属网络，私有网络格式如86323，如果是基础网络，则为0
        :type NumericalVpcId: int
        """
        self._Region = None
        self._VpcId = None
        self._NumericalVpcId = None

    @property
    def Region(self):
        r"""Target所属地域，如 ap-guangzhou
        :rtype: str
        """
        return self._Region

    @Region.setter
    def Region(self, Region):
        self._Region = Region

    @property
    def VpcId(self):
        r"""Target所属网络，私有网络格式如 vpc-abcd1234，如果是基础网络，则为"0"
        :rtype: str
        """
        return self._VpcId

    @VpcId.setter
    def VpcId(self, VpcId):
        self._VpcId = VpcId

    @property
    def NumericalVpcId(self):
        r"""Target所属网络，私有网络格式如86323，如果是基础网络，则为0
        :rtype: int
        """
        return self._NumericalVpcId

    @NumericalVpcId.setter
    def NumericalVpcId(self, NumericalVpcId):
        self._NumericalVpcId = NumericalVpcId


    def _deserialize(self, params):
        self._Region = params.get("Region")
        self._VpcId = params.get("VpcId")
        self._NumericalVpcId = params.get("NumericalVpcId")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class TestConnectionRequestInfo(AbstractModel):
    r"""BYOK健康检查请求

    """

    def __init__(self):
        r"""
        :param _RequestUrl: <p>请求URL</p>
        :type RequestUrl: str
        :param _RequestBody: <p>请求体</p>
        :type RequestBody: str
        :param _RequestHeaders: <p>请求头</p>
        :type RequestHeaders: str
        """
        self._RequestUrl = None
        self._RequestBody = None
        self._RequestHeaders = None

    @property
    def RequestUrl(self):
        r"""<p>请求URL</p>
        :rtype: str
        """
        return self._RequestUrl

    @RequestUrl.setter
    def RequestUrl(self, RequestUrl):
        self._RequestUrl = RequestUrl

    @property
    def RequestBody(self):
        r"""<p>请求体</p>
        :rtype: str
        """
        return self._RequestBody

    @RequestBody.setter
    def RequestBody(self, RequestBody):
        self._RequestBody = RequestBody

    @property
    def RequestHeaders(self):
        r"""<p>请求头</p>
        :rtype: str
        """
        return self._RequestHeaders

    @RequestHeaders.setter
    def RequestHeaders(self, RequestHeaders):
        self._RequestHeaders = RequestHeaders


    def _deserialize(self, params):
        self._RequestUrl = params.get("RequestUrl")
        self._RequestBody = params.get("RequestBody")
        self._RequestHeaders = params.get("RequestHeaders")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class TestModelInputModalitiesRequest(AbstractModel):
    r"""TestModelInputModalities请求参数结构体

    """

    def __init__(self):
        r"""
        :param _Model: <p>待探测的模型（原始模型名称）</p>
        :type Model: str
        :param _ProviderKey: <p>待探测的API Key（明文）</p>
        :type ProviderKey: str
        :param _ProviderKeyId: <p>已创建的BYOK API Key ID（与ProviderKey二选一传入）</p>
        :type ProviderKeyId: str
        :param _AccessType: <p>BYOK类型，当ProviderKey传入时必填</p>
        :type AccessType: str
        :param _ModelProtocol: <p>模型厂商协议，当ProviderKey传入时必填</p>
        :type ModelProtocol: str
        :param _ModelProvider: <p>模型的厂商</p>
        :type ModelProvider: str
        :param _ApiBase: <p>自定义ApiBase，当ProviderKey传入且AccessType且PrivateCustom/PublicCustom时必填</p>
        :type ApiBase: str
        :param _HostHeader: <p>请求携带的Host头部，当AccessType为PrivateCustom时生效</p>
        :type HostHeader: str
        :param _ServiceProviderId: <p>BYOK实例ID，当AccessType为PrivateCustom时生效，ProviderKey传入时必填</p>
        :type ServiceProviderId: str
        :param _VerifySSL: <p>是否校验服务提供商的SSL证书</p><p>PublicBYOK时为True且禁止传入；若传入VerifySSL，则优先同步入参逻辑；若传入了ServiceProviderId则同步已创建的Byok实例该Model的逻辑；否则PublicCustom模式下为True，PrivateCustom模式下为False。</p>
        :type VerifySSL: bool
        """
        self._Model = None
        self._ProviderKey = None
        self._ProviderKeyId = None
        self._AccessType = None
        self._ModelProtocol = None
        self._ModelProvider = None
        self._ApiBase = None
        self._HostHeader = None
        self._ServiceProviderId = None
        self._VerifySSL = None

    @property
    def Model(self):
        r"""<p>待探测的模型（原始模型名称）</p>
        :rtype: str
        """
        return self._Model

    @Model.setter
    def Model(self, Model):
        self._Model = Model

    @property
    def ProviderKey(self):
        r"""<p>待探测的API Key（明文）</p>
        :rtype: str
        """
        return self._ProviderKey

    @ProviderKey.setter
    def ProviderKey(self, ProviderKey):
        self._ProviderKey = ProviderKey

    @property
    def ProviderKeyId(self):
        r"""<p>已创建的BYOK API Key ID（与ProviderKey二选一传入）</p>
        :rtype: str
        """
        return self._ProviderKeyId

    @ProviderKeyId.setter
    def ProviderKeyId(self, ProviderKeyId):
        self._ProviderKeyId = ProviderKeyId

    @property
    def AccessType(self):
        r"""<p>BYOK类型，当ProviderKey传入时必填</p>
        :rtype: str
        """
        return self._AccessType

    @AccessType.setter
    def AccessType(self, AccessType):
        self._AccessType = AccessType

    @property
    def ModelProtocol(self):
        r"""<p>模型厂商协议，当ProviderKey传入时必填</p>
        :rtype: str
        """
        return self._ModelProtocol

    @ModelProtocol.setter
    def ModelProtocol(self, ModelProtocol):
        self._ModelProtocol = ModelProtocol

    @property
    def ModelProvider(self):
        r"""<p>模型的厂商</p>
        :rtype: str
        """
        return self._ModelProvider

    @ModelProvider.setter
    def ModelProvider(self, ModelProvider):
        self._ModelProvider = ModelProvider

    @property
    def ApiBase(self):
        r"""<p>自定义ApiBase，当ProviderKey传入且AccessType且PrivateCustom/PublicCustom时必填</p>
        :rtype: str
        """
        return self._ApiBase

    @ApiBase.setter
    def ApiBase(self, ApiBase):
        self._ApiBase = ApiBase

    @property
    def HostHeader(self):
        r"""<p>请求携带的Host头部，当AccessType为PrivateCustom时生效</p>
        :rtype: str
        """
        return self._HostHeader

    @HostHeader.setter
    def HostHeader(self, HostHeader):
        self._HostHeader = HostHeader

    @property
    def ServiceProviderId(self):
        r"""<p>BYOK实例ID，当AccessType为PrivateCustom时生效，ProviderKey传入时必填</p>
        :rtype: str
        """
        return self._ServiceProviderId

    @ServiceProviderId.setter
    def ServiceProviderId(self, ServiceProviderId):
        self._ServiceProviderId = ServiceProviderId

    @property
    def VerifySSL(self):
        r"""<p>是否校验服务提供商的SSL证书</p><p>PublicBYOK时为True且禁止传入；若传入VerifySSL，则优先同步入参逻辑；若传入了ServiceProviderId则同步已创建的Byok实例该Model的逻辑；否则PublicCustom模式下为True，PrivateCustom模式下为False。</p>
        :rtype: bool
        """
        return self._VerifySSL

    @VerifySSL.setter
    def VerifySSL(self, VerifySSL):
        self._VerifySSL = VerifySSL


    def _deserialize(self, params):
        self._Model = params.get("Model")
        self._ProviderKey = params.get("ProviderKey")
        self._ProviderKeyId = params.get("ProviderKeyId")
        self._AccessType = params.get("AccessType")
        self._ModelProtocol = params.get("ModelProtocol")
        self._ModelProvider = params.get("ModelProvider")
        self._ApiBase = params.get("ApiBase")
        self._HostHeader = params.get("HostHeader")
        self._ServiceProviderId = params.get("ServiceProviderId")
        self._VerifySSL = params.get("VerifySSL")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class TestModelInputModalitiesResponse(AbstractModel):
    r"""TestModelInputModalities返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Model: <p>探测的模型</p>
        :type Model: str
        :param _SupportedModalities: <p>该模型确认支持的输入模态列表</p><p>枚举值：</p><ul><li>text： 支持文本输入</li><li>image： 支持图像输入</li><li>file： 支持文件输入（当前仅支持pdf）</li></ul><p>收到上游大模型对于输入模态的响应即为“确认支持”</p>
        :type SupportedModalities: list of str
        :param _ProbeDetails: <p>每个待探测模态的详细请求结果</p>
        :type ProbeDetails: list of ModalityProbeDetail
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Model = None
        self._SupportedModalities = None
        self._ProbeDetails = None
        self._RequestId = None

    @property
    def Model(self):
        r"""<p>探测的模型</p>
        :rtype: str
        """
        return self._Model

    @Model.setter
    def Model(self, Model):
        self._Model = Model

    @property
    def SupportedModalities(self):
        r"""<p>该模型确认支持的输入模态列表</p><p>枚举值：</p><ul><li>text： 支持文本输入</li><li>image： 支持图像输入</li><li>file： 支持文件输入（当前仅支持pdf）</li></ul><p>收到上游大模型对于输入模态的响应即为“确认支持”</p>
        :rtype: list of str
        """
        return self._SupportedModalities

    @SupportedModalities.setter
    def SupportedModalities(self, SupportedModalities):
        self._SupportedModalities = SupportedModalities

    @property
    def ProbeDetails(self):
        r"""<p>每个待探测模态的详细请求结果</p>
        :rtype: list of ModalityProbeDetail
        """
        return self._ProbeDetails

    @ProbeDetails.setter
    def ProbeDetails(self, ProbeDetails):
        self._ProbeDetails = ProbeDetails

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        self._Model = params.get("Model")
        self._SupportedModalities = params.get("SupportedModalities")
        if params.get("ProbeDetails") is not None:
            self._ProbeDetails = []
            for item in params.get("ProbeDetails"):
                obj = ModalityProbeDetail()
                obj._deserialize(item)
                self._ProbeDetails.append(obj)
        self._RequestId = params.get("RequestId")


class TestServiceProviderConnectionRequest(AbstractModel):
    r"""TestServiceProviderConnection请求参数结构体

    """

    def __init__(self):
        r"""
        :param _Models: <p>需要探测的模型列表</p><p>入参限制：上限为20个模型</p>
        :type Models: list of str
        :param _ProviderKey: <p>需要探测的Key</p>
        :type ProviderKey: str
        :param _ProviderKeyId: <p>需要探测的KeyId，和ProviderKey二者传一个即可</p>
        :type ProviderKeyId: str
        :param _AccessType: <p>BYOK类型，当ProviderKey存在时必传</p>
        :type AccessType: str
        :param _ModelProvider: <p>模型的厂商</p>
        :type ModelProvider: str
        :param _ModelProtocol: <p>模型厂商协议，当ProviderKey存在时必传</p>
        :type ModelProtocol: str
        :param _ApiBase: <p>BYOK类型，当AccessType为PublicCustom时生效</p>
        :type ApiBase: str
        :param _HostHeader: <p>请求携带的Host头部，当AccessType为PrivateCustom时生效</p>
        :type HostHeader: str
        :param _ServiceProviderId: <p>BYOK的ID，当AccessType为PrivateCustom时生效</p>
        :type ServiceProviderId: str
        :param _VerifySSL: <p>是否校验服务提供商的SSL证书</p><p>默认值：AccessType取值为：</p><ul><li>PublicBYOK时，该参数无效；</li><li>PublicCustom时，该参数默认为true；</li><li>PrivateCustom时，该参数默认为false；</li></ul>
        :type VerifySSL: bool
        """
        self._Models = None
        self._ProviderKey = None
        self._ProviderKeyId = None
        self._AccessType = None
        self._ModelProvider = None
        self._ModelProtocol = None
        self._ApiBase = None
        self._HostHeader = None
        self._ServiceProviderId = None
        self._VerifySSL = None

    @property
    def Models(self):
        r"""<p>需要探测的模型列表</p><p>入参限制：上限为20个模型</p>
        :rtype: list of str
        """
        return self._Models

    @Models.setter
    def Models(self, Models):
        self._Models = Models

    @property
    def ProviderKey(self):
        r"""<p>需要探测的Key</p>
        :rtype: str
        """
        return self._ProviderKey

    @ProviderKey.setter
    def ProviderKey(self, ProviderKey):
        self._ProviderKey = ProviderKey

    @property
    def ProviderKeyId(self):
        r"""<p>需要探测的KeyId，和ProviderKey二者传一个即可</p>
        :rtype: str
        """
        return self._ProviderKeyId

    @ProviderKeyId.setter
    def ProviderKeyId(self, ProviderKeyId):
        self._ProviderKeyId = ProviderKeyId

    @property
    def AccessType(self):
        r"""<p>BYOK类型，当ProviderKey存在时必传</p>
        :rtype: str
        """
        return self._AccessType

    @AccessType.setter
    def AccessType(self, AccessType):
        self._AccessType = AccessType

    @property
    def ModelProvider(self):
        r"""<p>模型的厂商</p>
        :rtype: str
        """
        return self._ModelProvider

    @ModelProvider.setter
    def ModelProvider(self, ModelProvider):
        self._ModelProvider = ModelProvider

    @property
    def ModelProtocol(self):
        r"""<p>模型厂商协议，当ProviderKey存在时必传</p>
        :rtype: str
        """
        return self._ModelProtocol

    @ModelProtocol.setter
    def ModelProtocol(self, ModelProtocol):
        self._ModelProtocol = ModelProtocol

    @property
    def ApiBase(self):
        r"""<p>BYOK类型，当AccessType为PublicCustom时生效</p>
        :rtype: str
        """
        return self._ApiBase

    @ApiBase.setter
    def ApiBase(self, ApiBase):
        self._ApiBase = ApiBase

    @property
    def HostHeader(self):
        r"""<p>请求携带的Host头部，当AccessType为PrivateCustom时生效</p>
        :rtype: str
        """
        return self._HostHeader

    @HostHeader.setter
    def HostHeader(self, HostHeader):
        self._HostHeader = HostHeader

    @property
    def ServiceProviderId(self):
        r"""<p>BYOK的ID，当AccessType为PrivateCustom时生效</p>
        :rtype: str
        """
        return self._ServiceProviderId

    @ServiceProviderId.setter
    def ServiceProviderId(self, ServiceProviderId):
        self._ServiceProviderId = ServiceProviderId

    @property
    def VerifySSL(self):
        r"""<p>是否校验服务提供商的SSL证书</p><p>默认值：AccessType取值为：</p><ul><li>PublicBYOK时，该参数无效；</li><li>PublicCustom时，该参数默认为true；</li><li>PrivateCustom时，该参数默认为false；</li></ul>
        :rtype: bool
        """
        return self._VerifySSL

    @VerifySSL.setter
    def VerifySSL(self, VerifySSL):
        self._VerifySSL = VerifySSL


    def _deserialize(self, params):
        self._Models = params.get("Models")
        self._ProviderKey = params.get("ProviderKey")
        self._ProviderKeyId = params.get("ProviderKeyId")
        self._AccessType = params.get("AccessType")
        self._ModelProvider = params.get("ModelProvider")
        self._ModelProtocol = params.get("ModelProtocol")
        self._ApiBase = params.get("ApiBase")
        self._HostHeader = params.get("HostHeader")
        self._ServiceProviderId = params.get("ServiceProviderId")
        self._VerifySSL = params.get("VerifySSL")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class TestServiceProviderConnectionResponse(AbstractModel):
    r"""TestServiceProviderConnection返回参数结构体

    """

    def __init__(self):
        r"""
        :param _Results: <p>探测结果</p>
        :type Results: list of ModelTestResult
        :param _RequestId: 唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :type RequestId: str
        """
        self._Results = None
        self._RequestId = None

    @property
    def Results(self):
        r"""<p>探测结果</p>
        :rtype: list of ModelTestResult
        """
        return self._Results

    @Results.setter
    def Results(self, Results):
        self._Results = Results

    @property
    def RequestId(self):
        r"""唯一请求 ID，由服务端生成，每次请求都会返回（若请求因其他原因未能抵达服务端，则该次请求不会获得 RequestId）。定位问题时需要提供该次请求的 RequestId。
        :rtype: str
        """
        return self._RequestId

    @RequestId.setter
    def RequestId(self, RequestId):
        self._RequestId = RequestId


    def _deserialize(self, params):
        if params.get("Results") is not None:
            self._Results = []
            for item in params.get("Results"):
                obj = ModelTestResult()
                obj._deserialize(item)
                self._Results.append(obj)
        self._RequestId = params.get("RequestId")


class TierItem(AbstractModel):
    r"""意图路由分层配置对象。支持两种分层协议（二选一，不可混用）：① 复杂度分层——必须包含全部 4 个固定分层：SIMPLE/MEDIUM/COMPLEX/REASONING；② 语义分层——包含 default 及各语义 Tier。TierName 取值见下。

    """

    def __init__(self):
        r"""
        :param _Models: <p>该分层下的模型显示名称列表。</p><p>至少包含一个模型，模型名称必须是已关联到该模型路由实例的模型。同一分层内不允许重复模型名称。</p>
        :type Models: list of str
        :param _TierName: <p>Tier 标识。<br>枚举值：</p><ul><li>复杂度分层（4 个固定值，需全部包含）：SIMPLE、MEDIUM、COMPLEX、REASONING</li><li>default：默认</li><li>general_chat：通用对话</li><li>transformation_rewrite：转换与改写</li><li>knowledge_qa：知识问答</li><li>summarization：摘要</li><li>extraction_structuring：抽取与结构化输出</li><li>content_generation：内容生成</li><li>coding_technical：编码与技术</li><li>data_math_analysis：数据、数学与分析</li><li>reasoning_planning：推理与规划</li><li>tool_agentic_workflow：工具与智能体工作流</li></ul>
        :type TierName: str
        """
        self._Models = None
        self._TierName = None

    @property
    def Models(self):
        r"""<p>该分层下的模型显示名称列表。</p><p>至少包含一个模型，模型名称必须是已关联到该模型路由实例的模型。同一分层内不允许重复模型名称。</p>
        :rtype: list of str
        """
        return self._Models

    @Models.setter
    def Models(self, Models):
        self._Models = Models

    @property
    def TierName(self):
        r"""<p>Tier 标识。<br>枚举值：</p><ul><li>复杂度分层（4 个固定值，需全部包含）：SIMPLE、MEDIUM、COMPLEX、REASONING</li><li>default：默认</li><li>general_chat：通用对话</li><li>transformation_rewrite：转换与改写</li><li>knowledge_qa：知识问答</li><li>summarization：摘要</li><li>extraction_structuring：抽取与结构化输出</li><li>content_generation：内容生成</li><li>coding_technical：编码与技术</li><li>data_math_analysis：数据、数学与分析</li><li>reasoning_planning：推理与规划</li><li>tool_agentic_workflow：工具与智能体工作流</li></ul>
        :rtype: str
        """
        return self._TierName

    @TierName.setter
    def TierName(self, TierName):
        self._TierName = TierName


    def _deserialize(self, params):
        self._Models = params.get("Models")
        self._TierName = params.get("TierName")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class TypeInfo(AbstractModel):
    r"""运营商类型信息

    """

    def __init__(self):
        r"""
        :param _Type: 运营商类型
        :type Type: str
        :param _SpecAvailabilitySet: 规格可用性
        :type SpecAvailabilitySet: list of SpecAvailability
        """
        self._Type = None
        self._SpecAvailabilitySet = None

    @property
    def Type(self):
        r"""运营商类型
        :rtype: str
        """
        return self._Type

    @Type.setter
    def Type(self, Type):
        self._Type = Type

    @property
    def SpecAvailabilitySet(self):
        r"""规格可用性
        :rtype: list of SpecAvailability
        """
        return self._SpecAvailabilitySet

    @SpecAvailabilitySet.setter
    def SpecAvailabilitySet(self, SpecAvailabilitySet):
        self._SpecAvailabilitySet = SpecAvailabilitySet


    def _deserialize(self, params):
        self._Type = params.get("Type")
        if params.get("SpecAvailabilitySet") is not None:
            self._SpecAvailabilitySet = []
            for item in params.get("SpecAvailabilitySet"):
                obj = SpecAvailability()
                obj._deserialize(item)
                self._SpecAvailabilitySet.append(obj)
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class UserGroupInfo(AbstractModel):
    r"""用户组信息。

    """

    def __init__(self):
        r"""
        :param _UserGroupId: <p>用户组ID。「未分组」虚拟分组固定为 ugrp-ungrouped。</p>
        :type UserGroupId: str
        :param _UserGroupName: <p>用户组名称。「未分组」虚拟分组固定为 ungrouped。</p>
        :type UserGroupName: str
        :param _ModelRouterId: <p>所属模型路由实例ID。</p>
        :type ModelRouterId: str
        :param _Status: <p>用户组状态。</p><p>枚举值：</p><ul><li>Creating：创建中</li><li>Active：正常</li><li>Configuring：配置中</li><li>Deleting：删除中</li></ul><p>「未分组」虚拟分组（ugrp-ungrouped）恒为 Active。</p>
        :type Status: str
        :param _Models: <p>用户组真实模型白名单。「未分组」虚拟分组为空数组。</p>
        :type Models: list of str
        :param _IntentRouters: <p>用户组意图路由白名单（ir-xxx）。「未分组」虚拟分组为空数组。</p>
        :type IntentRouters: list of str
        :param _BudgetId: <p>关联的Budget ID。</p><p>未关联时为空；「未分组」虚拟分组恒为空。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type BudgetId: str
        :param _BudgetName: <p>关联的Budget名称。</p><p>未关联时为空；「未分组」虚拟分组恒为空。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :type BudgetName: str
        :param _PromptId: <p>关联的提示词 ID。</p><p>未关联时为空；「未分组」虚拟分组恒为空。</p><p>参数格式：pmt-1a2b3c4d</p>
        :type PromptId: str
        :param _PromptVersion: <p>关联的提示词版本。</p><p>未关联时为空；「未分组」虚拟分组恒为空。</p>
        :type PromptVersion: str
        :param _PromptName: <p>关联的提示词名称。</p><p>未关联时为空；「未分组」虚拟分组恒为空。</p>
        :type PromptName: str
        :param _CreditUsageSet: <p>用户组多刷新周期 Credit 使用情况。</p><p>无多周期预算时为空数组。</p>
        :type CreditUsageSet: list of CreditUsage
        :param _KeyCount: <p>用户组当前包含的 Key 数量。「未分组」虚拟分组（ugrp-ungrouped）返回该模型路由实例下未归属任何用户组的 Key 数量。</p>
        :type KeyCount: int
        :param _Tags: <p>标签列表。「未分组」虚拟分组为空数组。</p>
        :type Tags: list of TagInfo
        :param _CreatedTime: <p>创建时间。「未分组」虚拟分组不返回此字段。</p>
        :type CreatedTime: str
        :param _ModifiedTime: <p>修改时间。「未分组」虚拟分组不返回此字段。</p>
        :type ModifiedTime: str
        """
        self._UserGroupId = None
        self._UserGroupName = None
        self._ModelRouterId = None
        self._Status = None
        self._Models = None
        self._IntentRouters = None
        self._BudgetId = None
        self._BudgetName = None
        self._PromptId = None
        self._PromptVersion = None
        self._PromptName = None
        self._CreditUsageSet = None
        self._KeyCount = None
        self._Tags = None
        self._CreatedTime = None
        self._ModifiedTime = None

    @property
    def UserGroupId(self):
        r"""<p>用户组ID。「未分组」虚拟分组固定为 ugrp-ungrouped。</p>
        :rtype: str
        """
        return self._UserGroupId

    @UserGroupId.setter
    def UserGroupId(self, UserGroupId):
        self._UserGroupId = UserGroupId

    @property
    def UserGroupName(self):
        r"""<p>用户组名称。「未分组」虚拟分组固定为 ungrouped。</p>
        :rtype: str
        """
        return self._UserGroupName

    @UserGroupName.setter
    def UserGroupName(self, UserGroupName):
        self._UserGroupName = UserGroupName

    @property
    def ModelRouterId(self):
        r"""<p>所属模型路由实例ID。</p>
        :rtype: str
        """
        return self._ModelRouterId

    @ModelRouterId.setter
    def ModelRouterId(self, ModelRouterId):
        self._ModelRouterId = ModelRouterId

    @property
    def Status(self):
        r"""<p>用户组状态。</p><p>枚举值：</p><ul><li>Creating：创建中</li><li>Active：正常</li><li>Configuring：配置中</li><li>Deleting：删除中</li></ul><p>「未分组」虚拟分组（ugrp-ungrouped）恒为 Active。</p>
        :rtype: str
        """
        return self._Status

    @Status.setter
    def Status(self, Status):
        self._Status = Status

    @property
    def Models(self):
        r"""<p>用户组真实模型白名单。「未分组」虚拟分组为空数组。</p>
        :rtype: list of str
        """
        return self._Models

    @Models.setter
    def Models(self, Models):
        self._Models = Models

    @property
    def IntentRouters(self):
        r"""<p>用户组意图路由白名单（ir-xxx）。「未分组」虚拟分组为空数组。</p>
        :rtype: list of str
        """
        return self._IntentRouters

    @IntentRouters.setter
    def IntentRouters(self, IntentRouters):
        self._IntentRouters = IntentRouters

    @property
    def BudgetId(self):
        r"""<p>关联的Budget ID。</p><p>未关联时为空；「未分组」虚拟分组恒为空。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._BudgetId

    @BudgetId.setter
    def BudgetId(self, BudgetId):
        self._BudgetId = BudgetId

    @property
    def BudgetName(self):
        r"""<p>关联的Budget名称。</p><p>未关联时为空；「未分组」虚拟分组恒为空。</p>
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._BudgetName

    @BudgetName.setter
    def BudgetName(self, BudgetName):
        self._BudgetName = BudgetName

    @property
    def PromptId(self):
        r"""<p>关联的提示词 ID。</p><p>未关联时为空；「未分组」虚拟分组恒为空。</p><p>参数格式：pmt-1a2b3c4d</p>
        :rtype: str
        """
        return self._PromptId

    @PromptId.setter
    def PromptId(self, PromptId):
        self._PromptId = PromptId

    @property
    def PromptVersion(self):
        r"""<p>关联的提示词版本。</p><p>未关联时为空；「未分组」虚拟分组恒为空。</p>
        :rtype: str
        """
        return self._PromptVersion

    @PromptVersion.setter
    def PromptVersion(self, PromptVersion):
        self._PromptVersion = PromptVersion

    @property
    def PromptName(self):
        r"""<p>关联的提示词名称。</p><p>未关联时为空；「未分组」虚拟分组恒为空。</p>
        :rtype: str
        """
        return self._PromptName

    @PromptName.setter
    def PromptName(self, PromptName):
        self._PromptName = PromptName

    @property
    def CreditUsageSet(self):
        r"""<p>用户组多刷新周期 Credit 使用情况。</p><p>无多周期预算时为空数组。</p>
        :rtype: list of CreditUsage
        """
        return self._CreditUsageSet

    @CreditUsageSet.setter
    def CreditUsageSet(self, CreditUsageSet):
        self._CreditUsageSet = CreditUsageSet

    @property
    def KeyCount(self):
        r"""<p>用户组当前包含的 Key 数量。「未分组」虚拟分组（ugrp-ungrouped）返回该模型路由实例下未归属任何用户组的 Key 数量。</p>
        :rtype: int
        """
        return self._KeyCount

    @KeyCount.setter
    def KeyCount(self, KeyCount):
        self._KeyCount = KeyCount

    @property
    def Tags(self):
        r"""<p>标签列表。「未分组」虚拟分组为空数组。</p>
        :rtype: list of TagInfo
        """
        return self._Tags

    @Tags.setter
    def Tags(self, Tags):
        self._Tags = Tags

    @property
    def CreatedTime(self):
        r"""<p>创建时间。「未分组」虚拟分组不返回此字段。</p>
        :rtype: str
        """
        return self._CreatedTime

    @CreatedTime.setter
    def CreatedTime(self, CreatedTime):
        self._CreatedTime = CreatedTime

    @property
    def ModifiedTime(self):
        r"""<p>修改时间。「未分组」虚拟分组不返回此字段。</p>
        :rtype: str
        """
        return self._ModifiedTime

    @ModifiedTime.setter
    def ModifiedTime(self, ModifiedTime):
        self._ModifiedTime = ModifiedTime


    def _deserialize(self, params):
        self._UserGroupId = params.get("UserGroupId")
        self._UserGroupName = params.get("UserGroupName")
        self._ModelRouterId = params.get("ModelRouterId")
        self._Status = params.get("Status")
        self._Models = params.get("Models")
        self._IntentRouters = params.get("IntentRouters")
        self._BudgetId = params.get("BudgetId")
        self._BudgetName = params.get("BudgetName")
        self._PromptId = params.get("PromptId")
        self._PromptVersion = params.get("PromptVersion")
        self._PromptName = params.get("PromptName")
        if params.get("CreditUsageSet") is not None:
            self._CreditUsageSet = []
            for item in params.get("CreditUsageSet"):
                obj = CreditUsage()
                obj._deserialize(item)
                self._CreditUsageSet.append(obj)
        self._KeyCount = params.get("KeyCount")
        if params.get("Tags") is not None:
            self._Tags = []
            for item in params.get("Tags"):
                obj = TagInfo()
                obj._deserialize(item)
                self._Tags.append(obj)
        self._CreatedTime = params.get("CreatedTime")
        self._ModifiedTime = params.get("ModifiedTime")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ZoneInfo(AbstractModel):
    r"""可用区相关信息

    """

    def __init__(self):
        r"""
        :param _ZoneId: 可用区数值形式的唯一ID，如：100001
        :type ZoneId: int
        :param _Zone: 可用区字符串形式的唯一ID，如：ap-guangzhou-1
        :type Zone: str
        :param _ZoneName: 可用区名称，如：广州一区
        :type ZoneName: str
        :param _ZoneRegion: 可用区所属地域，如：ap-guangzhou
        :type ZoneRegion: str
        :param _LocalZone: 可用区是否是LocalZone可用区，如：false
        :type LocalZone: bool
        :param _EdgeZone: 可用区是否是EdgeZone可用区，如：false
        :type EdgeZone: bool
        """
        self._ZoneId = None
        self._Zone = None
        self._ZoneName = None
        self._ZoneRegion = None
        self._LocalZone = None
        self._EdgeZone = None

    @property
    def ZoneId(self):
        r"""可用区数值形式的唯一ID，如：100001
        :rtype: int
        """
        return self._ZoneId

    @ZoneId.setter
    def ZoneId(self, ZoneId):
        self._ZoneId = ZoneId

    @property
    def Zone(self):
        r"""可用区字符串形式的唯一ID，如：ap-guangzhou-1
        :rtype: str
        """
        return self._Zone

    @Zone.setter
    def Zone(self, Zone):
        self._Zone = Zone

    @property
    def ZoneName(self):
        r"""可用区名称，如：广州一区
        :rtype: str
        """
        return self._ZoneName

    @ZoneName.setter
    def ZoneName(self, ZoneName):
        self._ZoneName = ZoneName

    @property
    def ZoneRegion(self):
        r"""可用区所属地域，如：ap-guangzhou
        :rtype: str
        """
        return self._ZoneRegion

    @ZoneRegion.setter
    def ZoneRegion(self, ZoneRegion):
        self._ZoneRegion = ZoneRegion

    @property
    def LocalZone(self):
        r"""可用区是否是LocalZone可用区，如：false
        :rtype: bool
        """
        return self._LocalZone

    @LocalZone.setter
    def LocalZone(self, LocalZone):
        self._LocalZone = LocalZone

    @property
    def EdgeZone(self):
        r"""可用区是否是EdgeZone可用区，如：false
        :rtype: bool
        """
        return self._EdgeZone

    @EdgeZone.setter
    def EdgeZone(self, EdgeZone):
        self._EdgeZone = EdgeZone


    def _deserialize(self, params):
        self._ZoneId = params.get("ZoneId")
        self._Zone = params.get("Zone")
        self._ZoneName = params.get("ZoneName")
        self._ZoneRegion = params.get("ZoneRegion")
        self._LocalZone = params.get("LocalZone")
        self._EdgeZone = params.get("EdgeZone")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        


class ZoneResource(AbstractModel):
    r"""可用区资源列表

    """

    def __init__(self):
        r"""
        :param _MasterZone: 主可用区，如"ap-guangzhou-1"。
        :type MasterZone: str
        :param _ResourceSet: 资源列表。
        :type ResourceSet: list of Resource
        :param _SlaveZone: 备可用区，如"ap-guangzhou-2"，单可用区时，备可用区为null。
注意：此字段可能返回 null，表示取不到有效值。
        :type SlaveZone: str
        :param _IPVersion: IP版本，如IPv4，IPv6，IPv6_Nat。
        :type IPVersion: str
        :param _ZoneRegion: 可用区所属地域，如：ap-guangzhou
        :type ZoneRegion: str
        :param _LocalZone: 可用区是否是LocalZone可用区，如：false
        :type LocalZone: bool
        :param _ZoneResourceType: 可用区资源的类型，SHARED表示共享资源，EXCLUSIVE表示独占资源。
        :type ZoneResourceType: str
        :param _EdgeZone: 可用区是否是EdgeZone可用区，如：false
        :type EdgeZone: bool
        :param _Egress: 网络出口
        :type Egress: str
        """
        self._MasterZone = None
        self._ResourceSet = None
        self._SlaveZone = None
        self._IPVersion = None
        self._ZoneRegion = None
        self._LocalZone = None
        self._ZoneResourceType = None
        self._EdgeZone = None
        self._Egress = None

    @property
    def MasterZone(self):
        r"""主可用区，如"ap-guangzhou-1"。
        :rtype: str
        """
        return self._MasterZone

    @MasterZone.setter
    def MasterZone(self, MasterZone):
        self._MasterZone = MasterZone

    @property
    def ResourceSet(self):
        r"""资源列表。
        :rtype: list of Resource
        """
        return self._ResourceSet

    @ResourceSet.setter
    def ResourceSet(self, ResourceSet):
        self._ResourceSet = ResourceSet

    @property
    def SlaveZone(self):
        r"""备可用区，如"ap-guangzhou-2"，单可用区时，备可用区为null。
注意：此字段可能返回 null，表示取不到有效值。
        :rtype: str
        """
        return self._SlaveZone

    @SlaveZone.setter
    def SlaveZone(self, SlaveZone):
        self._SlaveZone = SlaveZone

    @property
    def IPVersion(self):
        r"""IP版本，如IPv4，IPv6，IPv6_Nat。
        :rtype: str
        """
        return self._IPVersion

    @IPVersion.setter
    def IPVersion(self, IPVersion):
        self._IPVersion = IPVersion

    @property
    def ZoneRegion(self):
        r"""可用区所属地域，如：ap-guangzhou
        :rtype: str
        """
        return self._ZoneRegion

    @ZoneRegion.setter
    def ZoneRegion(self, ZoneRegion):
        self._ZoneRegion = ZoneRegion

    @property
    def LocalZone(self):
        r"""可用区是否是LocalZone可用区，如：false
        :rtype: bool
        """
        return self._LocalZone

    @LocalZone.setter
    def LocalZone(self, LocalZone):
        self._LocalZone = LocalZone

    @property
    def ZoneResourceType(self):
        r"""可用区资源的类型，SHARED表示共享资源，EXCLUSIVE表示独占资源。
        :rtype: str
        """
        return self._ZoneResourceType

    @ZoneResourceType.setter
    def ZoneResourceType(self, ZoneResourceType):
        self._ZoneResourceType = ZoneResourceType

    @property
    def EdgeZone(self):
        r"""可用区是否是EdgeZone可用区，如：false
        :rtype: bool
        """
        return self._EdgeZone

    @EdgeZone.setter
    def EdgeZone(self, EdgeZone):
        self._EdgeZone = EdgeZone

    @property
    def Egress(self):
        r"""网络出口
        :rtype: str
        """
        return self._Egress

    @Egress.setter
    def Egress(self, Egress):
        self._Egress = Egress


    def _deserialize(self, params):
        self._MasterZone = params.get("MasterZone")
        if params.get("ResourceSet") is not None:
            self._ResourceSet = []
            for item in params.get("ResourceSet"):
                obj = Resource()
                obj._deserialize(item)
                self._ResourceSet.append(obj)
        self._SlaveZone = params.get("SlaveZone")
        self._IPVersion = params.get("IPVersion")
        self._ZoneRegion = params.get("ZoneRegion")
        self._LocalZone = params.get("LocalZone")
        self._ZoneResourceType = params.get("ZoneResourceType")
        self._EdgeZone = params.get("EdgeZone")
        self._Egress = params.get("Egress")
        memeber_set = set(params.keys())
        for name, value in vars(self).items():
            property_name = name[1:]
            if property_name in memeber_set:
                memeber_set.remove(property_name)
        if len(memeber_set) > 0:
            warnings.warn("%s fileds are useless." % ",".join(memeber_set))
        