1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

由丰鲁成发起的SLB SDK自动发布, BUILD_ID=343, 版本号：升级小版本

Browse Source 
发布日志：
1, First release slb for C++
This commit is contained in:
haowei.yao
2018-01-10 15:40:38 +08:00
parent 83a5d98a83
commit 8002c9424e
289 changed files with 30814 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

609
slb/include/alibabacloud/slb/SlbClient.h Normal file
View File

@@ -0,0 +1,609 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_SLBCLIENT_H_
#define ALIBABACLOUD_SLB_SLBCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "SlbExport.h"
#include "model/CreateLoadBalancerUDPListenerRequest.h"
#include "model/CreateLoadBalancerUDPListenerResult.h"
#include "model/DescribeMasterSlaveVServerGroupsRequest.h"
#include "model/DescribeMasterSlaveVServerGroupsResult.h"
#include "model/StartLoadBalancerListenerRequest.h"
#include "model/StartLoadBalancerListenerResult.h"
#include "model/DescribeLoadBalancerTCPListenerAttributeRequest.h"
#include "model/DescribeLoadBalancerTCPListenerAttributeResult.h"
#include "model/DescribeListenerAccessControlAttributeRequest.h"
#include "model/DescribeListenerAccessControlAttributeResult.h"
#include "model/StopLoadBalancerListenerRequest.h"
#include "model/StopLoadBalancerListenerResult.h"
#include "model/SetLoadBalancerStatusRequest.h"
#include "model/SetLoadBalancerStatusResult.h"
#include "model/ModifyLoadBalancerInstanceSpecRequest.h"
#include "model/ModifyLoadBalancerInstanceSpecResult.h"
#include "model/MoveResourceGroupRequest.h"
#include "model/MoveResourceGroupResult.h"
#include "model/SetLoadBalancerTCPListenerAttributeRequest.h"
#include "model/SetLoadBalancerTCPListenerAttributeResult.h"
#include "model/DeleteVServerGroupRequest.h"
#include "model/DeleteVServerGroupResult.h"
#include "model/DescribeVServerGroupAttributeRequest.h"
#include "model/DescribeVServerGroupAttributeResult.h"
#include "model/AddListenerWhiteListItemRequest.h"
#include "model/AddListenerWhiteListItemResult.h"
#include "model/RemoveTagsRequest.h"
#include "model/RemoveTagsResult.h"
#include "model/CreateLoadBalancerRequest.h"
#include "model/CreateLoadBalancerResult.h"
#include "model/SetLoadBalancerHTTPListenerAttributeRequest.h"
#include "model/SetLoadBalancerHTTPListenerAttributeResult.h"
#include "model/SetLoadBalancerAutoReleaseTimeRequest.h"
#include "model/SetLoadBalancerAutoReleaseTimeResult.h"
#include "model/SetListenerAccessControlStatusRequest.h"
#include "model/SetListenerAccessControlStatusResult.h"
#include "model/UploadCACertificateRequest.h"
#include "model/UploadCACertificateResult.h"
#include "model/DescribeZonesRequest.h"
#include "model/DescribeZonesResult.h"
#include "model/SetLoadBalancerHTTPSListenerAttributeRequest.h"
#include "model/SetLoadBalancerHTTPSListenerAttributeResult.h"
#include "model/DeleteLoadBalancerListenerRequest.h"
#include "model/DeleteLoadBalancerListenerResult.h"
#include "model/DescribeVServerGroupsRequest.h"
#include "model/DescribeVServerGroupsResult.h"
#include "model/DescribeLoadBalancerHTTPListenerAttributeRequest.h"
#include "model/DescribeLoadBalancerHTTPListenerAttributeResult.h"
#include "model/DescribeTagsRequest.h"
#include "model/DescribeTagsResult.h"
#include "model/DeleteLoadBalancerRequest.h"
#include "model/DeleteLoadBalancerResult.h"
#include "model/CreateVServerGroupRequest.h"
#include "model/CreateVServerGroupResult.h"
#include "model/DescribeLoadBalancersRelatedEcsRequest.h"
#include "model/DescribeLoadBalancersRelatedEcsResult.h"
#include "model/DescribeLoadBalancersRequest.h"
#include "model/DescribeLoadBalancersResult.h"
#include "model/SetCACertificateNameRequest.h"
#include "model/SetCACertificateNameResult.h"
#include "model/DescribeMasterSlaveVServerGroupAttributeRequest.h"
#include "model/DescribeMasterSlaveVServerGroupAttributeResult.h"
#include "model/CreateLoadBalancerHTTPListenerRequest.h"
#include "model/CreateLoadBalancerHTTPListenerResult.h"
#include "model/RemoveBackendServersRequest.h"
#include "model/RemoveBackendServersResult.h"
#include "model/ModifyVServerGroupBackendServersRequest.h"
#include "model/ModifyVServerGroupBackendServersResult.h"
#include "model/DescribeLoadBalancerUDPListenerAttributeRequest.h"
#include "model/DescribeLoadBalancerUDPListenerAttributeResult.h"
#include "model/DeleteRulesRequest.h"
#include "model/DeleteRulesResult.h"
#include "model/DeleteMasterSlaveVServerGroupRequest.h"
#include "model/DeleteMasterSlaveVServerGroupResult.h"
#include "model/DescribeCACertificatesRequest.h"
#include "model/DescribeCACertificatesResult.h"
#include "model/CreateMasterSlaveVServerGroupRequest.h"
#include "model/CreateMasterSlaveVServerGroupResult.h"
#include "model/SetBackendServersRequest.h"
#include "model/SetBackendServersResult.h"
#include "model/RemoveVServerGroupBackendServersRequest.h"
#include "model/RemoveVServerGroupBackendServersResult.h"
#include "model/DescribeLoadBalancerAttributeRequest.h"
#include "model/DescribeLoadBalancerAttributeResult.h"
#include "model/CreateMasterSlaveServerGroupRequest.h"
#include "model/CreateMasterSlaveServerGroupResult.h"
#include "model/SetServerCertificateNameRequest.h"
#include "model/SetServerCertificateNameResult.h"
#include "model/DeleteCACertificateRequest.h"
#include "model/DeleteCACertificateResult.h"
#include "model/CreateLoadBalancerTCPListenerRequest.h"
#include "model/CreateLoadBalancerTCPListenerResult.h"
#include "model/SetRuleRequest.h"
#include "model/SetRuleResult.h"
#include "model/DescribeMasterSlaveServerGroupsRequest.h"
#include "model/DescribeMasterSlaveServerGroupsResult.h"
#include "model/DescribeHealthStatusRequest.h"
#include "model/DescribeHealthStatusResult.h"
#include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h"
#include "model/RemoveListenerWhiteListItemRequest.h"
#include "model/RemoveListenerWhiteListItemResult.h"
#include "model/CreateLoadBalancerHTTPSListenerRequest.h"
#include "model/CreateLoadBalancerHTTPSListenerResult.h"
#include "model/DeleteMasterSlaveServerGroupRequest.h"
#include "model/DeleteMasterSlaveServerGroupResult.h"
#include "model/DescribeServerCertificatesRequest.h"
#include "model/DescribeServerCertificatesResult.h"
#include "model/DescribeRulesRequest.h"
#include "model/DescribeRulesResult.h"
#include "model/DescribeRuleAttributeRequest.h"
#include "model/DescribeRuleAttributeResult.h"
#include "model/UploadServerCertificateRequest.h"
#include "model/UploadServerCertificateResult.h"
#include "model/DescribeLoadBalancerAutoReleaseTimeRequest.h"
#include "model/DescribeLoadBalancerAutoReleaseTimeResult.h"
#include "model/DeleteServerCertificateRequest.h"
#include "model/DeleteServerCertificateResult.h"
#include "model/SetLoadBalancerNameRequest.h"
#include "model/SetLoadBalancerNameResult.h"
#include "model/SetVServerGroupAttributeRequest.h"
#include "model/SetVServerGroupAttributeResult.h"
#include "model/ModifyLoadBalancerInternetSpecRequest.h"
#include "model/ModifyLoadBalancerInternetSpecResult.h"
#include "model/DescribeLoadBalancerHTTPSListenerAttributeRequest.h"
#include "model/DescribeLoadBalancerHTTPSListenerAttributeResult.h"
#include "model/DescribeMasterSlaveServerGroupAttributeRequest.h"
#include "model/DescribeMasterSlaveServerGroupAttributeResult.h"
#include "model/AddTagsRequest.h"
#include "model/AddTagsResult.h"
#include "model/ModifyLoadBalancerPayTypeRequest.h"
#include "model/ModifyLoadBalancerPayTypeResult.h"
#include "model/AddBackendServersRequest.h"
#include "model/AddBackendServersResult.h"
#include "model/CreateRulesRequest.h"
#include "model/CreateRulesResult.h"
#include "model/AddVServerGroupBackendServersRequest.h"
#include "model/AddVServerGroupBackendServersResult.h"
#include "model/SetLoadBalancerUDPListenerAttributeRequest.h"
#include "model/SetLoadBalancerUDPListenerAttributeResult.h"
namespace AlibabaCloud
{
namespace Slb
{
class ALIBABACLOUD_SLB_EXPORT SlbClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::CreateLoadBalancerUDPListenerResult> CreateLoadBalancerUDPListenerOutcome;
typedef std::future<CreateLoadBalancerUDPListenerOutcome> CreateLoadBalancerUDPListenerOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateLoadBalancerUDPListenerRequest&, const CreateLoadBalancerUDPListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLoadBalancerUDPListenerAsyncHandler;
typedef Outcome<Error, Model::DescribeMasterSlaveVServerGroupsResult> DescribeMasterSlaveVServerGroupsOutcome;
typedef std::future<DescribeMasterSlaveVServerGroupsOutcome> DescribeMasterSlaveVServerGroupsOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeMasterSlaveVServerGroupsRequest&, const DescribeMasterSlaveVServerGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMasterSlaveVServerGroupsAsyncHandler;
typedef Outcome<Error, Model::StartLoadBalancerListenerResult> StartLoadBalancerListenerOutcome;
typedef std::future<StartLoadBalancerListenerOutcome> StartLoadBalancerListenerOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::StartLoadBalancerListenerRequest&, const StartLoadBalancerListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartLoadBalancerListenerAsyncHandler;
typedef Outcome<Error, Model::DescribeLoadBalancerTCPListenerAttributeResult> DescribeLoadBalancerTCPListenerAttributeOutcome;
typedef std::future<DescribeLoadBalancerTCPListenerAttributeOutcome> DescribeLoadBalancerTCPListenerAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancerTCPListenerAttributeRequest&, const DescribeLoadBalancerTCPListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancerTCPListenerAttributeAsyncHandler;
typedef Outcome<Error, Model::DescribeListenerAccessControlAttributeResult> DescribeListenerAccessControlAttributeOutcome;
typedef std::future<DescribeListenerAccessControlAttributeOutcome> DescribeListenerAccessControlAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeListenerAccessControlAttributeRequest&, const DescribeListenerAccessControlAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeListenerAccessControlAttributeAsyncHandler;
typedef Outcome<Error, Model::StopLoadBalancerListenerResult> StopLoadBalancerListenerOutcome;
typedef std::future<StopLoadBalancerListenerOutcome> StopLoadBalancerListenerOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::StopLoadBalancerListenerRequest&, const StopLoadBalancerListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopLoadBalancerListenerAsyncHandler;
typedef Outcome<Error, Model::SetLoadBalancerStatusResult> SetLoadBalancerStatusOutcome;
typedef std::future<SetLoadBalancerStatusOutcome> SetLoadBalancerStatusOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerStatusRequest&, const SetLoadBalancerStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerStatusAsyncHandler;
typedef Outcome<Error, Model::ModifyLoadBalancerInstanceSpecResult> ModifyLoadBalancerInstanceSpecOutcome;
typedef std::future<ModifyLoadBalancerInstanceSpecOutcome> ModifyLoadBalancerInstanceSpecOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::ModifyLoadBalancerInstanceSpecRequest&, const ModifyLoadBalancerInstanceSpecOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyLoadBalancerInstanceSpecAsyncHandler;
typedef Outcome<Error, Model::MoveResourceGroupResult> MoveResourceGroupOutcome;
typedef std::future<MoveResourceGroupOutcome> MoveResourceGroupOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::MoveResourceGroupRequest&, const MoveResourceGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MoveResourceGroupAsyncHandler;
typedef Outcome<Error, Model::SetLoadBalancerTCPListenerAttributeResult> SetLoadBalancerTCPListenerAttributeOutcome;
typedef std::future<SetLoadBalancerTCPListenerAttributeOutcome> SetLoadBalancerTCPListenerAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerTCPListenerAttributeRequest&, const SetLoadBalancerTCPListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerTCPListenerAttributeAsyncHandler;
typedef Outcome<Error, Model::DeleteVServerGroupResult> DeleteVServerGroupOutcome;
typedef std::future<DeleteVServerGroupOutcome> DeleteVServerGroupOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteVServerGroupRequest&, const DeleteVServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVServerGroupAsyncHandler;
typedef Outcome<Error, Model::DescribeVServerGroupAttributeResult> DescribeVServerGroupAttributeOutcome;
typedef std::future<DescribeVServerGroupAttributeOutcome> DescribeVServerGroupAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeVServerGroupAttributeRequest&, const DescribeVServerGroupAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVServerGroupAttributeAsyncHandler;
typedef Outcome<Error, Model::AddListenerWhiteListItemResult> AddListenerWhiteListItemOutcome;
typedef std::future<AddListenerWhiteListItemOutcome> AddListenerWhiteListItemOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::AddListenerWhiteListItemRequest&, const AddListenerWhiteListItemOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddListenerWhiteListItemAsyncHandler;
typedef Outcome<Error, Model::RemoveTagsResult> RemoveTagsOutcome;
typedef std::future<RemoveTagsOutcome> RemoveTagsOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::RemoveTagsRequest&, const RemoveTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveTagsAsyncHandler;
typedef Outcome<Error, Model::CreateLoadBalancerResult> CreateLoadBalancerOutcome;
typedef std::future<CreateLoadBalancerOutcome> CreateLoadBalancerOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateLoadBalancerRequest&, const CreateLoadBalancerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLoadBalancerAsyncHandler;
typedef Outcome<Error, Model::SetLoadBalancerHTTPListenerAttributeResult> SetLoadBalancerHTTPListenerAttributeOutcome;
typedef std::future<SetLoadBalancerHTTPListenerAttributeOutcome> SetLoadBalancerHTTPListenerAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerHTTPListenerAttributeRequest&, const SetLoadBalancerHTTPListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerHTTPListenerAttributeAsyncHandler;
typedef Outcome<Error, Model::SetLoadBalancerAutoReleaseTimeResult> SetLoadBalancerAutoReleaseTimeOutcome;
typedef std::future<SetLoadBalancerAutoReleaseTimeOutcome> SetLoadBalancerAutoReleaseTimeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerAutoReleaseTimeRequest&, const SetLoadBalancerAutoReleaseTimeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerAutoReleaseTimeAsyncHandler;
typedef Outcome<Error, Model::SetListenerAccessControlStatusResult> SetListenerAccessControlStatusOutcome;
typedef std::future<SetListenerAccessControlStatusOutcome> SetListenerAccessControlStatusOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetListenerAccessControlStatusRequest&, const SetListenerAccessControlStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetListenerAccessControlStatusAsyncHandler;
typedef Outcome<Error, Model::UploadCACertificateResult> UploadCACertificateOutcome;
typedef std::future<UploadCACertificateOutcome> UploadCACertificateOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::UploadCACertificateRequest&, const UploadCACertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UploadCACertificateAsyncHandler;
typedef Outcome<Error, Model::DescribeZonesResult> DescribeZonesOutcome;
typedef std::future<DescribeZonesOutcome> DescribeZonesOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeZonesRequest&, const DescribeZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeZonesAsyncHandler;
typedef Outcome<Error, Model::SetLoadBalancerHTTPSListenerAttributeResult> SetLoadBalancerHTTPSListenerAttributeOutcome;
typedef std::future<SetLoadBalancerHTTPSListenerAttributeOutcome> SetLoadBalancerHTTPSListenerAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerHTTPSListenerAttributeRequest&, const SetLoadBalancerHTTPSListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerHTTPSListenerAttributeAsyncHandler;
typedef Outcome<Error, Model::DeleteLoadBalancerListenerResult> DeleteLoadBalancerListenerOutcome;
typedef std::future<DeleteLoadBalancerListenerOutcome> DeleteLoadBalancerListenerOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteLoadBalancerListenerRequest&, const DeleteLoadBalancerListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLoadBalancerListenerAsyncHandler;
typedef Outcome<Error, Model::DescribeVServerGroupsResult> DescribeVServerGroupsOutcome;
typedef std::future<DescribeVServerGroupsOutcome> DescribeVServerGroupsOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeVServerGroupsRequest&, const DescribeVServerGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVServerGroupsAsyncHandler;
typedef Outcome<Error, Model::DescribeLoadBalancerHTTPListenerAttributeResult> DescribeLoadBalancerHTTPListenerAttributeOutcome;
typedef std::future<DescribeLoadBalancerHTTPListenerAttributeOutcome> DescribeLoadBalancerHTTPListenerAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancerHTTPListenerAttributeRequest&, const DescribeLoadBalancerHTTPListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancerHTTPListenerAttributeAsyncHandler;
typedef Outcome<Error, Model::DescribeTagsResult> DescribeTagsOutcome;
typedef std::future<DescribeTagsOutcome> DescribeTagsOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeTagsRequest&, const DescribeTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTagsAsyncHandler;
typedef Outcome<Error, Model::DeleteLoadBalancerResult> DeleteLoadBalancerOutcome;
typedef std::future<DeleteLoadBalancerOutcome> DeleteLoadBalancerOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteLoadBalancerRequest&, const DeleteLoadBalancerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLoadBalancerAsyncHandler;
typedef Outcome<Error, Model::CreateVServerGroupResult> CreateVServerGroupOutcome;
typedef std::future<CreateVServerGroupOutcome> CreateVServerGroupOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateVServerGroupRequest&, const CreateVServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVServerGroupAsyncHandler;
typedef Outcome<Error, Model::DescribeLoadBalancersRelatedEcsResult> DescribeLoadBalancersRelatedEcsOutcome;
typedef std::future<DescribeLoadBalancersRelatedEcsOutcome> DescribeLoadBalancersRelatedEcsOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancersRelatedEcsRequest&, const DescribeLoadBalancersRelatedEcsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancersRelatedEcsAsyncHandler;
typedef Outcome<Error, Model::DescribeLoadBalancersResult> DescribeLoadBalancersOutcome;
typedef std::future<DescribeLoadBalancersOutcome> DescribeLoadBalancersOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancersRequest&, const DescribeLoadBalancersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancersAsyncHandler;
typedef Outcome<Error, Model::SetCACertificateNameResult> SetCACertificateNameOutcome;
typedef std::future<SetCACertificateNameOutcome> SetCACertificateNameOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetCACertificateNameRequest&, const SetCACertificateNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetCACertificateNameAsyncHandler;
typedef Outcome<Error, Model::DescribeMasterSlaveVServerGroupAttributeResult> DescribeMasterSlaveVServerGroupAttributeOutcome;
typedef std::future<DescribeMasterSlaveVServerGroupAttributeOutcome> DescribeMasterSlaveVServerGroupAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeMasterSlaveVServerGroupAttributeRequest&, const DescribeMasterSlaveVServerGroupAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMasterSlaveVServerGroupAttributeAsyncHandler;
typedef Outcome<Error, Model::CreateLoadBalancerHTTPListenerResult> CreateLoadBalancerHTTPListenerOutcome;
typedef std::future<CreateLoadBalancerHTTPListenerOutcome> CreateLoadBalancerHTTPListenerOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateLoadBalancerHTTPListenerRequest&, const CreateLoadBalancerHTTPListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLoadBalancerHTTPListenerAsyncHandler;
typedef Outcome<Error, Model::RemoveBackendServersResult> RemoveBackendServersOutcome;
typedef std::future<RemoveBackendServersOutcome> RemoveBackendServersOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::RemoveBackendServersRequest&, const RemoveBackendServersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveBackendServersAsyncHandler;
typedef Outcome<Error, Model::ModifyVServerGroupBackendServersResult> ModifyVServerGroupBackendServersOutcome;
typedef std::future<ModifyVServerGroupBackendServersOutcome> ModifyVServerGroupBackendServersOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::ModifyVServerGroupBackendServersRequest&, const ModifyVServerGroupBackendServersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyVServerGroupBackendServersAsyncHandler;
typedef Outcome<Error, Model::DescribeLoadBalancerUDPListenerAttributeResult> DescribeLoadBalancerUDPListenerAttributeOutcome;
typedef std::future<DescribeLoadBalancerUDPListenerAttributeOutcome> DescribeLoadBalancerUDPListenerAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancerUDPListenerAttributeRequest&, const DescribeLoadBalancerUDPListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancerUDPListenerAttributeAsyncHandler;
typedef Outcome<Error, Model::DeleteRulesResult> DeleteRulesOutcome;
typedef std::future<DeleteRulesOutcome> DeleteRulesOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteRulesRequest&, const DeleteRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteRulesAsyncHandler;
typedef Outcome<Error, Model::DeleteMasterSlaveVServerGroupResult> DeleteMasterSlaveVServerGroupOutcome;
typedef std::future<DeleteMasterSlaveVServerGroupOutcome> DeleteMasterSlaveVServerGroupOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteMasterSlaveVServerGroupRequest&, const DeleteMasterSlaveVServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteMasterSlaveVServerGroupAsyncHandler;
typedef Outcome<Error, Model::DescribeCACertificatesResult> DescribeCACertificatesOutcome;
typedef std::future<DescribeCACertificatesOutcome> DescribeCACertificatesOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeCACertificatesRequest&, const DescribeCACertificatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCACertificatesAsyncHandler;
typedef Outcome<Error, Model::CreateMasterSlaveVServerGroupResult> CreateMasterSlaveVServerGroupOutcome;
typedef std::future<CreateMasterSlaveVServerGroupOutcome> CreateMasterSlaveVServerGroupOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateMasterSlaveVServerGroupRequest&, const CreateMasterSlaveVServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateMasterSlaveVServerGroupAsyncHandler;
typedef Outcome<Error, Model::SetBackendServersResult> SetBackendServersOutcome;
typedef std::future<SetBackendServersOutcome> SetBackendServersOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetBackendServersRequest&, const SetBackendServersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetBackendServersAsyncHandler;
typedef Outcome<Error, Model::RemoveVServerGroupBackendServersResult> RemoveVServerGroupBackendServersOutcome;
typedef std::future<RemoveVServerGroupBackendServersOutcome> RemoveVServerGroupBackendServersOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::RemoveVServerGroupBackendServersRequest&, const RemoveVServerGroupBackendServersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveVServerGroupBackendServersAsyncHandler;
typedef Outcome<Error, Model::DescribeLoadBalancerAttributeResult> DescribeLoadBalancerAttributeOutcome;
typedef std::future<DescribeLoadBalancerAttributeOutcome> DescribeLoadBalancerAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancerAttributeRequest&, const DescribeLoadBalancerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancerAttributeAsyncHandler;
typedef Outcome<Error, Model::CreateMasterSlaveServerGroupResult> CreateMasterSlaveServerGroupOutcome;
typedef std::future<CreateMasterSlaveServerGroupOutcome> CreateMasterSlaveServerGroupOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateMasterSlaveServerGroupRequest&, const CreateMasterSlaveServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateMasterSlaveServerGroupAsyncHandler;
typedef Outcome<Error, Model::SetServerCertificateNameResult> SetServerCertificateNameOutcome;
typedef std::future<SetServerCertificateNameOutcome> SetServerCertificateNameOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetServerCertificateNameRequest&, const SetServerCertificateNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetServerCertificateNameAsyncHandler;
typedef Outcome<Error, Model::DeleteCACertificateResult> DeleteCACertificateOutcome;
typedef std::future<DeleteCACertificateOutcome> DeleteCACertificateOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteCACertificateRequest&, const DeleteCACertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCACertificateAsyncHandler;
typedef Outcome<Error, Model::CreateLoadBalancerTCPListenerResult> CreateLoadBalancerTCPListenerOutcome;
typedef std::future<CreateLoadBalancerTCPListenerOutcome> CreateLoadBalancerTCPListenerOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateLoadBalancerTCPListenerRequest&, const CreateLoadBalancerTCPListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLoadBalancerTCPListenerAsyncHandler;
typedef Outcome<Error, Model::SetRuleResult> SetRuleOutcome;
typedef std::future<SetRuleOutcome> SetRuleOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetRuleRequest&, const SetRuleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetRuleAsyncHandler;
typedef Outcome<Error, Model::DescribeMasterSlaveServerGroupsResult> DescribeMasterSlaveServerGroupsOutcome;
typedef std::future<DescribeMasterSlaveServerGroupsOutcome> DescribeMasterSlaveServerGroupsOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeMasterSlaveServerGroupsRequest&, const DescribeMasterSlaveServerGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMasterSlaveServerGroupsAsyncHandler;
typedef Outcome<Error, Model::DescribeHealthStatusResult> DescribeHealthStatusOutcome;
typedef std::future<DescribeHealthStatusOutcome> DescribeHealthStatusOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeHealthStatusRequest&, const DescribeHealthStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeHealthStatusAsyncHandler;
typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
typedef Outcome<Error, Model::RemoveListenerWhiteListItemResult> RemoveListenerWhiteListItemOutcome;
typedef std::future<RemoveListenerWhiteListItemOutcome> RemoveListenerWhiteListItemOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::RemoveListenerWhiteListItemRequest&, const RemoveListenerWhiteListItemOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveListenerWhiteListItemAsyncHandler;
typedef Outcome<Error, Model::CreateLoadBalancerHTTPSListenerResult> CreateLoadBalancerHTTPSListenerOutcome;
typedef std::future<CreateLoadBalancerHTTPSListenerOutcome> CreateLoadBalancerHTTPSListenerOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateLoadBalancerHTTPSListenerRequest&, const CreateLoadBalancerHTTPSListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLoadBalancerHTTPSListenerAsyncHandler;
typedef Outcome<Error, Model::DeleteMasterSlaveServerGroupResult> DeleteMasterSlaveServerGroupOutcome;
typedef std::future<DeleteMasterSlaveServerGroupOutcome> DeleteMasterSlaveServerGroupOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteMasterSlaveServerGroupRequest&, const DeleteMasterSlaveServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteMasterSlaveServerGroupAsyncHandler;
typedef Outcome<Error, Model::DescribeServerCertificatesResult> DescribeServerCertificatesOutcome;
typedef std::future<DescribeServerCertificatesOutcome> DescribeServerCertificatesOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeServerCertificatesRequest&, const DescribeServerCertificatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeServerCertificatesAsyncHandler;
typedef Outcome<Error, Model::DescribeRulesResult> DescribeRulesOutcome;
typedef std::future<DescribeRulesOutcome> DescribeRulesOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeRulesRequest&, const DescribeRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRulesAsyncHandler;
typedef Outcome<Error, Model::DescribeRuleAttributeResult> DescribeRuleAttributeOutcome;
typedef std::future<DescribeRuleAttributeOutcome> DescribeRuleAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeRuleAttributeRequest&, const DescribeRuleAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRuleAttributeAsyncHandler;
typedef Outcome<Error, Model::UploadServerCertificateResult> UploadServerCertificateOutcome;
typedef std::future<UploadServerCertificateOutcome> UploadServerCertificateOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::UploadServerCertificateRequest&, const UploadServerCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UploadServerCertificateAsyncHandler;
typedef Outcome<Error, Model::DescribeLoadBalancerAutoReleaseTimeResult> DescribeLoadBalancerAutoReleaseTimeOutcome;
typedef std::future<DescribeLoadBalancerAutoReleaseTimeOutcome> DescribeLoadBalancerAutoReleaseTimeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancerAutoReleaseTimeRequest&, const DescribeLoadBalancerAutoReleaseTimeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancerAutoReleaseTimeAsyncHandler;
typedef Outcome<Error, Model::DeleteServerCertificateResult> DeleteServerCertificateOutcome;
typedef std::future<DeleteServerCertificateOutcome> DeleteServerCertificateOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteServerCertificateRequest&, const DeleteServerCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteServerCertificateAsyncHandler;
typedef Outcome<Error, Model::SetLoadBalancerNameResult> SetLoadBalancerNameOutcome;
typedef std::future<SetLoadBalancerNameOutcome> SetLoadBalancerNameOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerNameRequest&, const SetLoadBalancerNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerNameAsyncHandler;
typedef Outcome<Error, Model::SetVServerGroupAttributeResult> SetVServerGroupAttributeOutcome;
typedef std::future<SetVServerGroupAttributeOutcome> SetVServerGroupAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetVServerGroupAttributeRequest&, const SetVServerGroupAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetVServerGroupAttributeAsyncHandler;
typedef Outcome<Error, Model::ModifyLoadBalancerInternetSpecResult> ModifyLoadBalancerInternetSpecOutcome;
typedef std::future<ModifyLoadBalancerInternetSpecOutcome> ModifyLoadBalancerInternetSpecOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::ModifyLoadBalancerInternetSpecRequest&, const ModifyLoadBalancerInternetSpecOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyLoadBalancerInternetSpecAsyncHandler;
typedef Outcome<Error, Model::DescribeLoadBalancerHTTPSListenerAttributeResult> DescribeLoadBalancerHTTPSListenerAttributeOutcome;
typedef std::future<DescribeLoadBalancerHTTPSListenerAttributeOutcome> DescribeLoadBalancerHTTPSListenerAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancerHTTPSListenerAttributeRequest&, const DescribeLoadBalancerHTTPSListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancerHTTPSListenerAttributeAsyncHandler;
typedef Outcome<Error, Model::DescribeMasterSlaveServerGroupAttributeResult> DescribeMasterSlaveServerGroupAttributeOutcome;
typedef std::future<DescribeMasterSlaveServerGroupAttributeOutcome> DescribeMasterSlaveServerGroupAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeMasterSlaveServerGroupAttributeRequest&, const DescribeMasterSlaveServerGroupAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMasterSlaveServerGroupAttributeAsyncHandler;
typedef Outcome<Error, Model::AddTagsResult> AddTagsOutcome;
typedef std::future<AddTagsOutcome> AddTagsOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::AddTagsRequest&, const AddTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddTagsAsyncHandler;
typedef Outcome<Error, Model::ModifyLoadBalancerPayTypeResult> ModifyLoadBalancerPayTypeOutcome;
typedef std::future<ModifyLoadBalancerPayTypeOutcome> ModifyLoadBalancerPayTypeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::ModifyLoadBalancerPayTypeRequest&, const ModifyLoadBalancerPayTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyLoadBalancerPayTypeAsyncHandler;
typedef Outcome<Error, Model::AddBackendServersResult> AddBackendServersOutcome;
typedef std::future<AddBackendServersOutcome> AddBackendServersOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::AddBackendServersRequest&, const AddBackendServersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddBackendServersAsyncHandler;
typedef Outcome<Error, Model::CreateRulesResult> CreateRulesOutcome;
typedef std::future<CreateRulesOutcome> CreateRulesOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateRulesRequest&, const CreateRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRulesAsyncHandler;
typedef Outcome<Error, Model::AddVServerGroupBackendServersResult> AddVServerGroupBackendServersOutcome;
typedef std::future<AddVServerGroupBackendServersOutcome> AddVServerGroupBackendServersOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::AddVServerGroupBackendServersRequest&, const AddVServerGroupBackendServersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddVServerGroupBackendServersAsyncHandler;
typedef Outcome<Error, Model::SetLoadBalancerUDPListenerAttributeResult> SetLoadBalancerUDPListenerAttributeOutcome;
typedef std::future<SetLoadBalancerUDPListenerAttributeOutcome> SetLoadBalancerUDPListenerAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerUDPListenerAttributeRequest&, const SetLoadBalancerUDPListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerUDPListenerAttributeAsyncHandler;
SlbClient(const Credentials &credentials, const ClientConfiguration &configuration);
SlbClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
SlbClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~SlbClient();
CreateLoadBalancerUDPListenerOutcome createLoadBalancerUDPListener(const Model::CreateLoadBalancerUDPListenerRequest &request)const;
void createLoadBalancerUDPListenerAsync(const Model::CreateLoadBalancerUDPListenerRequest& request, const CreateLoadBalancerUDPListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateLoadBalancerUDPListenerOutcomeCallable createLoadBalancerUDPListenerCallable(const Model::CreateLoadBalancerUDPListenerRequest& request) const;
DescribeMasterSlaveVServerGroupsOutcome describeMasterSlaveVServerGroups(const Model::DescribeMasterSlaveVServerGroupsRequest &request)const;
void describeMasterSlaveVServerGroupsAsync(const Model::DescribeMasterSlaveVServerGroupsRequest& request, const DescribeMasterSlaveVServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeMasterSlaveVServerGroupsOutcomeCallable describeMasterSlaveVServerGroupsCallable(const Model::DescribeMasterSlaveVServerGroupsRequest& request) const;
StartLoadBalancerListenerOutcome startLoadBalancerListener(const Model::StartLoadBalancerListenerRequest &request)const;
void startLoadBalancerListenerAsync(const Model::StartLoadBalancerListenerRequest& request, const StartLoadBalancerListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartLoadBalancerListenerOutcomeCallable startLoadBalancerListenerCallable(const Model::StartLoadBalancerListenerRequest& request) const;
DescribeLoadBalancerTCPListenerAttributeOutcome describeLoadBalancerTCPListenerAttribute(const Model::DescribeLoadBalancerTCPListenerAttributeRequest &request)const;
void describeLoadBalancerTCPListenerAttributeAsync(const Model::DescribeLoadBalancerTCPListenerAttributeRequest& request, const DescribeLoadBalancerTCPListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLoadBalancerTCPListenerAttributeOutcomeCallable describeLoadBalancerTCPListenerAttributeCallable(const Model::DescribeLoadBalancerTCPListenerAttributeRequest& request) const;
DescribeListenerAccessControlAttributeOutcome describeListenerAccessControlAttribute(const Model::DescribeListenerAccessControlAttributeRequest &request)const;
void describeListenerAccessControlAttributeAsync(const Model::DescribeListenerAccessControlAttributeRequest& request, const DescribeListenerAccessControlAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeListenerAccessControlAttributeOutcomeCallable describeListenerAccessControlAttributeCallable(const Model::DescribeListenerAccessControlAttributeRequest& request) const;
StopLoadBalancerListenerOutcome stopLoadBalancerListener(const Model::StopLoadBalancerListenerRequest &request)const;
void stopLoadBalancerListenerAsync(const Model::StopLoadBalancerListenerRequest& request, const StopLoadBalancerListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopLoadBalancerListenerOutcomeCallable stopLoadBalancerListenerCallable(const Model::StopLoadBalancerListenerRequest& request) const;
SetLoadBalancerStatusOutcome setLoadBalancerStatus(const Model::SetLoadBalancerStatusRequest &request)const;
void setLoadBalancerStatusAsync(const Model::SetLoadBalancerStatusRequest& request, const SetLoadBalancerStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLoadBalancerStatusOutcomeCallable setLoadBalancerStatusCallable(const Model::SetLoadBalancerStatusRequest& request) const;
ModifyLoadBalancerInstanceSpecOutcome modifyLoadBalancerInstanceSpec(const Model::ModifyLoadBalancerInstanceSpecRequest &request)const;
void modifyLoadBalancerInstanceSpecAsync(const Model::ModifyLoadBalancerInstanceSpecRequest& request, const ModifyLoadBalancerInstanceSpecAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyLoadBalancerInstanceSpecOutcomeCallable modifyLoadBalancerInstanceSpecCallable(const Model::ModifyLoadBalancerInstanceSpecRequest& request) const;
MoveResourceGroupOutcome moveResourceGroup(const Model::MoveResourceGroupRequest &request)const;
void moveResourceGroupAsync(const Model::MoveResourceGroupRequest& request, const MoveResourceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
MoveResourceGroupOutcomeCallable moveResourceGroupCallable(const Model::MoveResourceGroupRequest& request) const;
SetLoadBalancerTCPListenerAttributeOutcome setLoadBalancerTCPListenerAttribute(const Model::SetLoadBalancerTCPListenerAttributeRequest &request)const;
void setLoadBalancerTCPListenerAttributeAsync(const Model::SetLoadBalancerTCPListenerAttributeRequest& request, const SetLoadBalancerTCPListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLoadBalancerTCPListenerAttributeOutcomeCallable setLoadBalancerTCPListenerAttributeCallable(const Model::SetLoadBalancerTCPListenerAttributeRequest& request) const;
DeleteVServerGroupOutcome deleteVServerGroup(const Model::DeleteVServerGroupRequest &request)const;
void deleteVServerGroupAsync(const Model::DeleteVServerGroupRequest& request, const DeleteVServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteVServerGroupOutcomeCallable deleteVServerGroupCallable(const Model::DeleteVServerGroupRequest& request) const;
DescribeVServerGroupAttributeOutcome describeVServerGroupAttribute(const Model::DescribeVServerGroupAttributeRequest &request)const;
void describeVServerGroupAttributeAsync(const Model::DescribeVServerGroupAttributeRequest& request, const DescribeVServerGroupAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVServerGroupAttributeOutcomeCallable describeVServerGroupAttributeCallable(const Model::DescribeVServerGroupAttributeRequest& request) const;
AddListenerWhiteListItemOutcome addListenerWhiteListItem(const Model::AddListenerWhiteListItemRequest &request)const;
void addListenerWhiteListItemAsync(const Model::AddListenerWhiteListItemRequest& request, const AddListenerWhiteListItemAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddListenerWhiteListItemOutcomeCallable addListenerWhiteListItemCallable(const Model::AddListenerWhiteListItemRequest& request) const;
RemoveTagsOutcome removeTags(const Model::RemoveTagsRequest &request)const;
void removeTagsAsync(const Model::RemoveTagsRequest& request, const RemoveTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RemoveTagsOutcomeCallable removeTagsCallable(const Model::RemoveTagsRequest& request) const;
CreateLoadBalancerOutcome createLoadBalancer(const Model::CreateLoadBalancerRequest &request)const;
void createLoadBalancerAsync(const Model::CreateLoadBalancerRequest& request, const CreateLoadBalancerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateLoadBalancerOutcomeCallable createLoadBalancerCallable(const Model::CreateLoadBalancerRequest& request) const;
SetLoadBalancerHTTPListenerAttributeOutcome setLoadBalancerHTTPListenerAttribute(const Model::SetLoadBalancerHTTPListenerAttributeRequest &request)const;
void setLoadBalancerHTTPListenerAttributeAsync(const Model::SetLoadBalancerHTTPListenerAttributeRequest& request, const SetLoadBalancerHTTPListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLoadBalancerHTTPListenerAttributeOutcomeCallable setLoadBalancerHTTPListenerAttributeCallable(const Model::SetLoadBalancerHTTPListenerAttributeRequest& request) const;
SetLoadBalancerAutoReleaseTimeOutcome setLoadBalancerAutoReleaseTime(const Model::SetLoadBalancerAutoReleaseTimeRequest &request)const;
void setLoadBalancerAutoReleaseTimeAsync(const Model::SetLoadBalancerAutoReleaseTimeRequest& request, const SetLoadBalancerAutoReleaseTimeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLoadBalancerAutoReleaseTimeOutcomeCallable setLoadBalancerAutoReleaseTimeCallable(const Model::SetLoadBalancerAutoReleaseTimeRequest& request) const;
SetListenerAccessControlStatusOutcome setListenerAccessControlStatus(const Model::SetListenerAccessControlStatusRequest &request)const;
void setListenerAccessControlStatusAsync(const Model::SetListenerAccessControlStatusRequest& request, const SetListenerAccessControlStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetListenerAccessControlStatusOutcomeCallable setListenerAccessControlStatusCallable(const Model::SetListenerAccessControlStatusRequest& request) const;
UploadCACertificateOutcome uploadCACertificate(const Model::UploadCACertificateRequest &request)const;
void uploadCACertificateAsync(const Model::UploadCACertificateRequest& request, const UploadCACertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UploadCACertificateOutcomeCallable uploadCACertificateCallable(const Model::UploadCACertificateRequest& request) const;
DescribeZonesOutcome describeZones(const Model::DescribeZonesRequest &request)const;
void describeZonesAsync(const Model::DescribeZonesRequest& request, const DescribeZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeZonesOutcomeCallable describeZonesCallable(const Model::DescribeZonesRequest& request) const;
SetLoadBalancerHTTPSListenerAttributeOutcome setLoadBalancerHTTPSListenerAttribute(const Model::SetLoadBalancerHTTPSListenerAttributeRequest &request)const;
void setLoadBalancerHTTPSListenerAttributeAsync(const Model::SetLoadBalancerHTTPSListenerAttributeRequest& request, const SetLoadBalancerHTTPSListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLoadBalancerHTTPSListenerAttributeOutcomeCallable setLoadBalancerHTTPSListenerAttributeCallable(const Model::SetLoadBalancerHTTPSListenerAttributeRequest& request) const;
DeleteLoadBalancerListenerOutcome deleteLoadBalancerListener(const Model::DeleteLoadBalancerListenerRequest &request)const;
void deleteLoadBalancerListenerAsync(const Model::DeleteLoadBalancerListenerRequest& request, const DeleteLoadBalancerListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLoadBalancerListenerOutcomeCallable deleteLoadBalancerListenerCallable(const Model::DeleteLoadBalancerListenerRequest& request) const;
DescribeVServerGroupsOutcome describeVServerGroups(const Model::DescribeVServerGroupsRequest &request)const;
void describeVServerGroupsAsync(const Model::DescribeVServerGroupsRequest& request, const DescribeVServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVServerGroupsOutcomeCallable describeVServerGroupsCallable(const Model::DescribeVServerGroupsRequest& request) const;
DescribeLoadBalancerHTTPListenerAttributeOutcome describeLoadBalancerHTTPListenerAttribute(const Model::DescribeLoadBalancerHTTPListenerAttributeRequest &request)const;
void describeLoadBalancerHTTPListenerAttributeAsync(const Model::DescribeLoadBalancerHTTPListenerAttributeRequest& request, const DescribeLoadBalancerHTTPListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLoadBalancerHTTPListenerAttributeOutcomeCallable describeLoadBalancerHTTPListenerAttributeCallable(const Model::DescribeLoadBalancerHTTPListenerAttributeRequest& request) const;
DescribeTagsOutcome describeTags(const Model::DescribeTagsRequest &request)const;
void describeTagsAsync(const Model::DescribeTagsRequest& request, const DescribeTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeTagsOutcomeCallable describeTagsCallable(const Model::DescribeTagsRequest& request) const;
DeleteLoadBalancerOutcome deleteLoadBalancer(const Model::DeleteLoadBalancerRequest &request)const;
void deleteLoadBalancerAsync(const Model::DeleteLoadBalancerRequest& request, const DeleteLoadBalancerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLoadBalancerOutcomeCallable deleteLoadBalancerCallable(const Model::DeleteLoadBalancerRequest& request) const;
CreateVServerGroupOutcome createVServerGroup(const Model::CreateVServerGroupRequest &request)const;
void createVServerGroupAsync(const Model::CreateVServerGroupRequest& request, const CreateVServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateVServerGroupOutcomeCallable createVServerGroupCallable(const Model::CreateVServerGroupRequest& request) const;
DescribeLoadBalancersRelatedEcsOutcome describeLoadBalancersRelatedEcs(const Model::DescribeLoadBalancersRelatedEcsRequest &request)const;
void describeLoadBalancersRelatedEcsAsync(const Model::DescribeLoadBalancersRelatedEcsRequest& request, const DescribeLoadBalancersRelatedEcsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLoadBalancersRelatedEcsOutcomeCallable describeLoadBalancersRelatedEcsCallable(const Model::DescribeLoadBalancersRelatedEcsRequest& request) const;
DescribeLoadBalancersOutcome describeLoadBalancers(const Model::DescribeLoadBalancersRequest &request)const;
void describeLoadBalancersAsync(const Model::DescribeLoadBalancersRequest& request, const DescribeLoadBalancersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLoadBalancersOutcomeCallable describeLoadBalancersCallable(const Model::DescribeLoadBalancersRequest& request) const;
SetCACertificateNameOutcome setCACertificateName(const Model::SetCACertificateNameRequest &request)const;
void setCACertificateNameAsync(const Model::SetCACertificateNameRequest& request, const SetCACertificateNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetCACertificateNameOutcomeCallable setCACertificateNameCallable(const Model::SetCACertificateNameRequest& request) const;
DescribeMasterSlaveVServerGroupAttributeOutcome describeMasterSlaveVServerGroupAttribute(const Model::DescribeMasterSlaveVServerGroupAttributeRequest &request)const;
void describeMasterSlaveVServerGroupAttributeAsync(const Model::DescribeMasterSlaveVServerGroupAttributeRequest& request, const DescribeMasterSlaveVServerGroupAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeMasterSlaveVServerGroupAttributeOutcomeCallable describeMasterSlaveVServerGroupAttributeCallable(const Model::DescribeMasterSlaveVServerGroupAttributeRequest& request) const;
CreateLoadBalancerHTTPListenerOutcome createLoadBalancerHTTPListener(const Model::CreateLoadBalancerHTTPListenerRequest &request)const;
void createLoadBalancerHTTPListenerAsync(const Model::CreateLoadBalancerHTTPListenerRequest& request, const CreateLoadBalancerHTTPListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateLoadBalancerHTTPListenerOutcomeCallable createLoadBalancerHTTPListenerCallable(const Model::CreateLoadBalancerHTTPListenerRequest& request) const;
RemoveBackendServersOutcome removeBackendServers(const Model::RemoveBackendServersRequest &request)const;
void removeBackendServersAsync(const Model::RemoveBackendServersRequest& request, const RemoveBackendServersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RemoveBackendServersOutcomeCallable removeBackendServersCallable(const Model::RemoveBackendServersRequest& request) const;
ModifyVServerGroupBackendServersOutcome modifyVServerGroupBackendServers(const Model::ModifyVServerGroupBackendServersRequest &request)const;
void modifyVServerGroupBackendServersAsync(const Model::ModifyVServerGroupBackendServersRequest& request, const ModifyVServerGroupBackendServersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyVServerGroupBackendServersOutcomeCallable modifyVServerGroupBackendServersCallable(const Model::ModifyVServerGroupBackendServersRequest& request) const;
DescribeLoadBalancerUDPListenerAttributeOutcome describeLoadBalancerUDPListenerAttribute(const Model::DescribeLoadBalancerUDPListenerAttributeRequest &request)const;
void describeLoadBalancerUDPListenerAttributeAsync(const Model::DescribeLoadBalancerUDPListenerAttributeRequest& request, const DescribeLoadBalancerUDPListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLoadBalancerUDPListenerAttributeOutcomeCallable describeLoadBalancerUDPListenerAttributeCallable(const Model::DescribeLoadBalancerUDPListenerAttributeRequest& request) const;
DeleteRulesOutcome deleteRules(const Model::DeleteRulesRequest &request)const;
void deleteRulesAsync(const Model::DeleteRulesRequest& request, const DeleteRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteRulesOutcomeCallable deleteRulesCallable(const Model::DeleteRulesRequest& request) const;
DeleteMasterSlaveVServerGroupOutcome deleteMasterSlaveVServerGroup(const Model::DeleteMasterSlaveVServerGroupRequest &request)const;
void deleteMasterSlaveVServerGroupAsync(const Model::DeleteMasterSlaveVServerGroupRequest& request, const DeleteMasterSlaveVServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteMasterSlaveVServerGroupOutcomeCallable deleteMasterSlaveVServerGroupCallable(const Model::DeleteMasterSlaveVServerGroupRequest& request) const;
DescribeCACertificatesOutcome describeCACertificates(const Model::DescribeCACertificatesRequest &request)const;
void describeCACertificatesAsync(const Model::DescribeCACertificatesRequest& request, const DescribeCACertificatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeCACertificatesOutcomeCallable describeCACertificatesCallable(const Model::DescribeCACertificatesRequest& request) const;
CreateMasterSlaveVServerGroupOutcome createMasterSlaveVServerGroup(const Model::CreateMasterSlaveVServerGroupRequest &request)const;
void createMasterSlaveVServerGroupAsync(const Model::CreateMasterSlaveVServerGroupRequest& request, const CreateMasterSlaveVServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateMasterSlaveVServerGroupOutcomeCallable createMasterSlaveVServerGroupCallable(const Model::CreateMasterSlaveVServerGroupRequest& request) const;
SetBackendServersOutcome setBackendServers(const Model::SetBackendServersRequest &request)const;
void setBackendServersAsync(const Model::SetBackendServersRequest& request, const SetBackendServersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetBackendServersOutcomeCallable setBackendServersCallable(const Model::SetBackendServersRequest& request) const;
RemoveVServerGroupBackendServersOutcome removeVServerGroupBackendServers(const Model::RemoveVServerGroupBackendServersRequest &request)const;
void removeVServerGroupBackendServersAsync(const Model::RemoveVServerGroupBackendServersRequest& request, const RemoveVServerGroupBackendServersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RemoveVServerGroupBackendServersOutcomeCallable removeVServerGroupBackendServersCallable(const Model::RemoveVServerGroupBackendServersRequest& request) const;
DescribeLoadBalancerAttributeOutcome describeLoadBalancerAttribute(const Model::DescribeLoadBalancerAttributeRequest &request)const;
void describeLoadBalancerAttributeAsync(const Model::DescribeLoadBalancerAttributeRequest& request, const DescribeLoadBalancerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLoadBalancerAttributeOutcomeCallable describeLoadBalancerAttributeCallable(const Model::DescribeLoadBalancerAttributeRequest& request) const;
CreateMasterSlaveServerGroupOutcome createMasterSlaveServerGroup(const Model::CreateMasterSlaveServerGroupRequest &request)const;
void createMasterSlaveServerGroupAsync(const Model::CreateMasterSlaveServerGroupRequest& request, const CreateMasterSlaveServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateMasterSlaveServerGroupOutcomeCallable createMasterSlaveServerGroupCallable(const Model::CreateMasterSlaveServerGroupRequest& request) const;
SetServerCertificateNameOutcome setServerCertificateName(const Model::SetServerCertificateNameRequest &request)const;
void setServerCertificateNameAsync(const Model::SetServerCertificateNameRequest& request, const SetServerCertificateNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetServerCertificateNameOutcomeCallable setServerCertificateNameCallable(const Model::SetServerCertificateNameRequest& request) const;
DeleteCACertificateOutcome deleteCACertificate(const Model::DeleteCACertificateRequest &request)const;
void deleteCACertificateAsync(const Model::DeleteCACertificateRequest& request, const DeleteCACertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteCACertificateOutcomeCallable deleteCACertificateCallable(const Model::DeleteCACertificateRequest& request) const;
CreateLoadBalancerTCPListenerOutcome createLoadBalancerTCPListener(const Model::CreateLoadBalancerTCPListenerRequest &request)const;
void createLoadBalancerTCPListenerAsync(const Model::CreateLoadBalancerTCPListenerRequest& request, const CreateLoadBalancerTCPListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateLoadBalancerTCPListenerOutcomeCallable createLoadBalancerTCPListenerCallable(const Model::CreateLoadBalancerTCPListenerRequest& request) const;
SetRuleOutcome setRule(const Model::SetRuleRequest &request)const;
void setRuleAsync(const Model::SetRuleRequest& request, const SetRuleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetRuleOutcomeCallable setRuleCallable(const Model::SetRuleRequest& request) const;
DescribeMasterSlaveServerGroupsOutcome describeMasterSlaveServerGroups(const Model::DescribeMasterSlaveServerGroupsRequest &request)const;
void describeMasterSlaveServerGroupsAsync(const Model::DescribeMasterSlaveServerGroupsRequest& request, const DescribeMasterSlaveServerGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeMasterSlaveServerGroupsOutcomeCallable describeMasterSlaveServerGroupsCallable(const Model::DescribeMasterSlaveServerGroupsRequest& request) const;
DescribeHealthStatusOutcome describeHealthStatus(const Model::DescribeHealthStatusRequest &request)const;
void describeHealthStatusAsync(const Model::DescribeHealthStatusRequest& request, const DescribeHealthStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeHealthStatusOutcomeCallable describeHealthStatusCallable(const Model::DescribeHealthStatusRequest& request) const;
DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
RemoveListenerWhiteListItemOutcome removeListenerWhiteListItem(const Model::RemoveListenerWhiteListItemRequest &request)const;
void removeListenerWhiteListItemAsync(const Model::RemoveListenerWhiteListItemRequest& request, const RemoveListenerWhiteListItemAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RemoveListenerWhiteListItemOutcomeCallable removeListenerWhiteListItemCallable(const Model::RemoveListenerWhiteListItemRequest& request) const;
CreateLoadBalancerHTTPSListenerOutcome createLoadBalancerHTTPSListener(const Model::CreateLoadBalancerHTTPSListenerRequest &request)const;
void createLoadBalancerHTTPSListenerAsync(const Model::CreateLoadBalancerHTTPSListenerRequest& request, const CreateLoadBalancerHTTPSListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateLoadBalancerHTTPSListenerOutcomeCallable createLoadBalancerHTTPSListenerCallable(const Model::CreateLoadBalancerHTTPSListenerRequest& request) const;
DeleteMasterSlaveServerGroupOutcome deleteMasterSlaveServerGroup(const Model::DeleteMasterSlaveServerGroupRequest &request)const;
void deleteMasterSlaveServerGroupAsync(const Model::DeleteMasterSlaveServerGroupRequest& request, const DeleteMasterSlaveServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteMasterSlaveServerGroupOutcomeCallable deleteMasterSlaveServerGroupCallable(const Model::DeleteMasterSlaveServerGroupRequest& request) const;
DescribeServerCertificatesOutcome describeServerCertificates(const Model::DescribeServerCertificatesRequest &request)const;
void describeServerCertificatesAsync(const Model::DescribeServerCertificatesRequest& request, const DescribeServerCertificatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeServerCertificatesOutcomeCallable describeServerCertificatesCallable(const Model::DescribeServerCertificatesRequest& request) const;
DescribeRulesOutcome describeRules(const Model::DescribeRulesRequest &request)const;
void describeRulesAsync(const Model::DescribeRulesRequest& request, const DescribeRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRulesOutcomeCallable describeRulesCallable(const Model::DescribeRulesRequest& request) const;
DescribeRuleAttributeOutcome describeRuleAttribute(const Model::DescribeRuleAttributeRequest &request)const;
void describeRuleAttributeAsync(const Model::DescribeRuleAttributeRequest& request, const DescribeRuleAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRuleAttributeOutcomeCallable describeRuleAttributeCallable(const Model::DescribeRuleAttributeRequest& request) const;
UploadServerCertificateOutcome uploadServerCertificate(const Model::UploadServerCertificateRequest &request)const;
void uploadServerCertificateAsync(const Model::UploadServerCertificateRequest& request, const UploadServerCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UploadServerCertificateOutcomeCallable uploadServerCertificateCallable(const Model::UploadServerCertificateRequest& request) const;
DescribeLoadBalancerAutoReleaseTimeOutcome describeLoadBalancerAutoReleaseTime(const Model::DescribeLoadBalancerAutoReleaseTimeRequest &request)const;
void describeLoadBalancerAutoReleaseTimeAsync(const Model::DescribeLoadBalancerAutoReleaseTimeRequest& request, const DescribeLoadBalancerAutoReleaseTimeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLoadBalancerAutoReleaseTimeOutcomeCallable describeLoadBalancerAutoReleaseTimeCallable(const Model::DescribeLoadBalancerAutoReleaseTimeRequest& request) const;
DeleteServerCertificateOutcome deleteServerCertificate(const Model::DeleteServerCertificateRequest &request)const;
void deleteServerCertificateAsync(const Model::DeleteServerCertificateRequest& request, const DeleteServerCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteServerCertificateOutcomeCallable deleteServerCertificateCallable(const Model::DeleteServerCertificateRequest& request) const;
SetLoadBalancerNameOutcome setLoadBalancerName(const Model::SetLoadBalancerNameRequest &request)const;
void setLoadBalancerNameAsync(const Model::SetLoadBalancerNameRequest& request, const SetLoadBalancerNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLoadBalancerNameOutcomeCallable setLoadBalancerNameCallable(const Model::SetLoadBalancerNameRequest& request) const;
SetVServerGroupAttributeOutcome setVServerGroupAttribute(const Model::SetVServerGroupAttributeRequest &request)const;
void setVServerGroupAttributeAsync(const Model::SetVServerGroupAttributeRequest& request, const SetVServerGroupAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetVServerGroupAttributeOutcomeCallable setVServerGroupAttributeCallable(const Model::SetVServerGroupAttributeRequest& request) const;
ModifyLoadBalancerInternetSpecOutcome modifyLoadBalancerInternetSpec(const Model::ModifyLoadBalancerInternetSpecRequest &request)const;
void modifyLoadBalancerInternetSpecAsync(const Model::ModifyLoadBalancerInternetSpecRequest& request, const ModifyLoadBalancerInternetSpecAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyLoadBalancerInternetSpecOutcomeCallable modifyLoadBalancerInternetSpecCallable(const Model::ModifyLoadBalancerInternetSpecRequest& request) const;
DescribeLoadBalancerHTTPSListenerAttributeOutcome describeLoadBalancerHTTPSListenerAttribute(const Model::DescribeLoadBalancerHTTPSListenerAttributeRequest &request)const;
void describeLoadBalancerHTTPSListenerAttributeAsync(const Model::DescribeLoadBalancerHTTPSListenerAttributeRequest& request, const DescribeLoadBalancerHTTPSListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLoadBalancerHTTPSListenerAttributeOutcomeCallable describeLoadBalancerHTTPSListenerAttributeCallable(const Model::DescribeLoadBalancerHTTPSListenerAttributeRequest& request) const;
DescribeMasterSlaveServerGroupAttributeOutcome describeMasterSlaveServerGroupAttribute(const Model::DescribeMasterSlaveServerGroupAttributeRequest &request)const;
void describeMasterSlaveServerGroupAttributeAsync(const Model::DescribeMasterSlaveServerGroupAttributeRequest& request, const DescribeMasterSlaveServerGroupAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeMasterSlaveServerGroupAttributeOutcomeCallable describeMasterSlaveServerGroupAttributeCallable(const Model::DescribeMasterSlaveServerGroupAttributeRequest& request) const;
AddTagsOutcome addTags(const Model::AddTagsRequest &request)const;
void addTagsAsync(const Model::AddTagsRequest& request, const AddTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddTagsOutcomeCallable addTagsCallable(const Model::AddTagsRequest& request) const;
ModifyLoadBalancerPayTypeOutcome modifyLoadBalancerPayType(const Model::ModifyLoadBalancerPayTypeRequest &request)const;
void modifyLoadBalancerPayTypeAsync(const Model::ModifyLoadBalancerPayTypeRequest& request, const ModifyLoadBalancerPayTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyLoadBalancerPayTypeOutcomeCallable modifyLoadBalancerPayTypeCallable(const Model::ModifyLoadBalancerPayTypeRequest& request) const;
AddBackendServersOutcome addBackendServers(const Model::AddBackendServersRequest &request)const;
void addBackendServersAsync(const Model::AddBackendServersRequest& request, const AddBackendServersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddBackendServersOutcomeCallable addBackendServersCallable(const Model::AddBackendServersRequest& request) const;
CreateRulesOutcome createRules(const Model::CreateRulesRequest &request)const;
void createRulesAsync(const Model::CreateRulesRequest& request, const CreateRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateRulesOutcomeCallable createRulesCallable(const Model::CreateRulesRequest& request) const;
AddVServerGroupBackendServersOutcome addVServerGroupBackendServers(const Model::AddVServerGroupBackendServersRequest &request)const;
void addVServerGroupBackendServersAsync(const Model::AddVServerGroupBackendServersRequest& request, const AddVServerGroupBackendServersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddVServerGroupBackendServersOutcomeCallable addVServerGroupBackendServersCallable(const Model::AddVServerGroupBackendServersRequest& request) const;
SetLoadBalancerUDPListenerAttributeOutcome setLoadBalancerUDPListenerAttribute(const Model::SetLoadBalancerUDPListenerAttributeRequest &request)const;
void setLoadBalancerUDPListenerAttributeAsync(const Model::SetLoadBalancerUDPListenerAttributeRequest& request, const SetLoadBalancerUDPListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLoadBalancerUDPListenerAttributeOutcomeCallable setLoadBalancerUDPListenerAttributeCallable(const Model::SetLoadBalancerUDPListenerAttributeRequest& request) const;
private:
virtual EndpointOutcome endpoint()const override;
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_SLB_SLBCLIENT_H_

32
slb/include/alibabacloud/slb/SlbExport.h Normal file
View File

@@ -0,0 +1,32 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_SLBEXPORT_H_
#define ALIBABACLOUD_SLB_SLBEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_SLB_LIBRARY)
# define ALIBABACLOUD_SLB_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_SLB_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_SLB_EXPORT
#endif
#endif // !ALIBABACLOUD_SLB_SLBEXPORT_H_

39
slb/include/alibabacloud/slb/SlbRequest.h Normal file
View File

@@ -0,0 +1,39 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_SLBREQUEST_H_
#define ALIBABACLOUD_SLB_SLBREQUEST_H_
#include <alibabacloud/core/RpcServiceRequest.h>
#include "SlbExport.h"
namespace AlibabaCloud
{
namespace Slb
{
class ALIBABACLOUD_SLB_EXPORT SlbRequest : public RpcServiceRequest
{
public:
explicit SlbRequest(const std::string & action);
virtual ~SlbRequest();
private:
};
}
}
#endif // !ALIBABACLOUD_SLB_SLBREQUEST_H_

74
slb/include/alibabacloud/slb/model/AddBackendServersRequest.h Normal file
View File

@@ -0,0 +1,74 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_ADDBACKENDSERVERSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_ADDBACKENDSERVERSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT AddBackendServersRequest : public SlbRequest
{
public:
AddBackendServersRequest();
~AddBackendServersRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getBackendServers()const;
void setBackendServers(const std::string& backendServers);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string loadBalancerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string backendServers_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_ADDBACKENDSERVERSREQUEST_H_

60
slb/include/alibabacloud/slb/model/AddBackendServersResult.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_ADDBACKENDSERVERSRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_ADDBACKENDSERVERSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT AddBackendServersResult : public ServiceResult
{
public:
struct BackendServer
{
std::string serverId;
std::string weight;
};
AddBackendServersResult();
explicit AddBackendServersResult(const std::string &payload);
~AddBackendServersResult();
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::vector<BackendServer> getBackendServers()const;
void setBackendServers(const std::vector<BackendServer>& backendServers);
protected:
void parse(const std::string &payload);
private:
std::string loadBalancerId_;
std::vector<BackendServer> backendServers_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_ADDBACKENDSERVERSRESULT_H_

77
slb/include/alibabacloud/slb/model/AddListenerWhiteListItemRequest.h Normal file
View File

@@ -0,0 +1,77 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_ADDLISTENERWHITELISTITEMREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_ADDLISTENERWHITELISTITEMREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT AddListenerWhiteListItemRequest : public SlbRequest
{
public:
AddListenerWhiteListItemRequest();
~AddListenerWhiteListItemRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getSourceItems()const;
void setSourceItems(const std::string& sourceItems);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
int listenerPort_;
std::string loadBalancerId_;
std::string sourceItems_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_ADDLISTENERWHITELISTITEMREQUEST_H_

49
slb/include/alibabacloud/slb/model/AddListenerWhiteListItemResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_ADDLISTENERWHITELISTITEMRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_ADDLISTENERWHITELISTITEMRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT AddListenerWhiteListItemResult : public ServiceResult
{
public:
AddListenerWhiteListItemResult();
explicit AddListenerWhiteListItemResult(const std::string &payload);
~AddListenerWhiteListItemResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_ADDLISTENERWHITELISTITEMRESULT_H_

71
slb/include/alibabacloud/slb/model/AddTagsRequest.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_ADDTAGSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_ADDTAGSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT AddTagsRequest : public SlbRequest
{
public:
AddTagsRequest();
~AddTagsRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string loadBalancerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_ADDTAGSREQUEST_H_

49
slb/include/alibabacloud/slb/model/AddTagsResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_ADDTAGSRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_ADDTAGSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT AddTagsResult : public ServiceResult
{
public:
AddTagsResult();
explicit AddTagsResult(const std::string &payload);
~AddTagsResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_ADDTAGSRESULT_H_

74
slb/include/alibabacloud/slb/model/AddVServerGroupBackendServersRequest.h Normal file
View File

@@ -0,0 +1,74 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_ADDVSERVERGROUPBACKENDSERVERSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_ADDVSERVERGROUPBACKENDSERVERSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT AddVServerGroupBackendServersRequest : public SlbRequest
{
public:
AddVServerGroupBackendServersRequest();
~AddVServerGroupBackendServersRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getBackendServers()const;
void setBackendServers(const std::string& backendServers);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
std::string vServerGroupId_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string backendServers_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_ADDVSERVERGROUPBACKENDSERVERSREQUEST_H_

61
slb/include/alibabacloud/slb/model/AddVServerGroupBackendServersResult.h Normal file
View File

@@ -0,0 +1,61 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_ADDVSERVERGROUPBACKENDSERVERSRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_ADDVSERVERGROUPBACKENDSERVERSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT AddVServerGroupBackendServersResult : public ServiceResult
{
public:
struct BackendServer
{
std::string serverId;
int port;
int weight;
};
AddVServerGroupBackendServersResult();
explicit AddVServerGroupBackendServersResult(const std::string &payload);
~AddVServerGroupBackendServersResult();
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
std::vector<BackendServer> getBackendServers()const;
void setBackendServers(const std::vector<BackendServer>& backendServers);
protected:
void parse(const std::string &payload);
private:
std::string vServerGroupId_;
std::vector<BackendServer> backendServers_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_ADDVSERVERGROUPBACKENDSERVERSRESULT_H_

143
slb/include/alibabacloud/slb/model/CreateLoadBalancerHTTPListenerRequest.h Normal file
View File

@@ -0,0 +1,143 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPLISTENERREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPLISTENERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerHTTPListenerRequest : public SlbRequest
{
public:
CreateLoadBalancerHTTPListenerRequest();
~CreateLoadBalancerHTTPListenerRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
int getHealthCheckTimeout()const;
void setHealthCheckTimeout(int healthCheckTimeout);
std::string getXForwardedFor()const;
void setXForwardedFor(const std::string& xForwardedFor);
std::string getHealthCheckURI()const;
void setHealthCheckURI(const std::string& healthCheckURI);
int getUnhealthyThreshold()const;
void setUnhealthyThreshold(int unhealthyThreshold);
int getHealthyThreshold()const;
void setHealthyThreshold(int healthyThreshold);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getScheduler()const;
void setScheduler(const std::string& scheduler);
std::string getHealthCheck()const;
void setHealthCheck(const std::string& healthCheck);
int getMaxConnection()const;
void setMaxConnection(int maxConnection);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getCookieTimeout()const;
void setCookieTimeout(int cookieTimeout);
std::string getStickySessionType()const;
void setStickySessionType(const std::string& stickySessionType);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getCookie()const;
void setCookie(const std::string& cookie);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
int getBandwidth()const;
void setBandwidth(int bandwidth);
std::string getStickySession()const;
void setStickySession(const std::string& stickySession);
std::string getHealthCheckDomain()const;
void setHealthCheckDomain(const std::string& healthCheckDomain);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getGzip()const;
void setGzip(const std::string& gzip);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getXForwardedFor_SLBIP()const;
void setXForwardedFor_SLBIP(const std::string& xForwardedFor_SLBIP);
int getBackendServerPort()const;
void setBackendServerPort(int backendServerPort);
int getHealthCheckInterval()const;
void setHealthCheckInterval(int healthCheckInterval);
std::string getXForwardedFor_proto()const;
void setXForwardedFor_proto(const std::string& xForwardedFor_proto);
std::string getXForwardedFor_SLBID()const;
void setXForwardedFor_SLBID(const std::string& xForwardedFor_SLBID);
int getHealthCheckConnectPort()const;
void setHealthCheckConnectPort(int healthCheckConnectPort);
std::string getHealthCheckHttpCode()const;
void setHealthCheckHttpCode(const std::string& healthCheckHttpCode);
private:
std::string access_key_id_;
long resourceOwnerId_;
int healthCheckTimeout_;
std::string xForwardedFor_;
std::string healthCheckURI_;
int unhealthyThreshold_;
int healthyThreshold_;
std::string accessKeyId_;
std::string scheduler_;
std::string healthCheck_;
int maxConnection_;
std::string regionId_;
int cookieTimeout_;
std::string stickySessionType_;
std::string vServerGroupId_;
int listenerPort_;
std::string cookie_;
std::string resourceOwnerAccount_;
int bandwidth_;
std::string stickySession_;
std::string healthCheckDomain_;
std::string ownerAccount_;
std::string gzip_;
long ownerId_;
std::string tags_;
std::string loadBalancerId_;
std::string xForwardedFor_SLBIP_;
int backendServerPort_;
int healthCheckInterval_;
std::string xForwardedFor_proto_;
std::string xForwardedFor_SLBID_;
int healthCheckConnectPort_;
std::string healthCheckHttpCode_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPLISTENERREQUEST_H_

49
slb/include/alibabacloud/slb/model/CreateLoadBalancerHTTPListenerResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPLISTENERRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPLISTENERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerHTTPListenerResult : public ServiceResult
{
public:
CreateLoadBalancerHTTPListenerResult();
explicit CreateLoadBalancerHTTPListenerResult(const std::string &payload);
~CreateLoadBalancerHTTPListenerResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPLISTENERRESULT_H_

149
slb/include/alibabacloud/slb/model/CreateLoadBalancerHTTPSListenerRequest.h Normal file
View File

@@ -0,0 +1,149 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPSLISTENERREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPSLISTENERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerHTTPSListenerRequest : public SlbRequest
{
public:
CreateLoadBalancerHTTPSListenerRequest();
~CreateLoadBalancerHTTPSListenerRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
int getHealthCheckTimeout()const;
void setHealthCheckTimeout(int healthCheckTimeout);
std::string getXForwardedFor()const;
void setXForwardedFor(const std::string& xForwardedFor);
std::string getHealthCheckURI()const;
void setHealthCheckURI(const std::string& healthCheckURI);
int getUnhealthyThreshold()const;
void setUnhealthyThreshold(int unhealthyThreshold);
int getHealthyThreshold()const;
void setHealthyThreshold(int healthyThreshold);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getScheduler()const;
void setScheduler(const std::string& scheduler);
std::string getHealthCheck()const;
void setHealthCheck(const std::string& healthCheck);
int getMaxConnection()const;
void setMaxConnection(int maxConnection);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getCookieTimeout()const;
void setCookieTimeout(int cookieTimeout);
std::string getStickySessionType()const;
void setStickySessionType(const std::string& stickySessionType);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getCookie()const;
void setCookie(const std::string& cookie);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
int getBandwidth()const;
void setBandwidth(int bandwidth);
std::string getStickySession()const;
void setStickySession(const std::string& stickySession);
std::string getHealthCheckDomain()const;
void setHealthCheckDomain(const std::string& healthCheckDomain);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getGzip()const;
void setGzip(const std::string& gzip);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getServerCertificateId()const;
void setServerCertificateId(const std::string& serverCertificateId);
std::string getCACertificateId()const;
void setCACertificateId(const std::string& cACertificateId);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getXForwardedFor_SLBIP()const;
void setXForwardedFor_SLBIP(const std::string& xForwardedFor_SLBIP);
int getBackendServerPort()const;
void setBackendServerPort(int backendServerPort);
int getHealthCheckInterval()const;
void setHealthCheckInterval(int healthCheckInterval);
std::string getXForwardedFor_proto()const;
void setXForwardedFor_proto(const std::string& xForwardedFor_proto);
std::string getXForwardedFor_SLBID()const;
void setXForwardedFor_SLBID(const std::string& xForwardedFor_SLBID);
int getHealthCheckConnectPort()const;
void setHealthCheckConnectPort(int healthCheckConnectPort);
std::string getHealthCheckHttpCode()const;
void setHealthCheckHttpCode(const std::string& healthCheckHttpCode);
private:
std::string access_key_id_;
long resourceOwnerId_;
int healthCheckTimeout_;
std::string xForwardedFor_;
std::string healthCheckURI_;
int unhealthyThreshold_;
int healthyThreshold_;
std::string accessKeyId_;
std::string scheduler_;
std::string healthCheck_;
int maxConnection_;
std::string regionId_;
int cookieTimeout_;
std::string stickySessionType_;
std::string vServerGroupId_;
int listenerPort_;
std::string cookie_;
std::string resourceOwnerAccount_;
int bandwidth_;
std::string stickySession_;
std::string healthCheckDomain_;
std::string ownerAccount_;
std::string gzip_;
long ownerId_;
std::string serverCertificateId_;
std::string cACertificateId_;
std::string tags_;
std::string loadBalancerId_;
std::string xForwardedFor_SLBIP_;
int backendServerPort_;
int healthCheckInterval_;
std::string xForwardedFor_proto_;
std::string xForwardedFor_SLBID_;
int healthCheckConnectPort_;
std::string healthCheckHttpCode_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPSLISTENERREQUEST_H_

49
slb/include/alibabacloud/slb/model/CreateLoadBalancerHTTPSListenerResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPSLISTENERRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPSLISTENERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerHTTPSListenerResult : public ServiceResult
{
public:
CreateLoadBalancerHTTPSListenerResult();
explicit CreateLoadBalancerHTTPSListenerResult(const std::string &payload);
~CreateLoadBalancerHTTPSListenerResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPSLISTENERRESULT_H_

116
slb/include/alibabacloud/slb/model/CreateLoadBalancerRequest.h Normal file
View File

@@ -0,0 +1,116 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerRequest : public SlbRequest
{
public:
CreateLoadBalancerRequest();
~CreateLoadBalancerRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getMasterZoneId()const;
void setMasterZoneId(const std::string& masterZoneId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
int getDuration()const;
void setDuration(int duration);
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
std::string getLoadBalancerName()const;
void setLoadBalancerName(const std::string& loadBalancerName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getAddressType()const;
void setAddressType(const std::string& addressType);
std::string getSlaveZoneId()const;
void setSlaveZoneId(const std::string& slaveZoneId);
std::string getLoadBalancerSpec()const;
void setLoadBalancerSpec(const std::string& loadBalancerSpec);
bool getAutoPay()const;
void setAutoPay(bool autoPay);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
int getBandwidth()const;
void setBandwidth(int bandwidth);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getVSwitchId()const;
void setVSwitchId(const std::string& vSwitchId);
std::string getEnableVpcVipFlow()const;
void setEnableVpcVipFlow(const std::string& enableVpcVipFlow);
std::string getInternetChargeType()const;
void setInternetChargeType(const std::string& internetChargeType);
std::string getVpcId()const;
void setVpcId(const std::string& vpcId);
std::string getPayType()const;
void setPayType(const std::string& payType);
std::string getPricingCycle()const;
void setPricingCycle(const std::string& pricingCycle);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string clientToken_;
std::string masterZoneId_;
std::string accessKeyId_;
int duration_;
std::string resourceGroupId_;
std::string loadBalancerName_;
std::string regionId_;
std::string addressType_;
std::string slaveZoneId_;
std::string loadBalancerSpec_;
bool autoPay_;
std::string resourceOwnerAccount_;
int bandwidth_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
std::string vSwitchId_;
std::string enableVpcVipFlow_;
std::string internetChargeType_;
std::string vpcId_;
std::string payType_;
std::string pricingCycle_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERREQUEST_H_

73
slb/include/alibabacloud/slb/model/CreateLoadBalancerResult.h Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerResult : public ServiceResult
{
public:
CreateLoadBalancerResult();
explicit CreateLoadBalancerResult(const std::string &payload);
~CreateLoadBalancerResult();
std::string getLoadBalancerName()const;
void setLoadBalancerName(const std::string& loadBalancerName);
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
std::string getAddress()const;
void setAddress(const std::string& address);
std::string getVpcId()const;
void setVpcId(const std::string& vpcId);
std::string getNetworkType()const;
void setNetworkType(const std::string& networkType);
std::string getVSwitchId()const;
void setVSwitchId(const std::string& vSwitchId);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
long getOrderId()const;
void setOrderId(long orderId);
protected:
void parse(const std::string &payload);
private:
std::string loadBalancerName_;
std::string resourceGroupId_;
std::string address_;
std::string vpcId_;
std::string networkType_;
std::string vSwitchId_;
std::string loadBalancerId_;
long orderId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERRESULT_H_

125
slb/include/alibabacloud/slb/model/CreateLoadBalancerTCPListenerRequest.h Normal file
View File

@@ -0,0 +1,125 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERTCPLISTENERREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERTCPLISTENERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerTCPListenerRequest : public SlbRequest
{
public:
CreateLoadBalancerTCPListenerRequest();
~CreateLoadBalancerTCPListenerRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
int getHealthCheckConnectTimeout()const;
void setHealthCheckConnectTimeout(int healthCheckConnectTimeout);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getHealthCheckURI()const;
void setHealthCheckURI(const std::string& healthCheckURI);
int getUnhealthyThreshold()const;
void setUnhealthyThreshold(int unhealthyThreshold);
int getHealthyThreshold()const;
void setHealthyThreshold(int healthyThreshold);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getScheduler()const;
void setScheduler(const std::string& scheduler);
int getEstablishedTimeout()const;
void setEstablishedTimeout(int establishedTimeout);
int getMaxConnection()const;
void setMaxConnection(int maxConnection);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getPersistenceTimeout()const;
void setPersistenceTimeout(int persistenceTimeout);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getHealthCheckType()const;
void setHealthCheckType(const std::string& healthCheckType);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
int getBandwidth()const;
void setBandwidth(int bandwidth);
std::string getHealthCheckDomain()const;
void setHealthCheckDomain(const std::string& healthCheckDomain);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getMasterSlaveServerGroupId()const;
void setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId);
int getBackendServerPort()const;
void setBackendServerPort(int backendServerPort);
int getHealthCheckInterval()const;
void setHealthCheckInterval(int healthCheckInterval);
int getHealthCheckConnectPort()const;
void setHealthCheckConnectPort(int healthCheckConnectPort);
std::string getHealthCheckHttpCode()const;
void setHealthCheckHttpCode(const std::string& healthCheckHttpCode);
private:
std::string access_key_id_;
int healthCheckConnectTimeout_;
long resourceOwnerId_;
std::string healthCheckURI_;
int unhealthyThreshold_;
int healthyThreshold_;
std::string accessKeyId_;
std::string scheduler_;
int establishedTimeout_;
int maxConnection_;
std::string regionId_;
int persistenceTimeout_;
std::string vServerGroupId_;
int listenerPort_;
std::string healthCheckType_;
std::string resourceOwnerAccount_;
int bandwidth_;
std::string healthCheckDomain_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
std::string loadBalancerId_;
std::string masterSlaveServerGroupId_;
int backendServerPort_;
int healthCheckInterval_;
int healthCheckConnectPort_;
std::string healthCheckHttpCode_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERTCPLISTENERREQUEST_H_

49
slb/include/alibabacloud/slb/model/CreateLoadBalancerTCPListenerResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERTCPLISTENERRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERTCPLISTENERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerTCPListenerResult : public ServiceResult
{
public:
CreateLoadBalancerTCPListenerResult();
explicit CreateLoadBalancerTCPListenerResult(const std::string &payload);
~CreateLoadBalancerTCPListenerResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERTCPLISTENERRESULT_H_

116
slb/include/alibabacloud/slb/model/CreateLoadBalancerUDPListenerRequest.h Normal file
View File

@@ -0,0 +1,116 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERUDPLISTENERREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERUDPLISTENERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerUDPListenerRequest : public SlbRequest
{
public:
CreateLoadBalancerUDPListenerRequest();
~CreateLoadBalancerUDPListenerRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
int getHealthCheckConnectTimeout()const;
void setHealthCheckConnectTimeout(int healthCheckConnectTimeout);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
int getUnhealthyThreshold()const;
void setUnhealthyThreshold(int unhealthyThreshold);
int getHealthyThreshold()const;
void setHealthyThreshold(int healthyThreshold);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getScheduler()const;
void setScheduler(const std::string& scheduler);
int getMaxConnection()const;
void setMaxConnection(int maxConnection);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getPersistenceTimeout()const;
void setPersistenceTimeout(int persistenceTimeout);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
int getBandwidth()const;
void setBandwidth(int bandwidth);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getMasterSlaveServerGroupId()const;
void setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId);
std::string getHealthCheckReq()const;
void setHealthCheckReq(const std::string& healthCheckReq);
int getBackendServerPort()const;
void setBackendServerPort(int backendServerPort);
int getHealthCheckInterval()const;
void setHealthCheckInterval(int healthCheckInterval);
std::string getHealthCheckExp()const;
void setHealthCheckExp(const std::string& healthCheckExp);
int getHealthCheckConnectPort()const;
void setHealthCheckConnectPort(int healthCheckConnectPort);
private:
std::string access_key_id_;
int healthCheckConnectTimeout_;
long resourceOwnerId_;
int unhealthyThreshold_;
int healthyThreshold_;
std::string accessKeyId_;
std::string scheduler_;
int maxConnection_;
std::string regionId_;
int persistenceTimeout_;
std::string vServerGroupId_;
int listenerPort_;
std::string resourceOwnerAccount_;
int bandwidth_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
std::string loadBalancerId_;
std::string masterSlaveServerGroupId_;
std::string healthCheckReq_;
int backendServerPort_;
int healthCheckInterval_;
std::string healthCheckExp_;
int healthCheckConnectPort_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERUDPLISTENERREQUEST_H_

49
slb/include/alibabacloud/slb/model/CreateLoadBalancerUDPListenerResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERUDPLISTENERRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERUDPLISTENERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerUDPListenerResult : public ServiceResult
{
public:
CreateLoadBalancerUDPListenerResult();
explicit CreateLoadBalancerUDPListenerResult(const std::string &payload);
~CreateLoadBalancerUDPListenerResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERUDPLISTENERRESULT_H_

77
slb/include/alibabacloud/slb/model/CreateMasterSlaveServerGroupRequest.h Normal file
View File

@@ -0,0 +1,77 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVESERVERGROUPREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVESERVERGROUPREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateMasterSlaveServerGroupRequest : public SlbRequest
{
public:
CreateMasterSlaveServerGroupRequest();
~CreateMasterSlaveServerGroupRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getMasterSlaveBackendServers()const;
void setMasterSlaveBackendServers(const std::string& masterSlaveBackendServers);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getMasterSlaveServerGroupName()const;
void setMasterSlaveServerGroupName(const std::string& masterSlaveServerGroupName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string masterSlaveBackendServers_;
std::string loadBalancerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
std::string masterSlaveServerGroupName_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVESERVERGROUPREQUEST_H_

62
slb/include/alibabacloud/slb/model/CreateMasterSlaveServerGroupResult.h Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVESERVERGROUPRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVESERVERGROUPRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateMasterSlaveServerGroupResult : public ServiceResult
{
public:
struct MasterSlaveBackendServer
{
std::string serverType;
std::string serverId;
int port;
int weight;
};
CreateMasterSlaveServerGroupResult();
explicit CreateMasterSlaveServerGroupResult(const std::string &payload);
~CreateMasterSlaveServerGroupResult();
std::string getMasterSlaveServerGroupId()const;
void setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId);
std::vector<MasterSlaveBackendServer> getMasterSlaveBackendServers()const;
void setMasterSlaveBackendServers(const std::vector<MasterSlaveBackendServer>& masterSlaveBackendServers);
protected:
void parse(const std::string &payload);
private:
std::string masterSlaveServerGroupId_;
std::vector<MasterSlaveBackendServer> masterSlaveBackendServers_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVESERVERGROUPRESULT_H_

77
slb/include/alibabacloud/slb/model/CreateMasterSlaveVServerGroupRequest.h Normal file
View File

@@ -0,0 +1,77 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateMasterSlaveVServerGroupRequest : public SlbRequest
{
public:
CreateMasterSlaveVServerGroupRequest();
~CreateMasterSlaveVServerGroupRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getMasterSlaveBackendServers()const;
void setMasterSlaveBackendServers(const std::string& masterSlaveBackendServers);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getMasterSlaveVServerGroupName()const;
void setMasterSlaveVServerGroupName(const std::string& masterSlaveVServerGroupName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string masterSlaveBackendServers_;
std::string loadBalancerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
std::string masterSlaveVServerGroupName_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPREQUEST_H_

62
slb/include/alibabacloud/slb/model/CreateMasterSlaveVServerGroupResult.h Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateMasterSlaveVServerGroupResult : public ServiceResult
{
public:
struct MasterSlaveBackendServer
{
std::string serverId;
int port;
int isBackup;
int weight;
};
CreateMasterSlaveVServerGroupResult();
explicit CreateMasterSlaveVServerGroupResult(const std::string &payload);
~CreateMasterSlaveVServerGroupResult();
std::string getMasterSlaveVServerGroupId()const;
void setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId);
std::vector<MasterSlaveBackendServer> getMasterSlaveBackendServers()const;
void setMasterSlaveBackendServers(const std::vector<MasterSlaveBackendServer>& masterSlaveBackendServers);
protected:
void parse(const std::string &payload);
private:
std::string masterSlaveVServerGroupId_;
std::vector<MasterSlaveBackendServer> masterSlaveBackendServers_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVEVSERVERGROUPRESULT_H_

77
slb/include/alibabacloud/slb/model/CreateRulesRequest.h Normal file
View File

@@ -0,0 +1,77 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_CREATERULESREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_CREATERULESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateRulesRequest : public SlbRequest
{
public:
CreateRulesRequest();
~CreateRulesRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getRuleList()const;
void setRuleList(const std::string& ruleList);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
int listenerPort_;
std::string loadBalancerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ruleList_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATERULESREQUEST_H_

57
slb/include/alibabacloud/slb/model/CreateRulesResult.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_CREATERULESRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_CREATERULESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateRulesResult : public ServiceResult
{
public:
struct Rule
{
std::string ruleId;
std::string ruleName;
};
CreateRulesResult();
explicit CreateRulesResult(const std::string &payload);
~CreateRulesResult();
std::vector<Rule> getRules()const;
void setRules(const std::vector<Rule>& rules);
protected:
void parse(const std::string &payload);
private:
std::vector<Rule> rules_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATERULESRESULT_H_

77
slb/include/alibabacloud/slb/model/CreateVServerGroupRequest.h Normal file
View File

@@ -0,0 +1,77 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_CREATEVSERVERGROUPREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_CREATEVSERVERGROUPREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateVServerGroupRequest : public SlbRequest
{
public:
CreateVServerGroupRequest();
~CreateVServerGroupRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getBackendServers()const;
void setBackendServers(const std::string& backendServers);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getVServerGroupName()const;
void setVServerGroupName(const std::string& vServerGroupName);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string loadBalancerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string backendServers_;
std::string accessKeyId_;
std::string tags_;
std::string vServerGroupName_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATEVSERVERGROUPREQUEST_H_

61
slb/include/alibabacloud/slb/model/CreateVServerGroupResult.h Normal file
View File

@@ -0,0 +1,61 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_CREATEVSERVERGROUPRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_CREATEVSERVERGROUPRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT CreateVServerGroupResult : public ServiceResult
{
public:
struct BackendServer
{
std::string serverId;
int port;
int weight;
};
CreateVServerGroupResult();
explicit CreateVServerGroupResult(const std::string &payload);
~CreateVServerGroupResult();
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
std::vector<BackendServer> getBackendServers()const;
void setBackendServers(const std::vector<BackendServer>& backendServers);
protected:
void parse(const std::string &payload);
private:
std::string vServerGroupId_;
std::vector<BackendServer> backendServers_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATEVSERVERGROUPRESULT_H_

68
slb/include/alibabacloud/slb/model/DeleteCACertificateRequest.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DELETECACERTIFICATEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETECACERTIFICATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteCACertificateRequest : public SlbRequest
{
public:
DeleteCACertificateRequest();
~DeleteCACertificateRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getCACertificateId()const;
void setCACertificateId(const std::string& cACertificateId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string cACertificateId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETECACERTIFICATEREQUEST_H_

49
slb/include/alibabacloud/slb/model/DeleteCACertificateResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DELETECACERTIFICATERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DELETECACERTIFICATERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteCACertificateResult : public ServiceResult
{
public:
DeleteCACertificateResult();
explicit DeleteCACertificateResult(const std::string &payload);
~DeleteCACertificateResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETECACERTIFICATERESULT_H_

74
slb/include/alibabacloud/slb/model/DeleteLoadBalancerListenerRequest.h Normal file
View File

@@ -0,0 +1,74 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERLISTENERREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERLISTENERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteLoadBalancerListenerRequest : public SlbRequest
{
public:
DeleteLoadBalancerListenerRequest();
~DeleteLoadBalancerListenerRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
int listenerPort_;
std::string loadBalancerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERLISTENERREQUEST_H_

49
slb/include/alibabacloud/slb/model/DeleteLoadBalancerListenerResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERLISTENERRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERLISTENERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteLoadBalancerListenerResult : public ServiceResult
{
public:
DeleteLoadBalancerListenerResult();
explicit DeleteLoadBalancerListenerResult(const std::string &payload);
~DeleteLoadBalancerListenerResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERLISTENERRESULT_H_

71
slb/include/alibabacloud/slb/model/DeleteLoadBalancerRequest.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteLoadBalancerRequest : public SlbRequest
{
public:
DeleteLoadBalancerRequest();
~DeleteLoadBalancerRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string loadBalancerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERREQUEST_H_

49
slb/include/alibabacloud/slb/model/DeleteLoadBalancerResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteLoadBalancerResult : public ServiceResult
{
public:
DeleteLoadBalancerResult();
explicit DeleteLoadBalancerResult(const std::string &payload);
~DeleteLoadBalancerResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETELOADBALANCERRESULT_H_

71
slb/include/alibabacloud/slb/model/DeleteMasterSlaveServerGroupRequest.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVESERVERGROUPREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVESERVERGROUPREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteMasterSlaveServerGroupRequest : public SlbRequest
{
public:
DeleteMasterSlaveServerGroupRequest();
~DeleteMasterSlaveServerGroupRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getMasterSlaveServerGroupId()const;
void setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string masterSlaveServerGroupId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVESERVERGROUPREQUEST_H_

49
slb/include/alibabacloud/slb/model/DeleteMasterSlaveServerGroupResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVESERVERGROUPRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVESERVERGROUPRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteMasterSlaveServerGroupResult : public ServiceResult
{
public:
DeleteMasterSlaveServerGroupResult();
explicit DeleteMasterSlaveServerGroupResult(const std::string &payload);
~DeleteMasterSlaveServerGroupResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVESERVERGROUPRESULT_H_

71
slb/include/alibabacloud/slb/model/DeleteMasterSlaveVServerGroupRequest.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteMasterSlaveVServerGroupRequest : public SlbRequest
{
public:
DeleteMasterSlaveVServerGroupRequest();
~DeleteMasterSlaveVServerGroupRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getMasterSlaveVServerGroupId()const;
void setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string masterSlaveVServerGroupId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPREQUEST_H_

49
slb/include/alibabacloud/slb/model/DeleteMasterSlaveVServerGroupResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteMasterSlaveVServerGroupResult : public ServiceResult
{
public:
DeleteMasterSlaveVServerGroupResult();
explicit DeleteMasterSlaveVServerGroupResult(const std::string &payload);
~DeleteMasterSlaveVServerGroupResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVEVSERVERGROUPRESULT_H_

71
slb/include/alibabacloud/slb/model/DeleteRulesRequest.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DELETERULESREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETERULESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteRulesRequest : public SlbRequest
{
public:
DeleteRulesRequest();
~DeleteRulesRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getRuleIds()const;
void setRuleIds(const std::string& ruleIds);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string ruleIds_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETERULESREQUEST_H_

49
slb/include/alibabacloud/slb/model/DeleteRulesResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DELETERULESRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DELETERULESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteRulesResult : public ServiceResult
{
public:
DeleteRulesResult();
explicit DeleteRulesResult(const std::string &payload);
~DeleteRulesResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETERULESRESULT_H_

71
slb/include/alibabacloud/slb/model/DeleteServerCertificateRequest.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DELETESERVERCERTIFICATEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETESERVERCERTIFICATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteServerCertificateRequest : public SlbRequest
{
public:
DeleteServerCertificateRequest();
~DeleteServerCertificateRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getServerCertificateId()const;
void setServerCertificateId(const std::string& serverCertificateId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string serverCertificateId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETESERVERCERTIFICATEREQUEST_H_

49
slb/include/alibabacloud/slb/model/DeleteServerCertificateResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DELETESERVERCERTIFICATERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DELETESERVERCERTIFICATERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteServerCertificateResult : public ServiceResult
{
public:
DeleteServerCertificateResult();
explicit DeleteServerCertificateResult(const std::string &payload);
~DeleteServerCertificateResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETESERVERCERTIFICATERESULT_H_

71
slb/include/alibabacloud/slb/model/DeleteVServerGroupRequest.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DELETEVSERVERGROUPREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETEVSERVERGROUPREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteVServerGroupRequest : public SlbRequest
{
public:
DeleteVServerGroupRequest();
~DeleteVServerGroupRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
std::string vServerGroupId_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETEVSERVERGROUPREQUEST_H_

49
slb/include/alibabacloud/slb/model/DeleteVServerGroupResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DELETEVSERVERGROUPRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DELETEVSERVERGROUPRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DeleteVServerGroupResult : public ServiceResult
{
public:
DeleteVServerGroupResult();
explicit DeleteVServerGroupResult(const std::string &payload);
~DeleteVServerGroupResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETEVSERVERGROUPRESULT_H_

71
slb/include/alibabacloud/slb/model/DescribeCACertificatesRequest.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBECACERTIFICATESREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBECACERTIFICATESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeCACertificatesRequest : public SlbRequest
{
public:
DescribeCACertificatesRequest();
~DescribeCACertificatesRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getCACertificateId()const;
void setCACertificateId(const std::string& cACertificateId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string access_key_id_;
std::string resourceGroupId_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string cACertificateId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBECACERTIFICATESREQUEST_H_

62
slb/include/alibabacloud/slb/model/DescribeCACertificatesResult.h Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBECACERTIFICATESRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBECACERTIFICATESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeCACertificatesResult : public ServiceResult
{
public:
struct CACertificate
{
std::string fingerprint;
std::string resourceGroupId;
std::string cACertificateId;
std::string createTime;
std::string cACertificateName;
std::string regionId;
long createTimeStamp;
};
DescribeCACertificatesResult();
explicit DescribeCACertificatesResult(const std::string &payload);
~DescribeCACertificatesResult();
std::vector<CACertificate> getCACertificates()const;
void setCACertificates(const std::vector<CACertificate>& cACertificates);
protected:
void parse(const std::string &payload);
private:
std::vector<CACertificate> cACertificates_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBECACERTIFICATESRESULT_H_

74
slb/include/alibabacloud/slb/model/DescribeHealthStatusRequest.h Normal file
View File

@@ -0,0 +1,74 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBEHEALTHSTATUSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEHEALTHSTATUSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeHealthStatusRequest : public SlbRequest
{
public:
DescribeHealthStatusRequest();
~DescribeHealthStatusRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
int listenerPort_;
std::string loadBalancerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEHEALTHSTATUSREQUEST_H_

59
slb/include/alibabacloud/slb/model/DescribeHealthStatusResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBEHEALTHSTATUSRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEHEALTHSTATUSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeHealthStatusResult : public ServiceResult
{
public:
struct BackendServer
{
int listenerPort;
std::string serverId;
int port;
std::string serverHealthStatus;
};
DescribeHealthStatusResult();
explicit DescribeHealthStatusResult(const std::string &payload);
~DescribeHealthStatusResult();
std::vector<BackendServer> getBackendServers()const;
void setBackendServers(const std::vector<BackendServer>& backendServers);
protected:
void parse(const std::string &payload);
private:
std::vector<BackendServer> backendServers_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEHEALTHSTATUSRESULT_H_

74
slb/include/alibabacloud/slb/model/DescribeListenerAccessControlAttributeRequest.h Normal file
View File

@@ -0,0 +1,74 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBELISTENERACCESSCONTROLATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELISTENERACCESSCONTROLATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeListenerAccessControlAttributeRequest : public SlbRequest
{
public:
DescribeListenerAccessControlAttributeRequest();
~DescribeListenerAccessControlAttributeRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
int listenerPort_;
std::string loadBalancerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELISTENERACCESSCONTROLATTRIBUTEREQUEST_H_

55
slb/include/alibabacloud/slb/model/DescribeListenerAccessControlAttributeResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBELISTENERACCESSCONTROLATTRIBUTERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELISTENERACCESSCONTROLATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeListenerAccessControlAttributeResult : public ServiceResult
{
public:
DescribeListenerAccessControlAttributeResult();
explicit DescribeListenerAccessControlAttributeResult(const std::string &payload);
~DescribeListenerAccessControlAttributeResult();
std::string getAccessControlStatus()const;
void setAccessControlStatus(const std::string& accessControlStatus);
std::string getSourceItems()const;
void setSourceItems(const std::string& sourceItems);
protected:
void parse(const std::string &payload);
private:
std::string accessControlStatus_;
std::string sourceItems_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELISTENERACCESSCONTROLATTRIBUTERESULT_H_

71
slb/include/alibabacloud/slb/model/DescribeLoadBalancerAttributeRequest.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerAttributeRequest : public SlbRequest
{
public:
DescribeLoadBalancerAttributeRequest();
~DescribeLoadBalancerAttributeRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string loadBalancerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERATTRIBUTEREQUEST_H_

142
slb/include/alibabacloud/slb/model/DescribeLoadBalancerAttributeResult.h Normal file
View File

@@ -0,0 +1,142 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERATTRIBUTERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerAttributeResult : public ServiceResult
{
public:
struct ListenerPortAndProtocal
{
int listenerPort;
std::string listenerProtocal;
};
struct ListenerPortAndProtocol
{
int listenerPort;
std::string listenerProtocol;
};
struct BackendServer
{
std::string serverId;
int weight;
};
DescribeLoadBalancerAttributeResult();
explicit DescribeLoadBalancerAttributeResult(const std::string &payload);
~DescribeLoadBalancerAttributeResult();
std::vector<ListenerPortAndProtocal> getListenerPortsAndProtocal()const;
void setListenerPortsAndProtocal(const std::vector<ListenerPortAndProtocal>& listenerPortsAndProtocal);
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
std::string getAddress()const;
void setAddress(const std::string& address);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::vector<ListenerPortAndProtocol> getListenerPortsAndProtocol()const;
void setListenerPortsAndProtocol(const std::vector<ListenerPortAndProtocol>& listenerPortsAndProtocol);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::vector<BackendServer> getBackendServers()const;
void setBackendServers(const std::vector<BackendServer>& backendServers);
std::string getLoadBalancerSpec()const;
void setLoadBalancerSpec(const std::string& loadBalancerSpec);
std::string getNetworkType()const;
void setNetworkType(const std::string& networkType);
int getBandwidth()const;
void setBandwidth(int bandwidth);
std::vector<std::string> getListenerPorts()const;
void setListenerPorts(const std::vector<std::string>& listenerPorts);
std::string getMasterZoneId()const;
void setMasterZoneId(const std::string& masterZoneId);
std::string getVSwitchId()const;
void setVSwitchId(const std::string& vSwitchId);
std::string getCreateTime()const;
void setCreateTime(const std::string& createTime);
std::string getPayType()const;
void setPayType(const std::string& payType);
std::string getSlaveZoneId()const;
void setSlaveZoneId(const std::string& slaveZoneId);
std::string getInternetChargeType()const;
void setInternetChargeType(const std::string& internetChargeType);
std::string getRegionIdAlias()const;
void setRegionIdAlias(const std::string& regionIdAlias);
std::string getLoadBalancerName()const;
void setLoadBalancerName(const std::string& loadBalancerName);
std::string getVpcId()const;
void setVpcId(const std::string& vpcId);
long getEndTimeStamp()const;
void setEndTimeStamp(long endTimeStamp);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getAddressType()const;
void setAddressType(const std::string& addressType);
std::string getLoadBalancerStatus()const;
void setLoadBalancerStatus(const std::string& loadBalancerStatus);
long getCreateTimeStamp()const;
void setCreateTimeStamp(long createTimeStamp);
long getAutoReleaseTime()const;
void setAutoReleaseTime(long autoReleaseTime);
protected:
void parse(const std::string &payload);
private:
std::vector<ListenerPortAndProtocal> listenerPortsAndProtocal_;
std::string resourceGroupId_;
std::string address_;
std::string endTime_;
std::vector<ListenerPortAndProtocol> listenerPortsAndProtocol_;
std::string loadBalancerId_;
std::vector<BackendServer> backendServers_;
std::string loadBalancerSpec_;
std::string networkType_;
int bandwidth_;
std::vector<std::string> listenerPorts_;
std::string masterZoneId_;
std::string vSwitchId_;
std::string createTime_;
std::string payType_;
std::string slaveZoneId_;
std::string internetChargeType_;
std::string regionIdAlias_;
std::string loadBalancerName_;
std::string vpcId_;
long endTimeStamp_;
std::string regionId_;
std::string addressType_;
std::string loadBalancerStatus_;
long createTimeStamp_;
long autoReleaseTime_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERATTRIBUTERESULT_H_

71
slb/include/alibabacloud/slb/model/DescribeLoadBalancerAutoReleaseTimeRequest.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERAUTORELEASETIMEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERAUTORELEASETIMEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerAutoReleaseTimeRequest : public SlbRequest
{
public:
DescribeLoadBalancerAutoReleaseTimeRequest();
~DescribeLoadBalancerAutoReleaseTimeRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string loadBalancerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERAUTORELEASETIMEREQUEST_H_

52
slb/include/alibabacloud/slb/model/DescribeLoadBalancerAutoReleaseTimeResult.h Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERAUTORELEASETIMERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERAUTORELEASETIMERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerAutoReleaseTimeResult : public ServiceResult
{
public:
DescribeLoadBalancerAutoReleaseTimeResult();
explicit DescribeLoadBalancerAutoReleaseTimeResult(const std::string &payload);
~DescribeLoadBalancerAutoReleaseTimeResult();
long getAutoReleaseTime()const;
void setAutoReleaseTime(long autoReleaseTime);
protected:
void parse(const std::string &payload);
private:
long autoReleaseTime_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERAUTORELEASETIMERESULT_H_

74
slb/include/alibabacloud/slb/model/DescribeLoadBalancerHTTPListenerAttributeRequest.h Normal file
View File

@@ -0,0 +1,74 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPLISTENERATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPLISTENERATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerHTTPListenerAttributeRequest : public SlbRequest
{
public:
DescribeLoadBalancerHTTPListenerAttributeRequest();
~DescribeLoadBalancerHTTPListenerAttributeRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
int listenerPort_;
std::string loadBalancerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPLISTENERATTRIBUTEREQUEST_H_

127
slb/include/alibabacloud/slb/model/DescribeLoadBalancerHTTPListenerAttributeResult.h Normal file
View File

@@ -0,0 +1,127 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPLISTENERATTRIBUTERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPLISTENERATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerHTTPListenerAttributeResult : public ServiceResult
{
public:
DescribeLoadBalancerHTTPListenerAttributeResult();
explicit DescribeLoadBalancerHTTPListenerAttributeResult(const std::string &payload);
~DescribeLoadBalancerHTTPListenerAttributeResult();
int getCookieTimeout()const;
void setCookieTimeout(int cookieTimeout);
int getMaxConnection()const;
void setMaxConnection(int maxConnection);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
int getUnhealthyThreshold()const;
void setUnhealthyThreshold(int unhealthyThreshold);
std::string getScheduler()const;
void setScheduler(const std::string& scheduler);
std::string getHealthCheckURI()const;
void setHealthCheckURI(const std::string& healthCheckURI);
std::string getHealthCheck()const;
void setHealthCheck(const std::string& healthCheck);
int getBackendServerPort()const;
void setBackendServerPort(int backendServerPort);
std::string getXForwardedFor_SLBID()const;
void setXForwardedFor_SLBID(const std::string& xForwardedFor_SLBID);
int getHealthCheckConnectPort()const;
void setHealthCheckConnectPort(int healthCheckConnectPort);
int getBandwidth()const;
void setBandwidth(int bandwidth);
std::string getSecurityStatus()const;
void setSecurityStatus(const std::string& securityStatus);
std::string getGzip()const;
void setGzip(const std::string& gzip);
std::string getStickySessionType()const;
void setStickySessionType(const std::string& stickySessionType);
std::string getXForwardedFor_SLBIP()const;
void setXForwardedFor_SLBIP(const std::string& xForwardedFor_SLBIP);
std::string getHealthCheckHttpCode()const;
void setHealthCheckHttpCode(const std::string& healthCheckHttpCode);
std::string getStatus()const;
void setStatus(const std::string& status);
std::string getCookie()const;
void setCookie(const std::string& cookie);
int getListenerPort()const;
void setListenerPort(int listenerPort);
int getHealthCheckInterval()const;
void setHealthCheckInterval(int healthCheckInterval);
int getHealthCheckTimeout()const;
void setHealthCheckTimeout(int healthCheckTimeout);
std::string getStickySession()const;
void setStickySession(const std::string& stickySession);
int getHealthyThreshold()const;
void setHealthyThreshold(int healthyThreshold);
std::string getXForwardedFor()const;
void setXForwardedFor(const std::string& xForwardedFor);
std::string getHealthCheckDomain()const;
void setHealthCheckDomain(const std::string& healthCheckDomain);
std::string getXForwardedFor_proto()const;
void setXForwardedFor_proto(const std::string& xForwardedFor_proto);
protected:
void parse(const std::string &payload);
private:
int cookieTimeout_;
int maxConnection_;
std::string vServerGroupId_;
int unhealthyThreshold_;
std::string scheduler_;
std::string healthCheckURI_;
std::string healthCheck_;
int backendServerPort_;
std::string xForwardedFor_SLBID_;
int healthCheckConnectPort_;
int bandwidth_;
std::string securityStatus_;
std::string gzip_;
std::string stickySessionType_;
std::string xForwardedFor_SLBIP_;
std::string healthCheckHttpCode_;
std::string status_;
std::string cookie_;
int listenerPort_;
int healthCheckInterval_;
int healthCheckTimeout_;
std::string stickySession_;
int healthyThreshold_;
std::string xForwardedFor_;
std::string healthCheckDomain_;
std::string xForwardedFor_proto_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPLISTENERATTRIBUTERESULT_H_

74
slb/include/alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeRequest.h Normal file
View File

@@ -0,0 +1,74 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPSLISTENERATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPSLISTENERATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerHTTPSListenerAttributeRequest : public SlbRequest
{
public:
DescribeLoadBalancerHTTPSListenerAttributeRequest();
~DescribeLoadBalancerHTTPSListenerAttributeRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
int listenerPort_;
std::string loadBalancerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPSLISTENERATTRIBUTEREQUEST_H_

133
slb/include/alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeResult.h Normal file
View File

@@ -0,0 +1,133 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPSLISTENERATTRIBUTERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPSLISTENERATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerHTTPSListenerAttributeResult : public ServiceResult
{
public:
DescribeLoadBalancerHTTPSListenerAttributeResult();
explicit DescribeLoadBalancerHTTPSListenerAttributeResult(const std::string &payload);
~DescribeLoadBalancerHTTPSListenerAttributeResult();
int getCookieTimeout()const;
void setCookieTimeout(int cookieTimeout);
int getMaxConnection()const;
void setMaxConnection(int maxConnection);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
int getUnhealthyThreshold()const;
void setUnhealthyThreshold(int unhealthyThreshold);
std::string getScheduler()const;
void setScheduler(const std::string& scheduler);
std::string getHealthCheckURI()const;
void setHealthCheckURI(const std::string& healthCheckURI);
std::string getHealthCheck()const;
void setHealthCheck(const std::string& healthCheck);
int getBackendServerPort()const;
void setBackendServerPort(int backendServerPort);
std::string getXForwardedFor_SLBID()const;
void setXForwardedFor_SLBID(const std::string& xForwardedFor_SLBID);
int getHealthCheckConnectPort()const;
void setHealthCheckConnectPort(int healthCheckConnectPort);
int getBandwidth()const;
void setBandwidth(int bandwidth);
std::string getSecurityStatus()const;
void setSecurityStatus(const std::string& securityStatus);
std::string getGzip()const;
void setGzip(const std::string& gzip);
std::string getServerCertificateId()const;
void setServerCertificateId(const std::string& serverCertificateId);
std::string getStickySessionType()const;
void setStickySessionType(const std::string& stickySessionType);
std::string getXForwardedFor_SLBIP()const;
void setXForwardedFor_SLBIP(const std::string& xForwardedFor_SLBIP);
std::string getHealthCheckHttpCode()const;
void setHealthCheckHttpCode(const std::string& healthCheckHttpCode);
std::string getStatus()const;
void setStatus(const std::string& status);
std::string getCookie()const;
void setCookie(const std::string& cookie);
int getListenerPort()const;
void setListenerPort(int listenerPort);
int getHealthCheckInterval()const;
void setHealthCheckInterval(int healthCheckInterval);
std::string getCACertificateId()const;
void setCACertificateId(const std::string& cACertificateId);
int getHealthCheckTimeout()const;
void setHealthCheckTimeout(int healthCheckTimeout);
std::string getStickySession()const;
void setStickySession(const std::string& stickySession);
int getHealthyThreshold()const;
void setHealthyThreshold(int healthyThreshold);
std::string getXForwardedFor()const;
void setXForwardedFor(const std::string& xForwardedFor);
std::string getHealthCheckDomain()const;
void setHealthCheckDomain(const std::string& healthCheckDomain);
std::string getXForwardedFor_proto()const;
void setXForwardedFor_proto(const std::string& xForwardedFor_proto);
protected:
void parse(const std::string &payload);
private:
int cookieTimeout_;
int maxConnection_;
std::string vServerGroupId_;
int unhealthyThreshold_;
std::string scheduler_;
std::string healthCheckURI_;
std::string healthCheck_;
int backendServerPort_;
std::string xForwardedFor_SLBID_;
int healthCheckConnectPort_;
int bandwidth_;
std::string securityStatus_;
std::string gzip_;
std::string serverCertificateId_;
std::string stickySessionType_;
std::string xForwardedFor_SLBIP_;
std::string healthCheckHttpCode_;
std::string status_;
std::string cookie_;
int listenerPort_;
int healthCheckInterval_;
std::string cACertificateId_;
int healthCheckTimeout_;
std::string stickySession_;
int healthyThreshold_;
std::string xForwardedFor_;
std::string healthCheckDomain_;
std::string xForwardedFor_proto_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPSLISTENERATTRIBUTERESULT_H_

74
slb/include/alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeRequest.h Normal file
View File

@@ -0,0 +1,74 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERTCPLISTENERATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERTCPLISTENERATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerTCPListenerAttributeRequest : public SlbRequest
{
public:
DescribeLoadBalancerTCPListenerAttributeRequest();
~DescribeLoadBalancerTCPListenerAttributeRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
int listenerPort_;
std::string loadBalancerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERTCPLISTENERATTRIBUTEREQUEST_H_

112
slb/include/alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeResult.h Normal file
View File

@@ -0,0 +1,112 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERTCPLISTENERATTRIBUTERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERTCPLISTENERATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerTCPListenerAttributeResult : public ServiceResult
{
public:
DescribeLoadBalancerTCPListenerAttributeResult();
explicit DescribeLoadBalancerTCPListenerAttributeResult(const std::string &payload);
~DescribeLoadBalancerTCPListenerAttributeResult();
std::string getStatus()const;
void setStatus(const std::string& status);
int getMaxConnection()const;
void setMaxConnection(int maxConnection);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
std::string getSynProxy()const;
void setSynProxy(const std::string& synProxy);
int getHealthCheckInterval()const;
void setHealthCheckInterval(int healthCheckInterval);
int getUnhealthyThreshold()const;
void setUnhealthyThreshold(int unhealthyThreshold);
std::string getScheduler()const;
void setScheduler(const std::string& scheduler);
std::string getHealthCheckURI()const;
void setHealthCheckURI(const std::string& healthCheckURI);
std::string getHealthCheck()const;
void setHealthCheck(const std::string& healthCheck);
int getHealthCheckConnectTimeout()const;
void setHealthCheckConnectTimeout(int healthCheckConnectTimeout);
int getBackendServerPort()const;
void setBackendServerPort(int backendServerPort);
int getPersistenceTimeout()const;
void setPersistenceTimeout(int persistenceTimeout);
int getHealthCheckConnectPort()const;
void setHealthCheckConnectPort(int healthCheckConnectPort);
int getBandwidth()const;
void setBandwidth(int bandwidth);
int getHealthyThreshold()const;
void setHealthyThreshold(int healthyThreshold);
std::string getHealthCheckDomain()const;
void setHealthCheckDomain(const std::string& healthCheckDomain);
std::string getMasterSlaveServerGroupId()const;
void setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId);
std::string getHealthCheckHttpCode()const;
void setHealthCheckHttpCode(const std::string& healthCheckHttpCode);
std::string getHealthCheckType()const;
void setHealthCheckType(const std::string& healthCheckType);
int getEstablishedTimeout()const;
void setEstablishedTimeout(int establishedTimeout);
protected:
void parse(const std::string &payload);
private:
std::string status_;
int maxConnection_;
int listenerPort_;
std::string vServerGroupId_;
std::string synProxy_;
int healthCheckInterval_;
int unhealthyThreshold_;
std::string scheduler_;
std::string healthCheckURI_;
std::string healthCheck_;
int healthCheckConnectTimeout_;
int backendServerPort_;
int persistenceTimeout_;
int healthCheckConnectPort_;
int bandwidth_;
int healthyThreshold_;
std::string healthCheckDomain_;
std::string masterSlaveServerGroupId_;
std::string healthCheckHttpCode_;
std::string healthCheckType_;
int establishedTimeout_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERTCPLISTENERATTRIBUTERESULT_H_

74
slb/include/alibabacloud/slb/model/DescribeLoadBalancerUDPListenerAttributeRequest.h Normal file
View File

@@ -0,0 +1,74 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERUDPLISTENERATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERUDPLISTENERATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerUDPListenerAttributeRequest : public SlbRequest
{
public:
DescribeLoadBalancerUDPListenerAttributeRequest();
~DescribeLoadBalancerUDPListenerAttributeRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
int listenerPort_;
std::string loadBalancerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERUDPLISTENERATTRIBUTEREQUEST_H_

100
slb/include/alibabacloud/slb/model/DescribeLoadBalancerUDPListenerAttributeResult.h Normal file
View File

@@ -0,0 +1,100 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERUDPLISTENERATTRIBUTERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERUDPLISTENERATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerUDPListenerAttributeResult : public ServiceResult
{
public:
DescribeLoadBalancerUDPListenerAttributeResult();
explicit DescribeLoadBalancerUDPListenerAttributeResult(const std::string &payload);
~DescribeLoadBalancerUDPListenerAttributeResult();
std::string getStatus()const;
void setStatus(const std::string& status);
int getMaxConnection()const;
void setMaxConnection(int maxConnection);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
int getHealthCheckInterval()const;
void setHealthCheckInterval(int healthCheckInterval);
int getUnhealthyThreshold()const;
void setUnhealthyThreshold(int unhealthyThreshold);
std::string getScheduler()const;
void setScheduler(const std::string& scheduler);
std::string getHealthCheck()const;
void setHealthCheck(const std::string& healthCheck);
int getHealthCheckConnectTimeout()const;
void setHealthCheckConnectTimeout(int healthCheckConnectTimeout);
int getBackendServerPort()const;
void setBackendServerPort(int backendServerPort);
int getPersistenceTimeout()const;
void setPersistenceTimeout(int persistenceTimeout);
int getHealthCheckConnectPort()const;
void setHealthCheckConnectPort(int healthCheckConnectPort);
std::string getHealthCheckReq()const;
void setHealthCheckReq(const std::string& healthCheckReq);
int getBandwidth()const;
void setBandwidth(int bandwidth);
int getHealthyThreshold()const;
void setHealthyThreshold(int healthyThreshold);
std::string getHealthCheckExp()const;
void setHealthCheckExp(const std::string& healthCheckExp);
std::string getMasterSlaveServerGroupId()const;
void setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId);
protected:
void parse(const std::string &payload);
private:
std::string status_;
int maxConnection_;
int listenerPort_;
std::string vServerGroupId_;
int healthCheckInterval_;
int unhealthyThreshold_;
std::string scheduler_;
std::string healthCheck_;
int healthCheckConnectTimeout_;
int backendServerPort_;
int persistenceTimeout_;
int healthCheckConnectPort_;
std::string healthCheckReq_;
int bandwidth_;
int healthyThreshold_;
std::string healthCheckExp_;
std::string masterSlaveServerGroupId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERUDPLISTENERATTRIBUTERESULT_H_

71
slb/include/alibabacloud/slb/model/DescribeLoadBalancersRelatedEcsRequest.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSRELATEDECSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSRELATEDECSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancersRelatedEcsRequest : public SlbRequest
{
public:
DescribeLoadBalancersRelatedEcsRequest();
~DescribeLoadBalancersRelatedEcsRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string loadBalancerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSRELATEDECSREQUEST_H_

99
slb/include/alibabacloud/slb/model/DescribeLoadBalancersRelatedEcsResult.h Normal file
View File

@@ -0,0 +1,99 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSRELATEDECSRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSRELATEDECSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancersRelatedEcsResult : public ServiceResult
{
public:
struct LoadBalancer
{
struct MasterSlaveVServerGroup
{
struct BackendServer
{
std::string networkType;
std::string vmName;
int port;
int weight;
};
std::string groupName;
std::vector<MasterSlaveVServerGroup::BackendServer> backendServers1;
std::string groupId;
};
struct VServerGroup
{
struct BackendServer
{
std::string networkType;
std::string vmName;
int port;
int weight;
};
std::string groupName;
std::vector<VServerGroup::BackendServer> backendServers2;
std::string groupId;
};
struct BackendServer
{
std::string networkType;
std::string vmName;
int port;
int weight;
};
std::string loadBalancerId;
std::vector<LoadBalancer::MasterSlaveVServerGroup> masterSlaveVServerGroups;
std::vector<LoadBalancer::VServerGroup> vServerGroups;
int count;
std::vector<LoadBalancer::BackendServer> backendServers;
};
DescribeLoadBalancersRelatedEcsResult();
explicit DescribeLoadBalancersRelatedEcsResult(const std::string &payload);
~DescribeLoadBalancersRelatedEcsResult();
std::string getMessage()const;
void setMessage(const std::string& message);
std::vector<LoadBalancer> getLoadBalancers()const;
void setLoadBalancers(const std::vector<LoadBalancer>& loadBalancers);
bool getSuccess()const;
void setSuccess(bool success);
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::vector<LoadBalancer> loadBalancers_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSRELATEDECSRESULT_H_

116
slb/include/alibabacloud/slb/model/DescribeLoadBalancersRequest.h Normal file
View File

@@ -0,0 +1,116 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancersRequest : public SlbRequest
{
public:
DescribeLoadBalancersRequest();
~DescribeLoadBalancersRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getNetworkType()const;
void setNetworkType(const std::string& networkType);
std::string getMasterZoneId()const;
void setMasterZoneId(const std::string& masterZoneId);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
std::string getLoadBalancerName()const;
void setLoadBalancerName(const std::string& loadBalancerName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getAddressType()const;
void setAddressType(const std::string& addressType);
std::string getSlaveZoneId()const;
void setSlaveZoneId(const std::string& slaveZoneId);
std::string getAddress()const;
void setAddress(const std::string& address);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getServerId()const;
void setServerId(const std::string& serverId);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getServerIntranetAddress()const;
void setServerIntranetAddress(const std::string& serverIntranetAddress);
std::string getVSwitchId()const;
void setVSwitchId(const std::string& vSwitchId);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getInternetChargeType()const;
void setInternetChargeType(const std::string& internetChargeType);
std::string getVpcId()const;
void setVpcId(const std::string& vpcId);
std::string getPayType()const;
void setPayType(const std::string& payType);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string networkType_;
std::string masterZoneId_;
int pageNumber_;
std::string accessKeyId_;
std::string resourceGroupId_;
std::string loadBalancerName_;
std::string regionId_;
int pageSize_;
std::string addressType_;
std::string slaveZoneId_;
std::string address_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string serverId_;
std::string tags_;
std::string serverIntranetAddress_;
std::string vSwitchId_;
std::string loadBalancerId_;
std::string internetChargeType_;
std::string vpcId_;
std::string payType_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSREQUEST_H_

81
slb/include/alibabacloud/slb/model/DescribeLoadBalancersResult.h Normal file
View File

@@ -0,0 +1,81 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancersResult : public ServiceResult
{
public:
struct LoadBalancer
{
std::string address;
std::string resourceGroupId;
std::string vSwitchId;
std::string createTime;
std::string loadBalancerId;
std::string payType;
std::string slaveZoneId;
std::string internetChargeType;
std::string regionIdAlias;
std::string loadBalancerName;
std::string vpcId;
std::string networkType;
std::string regionId;
std::string addressType;
std::string loadBalancerStatus;
std::string masterZoneId;
long createTimeStamp;
};
DescribeLoadBalancersResult();
explicit DescribeLoadBalancersResult(const std::string &payload);
~DescribeLoadBalancersResult();
int getTotalCount()const;
void setTotalCount(int totalCount);
int getPageSize()const;
void setPageSize(int pageSize);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::vector<LoadBalancer> getLoadBalancers()const;
void setLoadBalancers(const std::vector<LoadBalancer>& loadBalancers);
protected:
void parse(const std::string &payload);
private:
int totalCount_;
int pageSize_;
int pageNumber_;
std::vector<LoadBalancer> loadBalancers_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERSRESULT_H_

71
slb/include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupAttributeRequest.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveServerGroupAttributeRequest : public SlbRequest
{
public:
DescribeMasterSlaveServerGroupAttributeRequest();
~DescribeMasterSlaveServerGroupAttributeRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getMasterSlaveServerGroupId()const;
void setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string masterSlaveServerGroupId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPATTRIBUTEREQUEST_H_

65
slb/include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupAttributeResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPATTRIBUTERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveServerGroupAttributeResult : public ServiceResult
{
public:
struct MasterSlaveBackendServer
{
std::string serverType;
std::string serverId;
int port;
int weight;
};
DescribeMasterSlaveServerGroupAttributeResult();
explicit DescribeMasterSlaveServerGroupAttributeResult(const std::string &payload);
~DescribeMasterSlaveServerGroupAttributeResult();
std::string getMasterSlaveServerGroupId()const;
void setMasterSlaveServerGroupId(const std::string& masterSlaveServerGroupId);
std::string getMasterSlaveServerGroupName()const;
void setMasterSlaveServerGroupName(const std::string& masterSlaveServerGroupName);
std::vector<MasterSlaveBackendServer> getMasterSlaveBackendServers()const;
void setMasterSlaveBackendServers(const std::vector<MasterSlaveBackendServer>& masterSlaveBackendServers);
protected:
void parse(const std::string &payload);
private:
std::string masterSlaveServerGroupId_;
std::string masterSlaveServerGroupName_;
std::vector<MasterSlaveBackendServer> masterSlaveBackendServers_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPATTRIBUTERESULT_H_

71
slb/include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupsRequest.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveServerGroupsRequest : public SlbRequest
{
public:
DescribeMasterSlaveServerGroupsRequest();
~DescribeMasterSlaveServerGroupsRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string loadBalancerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPSREQUEST_H_

57
slb/include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupsResult.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPSRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveServerGroupsResult : public ServiceResult
{
public:
struct MasterSlaveServerGroup
{
std::string masterSlaveServerGroupId;
std::string masterSlaveServerGroupName;
};
DescribeMasterSlaveServerGroupsResult();
explicit DescribeMasterSlaveServerGroupsResult(const std::string &payload);
~DescribeMasterSlaveServerGroupsResult();
std::vector<MasterSlaveServerGroup> getMasterSlaveServerGroups()const;
void setMasterSlaveServerGroups(const std::vector<MasterSlaveServerGroup>& masterSlaveServerGroups);
protected:
void parse(const std::string &payload);
private:
std::vector<MasterSlaveServerGroup> masterSlaveServerGroups_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPSRESULT_H_

71
slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeRequest.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveVServerGroupAttributeRequest : public SlbRequest
{
public:
DescribeMasterSlaveVServerGroupAttributeRequest();
~DescribeMasterSlaveVServerGroupAttributeRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getMasterSlaveVServerGroupId()const;
void setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string masterSlaveVServerGroupId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTEREQUEST_H_

65
slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupAttributeResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveVServerGroupAttributeResult : public ServiceResult
{
public:
struct MasterSlaveBackendServer
{
std::string serverId;
int port;
int isBackup;
int weight;
};
DescribeMasterSlaveVServerGroupAttributeResult();
explicit DescribeMasterSlaveVServerGroupAttributeResult(const std::string &payload);
~DescribeMasterSlaveVServerGroupAttributeResult();
std::string getMasterSlaveVServerGroupId()const;
void setMasterSlaveVServerGroupId(const std::string& masterSlaveVServerGroupId);
std::vector<MasterSlaveBackendServer> getMasterSlaveBackendServers()const;
void setMasterSlaveBackendServers(const std::vector<MasterSlaveBackendServer>& masterSlaveBackendServers);
std::string getMasterSlaveVServerGroupName()const;
void setMasterSlaveVServerGroupName(const std::string& masterSlaveVServerGroupName);
protected:
void parse(const std::string &payload);
private:
std::string masterSlaveVServerGroupId_;
std::vector<MasterSlaveBackendServer> masterSlaveBackendServers_;
std::string masterSlaveVServerGroupName_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPATTRIBUTERESULT_H_

71
slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsRequest.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveVServerGroupsRequest : public SlbRequest
{
public:
DescribeMasterSlaveVServerGroupsRequest();
~DescribeMasterSlaveVServerGroupsRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string loadBalancerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSREQUEST_H_

57
slb/include/alibabacloud/slb/model/DescribeMasterSlaveVServerGroupsResult.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveVServerGroupsResult : public ServiceResult
{
public:
struct MasterSlaveVServerGroup
{
std::string masterSlaveVServerGroupId;
std::string masterSlaveVServerGroupName;
};
DescribeMasterSlaveVServerGroupsResult();
explicit DescribeMasterSlaveVServerGroupsResult(const std::string &payload);
~DescribeMasterSlaveVServerGroupsResult();
std::vector<MasterSlaveVServerGroup> getMasterSlaveVServerGroups()const;
void setMasterSlaveVServerGroups(const std::vector<MasterSlaveVServerGroup>& masterSlaveVServerGroups);
protected:
void parse(const std::string &payload);
private:
std::vector<MasterSlaveVServerGroup> masterSlaveVServerGroups_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVEVSERVERGROUPSRESULT_H_

68
slb/include/alibabacloud/slb/model/DescribeRegionsRequest.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBEREGIONSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEREGIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeRegionsRequest : public SlbRequest
{
public:
DescribeRegionsRequest();
~DescribeRegionsRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEREGIONSREQUEST_H_

57
slb/include/alibabacloud/slb/model/DescribeRegionsResult.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBEREGIONSRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEREGIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeRegionsResult : public ServiceResult
{
public:
struct Region
{
std::string regionId;
std::string localName;
};
DescribeRegionsResult();
explicit DescribeRegionsResult(const std::string &payload);
~DescribeRegionsResult();
std::vector<Region> getRegions()const;
void setRegions(const std::vector<Region>& regions);
protected:
void parse(const std::string &payload);
private:
std::vector<Region> regions_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEREGIONSRESULT_H_

71
slb/include/alibabacloud/slb/model/DescribeRuleAttributeRequest.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBERULEATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBERULEATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeRuleAttributeRequest : public SlbRequest
{
public:
DescribeRuleAttributeRequest();
~DescribeRuleAttributeRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getRuleId()const;
void setRuleId(const std::string& ruleId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string ruleId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBERULEATTRIBUTEREQUEST_H_

67
slb/include/alibabacloud/slb/model/DescribeRuleAttributeResult.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBERULEATTRIBUTERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBERULEATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeRuleAttributeResult : public ServiceResult
{
public:
DescribeRuleAttributeResult();
explicit DescribeRuleAttributeResult(const std::string &payload);
~DescribeRuleAttributeResult();
std::string getListenerPort()const;
void setListenerPort(const std::string& listenerPort);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getDomain()const;
void setDomain(const std::string& domain);
std::string getRuleName()const;
void setRuleName(const std::string& ruleName);
std::string getUrl()const;
void setUrl(const std::string& url);
protected:
void parse(const std::string &payload);
private:
std::string listenerPort_;
std::string vServerGroupId_;
std::string loadBalancerId_;
std::string domain_;
std::string ruleName_;
std::string url_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBERULEATTRIBUTERESULT_H_

74
slb/include/alibabacloud/slb/model/DescribeRulesRequest.h Normal file
View File

@@ -0,0 +1,74 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBERULESREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBERULESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeRulesRequest : public SlbRequest
{
public:
DescribeRulesRequest();
~DescribeRulesRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
int getListenerPort()const;
void setListenerPort(int listenerPort);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
int listenerPort_;
std::string loadBalancerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBERULESREQUEST_H_

60
slb/include/alibabacloud/slb/model/DescribeRulesResult.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBERULESRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBERULESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeRulesResult : public ServiceResult
{
public:
struct Rule
{
std::string vServerGroupId;
std::string ruleId;
std::string domain;
std::string ruleName;
std::string url;
};
DescribeRulesResult();
explicit DescribeRulesResult(const std::string &payload);
~DescribeRulesResult();
std::vector<Rule> getRules()const;
void setRules(const std::vector<Rule>& rules);
protected:
void parse(const std::string &payload);
private:
std::vector<Rule> rules_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBERULESRESULT_H_

74
slb/include/alibabacloud/slb/model/DescribeServerCertificatesRequest.h Normal file
View File

@@ -0,0 +1,74 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBESERVERCERTIFICATESREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBESERVERCERTIFICATESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeServerCertificatesRequest : public SlbRequest
{
public:
DescribeServerCertificatesRequest();
~DescribeServerCertificatesRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getServerCertificateId()const;
void setServerCertificateId(const std::string& serverCertificateId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
std::string resourceGroupId_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string serverCertificateId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBESERVERCERTIFICATESREQUEST_H_

66
slb/include/alibabacloud/slb/model/DescribeServerCertificatesResult.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBESERVERCERTIFICATESRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBESERVERCERTIFICATESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeServerCertificatesResult : public ServiceResult
{
public:
struct ServerCertificate
{
std::string regionIdAlias;
std::string fingerprint;
std::string aliCloudCertificateName;
std::string resourceGroupId;
int isAliCloudCertificate;
std::string createTime;
std::string serverCertificateId;
std::string serverCertificateName;
std::string regionId;
long createTimeStamp;
std::string aliCloudCertificateId;
};
DescribeServerCertificatesResult();
explicit DescribeServerCertificatesResult(const std::string &payload);
~DescribeServerCertificatesResult();
std::vector<ServerCertificate> getServerCertificates()const;
void setServerCertificates(const std::vector<ServerCertificate>& serverCertificates);
protected:
void parse(const std::string &payload);
private:
std::vector<ServerCertificate> serverCertificates_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBESERVERCERTIFICATESRESULT_H_

80
slb/include/alibabacloud/slb/model/DescribeTagsRequest.h Normal file
View File

@@ -0,0 +1,80 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBETAGSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBETAGSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeTagsRequest : public SlbRequest
{
public:
DescribeTagsRequest();
~DescribeTagsRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
bool getDistinctKey()const;
void setDistinctKey(bool distinctKey);
long getOwnerId()const;
void setOwnerId(long ownerId);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getPageSize()const;
void setPageSize(int pageSize);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
bool distinctKey_;
long ownerId_;
int pageNumber_;
std::string accessKeyId_;
std::string tags_;
std::string loadBalancerId_;
std::string regionId_;
int pageSize_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBETAGSREQUEST_H_

67
slb/include/alibabacloud/slb/model/DescribeTagsResult.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBETAGSRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBETAGSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeTagsResult : public ServiceResult
{
public:
struct TagSet
{
int instanceCount;
std::string tagKey;
std::string tagValue;
};
DescribeTagsResult();
explicit DescribeTagsResult(const std::string &payload);
~DescribeTagsResult();
int getTotalCount()const;
void setTotalCount(int totalCount);
int getPageSize()const;
void setPageSize(int pageSize);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::vector<TagSet> getTagSets()const;
void setTagSets(const std::vector<TagSet>& tagSets);
protected:
void parse(const std::string &payload);
private:
int totalCount_;
int pageSize_;
int pageNumber_;
std::vector<TagSet> tagSets_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBETAGSRESULT_H_

71
slb/include/alibabacloud/slb/model/DescribeVServerGroupAttributeRequest.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeVServerGroupAttributeRequest : public SlbRequest
{
public:
DescribeVServerGroupAttributeRequest();
~DescribeVServerGroupAttributeRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
std::string vServerGroupId_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPATTRIBUTEREQUEST_H_

64
slb/include/alibabacloud/slb/model/DescribeVServerGroupAttributeResult.h Normal file
View File

@@ -0,0 +1,64 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPATTRIBUTERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeVServerGroupAttributeResult : public ServiceResult
{
public:
struct BackendServer
{
std::string serverId;
int port;
int weight;
};
DescribeVServerGroupAttributeResult();
explicit DescribeVServerGroupAttributeResult(const std::string &payload);
~DescribeVServerGroupAttributeResult();
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
std::string getVServerGroupName()const;
void setVServerGroupName(const std::string& vServerGroupName);
std::vector<BackendServer> getBackendServers()const;
void setBackendServers(const std::vector<BackendServer>& backendServers);
protected:
void parse(const std::string &payload);
private:
std::string vServerGroupId_;
std::string vServerGroupName_;
std::vector<BackendServer> backendServers_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPATTRIBUTERESULT_H_

71
slb/include/alibabacloud/slb/model/DescribeVServerGroupsRequest.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeVServerGroupsRequest : public SlbRequest
{
public:
DescribeVServerGroupsRequest();
~DescribeVServerGroupsRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string loadBalancerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPSREQUEST_H_

57
slb/include/alibabacloud/slb/model/DescribeVServerGroupsResult.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPSRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeVServerGroupsResult : public ServiceResult
{
public:
struct VServerGroup
{
std::string vServerGroupId;
std::string vServerGroupName;
};
DescribeVServerGroupsResult();
explicit DescribeVServerGroupsResult(const std::string &payload);
~DescribeVServerGroupsResult();
std::vector<VServerGroup> getVServerGroups()const;
void setVServerGroups(const std::vector<VServerGroup>& vServerGroups);
protected:
void parse(const std::string &payload);
private:
std::vector<VServerGroup> vServerGroups_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPSRESULT_H_

68
slb/include/alibabacloud/slb/model/DescribeZonesRequest.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBEZONESREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEZONESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeZonesRequest : public SlbRequest
{
public:
DescribeZonesRequest();
~DescribeZonesRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEZONESREQUEST_H_

63
slb/include/alibabacloud/slb/model/DescribeZonesResult.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBEZONESRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEZONESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeZonesResult : public ServiceResult
{
public:
struct Zone
{
struct SlaveZone
{
std::string zoneId;
std::string localName;
};
std::vector<Zone::SlaveZone> slaveZones;
std::string zoneId;
std::string localName;
};
DescribeZonesResult();
explicit DescribeZonesResult(const std::string &payload);
~DescribeZonesResult();
std::vector<Zone> getZones()const;
void setZones(const std::vector<Zone>& zones);
protected:
void parse(const std::string &payload);
private:
std::vector<Zone> zones_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEZONESRESULT_H_

77
slb/include/alibabacloud/slb/model/ModifyLoadBalancerInstanceSpecRequest.h Normal file
View File

@@ -0,0 +1,77 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINSTANCESPECREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINSTANCESPECREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT ModifyLoadBalancerInstanceSpecRequest : public SlbRequest
{
public:
ModifyLoadBalancerInstanceSpecRequest();
~ModifyLoadBalancerInstanceSpecRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
std::string getLoadBalancerSpec()const;
void setLoadBalancerSpec(const std::string& loadBalancerSpec);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
bool getAutoPay()const;
void setAutoPay(bool autoPay);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
std::string loadBalancerSpec_;
long resourceOwnerId_;
std::string loadBalancerId_;
bool autoPay_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINSTANCESPECREQUEST_H_

52
slb/include/alibabacloud/slb/model/ModifyLoadBalancerInstanceSpecResult.h Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINSTANCESPECRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINSTANCESPECRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT ModifyLoadBalancerInstanceSpecResult : public ServiceResult
{
public:
ModifyLoadBalancerInstanceSpecResult();
explicit ModifyLoadBalancerInstanceSpecResult(const std::string &payload);
~ModifyLoadBalancerInstanceSpecResult();
long getOrderId()const;
void setOrderId(long orderId);
protected:
void parse(const std::string &payload);
private:
long orderId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINSTANCESPECRESULT_H_

80
slb/include/alibabacloud/slb/model/ModifyLoadBalancerInternetSpecRequest.h Normal file
View File

@@ -0,0 +1,80 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINTERNETSPECREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINTERNETSPECREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT ModifyLoadBalancerInternetSpecRequest : public SlbRequest
{
public:
ModifyLoadBalancerInternetSpecRequest();
~ModifyLoadBalancerInternetSpecRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
bool getAutoPay()const;
void setAutoPay(bool autoPay);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
int getBandwidth()const;
void setBandwidth(int bandwidth);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getInternetChargeType()const;
void setInternetChargeType(const std::string& internetChargeType);
private:
std::string access_key_id_;
long resourceOwnerId_;
bool autoPay_;
std::string resourceOwnerAccount_;
int bandwidth_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
std::string loadBalancerId_;
std::string regionId_;
std::string internetChargeType_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINTERNETSPECREQUEST_H_

52
slb/include/alibabacloud/slb/model/ModifyLoadBalancerInternetSpecResult.h Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINTERNETSPECRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINTERNETSPECRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT ModifyLoadBalancerInternetSpecResult : public ServiceResult
{
public:
ModifyLoadBalancerInternetSpecResult();
explicit ModifyLoadBalancerInternetSpecResult(const std::string &payload);
~ModifyLoadBalancerInternetSpecResult();
long getOrderId()const;
void setOrderId(long orderId);
protected:
void parse(const std::string &payload);
private:
long orderId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERINTERNETSPECRESULT_H_

83
slb/include/alibabacloud/slb/model/ModifyLoadBalancerPayTypeRequest.h Normal file
View File

@@ -0,0 +1,83 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERPAYTYPEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERPAYTYPEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT ModifyLoadBalancerPayTypeRequest : public SlbRequest
{
public:
ModifyLoadBalancerPayTypeRequest();
~ModifyLoadBalancerPayTypeRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
bool getAutoPay()const;
void setAutoPay(bool autoPay);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
int getDuration()const;
void setDuration(int duration);
std::string getLoadBalancerId()const;
void setLoadBalancerId(const std::string& loadBalancerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getPayType()const;
void setPayType(const std::string& payType);
std::string getPricingCycle()const;
void setPricingCycle(const std::string& pricingCycle);
private:
std::string access_key_id_;
long resourceOwnerId_;
bool autoPay_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
int duration_;
std::string loadBalancerId_;
std::string regionId_;
std::string payType_;
std::string pricingCycle_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERPAYTYPEREQUEST_H_

52
slb/include/alibabacloud/slb/model/ModifyLoadBalancerPayTypeResult.h Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERPAYTYPERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERPAYTYPERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT ModifyLoadBalancerPayTypeResult : public ServiceResult
{
public:
ModifyLoadBalancerPayTypeResult();
explicit ModifyLoadBalancerPayTypeResult(const std::string &payload);
~ModifyLoadBalancerPayTypeResult();
long getOrderId()const;
void setOrderId(long orderId);
protected:
void parse(const std::string &payload);
private:
long orderId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_MODIFYLOADBALANCERPAYTYPERESULT_H_

77
slb/include/alibabacloud/slb/model/ModifyVServerGroupBackendServersRequest.h Normal file
View File

@@ -0,0 +1,77 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_MODIFYVSERVERGROUPBACKENDSERVERSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_MODIFYVSERVERGROUPBACKENDSERVERSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT ModifyVServerGroupBackendServersRequest : public SlbRequest
{
public:
ModifyVServerGroupBackendServersRequest();
~ModifyVServerGroupBackendServersRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getOldBackendServers()const;
void setOldBackendServers(const std::string& oldBackendServers);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNewBackendServers()const;
void setNewBackendServers(const std::string& newBackendServers);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
private:
std::string access_key_id_;
std::string vServerGroupId_;
long resourceOwnerId_;
std::string oldBackendServers_;
std::string resourceOwnerAccount_;
std::string regionId_;
std::string newBackendServers_;
std::string ownerAccount_;
long ownerId_;
std::string accessKeyId_;
std::string tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_MODIFYVSERVERGROUPBACKENDSERVERSREQUEST_H_

61
slb/include/alibabacloud/slb/model/ModifyVServerGroupBackendServersResult.h Normal file
View File

@@ -0,0 +1,61 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_MODIFYVSERVERGROUPBACKENDSERVERSRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_MODIFYVSERVERGROUPBACKENDSERVERSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT ModifyVServerGroupBackendServersResult : public ServiceResult
{
public:
struct BackendServer
{
std::string serverId;
int port;
int weight;
};
ModifyVServerGroupBackendServersResult();
explicit ModifyVServerGroupBackendServersResult(const std::string &payload);
~ModifyVServerGroupBackendServersResult();
std::string getVServerGroupId()const;
void setVServerGroupId(const std::string& vServerGroupId);
std::vector<BackendServer> getBackendServers()const;
void setBackendServers(const std::vector<BackendServer>& backendServers);
protected:
void parse(const std::string &payload);
private:
std::string vServerGroupId_;
std::vector<BackendServer> backendServers_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_MODIFYVSERVERGROUPBACKENDSERVERSRESULT_H_

80
slb/include/alibabacloud/slb/model/MoveResourceGroupRequest.h Normal file
View File

@@ -0,0 +1,80 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_MOVERESOURCEGROUPREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_MOVERESOURCEGROUPREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/slb/SlbRequest.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT MoveResourceGroupRequest : public SlbRequest
{
public:
MoveResourceGroupRequest();
~MoveResourceGroupRequest();
std::string getAccess_key_id()const;
void setAccess_key_id(const std::string& access_key_id);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getResourceId()const;
void setResourceId(const std::string& resourceId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTags()const;
void setTags(const std::string& tags);
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
std::string getNewResourceGroupId()const;
void setNewResourceGroupId(const std::string& newResourceGroupId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string resourceId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string resourceType_;
std::string accessKeyId_;
std::string tags_;
std::string resourceGroupId_;
std::string newResourceGroupId_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_MOVERESOURCEGROUPREQUEST_H_

Some files were not shown because too many files have changed in this diff Show More