/*
 * Copyright (c) 2017-2019 THL A29 Limited, a Tencent company. 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.
 */

#ifndef TENCENTCLOUD_DAYU_V20180709_MODEL_MODIFYDDOSPOLICYCASEREQUEST_H_
#define TENCENTCLOUD_DAYU_V20180709_MODEL_MODIFYDDOSPOLICYCASEREQUEST_H_

#include <string>
#include <vector>
#include <map>
#include <tencentcloud/core/AbstractModel.h>


namespace TencentCloud
{
    namespace Dayu
    {
        namespace V20180709
        {
            namespace Model
            {
                /**
                * ModifyDDoSPolicyCase request structure.
                */
                class ModifyDDoSPolicyCaseRequest : public AbstractModel
                {
                public:
                    ModifyDDoSPolicyCaseRequest();
                    ~ModifyDDoSPolicyCaseRequest() = default;
                    std::string ToJsonString() const;


                    /**
                     * 获取Anti-DDoS service type. `bgpip`: Anti-DDoS Advanced; `bgp`: Anti-DDoS Pro (single IP); `bgp-multip`: Anti-DDoS Pro (multi-IP), `net`: Anti-DDoS Ultimate
                     * @return Business Anti-DDoS service type. `bgpip`: Anti-DDoS Advanced; `bgp`: Anti-DDoS Pro (single IP); `bgp-multip`: Anti-DDoS Pro (multi-IP), `net`: Anti-DDoS Ultimate
                     */
                    std::string GetBusiness() const;

                    /**
                     * 设置Anti-DDoS service type. `bgpip`: Anti-DDoS Advanced; `bgp`: Anti-DDoS Pro (single IP); `bgp-multip`: Anti-DDoS Pro (multi-IP), `net`: Anti-DDoS Ultimate
                     * @param Business Anti-DDoS service type. `bgpip`: Anti-DDoS Advanced; `bgp`: Anti-DDoS Pro (single IP); `bgp-multip`: Anti-DDoS Pro (multi-IP), `net`: Anti-DDoS Ultimate
                     */
                    void SetBusiness(const std::string& _business);

                    /**
                     * 判断参数 Business 是否已赋值
                     * @return Business 是否已赋值
                     */
                    bool BusinessHasBeenSet() const;

                    /**
                     * 获取Policy scenario ID
                     * @return SceneId Policy scenario ID
                     */
                    std::string GetSceneId() const;

                    /**
                     * 设置Policy scenario ID
                     * @param SceneId Policy scenario ID
                     */
                    void SetSceneId(const std::string& _sceneId);

                    /**
                     * 判断参数 SceneId 是否已赋值
                     * @return SceneId 是否已赋值
                     */
                    bool SceneIdHasBeenSet() const;

                    /**
                     * 获取Development platform. Valid values: [PC (PC client), MOBILE (mobile device), TV (TV), SERVER (server)]
                     * @return PlatformTypes Development platform. Valid values: [PC (PC client), MOBILE (mobile device), TV (TV), SERVER (server)]
                     */
                    std::vector<std::string> GetPlatformTypes() const;

                    /**
                     * 设置Development platform. Valid values: [PC (PC client), MOBILE (mobile device), TV (TV), SERVER (server)]
                     * @param PlatformTypes Development platform. Valid values: [PC (PC client), MOBILE (mobile device), TV (TV), SERVER (server)]
                     */
                    void SetPlatformTypes(const std::vector<std::string>& _platformTypes);

                    /**
                     * 判断参数 PlatformTypes 是否已赋值
                     * @return PlatformTypes 是否已赋值
                     */
                    bool PlatformTypesHasBeenSet() const;

                    /**
                     * 获取Category. Valid values: [WEB (website), GAME (game), APP (application), OTHER (other)]
                     * @return AppType Category. Valid values: [WEB (website), GAME (game), APP (application), OTHER (other)]
                     */
                    std::string GetAppType() const;

                    /**
                     * 设置Category. Valid values: [WEB (website), GAME (game), APP (application), OTHER (other)]
                     * @param AppType Category. Valid values: [WEB (website), GAME (game), APP (application), OTHER (other)]
                     */
                    void SetAppType(const std::string& _appType);

                    /**
                     * 判断参数 AppType 是否已赋值
                     * @return AppType 是否已赋值
                     */
                    bool AppTypeHasBeenSet() const;

                    /**
                     * 获取Application protocol. Valid values: [tcp (TCP protocol), udp (UDP protocol), icmp (ICMP protocol), all (other protocols)]
                     * @return AppProtocols Application protocol. Valid values: [tcp (TCP protocol), udp (UDP protocol), icmp (ICMP protocol), all (other protocols)]
                     */
                    std::vector<std::string> GetAppProtocols() const;

                    /**
                     * 设置Application protocol. Valid values: [tcp (TCP protocol), udp (UDP protocol), icmp (ICMP protocol), all (other protocols)]
                     * @param AppProtocols Application protocol. Valid values: [tcp (TCP protocol), udp (UDP protocol), icmp (ICMP protocol), all (other protocols)]
                     */
                    void SetAppProtocols(const std::vector<std::string>& _appProtocols);

                    /**
                     * 判断参数 AppProtocols 是否已赋值
                     * @return AppProtocols 是否已赋值
                     */
                    bool AppProtocolsHasBeenSet() const;

                    /**
                     * 获取TCP start port. Value range: (0, 65535]
                     * @return TcpSportStart TCP start port. Value range: (0, 65535]
                     */
                    std::string GetTcpSportStart() const;

                    /**
                     * 设置TCP start port. Value range: (0, 65535]
                     * @param TcpSportStart TCP start port. Value range: (0, 65535]
                     */
                    void SetTcpSportStart(const std::string& _tcpSportStart);

                    /**
                     * 判断参数 TcpSportStart 是否已赋值
                     * @return TcpSportStart 是否已赋值
                     */
                    bool TcpSportStartHasBeenSet() const;

                    /**
                     * 获取TCP end port. Value range: (0, 65535). It must be greater than or equal to the TCP start port
                     * @return TcpSportEnd TCP end port. Value range: (0, 65535). It must be greater than or equal to the TCP start port
                     */
                    std::string GetTcpSportEnd() const;

                    /**
                     * 设置TCP end port. Value range: (0, 65535). It must be greater than or equal to the TCP start port
                     * @param TcpSportEnd TCP end port. Value range: (0, 65535). It must be greater than or equal to the TCP start port
                     */
                    void SetTcpSportEnd(const std::string& _tcpSportEnd);

                    /**
                     * 判断参数 TcpSportEnd 是否已赋值
                     * @return TcpSportEnd 是否已赋值
                     */
                    bool TcpSportEndHasBeenSet() const;

                    /**
                     * 获取UDP start port. Value range: (0, 65535]
                     * @return UdpSportStart UDP start port. Value range: (0, 65535]
                     */
                    std::string GetUdpSportStart() const;

                    /**
                     * 设置UDP start port. Value range: (0, 65535]
                     * @param UdpSportStart UDP start port. Value range: (0, 65535]
                     */
                    void SetUdpSportStart(const std::string& _udpSportStart);

                    /**
                     * 判断参数 UdpSportStart 是否已赋值
                     * @return UdpSportStart 是否已赋值
                     */
                    bool UdpSportStartHasBeenSet() const;

                    /**
                     * 获取End UDP business port. Value range: (0, 65535). It must be greater than or equal to the start UDP business port
                     * @return UdpSportEnd End UDP business port. Value range: (0, 65535). It must be greater than or equal to the start UDP business port
                     */
                    std::string GetUdpSportEnd() const;

                    /**
                     * 设置End UDP business port. Value range: (0, 65535). It must be greater than or equal to the start UDP business port
                     * @param UdpSportEnd End UDP business port. Value range: (0, 65535). It must be greater than or equal to the start UDP business port
                     */
                    void SetUdpSportEnd(const std::string& _udpSportEnd);

                    /**
                     * 判断参数 UdpSportEnd 是否已赋值
                     * @return UdpSportEnd 是否已赋值
                     */
                    bool UdpSportEndHasBeenSet() const;

                    /**
                     * 获取Whether there are customers outside Mainland China. Valid values: [no, yes]
                     * @return HasAbroad Whether there are customers outside Mainland China. Valid values: [no, yes]
                     */
                    std::string GetHasAbroad() const;

                    /**
                     * 设置Whether there are customers outside Mainland China. Valid values: [no, yes]
                     * @param HasAbroad Whether there are customers outside Mainland China. Valid values: [no, yes]
                     */
                    void SetHasAbroad(const std::string& _hasAbroad);

                    /**
                     * 判断参数 HasAbroad 是否已赋值
                     * @return HasAbroad 是否已赋值
                     */
                    bool HasAbroadHasBeenSet() const;

                    /**
                     * 获取Whether to actively initiate outbound TCP requests. Valid values: [no, yes]
                     * @return HasInitiateTcp Whether to actively initiate outbound TCP requests. Valid values: [no, yes]
                     */
                    std::string GetHasInitiateTcp() const;

                    /**
                     * 设置Whether to actively initiate outbound TCP requests. Valid values: [no, yes]
                     * @param HasInitiateTcp Whether to actively initiate outbound TCP requests. Valid values: [no, yes]
                     */
                    void SetHasInitiateTcp(const std::string& _hasInitiateTcp);

                    /**
                     * 判断参数 HasInitiateTcp 是否已赋值
                     * @return HasInitiateTcp 是否已赋值
                     */
                    bool HasInitiateTcpHasBeenSet() const;

                    /**
                     * 获取Whether to actively initiate outbound UDP requests. Valid values: [no, yes]
                     * @return HasInitiateUdp Whether to actively initiate outbound UDP requests. Valid values: [no, yes]
                     */
                    std::string GetHasInitiateUdp() const;

                    /**
                     * 设置Whether to actively initiate outbound UDP requests. Valid values: [no, yes]
                     * @param HasInitiateUdp Whether to actively initiate outbound UDP requests. Valid values: [no, yes]
                     */
                    void SetHasInitiateUdp(const std::string& _hasInitiateUdp);

                    /**
                     * 判断参数 HasInitiateUdp 是否已赋值
                     * @return HasInitiateUdp 是否已赋值
                     */
                    bool HasInitiateUdpHasBeenSet() const;

                    /**
                     * 获取Port that actively initiates TCP requests. Value range: (0, 65535]
                     * @return PeerTcpPort Port that actively initiates TCP requests. Value range: (0, 65535]
                     */
                    std::string GetPeerTcpPort() const;

                    /**
                     * 设置Port that actively initiates TCP requests. Value range: (0, 65535]
                     * @param PeerTcpPort Port that actively initiates TCP requests. Value range: (0, 65535]
                     */
                    void SetPeerTcpPort(const std::string& _peerTcpPort);

                    /**
                     * 判断参数 PeerTcpPort 是否已赋值
                     * @return PeerTcpPort 是否已赋值
                     */
                    bool PeerTcpPortHasBeenSet() const;

                    /**
                     * 获取Port that actively initiates UDP requests. Value range: (0, 65535]
                     * @return PeerUdpPort Port that actively initiates UDP requests. Value range: (0, 65535]
                     */
                    std::string GetPeerUdpPort() const;

                    /**
                     * 设置Port that actively initiates UDP requests. Value range: (0, 65535]
                     * @param PeerUdpPort Port that actively initiates UDP requests. Value range: (0, 65535]
                     */
                    void SetPeerUdpPort(const std::string& _peerUdpPort);

                    /**
                     * 判断参数 PeerUdpPort 是否已赋值
                     * @return PeerUdpPort 是否已赋值
                     */
                    bool PeerUdpPortHasBeenSet() const;

                    /**
                     * 获取Fixed feature code of TCP payload. String length limit: 512
                     * @return TcpFootprint Fixed feature code of TCP payload. String length limit: 512
                     */
                    std::string GetTcpFootprint() const;

                    /**
                     * 设置Fixed feature code of TCP payload. String length limit: 512
                     * @param TcpFootprint Fixed feature code of TCP payload. String length limit: 512
                     */
                    void SetTcpFootprint(const std::string& _tcpFootprint);

                    /**
                     * 判断参数 TcpFootprint 是否已赋值
                     * @return TcpFootprint 是否已赋值
                     */
                    bool TcpFootprintHasBeenSet() const;

                    /**
                     * 获取Fixed feature code of UDP payload. String length limit: 512
                     * @return UdpFootprint Fixed feature code of UDP payload. String length limit: 512
                     */
                    std::string GetUdpFootprint() const;

                    /**
                     * 设置Fixed feature code of UDP payload. String length limit: 512
                     * @param UdpFootprint Fixed feature code of UDP payload. String length limit: 512
                     */
                    void SetUdpFootprint(const std::string& _udpFootprint);

                    /**
                     * 判断参数 UdpFootprint 是否已赋值
                     * @return UdpFootprint 是否已赋值
                     */
                    bool UdpFootprintHasBeenSet() const;

                    /**
                     * 获取Web business API URL
                     * @return WebApiUrl Web business API URL
                     */
                    std::vector<std::string> GetWebApiUrl() const;

                    /**
                     * 设置Web business API URL
                     * @param WebApiUrl Web business API URL
                     */
                    void SetWebApiUrl(const std::vector<std::string>& _webApiUrl);

                    /**
                     * 判断参数 WebApiUrl 是否已赋值
                     * @return WebApiUrl 是否已赋值
                     */
                    bool WebApiUrlHasBeenSet() const;

                    /**
                     * 获取Minimum length of TCP business packet. Value range: (0, 1500)
                     * @return MinTcpPackageLen Minimum length of TCP business packet. Value range: (0, 1500)
                     */
                    std::string GetMinTcpPackageLen() const;

                    /**
                     * 设置Minimum length of TCP business packet. Value range: (0, 1500)
                     * @param MinTcpPackageLen Minimum length of TCP business packet. Value range: (0, 1500)
                     */
                    void SetMinTcpPackageLen(const std::string& _minTcpPackageLen);

                    /**
                     * 判断参数 MinTcpPackageLen 是否已赋值
                     * @return MinTcpPackageLen 是否已赋值
                     */
                    bool MinTcpPackageLenHasBeenSet() const;

                    /**
                     * 获取Maximum length of TCP business packet. Value range: (0, 1500). It must be greater than or equal to the minimum length of TCP business packet
                     * @return MaxTcpPackageLen Maximum length of TCP business packet. Value range: (0, 1500). It must be greater than or equal to the minimum length of TCP business packet
                     */
                    std::string GetMaxTcpPackageLen() const;

                    /**
                     * 设置Maximum length of TCP business packet. Value range: (0, 1500). It must be greater than or equal to the minimum length of TCP business packet
                     * @param MaxTcpPackageLen Maximum length of TCP business packet. Value range: (0, 1500). It must be greater than or equal to the minimum length of TCP business packet
                     */
                    void SetMaxTcpPackageLen(const std::string& _maxTcpPackageLen);

                    /**
                     * 判断参数 MaxTcpPackageLen 是否已赋值
                     * @return MaxTcpPackageLen 是否已赋值
                     */
                    bool MaxTcpPackageLenHasBeenSet() const;

                    /**
                     * 获取Minimum length of UDP business packet. Value range: (0, 1500)
                     * @return MinUdpPackageLen Minimum length of UDP business packet. Value range: (0, 1500)
                     */
                    std::string GetMinUdpPackageLen() const;

                    /**
                     * 设置Minimum length of UDP business packet. Value range: (0, 1500)
                     * @param MinUdpPackageLen Minimum length of UDP business packet. Value range: (0, 1500)
                     */
                    void SetMinUdpPackageLen(const std::string& _minUdpPackageLen);

                    /**
                     * 判断参数 MinUdpPackageLen 是否已赋值
                     * @return MinUdpPackageLen 是否已赋值
                     */
                    bool MinUdpPackageLenHasBeenSet() const;

                    /**
                     * 获取Maximum length of UDP business packet. Value range: (0, 1500). It must be greater than or equal to the minimum length of UDP business packet
                     * @return MaxUdpPackageLen Maximum length of UDP business packet. Value range: (0, 1500). It must be greater than or equal to the minimum length of UDP business packet
                     */
                    std::string GetMaxUdpPackageLen() const;

                    /**
                     * 设置Maximum length of UDP business packet. Value range: (0, 1500). It must be greater than or equal to the minimum length of UDP business packet
                     * @param MaxUdpPackageLen Maximum length of UDP business packet. Value range: (0, 1500). It must be greater than or equal to the minimum length of UDP business packet
                     */
                    void SetMaxUdpPackageLen(const std::string& _maxUdpPackageLen);

                    /**
                     * 判断参数 MaxUdpPackageLen 是否已赋值
                     * @return MaxUdpPackageLen 是否已赋值
                     */
                    bool MaxUdpPackageLenHasBeenSet() const;

                    /**
                     * 获取Whether there are VPN businesses. Valid values: [no, yes]
                     * @return HasVPN Whether there are VPN businesses. Valid values: [no, yes]
                     */
                    std::string GetHasVPN() const;

                    /**
                     * 设置Whether there are VPN businesses. Valid values: [no, yes]
                     * @param HasVPN Whether there are VPN businesses. Valid values: [no, yes]
                     */
                    void SetHasVPN(const std::string& _hasVPN);

                    /**
                     * 判断参数 HasVPN 是否已赋值
                     * @return HasVPN 是否已赋值
                     */
                    bool HasVPNHasBeenSet() const;

                    /**
                     * 获取TCP business port list. Individual ports and port ranges are supported, which should be in string type, such as 80,443,700-800,53,1000-3000
                     * @return TcpPortList TCP business port list. Individual ports and port ranges are supported, which should be in string type, such as 80,443,700-800,53,1000-3000
                     */
                    std::string GetTcpPortList() const;

                    /**
                     * 设置TCP business port list. Individual ports and port ranges are supported, which should be in string type, such as 80,443,700-800,53,1000-3000
                     * @param TcpPortList TCP business port list. Individual ports and port ranges are supported, which should be in string type, such as 80,443,700-800,53,1000-3000
                     */
                    void SetTcpPortList(const std::string& _tcpPortList);

                    /**
                     * 判断参数 TcpPortList 是否已赋值
                     * @return TcpPortList 是否已赋值
                     */
                    bool TcpPortListHasBeenSet() const;

                    /**
                     * 获取UDP business port list. Individual ports and port ranges are supported, which should be in string type, such as 80,443,700-800,53,1000-3000
                     * @return UdpPortList UDP business port list. Individual ports and port ranges are supported, which should be in string type, such as 80,443,700-800,53,1000-3000
                     */
                    std::string GetUdpPortList() const;

                    /**
                     * 设置UDP business port list. Individual ports and port ranges are supported, which should be in string type, such as 80,443,700-800,53,1000-3000
                     * @param UdpPortList UDP business port list. Individual ports and port ranges are supported, which should be in string type, such as 80,443,700-800,53,1000-3000
                     */
                    void SetUdpPortList(const std::string& _udpPortList);

                    /**
                     * 判断参数 UdpPortList 是否已赋值
                     * @return UdpPortList 是否已赋值
                     */
                    bool UdpPortListHasBeenSet() const;

                private:

                    /**
                     * Anti-DDoS service type. `bgpip`: Anti-DDoS Advanced; `bgp`: Anti-DDoS Pro (single IP); `bgp-multip`: Anti-DDoS Pro (multi-IP), `net`: Anti-DDoS Ultimate
                     */
                    std::string m_business;
                    bool m_businessHasBeenSet;

                    /**
                     * Policy scenario ID
                     */
                    std::string m_sceneId;
                    bool m_sceneIdHasBeenSet;

                    /**
                     * Development platform. Valid values: [PC (PC client), MOBILE (mobile device), TV (TV), SERVER (server)]
                     */
                    std::vector<std::string> m_platformTypes;
                    bool m_platformTypesHasBeenSet;

                    /**
                     * Category. Valid values: [WEB (website), GAME (game), APP (application), OTHER (other)]
                     */
                    std::string m_appType;
                    bool m_appTypeHasBeenSet;

                    /**
                     * Application protocol. Valid values: [tcp (TCP protocol), udp (UDP protocol), icmp (ICMP protocol), all (other protocols)]
                     */
                    std::vector<std::string> m_appProtocols;
                    bool m_appProtocolsHasBeenSet;

                    /**
                     * TCP start port. Value range: (0, 65535]
                     */
                    std::string m_tcpSportStart;
                    bool m_tcpSportStartHasBeenSet;

                    /**
                     * TCP end port. Value range: (0, 65535). It must be greater than or equal to the TCP start port
                     */
                    std::string m_tcpSportEnd;
                    bool m_tcpSportEndHasBeenSet;

                    /**
                     * UDP start port. Value range: (0, 65535]
                     */
                    std::string m_udpSportStart;
                    bool m_udpSportStartHasBeenSet;

                    /**
                     * End UDP business port. Value range: (0, 65535). It must be greater than or equal to the start UDP business port
                     */
                    std::string m_udpSportEnd;
                    bool m_udpSportEndHasBeenSet;

                    /**
                     * Whether there are customers outside Mainland China. Valid values: [no, yes]
                     */
                    std::string m_hasAbroad;
                    bool m_hasAbroadHasBeenSet;

                    /**
                     * Whether to actively initiate outbound TCP requests. Valid values: [no, yes]
                     */
                    std::string m_hasInitiateTcp;
                    bool m_hasInitiateTcpHasBeenSet;

                    /**
                     * Whether to actively initiate outbound UDP requests. Valid values: [no, yes]
                     */
                    std::string m_hasInitiateUdp;
                    bool m_hasInitiateUdpHasBeenSet;

                    /**
                     * Port that actively initiates TCP requests. Value range: (0, 65535]
                     */
                    std::string m_peerTcpPort;
                    bool m_peerTcpPortHasBeenSet;

                    /**
                     * Port that actively initiates UDP requests. Value range: (0, 65535]
                     */
                    std::string m_peerUdpPort;
                    bool m_peerUdpPortHasBeenSet;

                    /**
                     * Fixed feature code of TCP payload. String length limit: 512
                     */
                    std::string m_tcpFootprint;
                    bool m_tcpFootprintHasBeenSet;

                    /**
                     * Fixed feature code of UDP payload. String length limit: 512
                     */
                    std::string m_udpFootprint;
                    bool m_udpFootprintHasBeenSet;

                    /**
                     * Web business API URL
                     */
                    std::vector<std::string> m_webApiUrl;
                    bool m_webApiUrlHasBeenSet;

                    /**
                     * Minimum length of TCP business packet. Value range: (0, 1500)
                     */
                    std::string m_minTcpPackageLen;
                    bool m_minTcpPackageLenHasBeenSet;

                    /**
                     * Maximum length of TCP business packet. Value range: (0, 1500). It must be greater than or equal to the minimum length of TCP business packet
                     */
                    std::string m_maxTcpPackageLen;
                    bool m_maxTcpPackageLenHasBeenSet;

                    /**
                     * Minimum length of UDP business packet. Value range: (0, 1500)
                     */
                    std::string m_minUdpPackageLen;
                    bool m_minUdpPackageLenHasBeenSet;

                    /**
                     * Maximum length of UDP business packet. Value range: (0, 1500). It must be greater than or equal to the minimum length of UDP business packet
                     */
                    std::string m_maxUdpPackageLen;
                    bool m_maxUdpPackageLenHasBeenSet;

                    /**
                     * Whether there are VPN businesses. Valid values: [no, yes]
                     */
                    std::string m_hasVPN;
                    bool m_hasVPNHasBeenSet;

                    /**
                     * TCP business port list. Individual ports and port ranges are supported, which should be in string type, such as 80,443,700-800,53,1000-3000
                     */
                    std::string m_tcpPortList;
                    bool m_tcpPortListHasBeenSet;

                    /**
                     * UDP business port list. Individual ports and port ranges are supported, which should be in string type, such as 80,443,700-800,53,1000-3000
                     */
                    std::string m_udpPortList;
                    bool m_udpPortListHasBeenSet;

                };
            }
        }
    }
}

#endif // !TENCENTCLOUD_DAYU_V20180709_MODEL_MODIFYDDOSPOLICYCASEREQUEST_H_
