Generated 2014-05-15 for Slb.

This commit is contained in:
sdk-team
2024-05-30 12:41:59 +00:00
parent 589d7c0177
commit 051077c805
363 changed files with 34489 additions and 1235 deletions

View File

@@ -1 +1 @@
1.36.1920 1.36.1921

View File

@@ -21,81 +21,381 @@ set(slb_public_header
include/alibabacloud/slb/SlbExport.h ) include/alibabacloud/slb/SlbExport.h )
set(slb_public_header_model set(slb_public_header_model
include/alibabacloud/slb/model/AddAccessControlListEntryRequest.h
include/alibabacloud/slb/model/AddAccessControlListEntryResult.h
include/alibabacloud/slb/model/AddBackendServersRequest.h include/alibabacloud/slb/model/AddBackendServersRequest.h
include/alibabacloud/slb/model/AddBackendServersResult.h include/alibabacloud/slb/model/AddBackendServersResult.h
include/alibabacloud/slb/model/AddListenerWhiteListItemRequest.h
include/alibabacloud/slb/model/AddListenerWhiteListItemResult.h
include/alibabacloud/slb/model/AddTagsRequest.h
include/alibabacloud/slb/model/AddTagsResult.h
include/alibabacloud/slb/model/AddVServerGroupBackendServersRequest.h
include/alibabacloud/slb/model/AddVServerGroupBackendServersResult.h
include/alibabacloud/slb/model/CreateAccessControlListRequest.h
include/alibabacloud/slb/model/CreateAccessControlListResult.h
include/alibabacloud/slb/model/CreateDomainExtensionRequest.h
include/alibabacloud/slb/model/CreateDomainExtensionResult.h
include/alibabacloud/slb/model/CreateLoadBalancerRequest.h include/alibabacloud/slb/model/CreateLoadBalancerRequest.h
include/alibabacloud/slb/model/CreateLoadBalancerResult.h include/alibabacloud/slb/model/CreateLoadBalancerResult.h
include/alibabacloud/slb/model/CreateLoadBalancerHTTPListenerRequest.h include/alibabacloud/slb/model/CreateLoadBalancerHTTPListenerRequest.h
include/alibabacloud/slb/model/CreateLoadBalancerHTTPListenerResult.h include/alibabacloud/slb/model/CreateLoadBalancerHTTPListenerResult.h
include/alibabacloud/slb/model/CreateLoadBalancerHTTPSListenerRequest.h
include/alibabacloud/slb/model/CreateLoadBalancerHTTPSListenerResult.h
include/alibabacloud/slb/model/CreateLoadBalancerTCPListenerRequest.h include/alibabacloud/slb/model/CreateLoadBalancerTCPListenerRequest.h
include/alibabacloud/slb/model/CreateLoadBalancerTCPListenerResult.h include/alibabacloud/slb/model/CreateLoadBalancerTCPListenerResult.h
include/alibabacloud/slb/model/CreateLoadBalancerUDPListenerRequest.h
include/alibabacloud/slb/model/CreateLoadBalancerUDPListenerResult.h
include/alibabacloud/slb/model/CreateMasterSlaveServerGroupRequest.h
include/alibabacloud/slb/model/CreateMasterSlaveServerGroupResult.h
include/alibabacloud/slb/model/CreateRulesRequest.h
include/alibabacloud/slb/model/CreateRulesResult.h
include/alibabacloud/slb/model/CreateTLSCipherPolicyRequest.h
include/alibabacloud/slb/model/CreateTLSCipherPolicyResult.h
include/alibabacloud/slb/model/CreateVServerGroupRequest.h
include/alibabacloud/slb/model/CreateVServerGroupResult.h
include/alibabacloud/slb/model/DeleteAccessControlListRequest.h
include/alibabacloud/slb/model/DeleteAccessControlListResult.h
include/alibabacloud/slb/model/DeleteAccessLogsDownloadAttributeRequest.h
include/alibabacloud/slb/model/DeleteAccessLogsDownloadAttributeResult.h
include/alibabacloud/slb/model/DeleteCACertificateRequest.h
include/alibabacloud/slb/model/DeleteCACertificateResult.h
include/alibabacloud/slb/model/DeleteDomainExtensionRequest.h
include/alibabacloud/slb/model/DeleteDomainExtensionResult.h
include/alibabacloud/slb/model/DeleteLoadBalancerRequest.h include/alibabacloud/slb/model/DeleteLoadBalancerRequest.h
include/alibabacloud/slb/model/DeleteLoadBalancerResult.h include/alibabacloud/slb/model/DeleteLoadBalancerResult.h
include/alibabacloud/slb/model/DeleteLoadBalancerListenerRequest.h include/alibabacloud/slb/model/DeleteLoadBalancerListenerRequest.h
include/alibabacloud/slb/model/DeleteLoadBalancerListenerResult.h include/alibabacloud/slb/model/DeleteLoadBalancerListenerResult.h
include/alibabacloud/slb/model/DescribeBackendServersRequest.h include/alibabacloud/slb/model/DeleteMasterSlaveServerGroupRequest.h
include/alibabacloud/slb/model/DescribeBackendServersResult.h include/alibabacloud/slb/model/DeleteMasterSlaveServerGroupResult.h
include/alibabacloud/slb/model/DeleteRulesRequest.h
include/alibabacloud/slb/model/DeleteRulesResult.h
include/alibabacloud/slb/model/DeleteServerCertificateRequest.h
include/alibabacloud/slb/model/DeleteServerCertificateResult.h
include/alibabacloud/slb/model/DeleteTLSCipherPolicyRequest.h
include/alibabacloud/slb/model/DeleteTLSCipherPolicyResult.h
include/alibabacloud/slb/model/DeleteVServerGroupRequest.h
include/alibabacloud/slb/model/DeleteVServerGroupResult.h
include/alibabacloud/slb/model/DescribeAccessControlListAttributeRequest.h
include/alibabacloud/slb/model/DescribeAccessControlListAttributeResult.h
include/alibabacloud/slb/model/DescribeAccessControlListsRequest.h
include/alibabacloud/slb/model/DescribeAccessControlListsResult.h
include/alibabacloud/slb/model/DescribeAccessLogsDownloadAttributeRequest.h
include/alibabacloud/slb/model/DescribeAccessLogsDownloadAttributeResult.h
include/alibabacloud/slb/model/DescribeAvailableResourceRequest.h
include/alibabacloud/slb/model/DescribeAvailableResourceResult.h
include/alibabacloud/slb/model/DescribeCACertificatesRequest.h
include/alibabacloud/slb/model/DescribeCACertificatesResult.h
include/alibabacloud/slb/model/DescribeDomainExtensionAttributeRequest.h
include/alibabacloud/slb/model/DescribeDomainExtensionAttributeResult.h
include/alibabacloud/slb/model/DescribeDomainExtensionsRequest.h
include/alibabacloud/slb/model/DescribeDomainExtensionsResult.h
include/alibabacloud/slb/model/DescribeHealthStatusRequest.h
include/alibabacloud/slb/model/DescribeHealthStatusResult.h
include/alibabacloud/slb/model/DescribeHighDefinationMonitorRequest.h
include/alibabacloud/slb/model/DescribeHighDefinationMonitorResult.h
include/alibabacloud/slb/model/DescribeListenerAccessControlAttributeRequest.h
include/alibabacloud/slb/model/DescribeListenerAccessControlAttributeResult.h
include/alibabacloud/slb/model/DescribeLoadBalancerAttributeRequest.h include/alibabacloud/slb/model/DescribeLoadBalancerAttributeRequest.h
include/alibabacloud/slb/model/DescribeLoadBalancerAttributeResult.h include/alibabacloud/slb/model/DescribeLoadBalancerAttributeResult.h
include/alibabacloud/slb/model/DescribeLoadBalancerHTTPListenerAttributeRequest.h include/alibabacloud/slb/model/DescribeLoadBalancerHTTPListenerAttributeRequest.h
include/alibabacloud/slb/model/DescribeLoadBalancerHTTPListenerAttributeResult.h include/alibabacloud/slb/model/DescribeLoadBalancerHTTPListenerAttributeResult.h
include/alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeRequest.h
include/alibabacloud/slb/model/DescribeLoadBalancerHTTPSListenerAttributeResult.h
include/alibabacloud/slb/model/DescribeLoadBalancerListenersRequest.h
include/alibabacloud/slb/model/DescribeLoadBalancerListenersResult.h
include/alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeRequest.h include/alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeRequest.h
include/alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeResult.h include/alibabacloud/slb/model/DescribeLoadBalancerTCPListenerAttributeResult.h
include/alibabacloud/slb/model/DescribeLoadBalancerUDPListenerAttributeRequest.h
include/alibabacloud/slb/model/DescribeLoadBalancerUDPListenerAttributeResult.h
include/alibabacloud/slb/model/DescribeLoadBalancersRequest.h include/alibabacloud/slb/model/DescribeLoadBalancersRequest.h
include/alibabacloud/slb/model/DescribeLoadBalancersResult.h include/alibabacloud/slb/model/DescribeLoadBalancersResult.h
include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupAttributeRequest.h
include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupAttributeResult.h
include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupsRequest.h
include/alibabacloud/slb/model/DescribeMasterSlaveServerGroupsResult.h
include/alibabacloud/slb/model/DescribeRegionsRequest.h include/alibabacloud/slb/model/DescribeRegionsRequest.h
include/alibabacloud/slb/model/DescribeRegionsResult.h include/alibabacloud/slb/model/DescribeRegionsResult.h
include/alibabacloud/slb/model/DescribeRuleAttributeRequest.h
include/alibabacloud/slb/model/DescribeRuleAttributeResult.h
include/alibabacloud/slb/model/DescribeRulesRequest.h
include/alibabacloud/slb/model/DescribeRulesResult.h
include/alibabacloud/slb/model/DescribeServerCertificatesRequest.h
include/alibabacloud/slb/model/DescribeServerCertificatesResult.h
include/alibabacloud/slb/model/DescribeTagsRequest.h
include/alibabacloud/slb/model/DescribeTagsResult.h
include/alibabacloud/slb/model/DescribeVServerGroupAttributeRequest.h
include/alibabacloud/slb/model/DescribeVServerGroupAttributeResult.h
include/alibabacloud/slb/model/DescribeVServerGroupsRequest.h
include/alibabacloud/slb/model/DescribeVServerGroupsResult.h
include/alibabacloud/slb/model/DescribeZonesRequest.h
include/alibabacloud/slb/model/DescribeZonesResult.h
include/alibabacloud/slb/model/EnableHighDefinationMonitorRequest.h
include/alibabacloud/slb/model/EnableHighDefinationMonitorResult.h
include/alibabacloud/slb/model/ListTLSCipherPoliciesRequest.h
include/alibabacloud/slb/model/ListTLSCipherPoliciesResult.h
include/alibabacloud/slb/model/ListTagResourcesRequest.h
include/alibabacloud/slb/model/ListTagResourcesResult.h
include/alibabacloud/slb/model/ModifyHighDefinationMonitorRequest.h
include/alibabacloud/slb/model/ModifyHighDefinationMonitorResult.h
include/alibabacloud/slb/model/ModifyLoadBalancerInstanceChargeTypeRequest.h
include/alibabacloud/slb/model/ModifyLoadBalancerInstanceChargeTypeResult.h
include/alibabacloud/slb/model/ModifyLoadBalancerInstanceSpecRequest.h
include/alibabacloud/slb/model/ModifyLoadBalancerInstanceSpecResult.h
include/alibabacloud/slb/model/ModifyLoadBalancerInternetSpecRequest.h
include/alibabacloud/slb/model/ModifyLoadBalancerInternetSpecResult.h
include/alibabacloud/slb/model/ModifyLoadBalancerPayTypeRequest.h
include/alibabacloud/slb/model/ModifyLoadBalancerPayTypeResult.h
include/alibabacloud/slb/model/ModifyVServerGroupBackendServersRequest.h
include/alibabacloud/slb/model/ModifyVServerGroupBackendServersResult.h
include/alibabacloud/slb/model/MoveResourceGroupRequest.h
include/alibabacloud/slb/model/MoveResourceGroupResult.h
include/alibabacloud/slb/model/RemoveAccessControlListEntryRequest.h
include/alibabacloud/slb/model/RemoveAccessControlListEntryResult.h
include/alibabacloud/slb/model/RemoveBackendServersRequest.h include/alibabacloud/slb/model/RemoveBackendServersRequest.h
include/alibabacloud/slb/model/RemoveBackendServersResult.h include/alibabacloud/slb/model/RemoveBackendServersResult.h
include/alibabacloud/slb/model/RemoveListenerWhiteListItemRequest.h
include/alibabacloud/slb/model/RemoveListenerWhiteListItemResult.h
include/alibabacloud/slb/model/RemoveTagsRequest.h
include/alibabacloud/slb/model/RemoveTagsResult.h
include/alibabacloud/slb/model/RemoveVServerGroupBackendServersRequest.h
include/alibabacloud/slb/model/RemoveVServerGroupBackendServersResult.h
include/alibabacloud/slb/model/SetAccessControlListAttributeRequest.h
include/alibabacloud/slb/model/SetAccessControlListAttributeResult.h
include/alibabacloud/slb/model/SetAccessLogsDownloadAttributeRequest.h
include/alibabacloud/slb/model/SetAccessLogsDownloadAttributeResult.h
include/alibabacloud/slb/model/SetBackendServersRequest.h
include/alibabacloud/slb/model/SetBackendServersResult.h
include/alibabacloud/slb/model/SetCACertificateNameRequest.h
include/alibabacloud/slb/model/SetCACertificateNameResult.h
include/alibabacloud/slb/model/SetDomainExtensionAttributeRequest.h
include/alibabacloud/slb/model/SetDomainExtensionAttributeResult.h
include/alibabacloud/slb/model/SetListenerAccessControlStatusRequest.h
include/alibabacloud/slb/model/SetListenerAccessControlStatusResult.h
include/alibabacloud/slb/model/SetLoadBalancerDeleteProtectionRequest.h
include/alibabacloud/slb/model/SetLoadBalancerDeleteProtectionResult.h
include/alibabacloud/slb/model/SetLoadBalancerHTTPListenerAttributeRequest.h include/alibabacloud/slb/model/SetLoadBalancerHTTPListenerAttributeRequest.h
include/alibabacloud/slb/model/SetLoadBalancerHTTPListenerAttributeResult.h include/alibabacloud/slb/model/SetLoadBalancerHTTPListenerAttributeResult.h
include/alibabacloud/slb/model/SetLoadBalancerListenerStatusRequest.h include/alibabacloud/slb/model/SetLoadBalancerHTTPSListenerAttributeRequest.h
include/alibabacloud/slb/model/SetLoadBalancerListenerStatusResult.h include/alibabacloud/slb/model/SetLoadBalancerHTTPSListenerAttributeResult.h
include/alibabacloud/slb/model/SetLoadBalancerModificationProtectionRequest.h
include/alibabacloud/slb/model/SetLoadBalancerModificationProtectionResult.h
include/alibabacloud/slb/model/SetLoadBalancerNameRequest.h include/alibabacloud/slb/model/SetLoadBalancerNameRequest.h
include/alibabacloud/slb/model/SetLoadBalancerNameResult.h include/alibabacloud/slb/model/SetLoadBalancerNameResult.h
include/alibabacloud/slb/model/SetLoadBalancerStatusRequest.h include/alibabacloud/slb/model/SetLoadBalancerStatusRequest.h
include/alibabacloud/slb/model/SetLoadBalancerStatusResult.h include/alibabacloud/slb/model/SetLoadBalancerStatusResult.h
include/alibabacloud/slb/model/SetLoadBalancerTCPListenerAttributeRequest.h include/alibabacloud/slb/model/SetLoadBalancerTCPListenerAttributeRequest.h
include/alibabacloud/slb/model/SetLoadBalancerTCPListenerAttributeResult.h ) include/alibabacloud/slb/model/SetLoadBalancerTCPListenerAttributeResult.h
include/alibabacloud/slb/model/SetLoadBalancerUDPListenerAttributeRequest.h
include/alibabacloud/slb/model/SetLoadBalancerUDPListenerAttributeResult.h
include/alibabacloud/slb/model/SetRuleRequest.h
include/alibabacloud/slb/model/SetRuleResult.h
include/alibabacloud/slb/model/SetServerCertificateNameRequest.h
include/alibabacloud/slb/model/SetServerCertificateNameResult.h
include/alibabacloud/slb/model/SetTLSCipherPolicyAttributeRequest.h
include/alibabacloud/slb/model/SetTLSCipherPolicyAttributeResult.h
include/alibabacloud/slb/model/SetVServerGroupAttributeRequest.h
include/alibabacloud/slb/model/SetVServerGroupAttributeResult.h
include/alibabacloud/slb/model/StartLoadBalancerListenerRequest.h
include/alibabacloud/slb/model/StartLoadBalancerListenerResult.h
include/alibabacloud/slb/model/StopLoadBalancerListenerRequest.h
include/alibabacloud/slb/model/StopLoadBalancerListenerResult.h
include/alibabacloud/slb/model/TagResourcesRequest.h
include/alibabacloud/slb/model/TagResourcesResult.h
include/alibabacloud/slb/model/UntagResourcesRequest.h
include/alibabacloud/slb/model/UntagResourcesResult.h
include/alibabacloud/slb/model/UploadCACertificateRequest.h
include/alibabacloud/slb/model/UploadCACertificateResult.h
include/alibabacloud/slb/model/UploadServerCertificateRequest.h
include/alibabacloud/slb/model/UploadServerCertificateResult.h )
set(slb_src set(slb_src
src/SlbClient.cc src/SlbClient.cc
src/model/AddAccessControlListEntryRequest.cc
src/model/AddAccessControlListEntryResult.cc
src/model/AddBackendServersRequest.cc src/model/AddBackendServersRequest.cc
src/model/AddBackendServersResult.cc src/model/AddBackendServersResult.cc
src/model/AddListenerWhiteListItemRequest.cc
src/model/AddListenerWhiteListItemResult.cc
src/model/AddTagsRequest.cc
src/model/AddTagsResult.cc
src/model/AddVServerGroupBackendServersRequest.cc
src/model/AddVServerGroupBackendServersResult.cc
src/model/CreateAccessControlListRequest.cc
src/model/CreateAccessControlListResult.cc
src/model/CreateDomainExtensionRequest.cc
src/model/CreateDomainExtensionResult.cc
src/model/CreateLoadBalancerRequest.cc src/model/CreateLoadBalancerRequest.cc
src/model/CreateLoadBalancerResult.cc src/model/CreateLoadBalancerResult.cc
src/model/CreateLoadBalancerHTTPListenerRequest.cc src/model/CreateLoadBalancerHTTPListenerRequest.cc
src/model/CreateLoadBalancerHTTPListenerResult.cc src/model/CreateLoadBalancerHTTPListenerResult.cc
src/model/CreateLoadBalancerHTTPSListenerRequest.cc
src/model/CreateLoadBalancerHTTPSListenerResult.cc
src/model/CreateLoadBalancerTCPListenerRequest.cc src/model/CreateLoadBalancerTCPListenerRequest.cc
src/model/CreateLoadBalancerTCPListenerResult.cc src/model/CreateLoadBalancerTCPListenerResult.cc
src/model/CreateLoadBalancerUDPListenerRequest.cc
src/model/CreateLoadBalancerUDPListenerResult.cc
src/model/CreateMasterSlaveServerGroupRequest.cc
src/model/CreateMasterSlaveServerGroupResult.cc
src/model/CreateRulesRequest.cc
src/model/CreateRulesResult.cc
src/model/CreateTLSCipherPolicyRequest.cc
src/model/CreateTLSCipherPolicyResult.cc
src/model/CreateVServerGroupRequest.cc
src/model/CreateVServerGroupResult.cc
src/model/DeleteAccessControlListRequest.cc
src/model/DeleteAccessControlListResult.cc
src/model/DeleteAccessLogsDownloadAttributeRequest.cc
src/model/DeleteAccessLogsDownloadAttributeResult.cc
src/model/DeleteCACertificateRequest.cc
src/model/DeleteCACertificateResult.cc
src/model/DeleteDomainExtensionRequest.cc
src/model/DeleteDomainExtensionResult.cc
src/model/DeleteLoadBalancerRequest.cc src/model/DeleteLoadBalancerRequest.cc
src/model/DeleteLoadBalancerResult.cc src/model/DeleteLoadBalancerResult.cc
src/model/DeleteLoadBalancerListenerRequest.cc src/model/DeleteLoadBalancerListenerRequest.cc
src/model/DeleteLoadBalancerListenerResult.cc src/model/DeleteLoadBalancerListenerResult.cc
src/model/DescribeBackendServersRequest.cc src/model/DeleteMasterSlaveServerGroupRequest.cc
src/model/DescribeBackendServersResult.cc src/model/DeleteMasterSlaveServerGroupResult.cc
src/model/DeleteRulesRequest.cc
src/model/DeleteRulesResult.cc
src/model/DeleteServerCertificateRequest.cc
src/model/DeleteServerCertificateResult.cc
src/model/DeleteTLSCipherPolicyRequest.cc
src/model/DeleteTLSCipherPolicyResult.cc
src/model/DeleteVServerGroupRequest.cc
src/model/DeleteVServerGroupResult.cc
src/model/DescribeAccessControlListAttributeRequest.cc
src/model/DescribeAccessControlListAttributeResult.cc
src/model/DescribeAccessControlListsRequest.cc
src/model/DescribeAccessControlListsResult.cc
src/model/DescribeAccessLogsDownloadAttributeRequest.cc
src/model/DescribeAccessLogsDownloadAttributeResult.cc
src/model/DescribeAvailableResourceRequest.cc
src/model/DescribeAvailableResourceResult.cc
src/model/DescribeCACertificatesRequest.cc
src/model/DescribeCACertificatesResult.cc
src/model/DescribeDomainExtensionAttributeRequest.cc
src/model/DescribeDomainExtensionAttributeResult.cc
src/model/DescribeDomainExtensionsRequest.cc
src/model/DescribeDomainExtensionsResult.cc
src/model/DescribeHealthStatusRequest.cc
src/model/DescribeHealthStatusResult.cc
src/model/DescribeHighDefinationMonitorRequest.cc
src/model/DescribeHighDefinationMonitorResult.cc
src/model/DescribeListenerAccessControlAttributeRequest.cc
src/model/DescribeListenerAccessControlAttributeResult.cc
src/model/DescribeLoadBalancerAttributeRequest.cc src/model/DescribeLoadBalancerAttributeRequest.cc
src/model/DescribeLoadBalancerAttributeResult.cc src/model/DescribeLoadBalancerAttributeResult.cc
src/model/DescribeLoadBalancerHTTPListenerAttributeRequest.cc src/model/DescribeLoadBalancerHTTPListenerAttributeRequest.cc
src/model/DescribeLoadBalancerHTTPListenerAttributeResult.cc src/model/DescribeLoadBalancerHTTPListenerAttributeResult.cc
src/model/DescribeLoadBalancerHTTPSListenerAttributeRequest.cc
src/model/DescribeLoadBalancerHTTPSListenerAttributeResult.cc
src/model/DescribeLoadBalancerListenersRequest.cc
src/model/DescribeLoadBalancerListenersResult.cc
src/model/DescribeLoadBalancerTCPListenerAttributeRequest.cc src/model/DescribeLoadBalancerTCPListenerAttributeRequest.cc
src/model/DescribeLoadBalancerTCPListenerAttributeResult.cc src/model/DescribeLoadBalancerTCPListenerAttributeResult.cc
src/model/DescribeLoadBalancerUDPListenerAttributeRequest.cc
src/model/DescribeLoadBalancerUDPListenerAttributeResult.cc
src/model/DescribeLoadBalancersRequest.cc src/model/DescribeLoadBalancersRequest.cc
src/model/DescribeLoadBalancersResult.cc src/model/DescribeLoadBalancersResult.cc
src/model/DescribeMasterSlaveServerGroupAttributeRequest.cc
src/model/DescribeMasterSlaveServerGroupAttributeResult.cc
src/model/DescribeMasterSlaveServerGroupsRequest.cc
src/model/DescribeMasterSlaveServerGroupsResult.cc
src/model/DescribeRegionsRequest.cc src/model/DescribeRegionsRequest.cc
src/model/DescribeRegionsResult.cc src/model/DescribeRegionsResult.cc
src/model/DescribeRuleAttributeRequest.cc
src/model/DescribeRuleAttributeResult.cc
src/model/DescribeRulesRequest.cc
src/model/DescribeRulesResult.cc
src/model/DescribeServerCertificatesRequest.cc
src/model/DescribeServerCertificatesResult.cc
src/model/DescribeTagsRequest.cc
src/model/DescribeTagsResult.cc
src/model/DescribeVServerGroupAttributeRequest.cc
src/model/DescribeVServerGroupAttributeResult.cc
src/model/DescribeVServerGroupsRequest.cc
src/model/DescribeVServerGroupsResult.cc
src/model/DescribeZonesRequest.cc
src/model/DescribeZonesResult.cc
src/model/EnableHighDefinationMonitorRequest.cc
src/model/EnableHighDefinationMonitorResult.cc
src/model/ListTLSCipherPoliciesRequest.cc
src/model/ListTLSCipherPoliciesResult.cc
src/model/ListTagResourcesRequest.cc
src/model/ListTagResourcesResult.cc
src/model/ModifyHighDefinationMonitorRequest.cc
src/model/ModifyHighDefinationMonitorResult.cc
src/model/ModifyLoadBalancerInstanceChargeTypeRequest.cc
src/model/ModifyLoadBalancerInstanceChargeTypeResult.cc
src/model/ModifyLoadBalancerInstanceSpecRequest.cc
src/model/ModifyLoadBalancerInstanceSpecResult.cc
src/model/ModifyLoadBalancerInternetSpecRequest.cc
src/model/ModifyLoadBalancerInternetSpecResult.cc
src/model/ModifyLoadBalancerPayTypeRequest.cc
src/model/ModifyLoadBalancerPayTypeResult.cc
src/model/ModifyVServerGroupBackendServersRequest.cc
src/model/ModifyVServerGroupBackendServersResult.cc
src/model/MoveResourceGroupRequest.cc
src/model/MoveResourceGroupResult.cc
src/model/RemoveAccessControlListEntryRequest.cc
src/model/RemoveAccessControlListEntryResult.cc
src/model/RemoveBackendServersRequest.cc src/model/RemoveBackendServersRequest.cc
src/model/RemoveBackendServersResult.cc src/model/RemoveBackendServersResult.cc
src/model/RemoveListenerWhiteListItemRequest.cc
src/model/RemoveListenerWhiteListItemResult.cc
src/model/RemoveTagsRequest.cc
src/model/RemoveTagsResult.cc
src/model/RemoveVServerGroupBackendServersRequest.cc
src/model/RemoveVServerGroupBackendServersResult.cc
src/model/SetAccessControlListAttributeRequest.cc
src/model/SetAccessControlListAttributeResult.cc
src/model/SetAccessLogsDownloadAttributeRequest.cc
src/model/SetAccessLogsDownloadAttributeResult.cc
src/model/SetBackendServersRequest.cc
src/model/SetBackendServersResult.cc
src/model/SetCACertificateNameRequest.cc
src/model/SetCACertificateNameResult.cc
src/model/SetDomainExtensionAttributeRequest.cc
src/model/SetDomainExtensionAttributeResult.cc
src/model/SetListenerAccessControlStatusRequest.cc
src/model/SetListenerAccessControlStatusResult.cc
src/model/SetLoadBalancerDeleteProtectionRequest.cc
src/model/SetLoadBalancerDeleteProtectionResult.cc
src/model/SetLoadBalancerHTTPListenerAttributeRequest.cc src/model/SetLoadBalancerHTTPListenerAttributeRequest.cc
src/model/SetLoadBalancerHTTPListenerAttributeResult.cc src/model/SetLoadBalancerHTTPListenerAttributeResult.cc
src/model/SetLoadBalancerListenerStatusRequest.cc src/model/SetLoadBalancerHTTPSListenerAttributeRequest.cc
src/model/SetLoadBalancerListenerStatusResult.cc src/model/SetLoadBalancerHTTPSListenerAttributeResult.cc
src/model/SetLoadBalancerModificationProtectionRequest.cc
src/model/SetLoadBalancerModificationProtectionResult.cc
src/model/SetLoadBalancerNameRequest.cc src/model/SetLoadBalancerNameRequest.cc
src/model/SetLoadBalancerNameResult.cc src/model/SetLoadBalancerNameResult.cc
src/model/SetLoadBalancerStatusRequest.cc src/model/SetLoadBalancerStatusRequest.cc
src/model/SetLoadBalancerStatusResult.cc src/model/SetLoadBalancerStatusResult.cc
src/model/SetLoadBalancerTCPListenerAttributeRequest.cc src/model/SetLoadBalancerTCPListenerAttributeRequest.cc
src/model/SetLoadBalancerTCPListenerAttributeResult.cc ) src/model/SetLoadBalancerTCPListenerAttributeResult.cc
src/model/SetLoadBalancerUDPListenerAttributeRequest.cc
src/model/SetLoadBalancerUDPListenerAttributeResult.cc
src/model/SetRuleRequest.cc
src/model/SetRuleResult.cc
src/model/SetServerCertificateNameRequest.cc
src/model/SetServerCertificateNameResult.cc
src/model/SetTLSCipherPolicyAttributeRequest.cc
src/model/SetTLSCipherPolicyAttributeResult.cc
src/model/SetVServerGroupAttributeRequest.cc
src/model/SetVServerGroupAttributeResult.cc
src/model/StartLoadBalancerListenerRequest.cc
src/model/StartLoadBalancerListenerResult.cc
src/model/StopLoadBalancerListenerRequest.cc
src/model/StopLoadBalancerListenerResult.cc
src/model/TagResourcesRequest.cc
src/model/TagResourcesResult.cc
src/model/UntagResourcesRequest.cc
src/model/UntagResourcesResult.cc
src/model/UploadCACertificateRequest.cc
src/model/UploadCACertificateResult.cc
src/model/UploadServerCertificateRequest.cc
src/model/UploadServerCertificateResult.cc )
add_library(slb ${LIB_TYPE} add_library(slb ${LIB_TYPE}
${slb_public_header} ${slb_public_header}

View File

@@ -22,42 +22,192 @@
#include <alibabacloud/core/EndpointProvider.h> #include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h> #include <alibabacloud/core/RpcServiceClient.h>
#include "SlbExport.h" #include "SlbExport.h"
#include "model/AddAccessControlListEntryRequest.h"
#include "model/AddAccessControlListEntryResult.h"
#include "model/AddBackendServersRequest.h" #include "model/AddBackendServersRequest.h"
#include "model/AddBackendServersResult.h" #include "model/AddBackendServersResult.h"
#include "model/AddListenerWhiteListItemRequest.h"
#include "model/AddListenerWhiteListItemResult.h"
#include "model/AddTagsRequest.h"
#include "model/AddTagsResult.h"
#include "model/AddVServerGroupBackendServersRequest.h"
#include "model/AddVServerGroupBackendServersResult.h"
#include "model/CreateAccessControlListRequest.h"
#include "model/CreateAccessControlListResult.h"
#include "model/CreateDomainExtensionRequest.h"
#include "model/CreateDomainExtensionResult.h"
#include "model/CreateLoadBalancerRequest.h" #include "model/CreateLoadBalancerRequest.h"
#include "model/CreateLoadBalancerResult.h" #include "model/CreateLoadBalancerResult.h"
#include "model/CreateLoadBalancerHTTPListenerRequest.h" #include "model/CreateLoadBalancerHTTPListenerRequest.h"
#include "model/CreateLoadBalancerHTTPListenerResult.h" #include "model/CreateLoadBalancerHTTPListenerResult.h"
#include "model/CreateLoadBalancerHTTPSListenerRequest.h"
#include "model/CreateLoadBalancerHTTPSListenerResult.h"
#include "model/CreateLoadBalancerTCPListenerRequest.h" #include "model/CreateLoadBalancerTCPListenerRequest.h"
#include "model/CreateLoadBalancerTCPListenerResult.h" #include "model/CreateLoadBalancerTCPListenerResult.h"
#include "model/CreateLoadBalancerUDPListenerRequest.h"
#include "model/CreateLoadBalancerUDPListenerResult.h"
#include "model/CreateMasterSlaveServerGroupRequest.h"
#include "model/CreateMasterSlaveServerGroupResult.h"
#include "model/CreateRulesRequest.h"
#include "model/CreateRulesResult.h"
#include "model/CreateTLSCipherPolicyRequest.h"
#include "model/CreateTLSCipherPolicyResult.h"
#include "model/CreateVServerGroupRequest.h"
#include "model/CreateVServerGroupResult.h"
#include "model/DeleteAccessControlListRequest.h"
#include "model/DeleteAccessControlListResult.h"
#include "model/DeleteAccessLogsDownloadAttributeRequest.h"
#include "model/DeleteAccessLogsDownloadAttributeResult.h"
#include "model/DeleteCACertificateRequest.h"
#include "model/DeleteCACertificateResult.h"
#include "model/DeleteDomainExtensionRequest.h"
#include "model/DeleteDomainExtensionResult.h"
#include "model/DeleteLoadBalancerRequest.h" #include "model/DeleteLoadBalancerRequest.h"
#include "model/DeleteLoadBalancerResult.h" #include "model/DeleteLoadBalancerResult.h"
#include "model/DeleteLoadBalancerListenerRequest.h" #include "model/DeleteLoadBalancerListenerRequest.h"
#include "model/DeleteLoadBalancerListenerResult.h" #include "model/DeleteLoadBalancerListenerResult.h"
#include "model/DescribeBackendServersRequest.h" #include "model/DeleteMasterSlaveServerGroupRequest.h"
#include "model/DescribeBackendServersResult.h" #include "model/DeleteMasterSlaveServerGroupResult.h"
#include "model/DeleteRulesRequest.h"
#include "model/DeleteRulesResult.h"
#include "model/DeleteServerCertificateRequest.h"
#include "model/DeleteServerCertificateResult.h"
#include "model/DeleteTLSCipherPolicyRequest.h"
#include "model/DeleteTLSCipherPolicyResult.h"
#include "model/DeleteVServerGroupRequest.h"
#include "model/DeleteVServerGroupResult.h"
#include "model/DescribeAccessControlListAttributeRequest.h"
#include "model/DescribeAccessControlListAttributeResult.h"
#include "model/DescribeAccessControlListsRequest.h"
#include "model/DescribeAccessControlListsResult.h"
#include "model/DescribeAccessLogsDownloadAttributeRequest.h"
#include "model/DescribeAccessLogsDownloadAttributeResult.h"
#include "model/DescribeAvailableResourceRequest.h"
#include "model/DescribeAvailableResourceResult.h"
#include "model/DescribeCACertificatesRequest.h"
#include "model/DescribeCACertificatesResult.h"
#include "model/DescribeDomainExtensionAttributeRequest.h"
#include "model/DescribeDomainExtensionAttributeResult.h"
#include "model/DescribeDomainExtensionsRequest.h"
#include "model/DescribeDomainExtensionsResult.h"
#include "model/DescribeHealthStatusRequest.h"
#include "model/DescribeHealthStatusResult.h"
#include "model/DescribeHighDefinationMonitorRequest.h"
#include "model/DescribeHighDefinationMonitorResult.h"
#include "model/DescribeListenerAccessControlAttributeRequest.h"
#include "model/DescribeListenerAccessControlAttributeResult.h"
#include "model/DescribeLoadBalancerAttributeRequest.h" #include "model/DescribeLoadBalancerAttributeRequest.h"
#include "model/DescribeLoadBalancerAttributeResult.h" #include "model/DescribeLoadBalancerAttributeResult.h"
#include "model/DescribeLoadBalancerHTTPListenerAttributeRequest.h" #include "model/DescribeLoadBalancerHTTPListenerAttributeRequest.h"
#include "model/DescribeLoadBalancerHTTPListenerAttributeResult.h" #include "model/DescribeLoadBalancerHTTPListenerAttributeResult.h"
#include "model/DescribeLoadBalancerHTTPSListenerAttributeRequest.h"
#include "model/DescribeLoadBalancerHTTPSListenerAttributeResult.h"
#include "model/DescribeLoadBalancerListenersRequest.h"
#include "model/DescribeLoadBalancerListenersResult.h"
#include "model/DescribeLoadBalancerTCPListenerAttributeRequest.h" #include "model/DescribeLoadBalancerTCPListenerAttributeRequest.h"
#include "model/DescribeLoadBalancerTCPListenerAttributeResult.h" #include "model/DescribeLoadBalancerTCPListenerAttributeResult.h"
#include "model/DescribeLoadBalancerUDPListenerAttributeRequest.h"
#include "model/DescribeLoadBalancerUDPListenerAttributeResult.h"
#include "model/DescribeLoadBalancersRequest.h" #include "model/DescribeLoadBalancersRequest.h"
#include "model/DescribeLoadBalancersResult.h" #include "model/DescribeLoadBalancersResult.h"
#include "model/DescribeMasterSlaveServerGroupAttributeRequest.h"
#include "model/DescribeMasterSlaveServerGroupAttributeResult.h"
#include "model/DescribeMasterSlaveServerGroupsRequest.h"
#include "model/DescribeMasterSlaveServerGroupsResult.h"
#include "model/DescribeRegionsRequest.h" #include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h" #include "model/DescribeRegionsResult.h"
#include "model/DescribeRuleAttributeRequest.h"
#include "model/DescribeRuleAttributeResult.h"
#include "model/DescribeRulesRequest.h"
#include "model/DescribeRulesResult.h"
#include "model/DescribeServerCertificatesRequest.h"
#include "model/DescribeServerCertificatesResult.h"
#include "model/DescribeTagsRequest.h"
#include "model/DescribeTagsResult.h"
#include "model/DescribeVServerGroupAttributeRequest.h"
#include "model/DescribeVServerGroupAttributeResult.h"
#include "model/DescribeVServerGroupsRequest.h"
#include "model/DescribeVServerGroupsResult.h"
#include "model/DescribeZonesRequest.h"
#include "model/DescribeZonesResult.h"
#include "model/EnableHighDefinationMonitorRequest.h"
#include "model/EnableHighDefinationMonitorResult.h"
#include "model/ListTLSCipherPoliciesRequest.h"
#include "model/ListTLSCipherPoliciesResult.h"
#include "model/ListTagResourcesRequest.h"
#include "model/ListTagResourcesResult.h"
#include "model/ModifyHighDefinationMonitorRequest.h"
#include "model/ModifyHighDefinationMonitorResult.h"
#include "model/ModifyLoadBalancerInstanceChargeTypeRequest.h"
#include "model/ModifyLoadBalancerInstanceChargeTypeResult.h"
#include "model/ModifyLoadBalancerInstanceSpecRequest.h"
#include "model/ModifyLoadBalancerInstanceSpecResult.h"
#include "model/ModifyLoadBalancerInternetSpecRequest.h"
#include "model/ModifyLoadBalancerInternetSpecResult.h"
#include "model/ModifyLoadBalancerPayTypeRequest.h"
#include "model/ModifyLoadBalancerPayTypeResult.h"
#include "model/ModifyVServerGroupBackendServersRequest.h"
#include "model/ModifyVServerGroupBackendServersResult.h"
#include "model/MoveResourceGroupRequest.h"
#include "model/MoveResourceGroupResult.h"
#include "model/RemoveAccessControlListEntryRequest.h"
#include "model/RemoveAccessControlListEntryResult.h"
#include "model/RemoveBackendServersRequest.h" #include "model/RemoveBackendServersRequest.h"
#include "model/RemoveBackendServersResult.h" #include "model/RemoveBackendServersResult.h"
#include "model/RemoveListenerWhiteListItemRequest.h"
#include "model/RemoveListenerWhiteListItemResult.h"
#include "model/RemoveTagsRequest.h"
#include "model/RemoveTagsResult.h"
#include "model/RemoveVServerGroupBackendServersRequest.h"
#include "model/RemoveVServerGroupBackendServersResult.h"
#include "model/SetAccessControlListAttributeRequest.h"
#include "model/SetAccessControlListAttributeResult.h"
#include "model/SetAccessLogsDownloadAttributeRequest.h"
#include "model/SetAccessLogsDownloadAttributeResult.h"
#include "model/SetBackendServersRequest.h"
#include "model/SetBackendServersResult.h"
#include "model/SetCACertificateNameRequest.h"
#include "model/SetCACertificateNameResult.h"
#include "model/SetDomainExtensionAttributeRequest.h"
#include "model/SetDomainExtensionAttributeResult.h"
#include "model/SetListenerAccessControlStatusRequest.h"
#include "model/SetListenerAccessControlStatusResult.h"
#include "model/SetLoadBalancerDeleteProtectionRequest.h"
#include "model/SetLoadBalancerDeleteProtectionResult.h"
#include "model/SetLoadBalancerHTTPListenerAttributeRequest.h" #include "model/SetLoadBalancerHTTPListenerAttributeRequest.h"
#include "model/SetLoadBalancerHTTPListenerAttributeResult.h" #include "model/SetLoadBalancerHTTPListenerAttributeResult.h"
#include "model/SetLoadBalancerListenerStatusRequest.h" #include "model/SetLoadBalancerHTTPSListenerAttributeRequest.h"
#include "model/SetLoadBalancerListenerStatusResult.h" #include "model/SetLoadBalancerHTTPSListenerAttributeResult.h"
#include "model/SetLoadBalancerModificationProtectionRequest.h"
#include "model/SetLoadBalancerModificationProtectionResult.h"
#include "model/SetLoadBalancerNameRequest.h" #include "model/SetLoadBalancerNameRequest.h"
#include "model/SetLoadBalancerNameResult.h" #include "model/SetLoadBalancerNameResult.h"
#include "model/SetLoadBalancerStatusRequest.h" #include "model/SetLoadBalancerStatusRequest.h"
#include "model/SetLoadBalancerStatusResult.h" #include "model/SetLoadBalancerStatusResult.h"
#include "model/SetLoadBalancerTCPListenerAttributeRequest.h" #include "model/SetLoadBalancerTCPListenerAttributeRequest.h"
#include "model/SetLoadBalancerTCPListenerAttributeResult.h" #include "model/SetLoadBalancerTCPListenerAttributeResult.h"
#include "model/SetLoadBalancerUDPListenerAttributeRequest.h"
#include "model/SetLoadBalancerUDPListenerAttributeResult.h"
#include "model/SetRuleRequest.h"
#include "model/SetRuleResult.h"
#include "model/SetServerCertificateNameRequest.h"
#include "model/SetServerCertificateNameResult.h"
#include "model/SetTLSCipherPolicyAttributeRequest.h"
#include "model/SetTLSCipherPolicyAttributeResult.h"
#include "model/SetVServerGroupAttributeRequest.h"
#include "model/SetVServerGroupAttributeResult.h"
#include "model/StartLoadBalancerListenerRequest.h"
#include "model/StartLoadBalancerListenerResult.h"
#include "model/StopLoadBalancerListenerRequest.h"
#include "model/StopLoadBalancerListenerResult.h"
#include "model/TagResourcesRequest.h"
#include "model/TagResourcesResult.h"
#include "model/UntagResourcesRequest.h"
#include "model/UntagResourcesResult.h"
#include "model/UploadCACertificateRequest.h"
#include "model/UploadCACertificateResult.h"
#include "model/UploadServerCertificateRequest.h"
#include "model/UploadServerCertificateResult.h"
namespace AlibabaCloud namespace AlibabaCloud
@@ -67,51 +217,243 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT SlbClient : public RpcServiceClient class ALIBABACLOUD_SLB_EXPORT SlbClient : public RpcServiceClient
{ {
public: public:
typedef Outcome<Error, Model::AddAccessControlListEntryResult> AddAccessControlListEntryOutcome;
typedef std::future<AddAccessControlListEntryOutcome> AddAccessControlListEntryOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::AddAccessControlListEntryRequest&, const AddAccessControlListEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddAccessControlListEntryAsyncHandler;
typedef Outcome<Error, Model::AddBackendServersResult> AddBackendServersOutcome; typedef Outcome<Error, Model::AddBackendServersResult> AddBackendServersOutcome;
typedef std::future<AddBackendServersOutcome> AddBackendServersOutcomeCallable; typedef std::future<AddBackendServersOutcome> AddBackendServersOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::AddBackendServersRequest&, const AddBackendServersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddBackendServersAsyncHandler; typedef std::function<void(const SlbClient*, const Model::AddBackendServersRequest&, const AddBackendServersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddBackendServersAsyncHandler;
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::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::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::CreateAccessControlListResult> CreateAccessControlListOutcome;
typedef std::future<CreateAccessControlListOutcome> CreateAccessControlListOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateAccessControlListRequest&, const CreateAccessControlListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAccessControlListAsyncHandler;
typedef Outcome<Error, Model::CreateDomainExtensionResult> CreateDomainExtensionOutcome;
typedef std::future<CreateDomainExtensionOutcome> CreateDomainExtensionOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateDomainExtensionRequest&, const CreateDomainExtensionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDomainExtensionAsyncHandler;
typedef Outcome<Error, Model::CreateLoadBalancerResult> CreateLoadBalancerOutcome; typedef Outcome<Error, Model::CreateLoadBalancerResult> CreateLoadBalancerOutcome;
typedef std::future<CreateLoadBalancerOutcome> CreateLoadBalancerOutcomeCallable; typedef std::future<CreateLoadBalancerOutcome> CreateLoadBalancerOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateLoadBalancerRequest&, const CreateLoadBalancerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLoadBalancerAsyncHandler; typedef std::function<void(const SlbClient*, const Model::CreateLoadBalancerRequest&, const CreateLoadBalancerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLoadBalancerAsyncHandler;
typedef Outcome<Error, Model::CreateLoadBalancerHTTPListenerResult> CreateLoadBalancerHTTPListenerOutcome; typedef Outcome<Error, Model::CreateLoadBalancerHTTPListenerResult> CreateLoadBalancerHTTPListenerOutcome;
typedef std::future<CreateLoadBalancerHTTPListenerOutcome> CreateLoadBalancerHTTPListenerOutcomeCallable; typedef std::future<CreateLoadBalancerHTTPListenerOutcome> CreateLoadBalancerHTTPListenerOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateLoadBalancerHTTPListenerRequest&, const CreateLoadBalancerHTTPListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLoadBalancerHTTPListenerAsyncHandler; typedef std::function<void(const SlbClient*, const Model::CreateLoadBalancerHTTPListenerRequest&, const CreateLoadBalancerHTTPListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLoadBalancerHTTPListenerAsyncHandler;
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::CreateLoadBalancerTCPListenerResult> CreateLoadBalancerTCPListenerOutcome; typedef Outcome<Error, Model::CreateLoadBalancerTCPListenerResult> CreateLoadBalancerTCPListenerOutcome;
typedef std::future<CreateLoadBalancerTCPListenerOutcome> CreateLoadBalancerTCPListenerOutcomeCallable; typedef std::future<CreateLoadBalancerTCPListenerOutcome> CreateLoadBalancerTCPListenerOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateLoadBalancerTCPListenerRequest&, const CreateLoadBalancerTCPListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLoadBalancerTCPListenerAsyncHandler; typedef std::function<void(const SlbClient*, const Model::CreateLoadBalancerTCPListenerRequest&, const CreateLoadBalancerTCPListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLoadBalancerTCPListenerAsyncHandler;
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::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::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::CreateTLSCipherPolicyResult> CreateTLSCipherPolicyOutcome;
typedef std::future<CreateTLSCipherPolicyOutcome> CreateTLSCipherPolicyOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::CreateTLSCipherPolicyRequest&, const CreateTLSCipherPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateTLSCipherPolicyAsyncHandler;
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::DeleteAccessControlListResult> DeleteAccessControlListOutcome;
typedef std::future<DeleteAccessControlListOutcome> DeleteAccessControlListOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteAccessControlListRequest&, const DeleteAccessControlListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAccessControlListAsyncHandler;
typedef Outcome<Error, Model::DeleteAccessLogsDownloadAttributeResult> DeleteAccessLogsDownloadAttributeOutcome;
typedef std::future<DeleteAccessLogsDownloadAttributeOutcome> DeleteAccessLogsDownloadAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteAccessLogsDownloadAttributeRequest&, const DeleteAccessLogsDownloadAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAccessLogsDownloadAttributeAsyncHandler;
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::DeleteDomainExtensionResult> DeleteDomainExtensionOutcome;
typedef std::future<DeleteDomainExtensionOutcome> DeleteDomainExtensionOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteDomainExtensionRequest&, const DeleteDomainExtensionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDomainExtensionAsyncHandler;
typedef Outcome<Error, Model::DeleteLoadBalancerResult> DeleteLoadBalancerOutcome; typedef Outcome<Error, Model::DeleteLoadBalancerResult> DeleteLoadBalancerOutcome;
typedef std::future<DeleteLoadBalancerOutcome> DeleteLoadBalancerOutcomeCallable; typedef std::future<DeleteLoadBalancerOutcome> DeleteLoadBalancerOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteLoadBalancerRequest&, const DeleteLoadBalancerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLoadBalancerAsyncHandler; typedef std::function<void(const SlbClient*, const Model::DeleteLoadBalancerRequest&, const DeleteLoadBalancerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLoadBalancerAsyncHandler;
typedef Outcome<Error, Model::DeleteLoadBalancerListenerResult> DeleteLoadBalancerListenerOutcome; typedef Outcome<Error, Model::DeleteLoadBalancerListenerResult> DeleteLoadBalancerListenerOutcome;
typedef std::future<DeleteLoadBalancerListenerOutcome> DeleteLoadBalancerListenerOutcomeCallable; typedef std::future<DeleteLoadBalancerListenerOutcome> DeleteLoadBalancerListenerOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteLoadBalancerListenerRequest&, const DeleteLoadBalancerListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLoadBalancerListenerAsyncHandler; typedef std::function<void(const SlbClient*, const Model::DeleteLoadBalancerListenerRequest&, const DeleteLoadBalancerListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLoadBalancerListenerAsyncHandler;
typedef Outcome<Error, Model::DescribeBackendServersResult> DescribeBackendServersOutcome; typedef Outcome<Error, Model::DeleteMasterSlaveServerGroupResult> DeleteMasterSlaveServerGroupOutcome;
typedef std::future<DescribeBackendServersOutcome> DescribeBackendServersOutcomeCallable; typedef std::future<DeleteMasterSlaveServerGroupOutcome> DeleteMasterSlaveServerGroupOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeBackendServersRequest&, const DescribeBackendServersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBackendServersAsyncHandler; typedef std::function<void(const SlbClient*, const Model::DeleteMasterSlaveServerGroupRequest&, const DeleteMasterSlaveServerGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteMasterSlaveServerGroupAsyncHandler;
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::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::DeleteTLSCipherPolicyResult> DeleteTLSCipherPolicyOutcome;
typedef std::future<DeleteTLSCipherPolicyOutcome> DeleteTLSCipherPolicyOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DeleteTLSCipherPolicyRequest&, const DeleteTLSCipherPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTLSCipherPolicyAsyncHandler;
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::DescribeAccessControlListAttributeResult> DescribeAccessControlListAttributeOutcome;
typedef std::future<DescribeAccessControlListAttributeOutcome> DescribeAccessControlListAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeAccessControlListAttributeRequest&, const DescribeAccessControlListAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccessControlListAttributeAsyncHandler;
typedef Outcome<Error, Model::DescribeAccessControlListsResult> DescribeAccessControlListsOutcome;
typedef std::future<DescribeAccessControlListsOutcome> DescribeAccessControlListsOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeAccessControlListsRequest&, const DescribeAccessControlListsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccessControlListsAsyncHandler;
typedef Outcome<Error, Model::DescribeAccessLogsDownloadAttributeResult> DescribeAccessLogsDownloadAttributeOutcome;
typedef std::future<DescribeAccessLogsDownloadAttributeOutcome> DescribeAccessLogsDownloadAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeAccessLogsDownloadAttributeRequest&, const DescribeAccessLogsDownloadAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccessLogsDownloadAttributeAsyncHandler;
typedef Outcome<Error, Model::DescribeAvailableResourceResult> DescribeAvailableResourceOutcome;
typedef std::future<DescribeAvailableResourceOutcome> DescribeAvailableResourceOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeAvailableResourceRequest&, const DescribeAvailableResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAvailableResourceAsyncHandler;
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::DescribeDomainExtensionAttributeResult> DescribeDomainExtensionAttributeOutcome;
typedef std::future<DescribeDomainExtensionAttributeOutcome> DescribeDomainExtensionAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeDomainExtensionAttributeRequest&, const DescribeDomainExtensionAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDomainExtensionAttributeAsyncHandler;
typedef Outcome<Error, Model::DescribeDomainExtensionsResult> DescribeDomainExtensionsOutcome;
typedef std::future<DescribeDomainExtensionsOutcome> DescribeDomainExtensionsOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeDomainExtensionsRequest&, const DescribeDomainExtensionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDomainExtensionsAsyncHandler;
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::DescribeHighDefinationMonitorResult> DescribeHighDefinationMonitorOutcome;
typedef std::future<DescribeHighDefinationMonitorOutcome> DescribeHighDefinationMonitorOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeHighDefinationMonitorRequest&, const DescribeHighDefinationMonitorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeHighDefinationMonitorAsyncHandler;
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::DescribeLoadBalancerAttributeResult> DescribeLoadBalancerAttributeOutcome; typedef Outcome<Error, Model::DescribeLoadBalancerAttributeResult> DescribeLoadBalancerAttributeOutcome;
typedef std::future<DescribeLoadBalancerAttributeOutcome> DescribeLoadBalancerAttributeOutcomeCallable; typedef std::future<DescribeLoadBalancerAttributeOutcome> DescribeLoadBalancerAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancerAttributeRequest&, const DescribeLoadBalancerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancerAttributeAsyncHandler; typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancerAttributeRequest&, const DescribeLoadBalancerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancerAttributeAsyncHandler;
typedef Outcome<Error, Model::DescribeLoadBalancerHTTPListenerAttributeResult> DescribeLoadBalancerHTTPListenerAttributeOutcome; typedef Outcome<Error, Model::DescribeLoadBalancerHTTPListenerAttributeResult> DescribeLoadBalancerHTTPListenerAttributeOutcome;
typedef std::future<DescribeLoadBalancerHTTPListenerAttributeOutcome> DescribeLoadBalancerHTTPListenerAttributeOutcomeCallable; typedef std::future<DescribeLoadBalancerHTTPListenerAttributeOutcome> DescribeLoadBalancerHTTPListenerAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancerHTTPListenerAttributeRequest&, const DescribeLoadBalancerHTTPListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancerHTTPListenerAttributeAsyncHandler; typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancerHTTPListenerAttributeRequest&, const DescribeLoadBalancerHTTPListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancerHTTPListenerAttributeAsyncHandler;
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::DescribeLoadBalancerListenersResult> DescribeLoadBalancerListenersOutcome;
typedef std::future<DescribeLoadBalancerListenersOutcome> DescribeLoadBalancerListenersOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancerListenersRequest&, const DescribeLoadBalancerListenersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancerListenersAsyncHandler;
typedef Outcome<Error, Model::DescribeLoadBalancerTCPListenerAttributeResult> DescribeLoadBalancerTCPListenerAttributeOutcome; typedef Outcome<Error, Model::DescribeLoadBalancerTCPListenerAttributeResult> DescribeLoadBalancerTCPListenerAttributeOutcome;
typedef std::future<DescribeLoadBalancerTCPListenerAttributeOutcome> DescribeLoadBalancerTCPListenerAttributeOutcomeCallable; typedef std::future<DescribeLoadBalancerTCPListenerAttributeOutcome> DescribeLoadBalancerTCPListenerAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancerTCPListenerAttributeRequest&, const DescribeLoadBalancerTCPListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancerTCPListenerAttributeAsyncHandler; typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancerTCPListenerAttributeRequest&, const DescribeLoadBalancerTCPListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancerTCPListenerAttributeAsyncHandler;
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::DescribeLoadBalancersResult> DescribeLoadBalancersOutcome; typedef Outcome<Error, Model::DescribeLoadBalancersResult> DescribeLoadBalancersOutcome;
typedef std::future<DescribeLoadBalancersOutcome> DescribeLoadBalancersOutcomeCallable; typedef std::future<DescribeLoadBalancersOutcome> DescribeLoadBalancersOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancersRequest&, const DescribeLoadBalancersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancersAsyncHandler; typedef std::function<void(const SlbClient*, const Model::DescribeLoadBalancersRequest&, const DescribeLoadBalancersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLoadBalancersAsyncHandler;
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::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::DescribeRegionsResult> DescribeRegionsOutcome; typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable; typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler; typedef std::function<void(const SlbClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
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::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::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::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::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::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::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::EnableHighDefinationMonitorResult> EnableHighDefinationMonitorOutcome;
typedef std::future<EnableHighDefinationMonitorOutcome> EnableHighDefinationMonitorOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::EnableHighDefinationMonitorRequest&, const EnableHighDefinationMonitorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableHighDefinationMonitorAsyncHandler;
typedef Outcome<Error, Model::ListTLSCipherPoliciesResult> ListTLSCipherPoliciesOutcome;
typedef std::future<ListTLSCipherPoliciesOutcome> ListTLSCipherPoliciesOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::ListTLSCipherPoliciesRequest&, const ListTLSCipherPoliciesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTLSCipherPoliciesAsyncHandler;
typedef Outcome<Error, Model::ListTagResourcesResult> ListTagResourcesOutcome;
typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
typedef Outcome<Error, Model::ModifyHighDefinationMonitorResult> ModifyHighDefinationMonitorOutcome;
typedef std::future<ModifyHighDefinationMonitorOutcome> ModifyHighDefinationMonitorOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::ModifyHighDefinationMonitorRequest&, const ModifyHighDefinationMonitorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyHighDefinationMonitorAsyncHandler;
typedef Outcome<Error, Model::ModifyLoadBalancerInstanceChargeTypeResult> ModifyLoadBalancerInstanceChargeTypeOutcome;
typedef std::future<ModifyLoadBalancerInstanceChargeTypeOutcome> ModifyLoadBalancerInstanceChargeTypeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::ModifyLoadBalancerInstanceChargeTypeRequest&, const ModifyLoadBalancerInstanceChargeTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyLoadBalancerInstanceChargeTypeAsyncHandler;
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::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::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::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::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::RemoveAccessControlListEntryResult> RemoveAccessControlListEntryOutcome;
typedef std::future<RemoveAccessControlListEntryOutcome> RemoveAccessControlListEntryOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::RemoveAccessControlListEntryRequest&, const RemoveAccessControlListEntryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveAccessControlListEntryAsyncHandler;
typedef Outcome<Error, Model::RemoveBackendServersResult> RemoveBackendServersOutcome; typedef Outcome<Error, Model::RemoveBackendServersResult> RemoveBackendServersOutcome;
typedef std::future<RemoveBackendServersOutcome> RemoveBackendServersOutcomeCallable; typedef std::future<RemoveBackendServersOutcome> RemoveBackendServersOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::RemoveBackendServersRequest&, const RemoveBackendServersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveBackendServersAsyncHandler; typedef std::function<void(const SlbClient*, const Model::RemoveBackendServersRequest&, const RemoveBackendServersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveBackendServersAsyncHandler;
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::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::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::SetAccessControlListAttributeResult> SetAccessControlListAttributeOutcome;
typedef std::future<SetAccessControlListAttributeOutcome> SetAccessControlListAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetAccessControlListAttributeRequest&, const SetAccessControlListAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetAccessControlListAttributeAsyncHandler;
typedef Outcome<Error, Model::SetAccessLogsDownloadAttributeResult> SetAccessLogsDownloadAttributeOutcome;
typedef std::future<SetAccessLogsDownloadAttributeOutcome> SetAccessLogsDownloadAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetAccessLogsDownloadAttributeRequest&, const SetAccessLogsDownloadAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetAccessLogsDownloadAttributeAsyncHandler;
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::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::SetDomainExtensionAttributeResult> SetDomainExtensionAttributeOutcome;
typedef std::future<SetDomainExtensionAttributeOutcome> SetDomainExtensionAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetDomainExtensionAttributeRequest&, const SetDomainExtensionAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetDomainExtensionAttributeAsyncHandler;
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::SetLoadBalancerDeleteProtectionResult> SetLoadBalancerDeleteProtectionOutcome;
typedef std::future<SetLoadBalancerDeleteProtectionOutcome> SetLoadBalancerDeleteProtectionOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerDeleteProtectionRequest&, const SetLoadBalancerDeleteProtectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerDeleteProtectionAsyncHandler;
typedef Outcome<Error, Model::SetLoadBalancerHTTPListenerAttributeResult> SetLoadBalancerHTTPListenerAttributeOutcome; typedef Outcome<Error, Model::SetLoadBalancerHTTPListenerAttributeResult> SetLoadBalancerHTTPListenerAttributeOutcome;
typedef std::future<SetLoadBalancerHTTPListenerAttributeOutcome> SetLoadBalancerHTTPListenerAttributeOutcomeCallable; typedef std::future<SetLoadBalancerHTTPListenerAttributeOutcome> SetLoadBalancerHTTPListenerAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerHTTPListenerAttributeRequest&, const SetLoadBalancerHTTPListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerHTTPListenerAttributeAsyncHandler; typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerHTTPListenerAttributeRequest&, const SetLoadBalancerHTTPListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerHTTPListenerAttributeAsyncHandler;
typedef Outcome<Error, Model::SetLoadBalancerListenerStatusResult> SetLoadBalancerListenerStatusOutcome; typedef Outcome<Error, Model::SetLoadBalancerHTTPSListenerAttributeResult> SetLoadBalancerHTTPSListenerAttributeOutcome;
typedef std::future<SetLoadBalancerListenerStatusOutcome> SetLoadBalancerListenerStatusOutcomeCallable; typedef std::future<SetLoadBalancerHTTPSListenerAttributeOutcome> SetLoadBalancerHTTPSListenerAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerListenerStatusRequest&, const SetLoadBalancerListenerStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerListenerStatusAsyncHandler; typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerHTTPSListenerAttributeRequest&, const SetLoadBalancerHTTPSListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerHTTPSListenerAttributeAsyncHandler;
typedef Outcome<Error, Model::SetLoadBalancerModificationProtectionResult> SetLoadBalancerModificationProtectionOutcome;
typedef std::future<SetLoadBalancerModificationProtectionOutcome> SetLoadBalancerModificationProtectionOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerModificationProtectionRequest&, const SetLoadBalancerModificationProtectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerModificationProtectionAsyncHandler;
typedef Outcome<Error, Model::SetLoadBalancerNameResult> SetLoadBalancerNameOutcome; typedef Outcome<Error, Model::SetLoadBalancerNameResult> SetLoadBalancerNameOutcome;
typedef std::future<SetLoadBalancerNameOutcome> SetLoadBalancerNameOutcomeCallable; typedef std::future<SetLoadBalancerNameOutcome> SetLoadBalancerNameOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerNameRequest&, const SetLoadBalancerNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerNameAsyncHandler; typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerNameRequest&, const SetLoadBalancerNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerNameAsyncHandler;
@@ -121,56 +463,281 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::SetLoadBalancerTCPListenerAttributeResult> SetLoadBalancerTCPListenerAttributeOutcome; typedef Outcome<Error, Model::SetLoadBalancerTCPListenerAttributeResult> SetLoadBalancerTCPListenerAttributeOutcome;
typedef std::future<SetLoadBalancerTCPListenerAttributeOutcome> SetLoadBalancerTCPListenerAttributeOutcomeCallable; typedef std::future<SetLoadBalancerTCPListenerAttributeOutcome> SetLoadBalancerTCPListenerAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerTCPListenerAttributeRequest&, const SetLoadBalancerTCPListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerTCPListenerAttributeAsyncHandler; typedef std::function<void(const SlbClient*, const Model::SetLoadBalancerTCPListenerAttributeRequest&, const SetLoadBalancerTCPListenerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLoadBalancerTCPListenerAttributeAsyncHandler;
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;
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::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::SetTLSCipherPolicyAttributeResult> SetTLSCipherPolicyAttributeOutcome;
typedef std::future<SetTLSCipherPolicyAttributeOutcome> SetTLSCipherPolicyAttributeOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::SetTLSCipherPolicyAttributeRequest&, const SetTLSCipherPolicyAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetTLSCipherPolicyAttributeAsyncHandler;
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::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::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::TagResourcesResult> TagResourcesOutcome;
typedef std::future<TagResourcesOutcome> TagResourcesOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::TagResourcesRequest&, const TagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TagResourcesAsyncHandler;
typedef Outcome<Error, Model::UntagResourcesResult> UntagResourcesOutcome;
typedef std::future<UntagResourcesOutcome> UntagResourcesOutcomeCallable;
typedef std::function<void(const SlbClient*, const Model::UntagResourcesRequest&, const UntagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UntagResourcesAsyncHandler;
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::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;
SlbClient(const Credentials &credentials, const ClientConfiguration &configuration); SlbClient(const Credentials &credentials, const ClientConfiguration &configuration);
SlbClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, 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(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~SlbClient(); ~SlbClient();
AddAccessControlListEntryOutcome addAccessControlListEntry(const Model::AddAccessControlListEntryRequest &request)const;
void addAccessControlListEntryAsync(const Model::AddAccessControlListEntryRequest& request, const AddAccessControlListEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddAccessControlListEntryOutcomeCallable addAccessControlListEntryCallable(const Model::AddAccessControlListEntryRequest& request) const;
AddBackendServersOutcome addBackendServers(const Model::AddBackendServersRequest &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; 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; AddBackendServersOutcomeCallable addBackendServersCallable(const Model::AddBackendServersRequest& 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;
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;
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;
CreateAccessControlListOutcome createAccessControlList(const Model::CreateAccessControlListRequest &request)const;
void createAccessControlListAsync(const Model::CreateAccessControlListRequest& request, const CreateAccessControlListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateAccessControlListOutcomeCallable createAccessControlListCallable(const Model::CreateAccessControlListRequest& request) const;
CreateDomainExtensionOutcome createDomainExtension(const Model::CreateDomainExtensionRequest &request)const;
void createDomainExtensionAsync(const Model::CreateDomainExtensionRequest& request, const CreateDomainExtensionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDomainExtensionOutcomeCallable createDomainExtensionCallable(const Model::CreateDomainExtensionRequest& request) const;
CreateLoadBalancerOutcome createLoadBalancer(const Model::CreateLoadBalancerRequest &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; 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; CreateLoadBalancerOutcomeCallable createLoadBalancerCallable(const Model::CreateLoadBalancerRequest& request) const;
CreateLoadBalancerHTTPListenerOutcome createLoadBalancerHTTPListener(const Model::CreateLoadBalancerHTTPListenerRequest &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; 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; CreateLoadBalancerHTTPListenerOutcomeCallable createLoadBalancerHTTPListenerCallable(const Model::CreateLoadBalancerHTTPListenerRequest& 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;
CreateLoadBalancerTCPListenerOutcome createLoadBalancerTCPListener(const Model::CreateLoadBalancerTCPListenerRequest &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; 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; CreateLoadBalancerTCPListenerOutcomeCallable createLoadBalancerTCPListenerCallable(const Model::CreateLoadBalancerTCPListenerRequest& request) const;
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;
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;
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;
CreateTLSCipherPolicyOutcome createTLSCipherPolicy(const Model::CreateTLSCipherPolicyRequest &request)const;
void createTLSCipherPolicyAsync(const Model::CreateTLSCipherPolicyRequest& request, const CreateTLSCipherPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateTLSCipherPolicyOutcomeCallable createTLSCipherPolicyCallable(const Model::CreateTLSCipherPolicyRequest& 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;
DeleteAccessControlListOutcome deleteAccessControlList(const Model::DeleteAccessControlListRequest &request)const;
void deleteAccessControlListAsync(const Model::DeleteAccessControlListRequest& request, const DeleteAccessControlListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteAccessControlListOutcomeCallable deleteAccessControlListCallable(const Model::DeleteAccessControlListRequest& request) const;
DeleteAccessLogsDownloadAttributeOutcome deleteAccessLogsDownloadAttribute(const Model::DeleteAccessLogsDownloadAttributeRequest &request)const;
void deleteAccessLogsDownloadAttributeAsync(const Model::DeleteAccessLogsDownloadAttributeRequest& request, const DeleteAccessLogsDownloadAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteAccessLogsDownloadAttributeOutcomeCallable deleteAccessLogsDownloadAttributeCallable(const Model::DeleteAccessLogsDownloadAttributeRequest& 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;
DeleteDomainExtensionOutcome deleteDomainExtension(const Model::DeleteDomainExtensionRequest &request)const;
void deleteDomainExtensionAsync(const Model::DeleteDomainExtensionRequest& request, const DeleteDomainExtensionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDomainExtensionOutcomeCallable deleteDomainExtensionCallable(const Model::DeleteDomainExtensionRequest& request) const;
DeleteLoadBalancerOutcome deleteLoadBalancer(const Model::DeleteLoadBalancerRequest &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; 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; DeleteLoadBalancerOutcomeCallable deleteLoadBalancerCallable(const Model::DeleteLoadBalancerRequest& request) const;
DeleteLoadBalancerListenerOutcome deleteLoadBalancerListener(const Model::DeleteLoadBalancerListenerRequest &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; 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; DeleteLoadBalancerListenerOutcomeCallable deleteLoadBalancerListenerCallable(const Model::DeleteLoadBalancerListenerRequest& request) const;
DescribeBackendServersOutcome describeBackendServers(const Model::DescribeBackendServersRequest &request)const; DeleteMasterSlaveServerGroupOutcome deleteMasterSlaveServerGroup(const Model::DeleteMasterSlaveServerGroupRequest &request)const;
void describeBackendServersAsync(const Model::DescribeBackendServersRequest& request, const DescribeBackendServersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const; void deleteMasterSlaveServerGroupAsync(const Model::DeleteMasterSlaveServerGroupRequest& request, const DeleteMasterSlaveServerGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeBackendServersOutcomeCallable describeBackendServersCallable(const Model::DescribeBackendServersRequest& request) const; DeleteMasterSlaveServerGroupOutcomeCallable deleteMasterSlaveServerGroupCallable(const Model::DeleteMasterSlaveServerGroupRequest& 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;
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;
DeleteTLSCipherPolicyOutcome deleteTLSCipherPolicy(const Model::DeleteTLSCipherPolicyRequest &request)const;
void deleteTLSCipherPolicyAsync(const Model::DeleteTLSCipherPolicyRequest& request, const DeleteTLSCipherPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteTLSCipherPolicyOutcomeCallable deleteTLSCipherPolicyCallable(const Model::DeleteTLSCipherPolicyRequest& 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;
DescribeAccessControlListAttributeOutcome describeAccessControlListAttribute(const Model::DescribeAccessControlListAttributeRequest &request)const;
void describeAccessControlListAttributeAsync(const Model::DescribeAccessControlListAttributeRequest& request, const DescribeAccessControlListAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAccessControlListAttributeOutcomeCallable describeAccessControlListAttributeCallable(const Model::DescribeAccessControlListAttributeRequest& request) const;
DescribeAccessControlListsOutcome describeAccessControlLists(const Model::DescribeAccessControlListsRequest &request)const;
void describeAccessControlListsAsync(const Model::DescribeAccessControlListsRequest& request, const DescribeAccessControlListsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAccessControlListsOutcomeCallable describeAccessControlListsCallable(const Model::DescribeAccessControlListsRequest& request) const;
DescribeAccessLogsDownloadAttributeOutcome describeAccessLogsDownloadAttribute(const Model::DescribeAccessLogsDownloadAttributeRequest &request)const;
void describeAccessLogsDownloadAttributeAsync(const Model::DescribeAccessLogsDownloadAttributeRequest& request, const DescribeAccessLogsDownloadAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAccessLogsDownloadAttributeOutcomeCallable describeAccessLogsDownloadAttributeCallable(const Model::DescribeAccessLogsDownloadAttributeRequest& request) const;
DescribeAvailableResourceOutcome describeAvailableResource(const Model::DescribeAvailableResourceRequest &request)const;
void describeAvailableResourceAsync(const Model::DescribeAvailableResourceRequest& request, const DescribeAvailableResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAvailableResourceOutcomeCallable describeAvailableResourceCallable(const Model::DescribeAvailableResourceRequest& 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;
DescribeDomainExtensionAttributeOutcome describeDomainExtensionAttribute(const Model::DescribeDomainExtensionAttributeRequest &request)const;
void describeDomainExtensionAttributeAsync(const Model::DescribeDomainExtensionAttributeRequest& request, const DescribeDomainExtensionAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDomainExtensionAttributeOutcomeCallable describeDomainExtensionAttributeCallable(const Model::DescribeDomainExtensionAttributeRequest& request) const;
DescribeDomainExtensionsOutcome describeDomainExtensions(const Model::DescribeDomainExtensionsRequest &request)const;
void describeDomainExtensionsAsync(const Model::DescribeDomainExtensionsRequest& request, const DescribeDomainExtensionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDomainExtensionsOutcomeCallable describeDomainExtensionsCallable(const Model::DescribeDomainExtensionsRequest& 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;
DescribeHighDefinationMonitorOutcome describeHighDefinationMonitor(const Model::DescribeHighDefinationMonitorRequest &request)const;
void describeHighDefinationMonitorAsync(const Model::DescribeHighDefinationMonitorRequest& request, const DescribeHighDefinationMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeHighDefinationMonitorOutcomeCallable describeHighDefinationMonitorCallable(const Model::DescribeHighDefinationMonitorRequest& 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;
DescribeLoadBalancerAttributeOutcome describeLoadBalancerAttribute(const Model::DescribeLoadBalancerAttributeRequest &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; 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; DescribeLoadBalancerAttributeOutcomeCallable describeLoadBalancerAttributeCallable(const Model::DescribeLoadBalancerAttributeRequest& request) const;
DescribeLoadBalancerHTTPListenerAttributeOutcome describeLoadBalancerHTTPListenerAttribute(const Model::DescribeLoadBalancerHTTPListenerAttributeRequest &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; 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; DescribeLoadBalancerHTTPListenerAttributeOutcomeCallable describeLoadBalancerHTTPListenerAttributeCallable(const Model::DescribeLoadBalancerHTTPListenerAttributeRequest& 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;
DescribeLoadBalancerListenersOutcome describeLoadBalancerListeners(const Model::DescribeLoadBalancerListenersRequest &request)const;
void describeLoadBalancerListenersAsync(const Model::DescribeLoadBalancerListenersRequest& request, const DescribeLoadBalancerListenersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLoadBalancerListenersOutcomeCallable describeLoadBalancerListenersCallable(const Model::DescribeLoadBalancerListenersRequest& request) const;
DescribeLoadBalancerTCPListenerAttributeOutcome describeLoadBalancerTCPListenerAttribute(const Model::DescribeLoadBalancerTCPListenerAttributeRequest &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; 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; DescribeLoadBalancerTCPListenerAttributeOutcomeCallable describeLoadBalancerTCPListenerAttributeCallable(const Model::DescribeLoadBalancerTCPListenerAttributeRequest& 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;
DescribeLoadBalancersOutcome describeLoadBalancers(const Model::DescribeLoadBalancersRequest &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; 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; DescribeLoadBalancersOutcomeCallable describeLoadBalancersCallable(const Model::DescribeLoadBalancersRequest& 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;
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;
DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &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; 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; DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& 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;
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;
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;
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;
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;
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;
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;
EnableHighDefinationMonitorOutcome enableHighDefinationMonitor(const Model::EnableHighDefinationMonitorRequest &request)const;
void enableHighDefinationMonitorAsync(const Model::EnableHighDefinationMonitorRequest& request, const EnableHighDefinationMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EnableHighDefinationMonitorOutcomeCallable enableHighDefinationMonitorCallable(const Model::EnableHighDefinationMonitorRequest& request) const;
ListTLSCipherPoliciesOutcome listTLSCipherPolicies(const Model::ListTLSCipherPoliciesRequest &request)const;
void listTLSCipherPoliciesAsync(const Model::ListTLSCipherPoliciesRequest& request, const ListTLSCipherPoliciesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTLSCipherPoliciesOutcomeCallable listTLSCipherPoliciesCallable(const Model::ListTLSCipherPoliciesRequest& request) const;
ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const;
void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const;
ModifyHighDefinationMonitorOutcome modifyHighDefinationMonitor(const Model::ModifyHighDefinationMonitorRequest &request)const;
void modifyHighDefinationMonitorAsync(const Model::ModifyHighDefinationMonitorRequest& request, const ModifyHighDefinationMonitorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyHighDefinationMonitorOutcomeCallable modifyHighDefinationMonitorCallable(const Model::ModifyHighDefinationMonitorRequest& request) const;
ModifyLoadBalancerInstanceChargeTypeOutcome modifyLoadBalancerInstanceChargeType(const Model::ModifyLoadBalancerInstanceChargeTypeRequest &request)const;
void modifyLoadBalancerInstanceChargeTypeAsync(const Model::ModifyLoadBalancerInstanceChargeTypeRequest& request, const ModifyLoadBalancerInstanceChargeTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyLoadBalancerInstanceChargeTypeOutcomeCallable modifyLoadBalancerInstanceChargeTypeCallable(const Model::ModifyLoadBalancerInstanceChargeTypeRequest& 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;
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;
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;
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;
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;
RemoveAccessControlListEntryOutcome removeAccessControlListEntry(const Model::RemoveAccessControlListEntryRequest &request)const;
void removeAccessControlListEntryAsync(const Model::RemoveAccessControlListEntryRequest& request, const RemoveAccessControlListEntryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RemoveAccessControlListEntryOutcomeCallable removeAccessControlListEntryCallable(const Model::RemoveAccessControlListEntryRequest& request) const;
RemoveBackendServersOutcome removeBackendServers(const Model::RemoveBackendServersRequest &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; 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; RemoveBackendServersOutcomeCallable removeBackendServersCallable(const Model::RemoveBackendServersRequest& 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;
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;
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;
SetAccessControlListAttributeOutcome setAccessControlListAttribute(const Model::SetAccessControlListAttributeRequest &request)const;
void setAccessControlListAttributeAsync(const Model::SetAccessControlListAttributeRequest& request, const SetAccessControlListAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetAccessControlListAttributeOutcomeCallable setAccessControlListAttributeCallable(const Model::SetAccessControlListAttributeRequest& request) const;
SetAccessLogsDownloadAttributeOutcome setAccessLogsDownloadAttribute(const Model::SetAccessLogsDownloadAttributeRequest &request)const;
void setAccessLogsDownloadAttributeAsync(const Model::SetAccessLogsDownloadAttributeRequest& request, const SetAccessLogsDownloadAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetAccessLogsDownloadAttributeOutcomeCallable setAccessLogsDownloadAttributeCallable(const Model::SetAccessLogsDownloadAttributeRequest& 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;
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;
SetDomainExtensionAttributeOutcome setDomainExtensionAttribute(const Model::SetDomainExtensionAttributeRequest &request)const;
void setDomainExtensionAttributeAsync(const Model::SetDomainExtensionAttributeRequest& request, const SetDomainExtensionAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetDomainExtensionAttributeOutcomeCallable setDomainExtensionAttributeCallable(const Model::SetDomainExtensionAttributeRequest& 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;
SetLoadBalancerDeleteProtectionOutcome setLoadBalancerDeleteProtection(const Model::SetLoadBalancerDeleteProtectionRequest &request)const;
void setLoadBalancerDeleteProtectionAsync(const Model::SetLoadBalancerDeleteProtectionRequest& request, const SetLoadBalancerDeleteProtectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLoadBalancerDeleteProtectionOutcomeCallable setLoadBalancerDeleteProtectionCallable(const Model::SetLoadBalancerDeleteProtectionRequest& request) const;
SetLoadBalancerHTTPListenerAttributeOutcome setLoadBalancerHTTPListenerAttribute(const Model::SetLoadBalancerHTTPListenerAttributeRequest &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; 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; SetLoadBalancerHTTPListenerAttributeOutcomeCallable setLoadBalancerHTTPListenerAttributeCallable(const Model::SetLoadBalancerHTTPListenerAttributeRequest& request) const;
SetLoadBalancerListenerStatusOutcome setLoadBalancerListenerStatus(const Model::SetLoadBalancerListenerStatusRequest &request)const; SetLoadBalancerHTTPSListenerAttributeOutcome setLoadBalancerHTTPSListenerAttribute(const Model::SetLoadBalancerHTTPSListenerAttributeRequest &request)const;
void setLoadBalancerListenerStatusAsync(const Model::SetLoadBalancerListenerStatusRequest& request, const SetLoadBalancerListenerStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const; void setLoadBalancerHTTPSListenerAttributeAsync(const Model::SetLoadBalancerHTTPSListenerAttributeRequest& request, const SetLoadBalancerHTTPSListenerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLoadBalancerListenerStatusOutcomeCallable setLoadBalancerListenerStatusCallable(const Model::SetLoadBalancerListenerStatusRequest& request) const; SetLoadBalancerHTTPSListenerAttributeOutcomeCallable setLoadBalancerHTTPSListenerAttributeCallable(const Model::SetLoadBalancerHTTPSListenerAttributeRequest& request) const;
SetLoadBalancerModificationProtectionOutcome setLoadBalancerModificationProtection(const Model::SetLoadBalancerModificationProtectionRequest &request)const;
void setLoadBalancerModificationProtectionAsync(const Model::SetLoadBalancerModificationProtectionRequest& request, const SetLoadBalancerModificationProtectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLoadBalancerModificationProtectionOutcomeCallable setLoadBalancerModificationProtectionCallable(const Model::SetLoadBalancerModificationProtectionRequest& request) const;
SetLoadBalancerNameOutcome setLoadBalancerName(const Model::SetLoadBalancerNameRequest &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; 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; SetLoadBalancerNameOutcomeCallable setLoadBalancerNameCallable(const Model::SetLoadBalancerNameRequest& request) const;
@@ -180,6 +747,39 @@ namespace AlibabaCloud
SetLoadBalancerTCPListenerAttributeOutcome setLoadBalancerTCPListenerAttribute(const Model::SetLoadBalancerTCPListenerAttributeRequest &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; 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; SetLoadBalancerTCPListenerAttributeOutcomeCallable setLoadBalancerTCPListenerAttributeCallable(const Model::SetLoadBalancerTCPListenerAttributeRequest& 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;
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;
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;
SetTLSCipherPolicyAttributeOutcome setTLSCipherPolicyAttribute(const Model::SetTLSCipherPolicyAttributeRequest &request)const;
void setTLSCipherPolicyAttributeAsync(const Model::SetTLSCipherPolicyAttributeRequest& request, const SetTLSCipherPolicyAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetTLSCipherPolicyAttributeOutcomeCallable setTLSCipherPolicyAttributeCallable(const Model::SetTLSCipherPolicyAttributeRequest& 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;
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;
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;
TagResourcesOutcome tagResources(const Model::TagResourcesRequest &request)const;
void tagResourcesAsync(const Model::TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TagResourcesOutcomeCallable tagResourcesCallable(const Model::TagResourcesRequest& request) const;
UntagResourcesOutcome untagResources(const Model::UntagResourcesRequest &request)const;
void untagResourcesAsync(const Model::UntagResourcesRequest& request, const UntagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UntagResourcesOutcomeCallable untagResourcesCallable(const Model::UntagResourcesRequest& 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;
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;
private: private:
std::shared_ptr<EndpointProvider> endpointProvider_; std::shared_ptr<EndpointProvider> endpointProvider_;

View File

@@ -0,0 +1,69 @@
/*
* 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_ADDACCESSCONTROLLISTENTRYREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_ADDACCESSCONTROLLISTENTRYREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT AddAccessControlListEntryRequest : public RpcServiceRequest {
public:
AddAccessControlListEntryRequest();
~AddAccessControlListEntryRequest();
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 getAclEntrys() const;
void setAclEntrys(const std::string &aclEntrys);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getAclId() const;
void setAclId(const std::string &aclId);
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 getTags() const;
void setTags(const std::string &tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string aclEntrys_;
std::string accessKeyId_;
std::string regionId_;
std::string aclId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_ADDACCESSCONTROLLISTENTRYREQUEST_H_

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_ADDACCESSCONTROLLISTENTRYRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_ADDACCESSCONTROLLISTENTRYRESULT_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 AddAccessControlListEntryResult : public ServiceResult
{
public:
AddAccessControlListEntryResult();
explicit AddAccessControlListEntryResult(const std::string &payload);
~AddAccessControlListEntryResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_ADDACCESSCONTROLLISTENTRYRESULT_H_

View File

@@ -36,8 +36,8 @@ public:
void setResourceOwnerId(long resourceOwnerId); void setResourceOwnerId(long resourceOwnerId);
std::string getBackendServers() const; std::string getBackendServers() const;
void setBackendServers(const std::string &backendServers); void setBackendServers(const std::string &backendServers);
std::string getAccessKeyId() const; std::string getRegionId() const;
void setAccessKeyId(const std::string &accessKeyId); void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const; std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount); void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const; std::string getOwnerAccount() const;
@@ -53,7 +53,7 @@ private:
std::string access_key_id_; std::string access_key_id_;
long resourceOwnerId_; long resourceOwnerId_;
std::string backendServers_; std::string backendServers_;
std::string accessKeyId_; std::string regionId_;
std::string resourceOwnerAccount_; std::string resourceOwnerAccount_;
std::string ownerAccount_; std::string ownerAccount_;
long ownerId_; long ownerId_;

View File

@@ -34,7 +34,11 @@ namespace AlibabaCloud
public: public:
struct BackendServer struct BackendServer
{ {
std::string type;
std::string description;
std::string serverId; std::string serverId;
std::string vpcId;
std::string serverIp;
std::string weight; std::string weight;
}; };

View File

@@ -0,0 +1,72 @@
/*
* 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 <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT AddListenerWhiteListItemRequest : public RpcServiceRequest {
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);
std::string getSourceItems() const;
void setSourceItems(const std::string &sourceItems);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getListenerPort() const;
void setListenerPort(int listenerPort);
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 getListenerProtocol() const;
void setListenerProtocol(const std::string &listenerProtocol);
std::string getTags() const;
void setTags(const std::string &tags);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string sourceItems_;
std::string regionId_;
int listenerPort_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string listenerProtocol_;
std::string tags_;
std::string loadBalancerId_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_ADDLISTENERWHITELISTITEMREQUEST_H_

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_

View File

@@ -14,8 +14,8 @@
* limitations under the License. * limitations under the License.
*/ */
#ifndef ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERLISTENERSTATUSREQUEST_H_ #ifndef ALIBABACLOUD_SLB_MODEL_ADDTAGSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERLISTENERSTATUSREQUEST_H_ #define ALIBABACLOUD_SLB_MODEL_ADDTAGSREQUEST_H_
#include <alibabacloud/slb/SlbExport.h> #include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h> #include <alibabacloud/core/RpcServiceRequest.h>
@@ -26,35 +26,38 @@
namespace AlibabaCloud { namespace AlibabaCloud {
namespace Slb { namespace Slb {
namespace Model { namespace Model {
class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerListenerStatusRequest : public RpcServiceRequest { class ALIBABACLOUD_SLB_EXPORT AddTagsRequest : public RpcServiceRequest {
public: public:
SetLoadBalancerListenerStatusRequest(); AddTagsRequest();
~SetLoadBalancerListenerStatusRequest(); ~AddTagsRequest();
int getListenerPort() const; std::string getAccess_key_id() const;
void setListenerPort(int listenerPort); 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; std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount); void setOwnerAccount(const std::string &ownerAccount);
std::string getHostId() const; long getOwnerId() const;
void setHostId(const std::string &hostId); void setOwnerId(long ownerId);
std::string getOwnerId() const; std::string getTags() const;
void setOwnerId(const std::string &ownerId); void setTags(const std::string &tags);
std::string getListenerStatus() const;
void setListenerStatus(const std::string &listenerStatus);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getLoadBalancerId() const; std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId); void setLoadBalancerId(const std::string &loadBalancerId);
private: private:
int listenerPort_; std::string access_key_id_;
long resourceOwnerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_; std::string ownerAccount_;
std::string hostId_; long ownerId_;
std::string ownerId_; std::string tags_;
std::string listenerStatus_;
std::string accessKeyId_;
std::string loadBalancerId_; std::string loadBalancerId_;
}; };
} // namespace Model } // namespace Model
} // namespace Slb } // namespace Slb
} // namespace AlibabaCloud } // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERLISTENERSTATUSREQUEST_H_ #endif // !ALIBABACLOUD_SLB_MODEL_ADDTAGSREQUEST_H_

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_

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_ADDVSERVERGROUPBACKENDSERVERSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_ADDVSERVERGROUPBACKENDSERVERSREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT AddVServerGroupBackendServersRequest : public RpcServiceRequest {
public:
AddVServerGroupBackendServersRequest();
~AddVServerGroupBackendServersRequest();
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 getBackendServers() const;
void setBackendServers(const std::string &backendServers);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getVServerGroupId() const;
void setVServerGroupId(const std::string &vServerGroupId);
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 getTags() const;
void setTags(const std::string &tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string backendServers_;
std::string regionId_;
std::string vServerGroupId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_ADDVSERVERGROUPBACKENDSERVERSREQUEST_H_

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_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 type;
std::string description;
std::string serverId;
std::string vpcId;
std::string serverRegionId;
std::string serverIp;
int port;
std::string vbrId;
int weight;
};
AddVServerGroupBackendServersResult();
explicit AddVServerGroupBackendServersResult(const std::string &payload);
~AddVServerGroupBackendServersResult();
std::string getVServerGroupId()const;
std::vector<BackendServer> getBackendServers()const;
protected:
void parse(const std::string &payload);
private:
std::string vServerGroupId_;
std::vector<BackendServer> backendServers_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_ADDVSERVERGROUPBACKENDSERVERSRESULT_H_

View File

@@ -0,0 +1,79 @@
/*
* 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_CREATEACCESSCONTROLLISTREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_CREATEACCESSCONTROLLISTREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT CreateAccessControlListRequest : public RpcServiceRequest {
public:
struct Tag {
std::string value;
std::string key;
};
CreateAccessControlListRequest();
~CreateAccessControlListRequest();
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 getAclName() const;
void setAclName(const std::string &aclName);
std::string getAddressIPVersion() const;
void setAddressIPVersion(const std::string &addressIPVersion);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
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 getTags() const;
void setTags(const std::string &tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string aclName_;
std::string addressIPVersion_;
std::string accessKeyId_;
std::string resourceGroupId_;
std::string regionId_;
std::vector<Tag> tag_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_CREATEACCESSCONTROLLISTREQUEST_H_

View File

@@ -0,0 +1,51 @@
/*
* 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_CREATEACCESSCONTROLLISTRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_CREATEACCESSCONTROLLISTRESULT_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 CreateAccessControlListResult : public ServiceResult
{
public:
CreateAccessControlListResult();
explicit CreateAccessControlListResult(const std::string &payload);
~CreateAccessControlListResult();
std::string getAclId()const;
protected:
void parse(const std::string &payload);
private:
std::string aclId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATEACCESSCONTROLLISTRESULT_H_

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_CREATEDOMAINEXTENSIONREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_CREATEDOMAINEXTENSIONREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT CreateDomainExtensionRequest : public RpcServiceRequest {
public:
struct ServerCertificate {
std::string bindingType;
std::string certificateId;
std::string standardType;
};
CreateDomainExtensionRequest();
~CreateDomainExtensionRequest();
std::string getAccess_key_id() const;
void setAccess_key_id(const std::string &access_key_id);
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::vector<ServerCertificate> getServerCertificate() const;
void setServerCertificate(const std::vector<ServerCertificate> &serverCertificate);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getListenerPort() const;
void setListenerPort(int listenerPort);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
std::vector<std::string> getCertificateId() const;
void setCertificateId(const std::vector<std::string> &certificateId);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getServerCertificateId() const;
void setServerCertificateId(const std::string &serverCertificateId);
std::string getTags() const;
void setTags(const std::string &tags);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
std::string getDomain() const;
void setDomain(const std::string &domain);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::vector<ServerCertificate> serverCertificate_;
std::string regionId_;
int listenerPort_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::vector<std::string> certificateId_;
long ownerId_;
std::string serverCertificateId_;
std::string tags_;
std::string loadBalancerId_;
std::string domain_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_CREATEDOMAINEXTENSIONREQUEST_H_

View File

@@ -0,0 +1,53 @@
/*
* 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_CREATEDOMAINEXTENSIONRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_CREATEDOMAINEXTENSIONRESULT_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 CreateDomainExtensionResult : public ServiceResult
{
public:
CreateDomainExtensionResult();
explicit CreateDomainExtensionResult(const std::string &payload);
~CreateDomainExtensionResult();
int getListenerPort()const;
std::string getDomainExtensionId()const;
protected:
void parse(const std::string &payload);
private:
int listenerPort_;
std::string domainExtensionId_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATEDOMAINEXTENSIONRESULT_H_

View File

@@ -28,79 +28,158 @@ namespace Slb {
namespace Model { namespace Model {
class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerHTTPListenerRequest : public RpcServiceRequest { class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerHTTPListenerRequest : public RpcServiceRequest {
public: public:
struct Tag {
std::string value;
std::string key;
};
CreateLoadBalancerHTTPListenerRequest(); CreateLoadBalancerHTTPListenerRequest();
~CreateLoadBalancerHTTPListenerRequest(); ~CreateLoadBalancerHTTPListenerRequest();
long getResourceOwnerId() const; long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId); void setResourceOwnerId(long resourceOwnerId);
int getHealthCheckTimeout() const; int getHealthCheckTimeout() const;
void setHealthCheckTimeout(int healthCheckTimeout); void setHealthCheckTimeout(int healthCheckTimeout);
std::string getListenerForward() const;
void setListenerForward(const std::string &listenerForward);
std::string getXForwardedFor() const; std::string getXForwardedFor() const;
void setXForwardedFor(const std::string &xForwardedFor); void setXForwardedFor(const std::string &xForwardedFor);
std::string getHostId() const; std::string getHealthCheckURI() const;
void setHostId(const std::string &hostId); void setHealthCheckURI(const std::string &healthCheckURI);
std::string getXForwardedFor_SLBPORT() const;
void setXForwardedFor_SLBPORT(const std::string &xForwardedFor_SLBPORT);
std::string getAclStatus() const;
void setAclStatus(const std::string &aclStatus);
std::string getAclType() const;
void setAclType(const std::string &aclType);
std::string getHealthCheck() const;
void setHealthCheck(const std::string &healthCheck);
std::string getVpcIds() const;
void setVpcIds(const std::string &vpcIds);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
std::string getVServerGroupId() const;
void setVServerGroupId(const std::string &vServerGroupId);
std::string getAclId() const;
void setAclId(const std::string &aclId);
int getForwardCode() const;
void setForwardCode(int forwardCode);
std::string getCookie() const;
void setCookie(const std::string &cookie);
std::string getHealthCheckMethod() const;
void setHealthCheckMethod(const std::string &healthCheckMethod);
std::string getHealthCheckDomain() const;
void setHealthCheckDomain(const std::string &healthCheckDomain);
int getRequestTimeout() const;
void setRequestTimeout(int requestTimeout);
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_SLBID() const;
void setXForwardedFor_SLBID(const std::string &xForwardedFor_SLBID);
std::string getHealthCheckHttpVersion() const;
void setHealthCheckHttpVersion(const std::string &healthCheckHttpVersion);
std::string getAccess_key_id() const;
void setAccess_key_id(const std::string &access_key_id);
std::string getXForwardedFor_ClientSrcPort() const;
void setXForwardedFor_ClientSrcPort(const std::string &xForwardedFor_ClientSrcPort);
std::string getDescription() const;
void setDescription(const std::string &description);
int getUnhealthyThreshold() const; int getUnhealthyThreshold() const;
void setUnhealthyThreshold(int unhealthyThreshold); void setUnhealthyThreshold(int unhealthyThreshold);
int getHealthyThreshold() const; int getHealthyThreshold() const;
void setHealthyThreshold(int healthyThreshold); void setHealthyThreshold(int healthyThreshold);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getScheduler() const; std::string getScheduler() const;
void setScheduler(const std::string &scheduler); void setScheduler(const std::string &scheduler);
std::string getHealthCheck() const; int getForwardPort() const;
void setHealthCheck(const std::string &healthCheck); void setForwardPort(int forwardPort);
int getMaxConnection() const;
void setMaxConnection(int maxConnection);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getCookieTimeout() const; int getCookieTimeout() const;
void setCookieTimeout(int cookieTimeout); void setCookieTimeout(int cookieTimeout);
std::string getStickySessionType() const; std::string getStickySessionType() const;
void setStickySessionType(const std::string &stickySessionType); void setStickySessionType(const std::string &stickySessionType);
int getListenerPort() const; int getListenerPort() const;
void setListenerPort(int listenerPort); void setListenerPort(int listenerPort);
std::string getCookie() const; std::string getHealthCheckType() const;
void setCookie(const std::string &cookie); void setHealthCheckType(const std::string &healthCheckType);
std::string getStickySession() const; std::string getResourceOwnerAccount() const;
void setStickySession(const std::string &stickySession); void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
int getBandwidth() const; int getBandwidth() const;
void setBandwidth(int bandwidth); void setBandwidth(int bandwidth);
std::string getStickySession() const;
void setStickySession(const std::string &stickySession);
std::string getOwnerAccount() const; std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount); void setOwnerAccount(const std::string &ownerAccount);
std::string getOwnerId() const; std::string getGzip() const;
void setOwnerId(const std::string &ownerId); void setGzip(const std::string &gzip);
std::string getURI() const; int getIdleTimeout() const;
void setURI(const std::string &uRI); void setIdleTimeout(int idleTimeout);
std::string getListenerStatus() const; std::string getXForwardedFor_proto() const;
void setListenerStatus(const std::string &listenerStatus); void setXForwardedFor_proto(const std::string &xForwardedFor_proto);
std::string getLoadBalancerId() const; int getHealthCheckConnectPort() const;
void setLoadBalancerId(const std::string &loadBalancerId); void setHealthCheckConnectPort(int healthCheckConnectPort);
int getBackendServerPort() const; std::string getHealthCheckHttpCode() const;
void setBackendServerPort(int backendServerPort); void setHealthCheckHttpCode(const std::string &healthCheckHttpCode);
std::string getDomain() const;
void setDomain(const std::string &domain);
int getInterval() const;
void setInterval(int interval);
private: private:
long resourceOwnerId_; long resourceOwnerId_;
int healthCheckTimeout_; int healthCheckTimeout_;
std::string listenerForward_;
std::string xForwardedFor_; std::string xForwardedFor_;
std::string hostId_; std::string healthCheckURI_;
std::string xForwardedFor_SLBPORT_;
std::string aclStatus_;
std::string aclType_;
std::string healthCheck_;
std::string vpcIds_;
std::vector<Tag> tag_;
std::string vServerGroupId_;
std::string aclId_;
int forwardCode_;
std::string cookie_;
std::string healthCheckMethod_;
std::string healthCheckDomain_;
int requestTimeout_;
long ownerId_;
std::string tags_;
std::string loadBalancerId_;
std::string xForwardedFor_SLBIP_;
int backendServerPort_;
int healthCheckInterval_;
std::string xForwardedFor_SLBID_;
std::string healthCheckHttpVersion_;
std::string access_key_id_;
std::string xForwardedFor_ClientSrcPort_;
std::string description_;
int unhealthyThreshold_; int unhealthyThreshold_;
int healthyThreshold_; int healthyThreshold_;
std::string accessKeyId_;
std::string scheduler_; std::string scheduler_;
std::string healthCheck_; int forwardPort_;
int maxConnection_;
std::string regionId_;
int cookieTimeout_; int cookieTimeout_;
std::string stickySessionType_; std::string stickySessionType_;
int listenerPort_; int listenerPort_;
std::string cookie_; std::string healthCheckType_;
std::string stickySession_; std::string resourceOwnerAccount_;
int bandwidth_; int bandwidth_;
std::string stickySession_;
std::string ownerAccount_; std::string ownerAccount_;
std::string ownerId_; std::string gzip_;
std::string uRI_; int idleTimeout_;
std::string listenerStatus_; std::string xForwardedFor_proto_;
std::string loadBalancerId_; int healthCheckConnectPort_;
int backendServerPort_; std::string healthCheckHttpCode_;
std::string domain_;
int interval_;
}; };
} // namespace Model } // namespace Model
} // namespace Slb } // namespace Slb

View File

@@ -0,0 +1,225 @@
/*
* 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 <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerHTTPSListenerRequest : public RpcServiceRequest {
public:
struct ServerCertificate {
std::string bindingType;
std::string certificateId;
std::string standardType;
};
struct Tag {
std::string value;
std::string key;
};
CreateLoadBalancerHTTPSListenerRequest();
~CreateLoadBalancerHTTPSListenerRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::vector<ServerCertificate> getServerCertificate() const;
void setServerCertificate(const std::vector<ServerCertificate> &serverCertificate);
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);
std::string getXForwardedFor_SLBPORT() const;
void setXForwardedFor_SLBPORT(const std::string &xForwardedFor_SLBPORT);
std::string getAclStatus() const;
void setAclStatus(const std::string &aclStatus);
std::string getAclType() const;
void setAclType(const std::string &aclType);
std::string getHealthCheck() const;
void setHealthCheck(const std::string &healthCheck);
std::string getVpcIds() const;
void setVpcIds(const std::string &vpcIds);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
std::string getVServerGroupId() const;
void setVServerGroupId(const std::string &vServerGroupId);
std::string getAclId() const;
void setAclId(const std::string &aclId);
std::string getXForwardedFor_ClientCertClientVerify() const;
void setXForwardedFor_ClientCertClientVerify(const std::string &xForwardedFor_ClientCertClientVerify);
std::string getCookie() const;
void setCookie(const std::string &cookie);
std::string getHealthCheckMethod() const;
void setHealthCheckMethod(const std::string &healthCheckMethod);
std::string getHealthCheckDomain() const;
void setHealthCheckDomain(const std::string &healthCheckDomain);
int getRequestTimeout() const;
void setRequestTimeout(int requestTimeout);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getCACertificateId() const;
void setCACertificateId(const std::string &cACertificateId);
std::string getBackendProtocol() const;
void setBackendProtocol(const std::string &backendProtocol);
std::string getTags() const;
void setTags(const std::string &tags);
std::string getXForwardedFor_ClientCertFingerprintAlias() const;
void setXForwardedFor_ClientCertFingerprintAlias(const std::string &xForwardedFor_ClientCertFingerprintAlias);
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_ClientCertClientVerifyAlias() const;
void setXForwardedFor_ClientCertClientVerifyAlias(const std::string &xForwardedFor_ClientCertClientVerifyAlias);
std::string getXForwardedFor_SLBID() const;
void setXForwardedFor_SLBID(const std::string &xForwardedFor_SLBID);
std::string getXForwardedFor_ClientCertFingerprint() const;
void setXForwardedFor_ClientCertFingerprint(const std::string &xForwardedFor_ClientCertFingerprint);
std::string getHealthCheckHttpVersion() const;
void setHealthCheckHttpVersion(const std::string &healthCheckHttpVersion);
std::string getAccess_key_id() const;
void setAccess_key_id(const std::string &access_key_id);
std::string getXForwardedFor_ClientSrcPort() const;
void setXForwardedFor_ClientSrcPort(const std::string &xForwardedFor_ClientSrcPort);
std::string getDescription() const;
void setDescription(const std::string &description);
int getUnhealthyThreshold() const;
void setUnhealthyThreshold(int unhealthyThreshold);
std::string getXForwardedFor_ClientCertIssuerDNAlias() const;
void setXForwardedFor_ClientCertIssuerDNAlias(const std::string &xForwardedFor_ClientCertIssuerDNAlias);
int getHealthyThreshold() const;
void setHealthyThreshold(int healthyThreshold);
std::string getScheduler() const;
void setScheduler(const std::string &scheduler);
int getMaxConnection() const;
void setMaxConnection(int maxConnection);
std::string getEnableHttp2() const;
void setEnableHttp2(const std::string &enableHttp2);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getXForwardedFor_ClientCertSubjectDN() const;
void setXForwardedFor_ClientCertSubjectDN(const std::string &xForwardedFor_ClientCertSubjectDN);
int getCookieTimeout() const;
void setCookieTimeout(int cookieTimeout);
std::string getStickySessionType() const;
void setStickySessionType(const std::string &stickySessionType);
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 getStickySession() const;
void setStickySession(const std::string &stickySession);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
std::string getGzip() const;
void setGzip(const std::string &gzip);
std::string getTLSCipherPolicy() const;
void setTLSCipherPolicy(const std::string &tLSCipherPolicy);
std::string getServerCertificateId() const;
void setServerCertificateId(const std::string &serverCertificateId);
int getIdleTimeout() const;
void setIdleTimeout(int idleTimeout);
std::string getXForwardedFor_proto() const;
void setXForwardedFor_proto(const std::string &xForwardedFor_proto);
std::string getXForwardedFor_ClientCertSubjectDNAlias() const;
void setXForwardedFor_ClientCertSubjectDNAlias(const std::string &xForwardedFor_ClientCertSubjectDNAlias);
int getHealthCheckConnectPort() const;
void setHealthCheckConnectPort(int healthCheckConnectPort);
std::string getHealthCheckHttpCode() const;
void setHealthCheckHttpCode(const std::string &healthCheckHttpCode);
std::string getXForwardedFor_ClientCertIssuerDN() const;
void setXForwardedFor_ClientCertIssuerDN(const std::string &xForwardedFor_ClientCertIssuerDN);
private:
long resourceOwnerId_;
std::vector<ServerCertificate> serverCertificate_;
int healthCheckTimeout_;
std::string xForwardedFor_;
std::string healthCheckURI_;
std::string xForwardedFor_SLBPORT_;
std::string aclStatus_;
std::string aclType_;
std::string healthCheck_;
std::string vpcIds_;
std::vector<Tag> tag_;
std::string vServerGroupId_;
std::string aclId_;
std::string xForwardedFor_ClientCertClientVerify_;
std::string cookie_;
std::string healthCheckMethod_;
std::string healthCheckDomain_;
int requestTimeout_;
long ownerId_;
std::string cACertificateId_;
std::string backendProtocol_;
std::string tags_;
std::string xForwardedFor_ClientCertFingerprintAlias_;
std::string loadBalancerId_;
std::string xForwardedFor_SLBIP_;
int backendServerPort_;
int healthCheckInterval_;
std::string xForwardedFor_ClientCertClientVerifyAlias_;
std::string xForwardedFor_SLBID_;
std::string xForwardedFor_ClientCertFingerprint_;
std::string healthCheckHttpVersion_;
std::string access_key_id_;
std::string xForwardedFor_ClientSrcPort_;
std::string description_;
int unhealthyThreshold_;
std::string xForwardedFor_ClientCertIssuerDNAlias_;
int healthyThreshold_;
std::string scheduler_;
int maxConnection_;
std::string enableHttp2_;
std::string regionId_;
std::string xForwardedFor_ClientCertSubjectDN_;
int cookieTimeout_;
std::string stickySessionType_;
int listenerPort_;
std::string healthCheckType_;
std::string resourceOwnerAccount_;
int bandwidth_;
std::string stickySession_;
std::string ownerAccount_;
std::string gzip_;
std::string tLSCipherPolicy_;
std::string serverCertificateId_;
int idleTimeout_;
std::string xForwardedFor_proto_;
std::string xForwardedFor_ClientCertSubjectDNAlias_;
int healthCheckConnectPort_;
std::string healthCheckHttpCode_;
std::string xForwardedFor_ClientCertIssuerDN_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERHTTPSLISTENERREQUEST_H_

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_

View File

@@ -28,43 +28,122 @@ namespace Slb {
namespace Model { namespace Model {
class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerRequest : public RpcServiceRequest { class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerRequest : public RpcServiceRequest {
public: public:
struct Tag {
std::string value;
std::string key;
};
CreateLoadBalancerRequest(); CreateLoadBalancerRequest();
~CreateLoadBalancerRequest(); ~CreateLoadBalancerRequest();
long getResourceOwnerId() const; long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId); void setResourceOwnerId(long resourceOwnerId);
std::string getClientToken() const; std::string getAddressIPVersion() const;
void setClientToken(const std::string &clientToken); void setAddressIPVersion(const std::string &addressIPVersion);
std::string getLoadBalancerMode() const; std::string getMasterZoneId() const;
void setLoadBalancerMode(const std::string &loadBalancerMode); void setMasterZoneId(const std::string &masterZoneId);
std::string getAccessKeyId() const; std::string getResourceGroupId() const;
void setAccessKeyId(const std::string &accessKeyId); void setResourceGroupId(const std::string &resourceGroupId);
std::string getLoadBalancerName() const; std::string getLoadBalancerName() const;
void setLoadBalancerName(const std::string &loadBalancerName); void setLoadBalancerName(const std::string &loadBalancerName);
std::string getSlaveZoneId() const;
void setSlaveZoneId(const std::string &slaveZoneId);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
std::string getLoadBalancerSpec() const;
void setLoadBalancerSpec(const std::string &loadBalancerSpec);
int getAutoRenewPeriod() const;
void setAutoRenewPeriod(int autoRenewPeriod);
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);
bool getAutoRenew() const;
void setAutoRenew(bool autoRenew);
std::string getInternetChargeType() const;
void setInternetChargeType(const std::string &internetChargeType);
std::string getPricingCycle() const;
void setPricingCycle(const std::string &pricingCycle);
std::string getAccess_key_id() const;
void setAccess_key_id(const std::string &access_key_id);
std::string getModificationProtectionReason() const;
void setModificationProtectionReason(const std::string &modificationProtectionReason);
bool getSupportPrivateLink() const;
void setSupportPrivateLink(bool supportPrivateLink);
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getCloudType() const;
void setCloudType(const std::string &cloudType);
int getDuration() const;
void setDuration(int duration);
std::string getRegionId() const; std::string getRegionId() const;
void setRegionId(const std::string &regionId); void setRegionId(const std::string &regionId);
std::string getAddressType() const;
void setAddressType(const std::string &addressType);
std::string getInstanceChargeType() const;
void setInstanceChargeType(const std::string &instanceChargeType);
std::string getDeleteProtection() const;
void setDeleteProtection(const std::string &deleteProtection);
bool getAutoPay() const;
void setAutoPay(bool autoPay);
std::string getAddress() const; std::string getAddress() const;
void setAddress(const std::string &address); void setAddress(const std::string &address);
std::string getResourceOwnerAccount() const; std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount); void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
int getBandwidth() const;
void setBandwidth(int bandwidth);
std::string getOwnerAccount() const; std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount); void setOwnerAccount(const std::string &ownerAccount);
std::string getIsPublicAddress() const; std::string getModificationProtectionStatus() const;
void setIsPublicAddress(const std::string &isPublicAddress); void setModificationProtectionStatus(const std::string &modificationProtectionStatus);
long getOwnerId() const; std::string getInstanceListenerType() const;
void setOwnerId(long ownerId); void setInstanceListenerType(const std::string &instanceListenerType);
std::string getVpcId() const;
void setVpcId(const std::string &vpcId);
std::string getPayType() const;
void setPayType(const std::string &payType);
int getRatio() const;
void setRatio(int ratio);
private: private:
long resourceOwnerId_; long resourceOwnerId_;
std::string clientToken_; std::string addressIPVersion_;
std::string loadBalancerMode_; std::string masterZoneId_;
std::string accessKeyId_; std::string resourceGroupId_;
std::string loadBalancerName_; std::string loadBalancerName_;
std::string slaveZoneId_;
std::vector<Tag> tag_;
std::string loadBalancerSpec_;
int autoRenewPeriod_;
long ownerId_;
std::string tags_;
std::string vSwitchId_;
std::string enableVpcVipFlow_;
bool autoRenew_;
std::string internetChargeType_;
std::string pricingCycle_;
std::string access_key_id_;
std::string modificationProtectionReason_;
bool supportPrivateLink_;
std::string clientToken_;
std::string cloudType_;
int duration_;
std::string regionId_; std::string regionId_;
std::string addressType_;
std::string instanceChargeType_;
std::string deleteProtection_;
bool autoPay_;
std::string address_; std::string address_;
std::string resourceOwnerAccount_; std::string resourceOwnerAccount_;
int bandwidth_;
std::string ownerAccount_; std::string ownerAccount_;
std::string isPublicAddress_; std::string modificationProtectionStatus_;
long ownerId_; std::string instanceListenerType_;
std::string vpcId_;
std::string payType_;
int ratio_;
}; };
} // namespace Model } // namespace Model
} // namespace Slb } // namespace Slb

View File

@@ -38,15 +38,27 @@ namespace AlibabaCloud
explicit CreateLoadBalancerResult(const std::string &payload); explicit CreateLoadBalancerResult(const std::string &payload);
~CreateLoadBalancerResult(); ~CreateLoadBalancerResult();
std::string getLoadBalancerName()const; std::string getLoadBalancerName()const;
std::string getVpcId()const;
std::string getResourceGroupId()const;
std::string getAddress()const; std::string getAddress()const;
std::string getNetworkType()const;
std::string getAddressIPVersion()const;
std::string getVSwitchId()const;
std::string getLoadBalancerId()const; std::string getLoadBalancerId()const;
long getOrderId()const;
protected: protected:
void parse(const std::string &payload); void parse(const std::string &payload);
private: private:
std::string loadBalancerName_; std::string loadBalancerName_;
std::string vpcId_;
std::string resourceGroupId_;
std::string address_; std::string address_;
std::string networkType_;
std::string addressIPVersion_;
std::string vSwitchId_;
std::string loadBalancerId_; std::string loadBalancerId_;
long orderId_;
}; };
} }

View File

@@ -28,52 +28,52 @@ namespace Slb {
namespace Model { namespace Model {
class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerTCPListenerRequest : public RpcServiceRequest { class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerTCPListenerRequest : public RpcServiceRequest {
public: public:
struct Tag {
std::string value;
std::string key;
};
struct PortRange {
int startPort;
int endPort;
};
CreateLoadBalancerTCPListenerRequest(); CreateLoadBalancerTCPListenerRequest();
~CreateLoadBalancerTCPListenerRequest(); ~CreateLoadBalancerTCPListenerRequest();
std::string getAccess_key_id() const;
void setAccess_key_id(const std::string &access_key_id);
long getResourceOwnerId() const; long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId); void setResourceOwnerId(long resourceOwnerId);
std::string getHealthCheckURI() const; std::string getHealthCheckURI() const;
void setHealthCheckURI(const std::string &healthCheckURI); void setHealthCheckURI(const std::string &healthCheckURI);
int getUnhealthyThreshold() const; std::string getAclStatus() const;
void setUnhealthyThreshold(int unhealthyThreshold); void setAclStatus(const std::string &aclStatus);
int getHealthyThreshold() const; bool getFullNatEnabled() const;
void setHealthyThreshold(int healthyThreshold); void setFullNatEnabled(bool fullNatEnabled);
std::string getAccessKeyId() const; bool getHealthCheckTcpFastCloseEnabled() const;
void setAccessKeyId(const std::string &accessKeyId); void setHealthCheckTcpFastCloseEnabled(bool healthCheckTcpFastCloseEnabled);
std::string getScheduler() const; std::string getAclType() const;
void setScheduler(const std::string &scheduler); void setAclType(const std::string &aclType);
std::string getHealthCheck() const;
void setHealthCheck(const std::string &healthCheck);
int getEstablishedTimeout() const; int getEstablishedTimeout() const;
void setEstablishedTimeout(int establishedTimeout); void setEstablishedTimeout(int establishedTimeout);
int getMaxConnection() const; std::string getFailoverStrategy() const;
void setMaxConnection(int maxConnection); void setFailoverStrategy(const std::string &failoverStrategy);
int getPersistenceTimeout() const; int getPersistenceTimeout() const;
void setPersistenceTimeout(int persistenceTimeout); void setPersistenceTimeout(int persistenceTimeout);
std::string getVpcIds() const;
void setVpcIds(const std::string &vpcIds);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
bool getMasterSlaveModeEnabled() const;
void setMasterSlaveModeEnabled(bool masterSlaveModeEnabled);
std::string getVServerGroupId() const; std::string getVServerGroupId() const;
void setVServerGroupId(const std::string &vServerGroupId); void setVServerGroupId(const std::string &vServerGroupId);
int getConnectTimeout() const; std::string getAclId() const;
void setConnectTimeout(int connectTimeout); void setAclId(const std::string &aclId);
int getListenerPort() const; std::vector<PortRange> getPortRange() const;
void setListenerPort(int listenerPort); void setPortRange(const std::vector<PortRange> &portRange);
std::string getHealthCheckType() const; std::string getHealthCheckMethod() const;
void setHealthCheckType(const std::string &healthCheckType); void setHealthCheckMethod(const std::string &healthCheckMethod);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
int getBandwidth() const;
void setBandwidth(int bandwidth);
int getConnectPort() const;
void setConnectPort(int connectPort);
std::string getHealthCheckDomain() const; std::string getHealthCheckDomain() const;
void setHealthCheckDomain(const std::string &healthCheckDomain); void setHealthCheckDomain(const std::string &healthCheckDomain);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const; long getOwnerId() const;
void setOwnerId(long ownerId); void setOwnerId(long ownerId);
std::string getListenerStatus() const;
void setListenerStatus(const std::string &listenerStatus);
std::string getTags() const; std::string getTags() const;
void setTags(const std::string &tags); void setTags(const std::string &tags);
std::string getLoadBalancerId() const; std::string getLoadBalancerId() const;
@@ -82,39 +82,98 @@ public:
void setMasterSlaveServerGroupId(const std::string &masterSlaveServerGroupId); void setMasterSlaveServerGroupId(const std::string &masterSlaveServerGroupId);
int getBackendServerPort() const; int getBackendServerPort() const;
void setBackendServerPort(int backendServerPort); void setBackendServerPort(int backendServerPort);
int getInterval() const; int getHealthCheckInterval() const;
void setInterval(int interval); void setHealthCheckInterval(int healthCheckInterval);
int getFailoverThreshold() const;
void setFailoverThreshold(int failoverThreshold);
bool getProxyProtocolV2Enabled() const;
void setProxyProtocolV2Enabled(bool proxyProtocolV2Enabled);
std::string getConnectionDrain() const;
void setConnectionDrain(const std::string &connectionDrain);
std::string getHealthCheckSwitch() const;
void setHealthCheckSwitch(const std::string &healthCheckSwitch);
std::string getAccess_key_id() const;
void setAccess_key_id(const std::string &access_key_id);
int getHealthCheckConnectTimeout() const;
void setHealthCheckConnectTimeout(int healthCheckConnectTimeout);
std::string getSlaveServerGroupId() const;
void setSlaveServerGroupId(const std::string &slaveServerGroupId);
std::string getDescription() const;
void setDescription(const std::string &description);
int getUnhealthyThreshold() const;
void setUnhealthyThreshold(int unhealthyThreshold);
int getHealthyThreshold() const;
void setHealthyThreshold(int healthyThreshold);
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);
std::string getMasterServerGroupId() const;
void setMasterServerGroupId(const std::string &masterServerGroupId);
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 getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
int getConnectionDrainTimeout() const;
void setConnectionDrainTimeout(int connectionDrainTimeout);
int getHealthCheckConnectPort() const;
void setHealthCheckConnectPort(int healthCheckConnectPort);
std::string getHealthCheckHttpCode() const; std::string getHealthCheckHttpCode() const;
void setHealthCheckHttpCode(const std::string &healthCheckHttpCode); void setHealthCheckHttpCode(const std::string &healthCheckHttpCode);
private: private:
std::string access_key_id_;
long resourceOwnerId_; long resourceOwnerId_;
std::string healthCheckURI_; std::string healthCheckURI_;
int unhealthyThreshold_; std::string aclStatus_;
int healthyThreshold_; bool fullNatEnabled_;
std::string accessKeyId_; bool healthCheckTcpFastCloseEnabled_;
std::string scheduler_; std::string aclType_;
std::string healthCheck_;
int establishedTimeout_; int establishedTimeout_;
int maxConnection_; std::string failoverStrategy_;
int persistenceTimeout_; int persistenceTimeout_;
std::string vpcIds_;
std::vector<Tag> tag_;
bool masterSlaveModeEnabled_;
std::string vServerGroupId_; std::string vServerGroupId_;
int connectTimeout_; std::string aclId_;
int listenerPort_; std::vector<PortRange> portRange_;
std::string healthCheckType_; std::string healthCheckMethod_;
std::string resourceOwnerAccount_;
int bandwidth_;
int connectPort_;
std::string healthCheckDomain_; std::string healthCheckDomain_;
std::string ownerAccount_;
long ownerId_; long ownerId_;
std::string listenerStatus_;
std::string tags_; std::string tags_;
std::string loadBalancerId_; std::string loadBalancerId_;
std::string masterSlaveServerGroupId_; std::string masterSlaveServerGroupId_;
int backendServerPort_; int backendServerPort_;
int interval_; int healthCheckInterval_;
int failoverThreshold_;
bool proxyProtocolV2Enabled_;
std::string connectionDrain_;
std::string healthCheckSwitch_;
std::string access_key_id_;
int healthCheckConnectTimeout_;
std::string slaveServerGroupId_;
std::string description_;
int unhealthyThreshold_;
int healthyThreshold_;
std::string scheduler_;
int maxConnection_;
std::string regionId_;
std::string masterServerGroupId_;
int listenerPort_;
std::string healthCheckType_;
std::string resourceOwnerAccount_;
int bandwidth_;
std::string ownerAccount_;
int connectionDrainTimeout_;
int healthCheckConnectPort_;
std::string healthCheckHttpCode_; std::string healthCheckHttpCode_;
}; };
} // namespace Model } // namespace Model

View File

@@ -0,0 +1,185 @@
/*
* 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 <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerUDPListenerRequest : public RpcServiceRequest {
public:
struct Tag {
std::string value;
std::string key;
};
struct PortRange {
int startPort;
int endPort;
};
CreateLoadBalancerUDPListenerRequest();
~CreateLoadBalancerUDPListenerRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getHealthCheckURI() const;
void setHealthCheckURI(const std::string &healthCheckURI);
std::string getAclStatus() const;
void setAclStatus(const std::string &aclStatus);
bool getFullNatEnabled() const;
void setFullNatEnabled(bool fullNatEnabled);
std::string getAclType() const;
void setAclType(const std::string &aclType);
std::string getFailoverStrategy() const;
void setFailoverStrategy(const std::string &failoverStrategy);
int getPersistenceTimeout() const;
void setPersistenceTimeout(int persistenceTimeout);
std::string getVpcIds() const;
void setVpcIds(const std::string &vpcIds);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
bool getMasterSlaveModeEnabled() const;
void setMasterSlaveModeEnabled(bool masterSlaveModeEnabled);
std::string getVServerGroupId() const;
void setVServerGroupId(const std::string &vServerGroupId);
std::string getAclId() const;
void setAclId(const std::string &aclId);
std::vector<PortRange> getPortRange() const;
void setPortRange(const std::vector<PortRange> &portRange);
std::string getHealthCheckMethod() const;
void setHealthCheckMethod(const std::string &healthCheckMethod);
std::string getHealthCheckDomain() const;
void setHealthCheckDomain(const std::string &healthCheckDomain);
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 getFailoverThreshold() const;
void setFailoverThreshold(int failoverThreshold);
bool getProxyProtocolV2Enabled() const;
void setProxyProtocolV2Enabled(bool proxyProtocolV2Enabled);
std::string getConnectionDrain() const;
void setConnectionDrain(const std::string &connectionDrain);
std::string getHealthCheckSwitch() const;
void setHealthCheckSwitch(const std::string &healthCheckSwitch);
std::string getAccess_key_id() const;
void setAccess_key_id(const std::string &access_key_id);
int getHealthCheckConnectTimeout() const;
void setHealthCheckConnectTimeout(int healthCheckConnectTimeout);
std::string getSlaveServerGroupId() const;
void setSlaveServerGroupId(const std::string &slaveServerGroupId);
std::string getQuicVersion() const;
void setQuicVersion(const std::string &quicVersion);
std::string getDescription() const;
void setDescription(const std::string &description);
int getUnhealthyThreshold() const;
void setUnhealthyThreshold(int unhealthyThreshold);
int getHealthyThreshold() const;
void setHealthyThreshold(int healthyThreshold);
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);
std::string getMasterServerGroupId() const;
void setMasterServerGroupId(const std::string &masterServerGroupId);
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 getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
int getConnectionDrainTimeout() const;
void setConnectionDrainTimeout(int connectionDrainTimeout);
int getHealthCheckConnectPort() const;
void setHealthCheckConnectPort(int healthCheckConnectPort);
std::string getHealthCheckHttpCode() const;
void setHealthCheckHttpCode(const std::string &healthCheckHttpCode);
private:
long resourceOwnerId_;
std::string healthCheckURI_;
std::string aclStatus_;
bool fullNatEnabled_;
std::string aclType_;
std::string failoverStrategy_;
int persistenceTimeout_;
std::string vpcIds_;
std::vector<Tag> tag_;
bool masterSlaveModeEnabled_;
std::string vServerGroupId_;
std::string aclId_;
std::vector<PortRange> portRange_;
std::string healthCheckMethod_;
std::string healthCheckDomain_;
long ownerId_;
std::string tags_;
std::string loadBalancerId_;
std::string masterSlaveServerGroupId_;
std::string healthCheckReq_;
int backendServerPort_;
int healthCheckInterval_;
std::string healthCheckExp_;
int failoverThreshold_;
bool proxyProtocolV2Enabled_;
std::string connectionDrain_;
std::string healthCheckSwitch_;
std::string access_key_id_;
int healthCheckConnectTimeout_;
std::string slaveServerGroupId_;
std::string quicVersion_;
std::string description_;
int unhealthyThreshold_;
int healthyThreshold_;
std::string scheduler_;
int maxConnection_;
std::string regionId_;
std::string masterServerGroupId_;
int listenerPort_;
std::string healthCheckType_;
std::string resourceOwnerAccount_;
int bandwidth_;
std::string ownerAccount_;
int connectionDrainTimeout_;
int healthCheckConnectPort_;
std::string healthCheckHttpCode_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERUDPLISTENERREQUEST_H_

View File

@@ -14,8 +14,8 @@
* limitations under the License. * limitations under the License.
*/ */
#ifndef ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERLISTENERSTATUSRESULT_H_ #ifndef ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERUDPLISTENERRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERLISTENERSTATUSRESULT_H_ #define ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERUDPLISTENERRESULT_H_
#include <string> #include <string>
#include <vector> #include <vector>
@@ -29,14 +29,14 @@ namespace AlibabaCloud
{ {
namespace Model namespace Model
{ {
class ALIBABACLOUD_SLB_EXPORT SetLoadBalancerListenerStatusResult : public ServiceResult class ALIBABACLOUD_SLB_EXPORT CreateLoadBalancerUDPListenerResult : public ServiceResult
{ {
public: public:
SetLoadBalancerListenerStatusResult(); CreateLoadBalancerUDPListenerResult();
explicit SetLoadBalancerListenerStatusResult(const std::string &payload); explicit CreateLoadBalancerUDPListenerResult(const std::string &payload);
~SetLoadBalancerListenerStatusResult(); ~CreateLoadBalancerUDPListenerResult();
protected: protected:
void parse(const std::string &payload); void parse(const std::string &payload);
@@ -46,4 +46,4 @@ namespace AlibabaCloud
} }
} }
} }
#endif // !ALIBABACLOUD_SLB_MODEL_SETLOADBALANCERLISTENERSTATUSRESULT_H_ #endif // !ALIBABACLOUD_SLB_MODEL_CREATELOADBALANCERUDPLISTENERRESULT_H_

View File

@@ -0,0 +1,76 @@
/*
* 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 <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT CreateMasterSlaveServerGroupRequest : public RpcServiceRequest {
public:
struct Tag {
std::string value;
std::string key;
};
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 getRegionId() const;
void setRegionId(const std::string &regionId);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
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 getTags() const;
void setTags(const std::string &tags);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string masterSlaveBackendServers_;
std::string regionId_;
std::vector<Tag> tag_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::string masterSlaveServerGroupName_;
long ownerId_;
std::string tags_;
std::string loadBalancerId_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVESERVERGROUPREQUEST_H_

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_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 type;
std::string description;
std::string serverId;
std::string vpcId;
std::string serverIp;
int port;
int weight;
};
CreateMasterSlaveServerGroupResult();
explicit CreateMasterSlaveServerGroupResult(const std::string &payload);
~CreateMasterSlaveServerGroupResult();
std::string getMasterSlaveServerGroupId()const;
std::vector<MasterSlaveBackendServer> getMasterSlaveBackendServers()const;
protected:
void parse(const std::string &payload);
private:
std::string masterSlaveServerGroupId_;
std::vector<MasterSlaveBackendServer> masterSlaveBackendServers_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATEMASTERSLAVESERVERGROUPRESULT_H_

View File

@@ -0,0 +1,72 @@
/*
* 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 <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT CreateRulesRequest : public RpcServiceRequest {
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);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getRuleList() const;
void setRuleList(const std::string &ruleList);
int getListenerPort() const;
void setListenerPort(int listenerPort);
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 getListenerProtocol() const;
void setListenerProtocol(const std::string &listenerProtocol);
std::string getTags() const;
void setTags(const std::string &tags);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string regionId_;
std::string ruleList_;
int listenerPort_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string listenerProtocol_;
std::string tags_;
std::string loadBalancerId_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_CREATERULESREQUEST_H_

View File

@@ -0,0 +1,56 @@
/*
* 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;
protected:
void parse(const std::string &payload);
private:
std::vector<Rule> rules_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATERULESRESULT_H_

View File

@@ -0,0 +1,69 @@
/*
* 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_CREATETLSCIPHERPOLICYREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_CREATETLSCIPHERPOLICYREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT CreateTLSCipherPolicyRequest : public RpcServiceRequest {
public:
CreateTLSCipherPolicyRequest();
~CreateTLSCipherPolicyRequest();
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 getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::vector<std::string> getCiphers() const;
void setCiphers(const std::vector<std::string> &ciphers);
std::vector<std::string> getTLSVersions() const;
void setTLSVersions(const std::vector<std::string> &tLSVersions);
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 getName() const;
void setName(const std::string &name);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string accessKeyId_;
std::string regionId_;
std::vector<std::string> ciphers_;
std::vector<std::string> tLSVersions_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string name_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_CREATETLSCIPHERPOLICYREQUEST_H_

View File

@@ -14,8 +14,8 @@
* limitations under the License. * limitations under the License.
*/ */
#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEBACKENDSERVERSRESULT_H_ #ifndef ALIBABACLOUD_SLB_MODEL_CREATETLSCIPHERPOLICYRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEBACKENDSERVERSRESULT_H_ #define ALIBABACLOUD_SLB_MODEL_CREATETLSCIPHERPOLICYRESULT_H_
#include <string> #include <string>
#include <vector> #include <vector>
@@ -29,33 +29,23 @@ namespace AlibabaCloud
{ {
namespace Model namespace Model
{ {
class ALIBABACLOUD_SLB_EXPORT DescribeBackendServersResult : public ServiceResult class ALIBABACLOUD_SLB_EXPORT CreateTLSCipherPolicyResult : public ServiceResult
{ {
public: public:
struct Listener
{
struct BackendServer
{
std::string serverId;
std::string serverHealthStatus;
};
int listenerPort;
std::vector<Listener::BackendServer> backendServers;
};
DescribeBackendServersResult(); CreateTLSCipherPolicyResult();
explicit DescribeBackendServersResult(const std::string &payload); explicit CreateTLSCipherPolicyResult(const std::string &payload);
~DescribeBackendServersResult(); ~CreateTLSCipherPolicyResult();
std::vector<Listener> getListeners()const; std::string getTLSCipherPolicyId()const;
protected: protected:
void parse(const std::string &payload); void parse(const std::string &payload);
private: private:
std::vector<Listener> listeners_; std::string tLSCipherPolicyId_;
}; };
} }
} }
} }
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEBACKENDSERVERSRESULT_H_ #endif // !ALIBABACLOUD_SLB_MODEL_CREATETLSCIPHERPOLICYRESULT_H_

View File

@@ -0,0 +1,76 @@
/*
* 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 <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT CreateVServerGroupRequest : public RpcServiceRequest {
public:
struct Tag {
std::string value;
std::string key;
};
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 getBackendServers() const;
void setBackendServers(const std::string &backendServers);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
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 getTags() const;
void setTags(const std::string &tags);
std::string getVServerGroupName() const;
void setVServerGroupName(const std::string &vServerGroupName);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string backendServers_;
std::string regionId_;
std::vector<Tag> tag_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
std::string vServerGroupName_;
std::string loadBalancerId_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_CREATEVSERVERGROUPREQUEST_H_

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_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 type;
std::string description;
std::string serverId;
std::string vpcId;
std::string serverRegionId;
std::string serverIp;
int port;
std::string vbrId;
int weight;
};
CreateVServerGroupResult();
explicit CreateVServerGroupResult(const std::string &payload);
~CreateVServerGroupResult();
std::string getVServerGroupId()const;
std::vector<BackendServer> getBackendServers()const;
protected:
void parse(const std::string &payload);
private:
std::string vServerGroupId_;
std::vector<BackendServer> backendServers_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_CREATEVSERVERGROUPRESULT_H_

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_DELETEACCESSCONTROLLISTREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETEACCESSCONTROLLISTREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DeleteAccessControlListRequest : public RpcServiceRequest {
public:
DeleteAccessControlListRequest();
~DeleteAccessControlListRequest();
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 getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getAclId() const;
void setAclId(const std::string &aclId);
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 getTags() const;
void setTags(const std::string &tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string accessKeyId_;
std::string regionId_;
std::string aclId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DELETEACCESSCONTROLLISTREQUEST_H_

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_DELETEACCESSCONTROLLISTRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DELETEACCESSCONTROLLISTRESULT_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 DeleteAccessControlListResult : public ServiceResult
{
public:
DeleteAccessControlListResult();
explicit DeleteAccessControlListResult(const std::string &payload);
~DeleteAccessControlListResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETEACCESSCONTROLLISTRESULT_H_

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_DELETEACCESSLOGSDOWNLOADATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETEACCESSLOGSDOWNLOADATTRIBUTEREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DeleteAccessLogsDownloadAttributeRequest : public RpcServiceRequest {
public:
DeleteAccessLogsDownloadAttributeRequest();
~DeleteAccessLogsDownloadAttributeRequest();
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 getLogsDownloadAttributes() const;
void setLogsDownloadAttributes(const std::string &logsDownloadAttributes);
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 getTags() const;
void setTags(const std::string &tags);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string regionId_;
std::string logsDownloadAttributes_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
std::string loadBalancerId_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DELETEACCESSLOGSDOWNLOADATTRIBUTEREQUEST_H_

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_DELETEACCESSLOGSDOWNLOADATTRIBUTERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DELETEACCESSLOGSDOWNLOADATTRIBUTERESULT_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 DeleteAccessLogsDownloadAttributeResult : public ServiceResult
{
public:
DeleteAccessLogsDownloadAttributeResult();
explicit DeleteAccessLogsDownloadAttributeResult(const std::string &payload);
~DeleteAccessLogsDownloadAttributeResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETEACCESSLOGSDOWNLOADATTRIBUTERESULT_H_

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_DELETECACERTIFICATEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETECACERTIFICATEREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DeleteCACertificateRequest : public RpcServiceRequest {
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 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 getCACertificateId() const;
void setCACertificateId(const std::string &cACertificateId);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string cACertificateId_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DELETECACERTIFICATEREQUEST_H_

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_

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_DELETEDOMAINEXTENSIONREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETEDOMAINEXTENSIONREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DeleteDomainExtensionRequest : public RpcServiceRequest {
public:
DeleteDomainExtensionRequest();
~DeleteDomainExtensionRequest();
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 getDomainExtensionId() const;
void setDomainExtensionId(const std::string &domainExtensionId);
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 getTags() const;
void setTags(const std::string &tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string regionId_;
std::string domainExtensionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DELETEDOMAINEXTENSIONREQUEST_H_

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_DELETEDOMAINEXTENSIONRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DELETEDOMAINEXTENSIONRESULT_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 DeleteDomainExtensionResult : public ServiceResult
{
public:
DeleteDomainExtensionResult();
explicit DeleteDomainExtensionResult(const std::string &payload);
~DeleteDomainExtensionResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETEDOMAINEXTENSIONRESULT_H_

View File

@@ -34,8 +34,8 @@ public:
void setAccess_key_id(const std::string &access_key_id); void setAccess_key_id(const std::string &access_key_id);
long getResourceOwnerId() const; long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId); void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const; std::string getRegionId() const;
void setAccessKeyId(const std::string &accessKeyId); void setRegionId(const std::string &regionId);
int getListenerPort() const; int getListenerPort() const;
void setListenerPort(int listenerPort); void setListenerPort(int listenerPort);
std::string getResourceOwnerAccount() const; std::string getResourceOwnerAccount() const;
@@ -44,6 +44,8 @@ public:
void setOwnerAccount(const std::string &ownerAccount); void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const; long getOwnerId() const;
void setOwnerId(long ownerId); void setOwnerId(long ownerId);
std::string getListenerProtocol() const;
void setListenerProtocol(const std::string &listenerProtocol);
std::string getTags() const; std::string getTags() const;
void setTags(const std::string &tags); void setTags(const std::string &tags);
std::string getLoadBalancerId() const; std::string getLoadBalancerId() const;
@@ -52,11 +54,12 @@ public:
private: private:
std::string access_key_id_; std::string access_key_id_;
long resourceOwnerId_; long resourceOwnerId_;
std::string accessKeyId_; std::string regionId_;
int listenerPort_; int listenerPort_;
std::string resourceOwnerAccount_; std::string resourceOwnerAccount_;
std::string ownerAccount_; std::string ownerAccount_;
long ownerId_; long ownerId_;
std::string listenerProtocol_;
std::string tags_; std::string tags_;
std::string loadBalancerId_; std::string loadBalancerId_;
}; };

View File

@@ -34,8 +34,10 @@ public:
void setAccess_key_id(const std::string &access_key_id); void setAccess_key_id(const std::string &access_key_id);
long getResourceOwnerId() const; long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId); void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const; std::string getRegionId() const;
void setAccessKeyId(const std::string &accessKeyId); void setRegionId(const std::string &regionId);
std::string getEnableEipReserve() const;
void setEnableEipReserve(const std::string &enableEipReserve);
std::string getResourceOwnerAccount() const; std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount); void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const; std::string getOwnerAccount() const;
@@ -50,7 +52,8 @@ public:
private: private:
std::string access_key_id_; std::string access_key_id_;
long resourceOwnerId_; long resourceOwnerId_;
std::string accessKeyId_; std::string regionId_;
std::string enableEipReserve_;
std::string resourceOwnerAccount_; std::string resourceOwnerAccount_;
std::string ownerAccount_; std::string ownerAccount_;
long ownerId_; long ownerId_;

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_DELETEMASTERSLAVESERVERGROUPREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVESERVERGROUPREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DeleteMasterSlaveServerGroupRequest : public RpcServiceRequest {
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 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 getTags() const;
void setTags(const std::string &tags);
std::string getMasterSlaveServerGroupId() const;
void setMasterSlaveServerGroupId(const std::string &masterSlaveServerGroupId);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
std::string masterSlaveServerGroupId_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DELETEMASTERSLAVESERVERGROUPREQUEST_H_

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_

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_DELETERULESREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETERULESREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DeleteRulesRequest : public RpcServiceRequest {
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 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 getTags() const;
void setTags(const std::string &tags);
std::string getRuleIds() const;
void setRuleIds(const std::string &ruleIds);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
std::string ruleIds_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DELETERULESREQUEST_H_

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_

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_DELETESERVERCERTIFICATEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETESERVERCERTIFICATEREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DeleteServerCertificateRequest : public RpcServiceRequest {
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 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 getServerCertificateId() const;
void setServerCertificateId(const std::string &serverCertificateId);
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 serverCertificateId_;
std::string tags_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DELETESERVERCERTIFICATEREQUEST_H_

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_

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_DELETETLSCIPHERPOLICYREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETETLSCIPHERPOLICYREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DeleteTLSCipherPolicyRequest : public RpcServiceRequest {
public:
DeleteTLSCipherPolicyRequest();
~DeleteTLSCipherPolicyRequest();
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 getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getTLSCipherPolicyId() const;
void setTLSCipherPolicyId(const std::string &tLSCipherPolicyId);
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);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string accessKeyId_;
std::string tLSCipherPolicyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DELETETLSCIPHERPOLICYREQUEST_H_

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_DELETETLSCIPHERPOLICYRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DELETETLSCIPHERPOLICYRESULT_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 DeleteTLSCipherPolicyResult : public ServiceResult
{
public:
DeleteTLSCipherPolicyResult();
explicit DeleteTLSCipherPolicyResult(const std::string &payload);
~DeleteTLSCipherPolicyResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DELETETLSCIPHERPOLICYRESULT_H_

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_DELETEVSERVERGROUPREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DELETEVSERVERGROUPREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DeleteVServerGroupRequest : public RpcServiceRequest {
public:
DeleteVServerGroupRequest();
~DeleteVServerGroupRequest();
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 getVServerGroupId() const;
void setVServerGroupId(const std::string &vServerGroupId);
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 getTags() const;
void setTags(const std::string &tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string regionId_;
std::string vServerGroupId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DELETEVSERVERGROUPREQUEST_H_

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_

View File

@@ -0,0 +1,75 @@
/*
* 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_DESCRIBEACCESSCONTROLLISTATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSCONTROLLISTATTRIBUTEREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DescribeAccessControlListAttributeRequest : public RpcServiceRequest {
public:
DescribeAccessControlListAttributeRequest();
~DescribeAccessControlListAttributeRequest();
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 getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getAclId() const;
void setAclId(const std::string &aclId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
std::string getAclEntryComment() const;
void setAclEntryComment(const std::string &aclEntryComment);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getTags() const;
void setTags(const std::string &tags);
int getPage() const;
void setPage(int page);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string accessKeyId_;
std::string regionId_;
int pageSize_;
std::string aclId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::string aclEntryComment_;
long ownerId_;
std::string tags_;
int page_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSCONTROLLISTATTRIBUTEREQUEST_H_

View File

@@ -0,0 +1,86 @@
/*
* 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_DESCRIBEACCESSCONTROLLISTATTRIBUTERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSCONTROLLISTATTRIBUTERESULT_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 DescribeAccessControlListAttributeResult : public ServiceResult
{
public:
struct Tag
{
std::string tagKey;
std::string tagValue;
};
struct AclEntry
{
std::string aclEntryComment;
std::string aclEntryIP;
};
struct RelatedListener
{
int listenerPort;
std::string aclType;
std::string loadBalancerId;
std::string protocol;
};
DescribeAccessControlListAttributeResult();
explicit DescribeAccessControlListAttributeResult(const std::string &payload);
~DescribeAccessControlListAttributeResult();
std::vector<AclEntry> getAclEntrys()const;
std::string getResourceGroupId()const;
int getTotalAclEntry()const;
std::string getServiceManagedMode()const;
std::string getAclId()const;
std::string getAddressIPVersion()const;
std::string getCreateTime()const;
std::vector<RelatedListener> getRelatedListeners()const;
std::vector<Tag> getTags()const;
std::string getAclName()const;
protected:
void parse(const std::string &payload);
private:
std::vector<AclEntry> aclEntrys_;
std::string resourceGroupId_;
int totalAclEntry_;
std::string serviceManagedMode_;
std::string aclId_;
std::string addressIPVersion_;
std::string createTime_;
std::vector<RelatedListener> relatedListeners_;
std::vector<Tag> tags_;
std::string aclName_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSCONTROLLISTATTRIBUTERESULT_H_

View File

@@ -0,0 +1,85 @@
/*
* 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_DESCRIBEACCESSCONTROLLISTSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSCONTROLLISTSREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DescribeAccessControlListsRequest : public RpcServiceRequest {
public:
struct Tag {
std::string value;
std::string key;
};
DescribeAccessControlListsRequest();
~DescribeAccessControlListsRequest();
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 getAclName() const;
void setAclName(const std::string &aclName);
std::string getAddressIPVersion() const;
void setAddressIPVersion(const std::string &addressIPVersion);
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 getRegionId() const;
void setRegionId(const std::string &regionId);
int getPageSize() const;
void setPageSize(int pageSize);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
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 getTags() const;
void setTags(const std::string &tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string aclName_;
std::string addressIPVersion_;
int pageNumber_;
std::string accessKeyId_;
std::string resourceGroupId_;
std::string regionId_;
int pageSize_;
std::vector<Tag> tag_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSCONTROLLISTSREQUEST_H_

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_DESCRIBEACCESSCONTROLLISTSRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSCONTROLLISTSRESULT_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 DescribeAccessControlListsResult : public ServiceResult
{
public:
struct Acl
{
struct Tag
{
std::string tagKey;
std::string tagValue;
};
std::string resourceGroupId;
std::string serviceManagedMode;
std::string aclId;
std::string addressIPVersion;
std::string createTime;
std::vector<Acl::Tag> tags;
std::string aclName;
};
DescribeAccessControlListsResult();
explicit DescribeAccessControlListsResult(const std::string &payload);
~DescribeAccessControlListsResult();
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<Acl> getAcls()const;
int getCount()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
int pageSize_;
int pageNumber_;
std::vector<Acl> acls_;
int count_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSCONTROLLISTSRESULT_H_

View File

@@ -0,0 +1,72 @@
/*
* 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_DESCRIBEACCESSLOGSDOWNLOADATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSLOGSDOWNLOADATTRIBUTEREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DescribeAccessLogsDownloadAttributeRequest : public RpcServiceRequest {
public:
DescribeAccessLogsDownloadAttributeRequest();
~DescribeAccessLogsDownloadAttributeRequest();
std::string getAccess_key_id() const;
void setAccess_key_id(const std::string &access_key_id);
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getLogType() const;
void setLogType(const std::string &logType);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getPageSize() const;
void setPageSize(int pageSize);
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 getTags() const;
void setTags(const std::string &tags);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
private:
std::string access_key_id_;
long resourceOwnerId_;
int pageNumber_;
std::string logType_;
std::string regionId_;
int pageSize_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
std::string loadBalancerId_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSLOGSDOWNLOADATTRIBUTEREQUEST_H_

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_DESCRIBEACCESSLOGSDOWNLOADATTRIBUTERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSLOGSDOWNLOADATTRIBUTERESULT_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 DescribeAccessLogsDownloadAttributeResult : public ServiceResult
{
public:
struct LogsDownloadAttribute
{
std::string logStore;
std::string logType;
std::string region;
std::string loadBalancerId;
std::string logProject;
std::string roleArn;
};
DescribeAccessLogsDownloadAttributeResult();
explicit DescribeAccessLogsDownloadAttributeResult(const std::string &payload);
~DescribeAccessLogsDownloadAttributeResult();
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
int getCount()const;
std::vector<LogsDownloadAttribute> getLogsDownloadAttributes()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
int pageSize_;
int pageNumber_;
int count_;
std::vector<LogsDownloadAttribute> logsDownloadAttributes_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEACCESSLOGSDOWNLOADATTRIBUTERESULT_H_

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_DESCRIBEAVAILABLERESOURCEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEAVAILABLERESOURCEREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DescribeAvailableResourceRequest : public RpcServiceRequest {
public:
DescribeAvailableResourceRequest();
~DescribeAvailableResourceRequest();
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 getAddressIPVersion() const;
void setAddressIPVersion(const std::string &addressIPVersion);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getAddressType() const;
void setAddressType(const std::string &addressType);
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);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string addressIPVersion_;
std::string regionId_;
std::string addressType_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEAVAILABLERESOURCEREQUEST_H_

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_DESCRIBEAVAILABLERESOURCERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEAVAILABLERESOURCERESULT_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 DescribeAvailableResourceResult : public ServiceResult
{
public:
struct AvailableResource
{
struct SupportResource
{
std::string addressIPVersion;
std::string addressType;
};
std::vector<AvailableResource::SupportResource> supportResources;
std::string slaveZoneId;
std::string masterZoneId;
};
DescribeAvailableResourceResult();
explicit DescribeAvailableResourceResult(const std::string &payload);
~DescribeAvailableResourceResult();
std::vector<AvailableResource> getAvailableResources()const;
protected:
void parse(const std::string &payload);
private:
std::vector<AvailableResource> availableResources_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEAVAILABLERESOURCERESULT_H_

View File

@@ -0,0 +1,70 @@
/*
* 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 <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DescribeCACertificatesRequest : public RpcServiceRequest {
public:
struct Tag {
std::string value;
std::string key;
};
DescribeCACertificatesRequest();
~DescribeCACertificatesRequest();
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 getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
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 getCACertificateId() const;
void setCACertificateId(const std::string &cACertificateId);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string resourceGroupId_;
std::string regionId_;
std::vector<Tag> tag_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string cACertificateId_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBECACERTIFICATESREQUEST_H_

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_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
{
struct Tag
{
std::string tagKey;
std::string tagValue;
};
std::string fingerprint;
long expireTimeStamp;
std::string resourceGroupId;
std::string cACertificateId;
std::string createTime;
std::string standardType;
int encryptionKeyLength;
std::string cACertificateName;
std::string encryptionAlgorithm;
std::string regionId;
std::string expireTime;
std::vector<CACertificate::Tag> tags;
long createTimeStamp;
std::string commonName;
};
DescribeCACertificatesResult();
explicit DescribeCACertificatesResult(const std::string &payload);
~DescribeCACertificatesResult();
std::vector<CACertificate> getCACertificates()const;
protected:
void parse(const std::string &payload);
private:
std::vector<CACertificate> cACertificates_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBECACERTIFICATESRESULT_H_

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_DESCRIBEDOMAINEXTENSIONATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEDOMAINEXTENSIONATTRIBUTEREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DescribeDomainExtensionAttributeRequest : public RpcServiceRequest {
public:
DescribeDomainExtensionAttributeRequest();
~DescribeDomainExtensionAttributeRequest();
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 getDomainExtensionId() const;
void setDomainExtensionId(const std::string &domainExtensionId);
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 getTags() const;
void setTags(const std::string &tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string regionId_;
std::string domainExtensionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEDOMAINEXTENSIONATTRIBUTEREQUEST_H_

View File

@@ -0,0 +1,75 @@
/*
* 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_DESCRIBEDOMAINEXTENSIONATTRIBUTERESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEDOMAINEXTENSIONATTRIBUTERESULT_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 DescribeDomainExtensionAttributeResult : public ServiceResult
{
public:
struct Certificate
{
std::string certificateId;
std::string encryptionAlgorithm;
};
struct ServerCertificate
{
std::string bindingType;
std::string certificateId;
std::string encryptionAlgorithm;
std::string standardType;
};
DescribeDomainExtensionAttributeResult();
explicit DescribeDomainExtensionAttributeResult(const std::string &payload);
~DescribeDomainExtensionAttributeResult();
int getListenerPort()const;
std::string getDomainExtensionId()const;
std::vector<Certificate> getCertificates()const;
std::vector<ServerCertificate> getServerCertificates()const;
std::string getServerCertificateId()const;
std::string getLoadBalancerId()const;
std::string getDomain()const;
protected:
void parse(const std::string &payload);
private:
int listenerPort_;
std::string domainExtensionId_;
std::vector<Certificate> certificates_;
std::vector<ServerCertificate> serverCertificates_;
std::string serverCertificateId_;
std::string loadBalancerId_;
std::string domain_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEDOMAINEXTENSIONATTRIBUTERESULT_H_

View File

@@ -0,0 +1,69 @@
/*
* 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_DESCRIBEDOMAINEXTENSIONSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEDOMAINEXTENSIONSREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DescribeDomainExtensionsRequest : public RpcServiceRequest {
public:
DescribeDomainExtensionsRequest();
~DescribeDomainExtensionsRequest();
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 getDomainExtensionId() const;
void setDomainExtensionId(const std::string &domainExtensionId);
int getListenerPort() const;
void setListenerPort(int listenerPort);
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 getTags() const;
void setTags(const std::string &tags);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string regionId_;
std::string domainExtensionId_;
int listenerPort_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
std::string loadBalancerId_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEDOMAINEXTENSIONSREQUEST_H_

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_DESCRIBEDOMAINEXTENSIONSRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEDOMAINEXTENSIONSRESULT_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 DescribeDomainExtensionsResult : public ServiceResult
{
public:
struct DomainExtension
{
struct Certificate
{
std::string certificateId;
std::string encryptionAlgorithm;
};
struct ServerCertificate
{
std::string certificateId;
std::string bindingType;
std::string encryptionAlgorithm;
std::string standardType;
};
std::string domainExtensionId;
std::vector<DomainExtension::Certificate> certificates;
std::vector<DomainExtension::ServerCertificate> serverCertificates;
std::string serverCertificateId;
std::string domain;
};
DescribeDomainExtensionsResult();
explicit DescribeDomainExtensionsResult(const std::string &payload);
~DescribeDomainExtensionsResult();
std::vector<DomainExtension> getDomainExtensions()const;
protected:
void parse(const std::string &payload);
private:
std::vector<DomainExtension> domainExtensions_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEDOMAINEXTENSIONSRESULT_H_

View File

@@ -0,0 +1,69 @@
/*
* 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 <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DescribeHealthStatusRequest : public RpcServiceRequest {
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);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getListenerPort() const;
void setListenerPort(int listenerPort);
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 getListenerProtocol() const;
void setListenerProtocol(const std::string &listenerProtocol);
std::string getTags() const;
void setTags(const std::string &tags);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string regionId_;
int listenerPort_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string listenerProtocol_;
std::string tags_;
std::string loadBalancerId_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEHEALTHSTATUSREQUEST_H_

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_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 type;
std::string serverId;
std::string eniHost;
std::string serverIp;
int port;
std::string serverHealthStatus;
std::string protocol;
};
DescribeHealthStatusResult();
explicit DescribeHealthStatusResult(const std::string &payload);
~DescribeHealthStatusResult();
std::vector<BackendServer> getBackendServers()const;
protected:
void parse(const std::string &payload);
private:
std::vector<BackendServer> backendServers_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEHEALTHSTATUSRESULT_H_

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_DESCRIBEHIGHDEFINATIONMONITORREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEHIGHDEFINATIONMONITORREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DescribeHighDefinationMonitorRequest : public RpcServiceRequest {
public:
DescribeHighDefinationMonitorRequest();
~DescribeHighDefinationMonitorRequest();
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 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 tags_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEHIGHDEFINATIONMONITORREQUEST_H_

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_DESCRIBEHIGHDEFINATIONMONITORRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEHIGHDEFINATIONMONITORRESULT_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 DescribeHighDefinationMonitorResult : public ServiceResult
{
public:
DescribeHighDefinationMonitorResult();
explicit DescribeHighDefinationMonitorResult(const std::string &payload);
~DescribeHighDefinationMonitorResult();
std::string getLogStore()const;
std::string getLogProject()const;
std::string getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string logStore_;
std::string logProject_;
std::string success_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEHIGHDEFINATIONMONITORRESULT_H_

View File

@@ -0,0 +1,69 @@
/*
* 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 <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DescribeListenerAccessControlAttributeRequest : public RpcServiceRequest {
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);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getListenerPort() const;
void setListenerPort(int listenerPort);
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 getListenerProtocol() const;
void setListenerProtocol(const std::string &listenerProtocol);
std::string getTags() const;
void setTags(const std::string &tags);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string regionId_;
int listenerPort_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string listenerProtocol_;
std::string tags_;
std::string loadBalancerId_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELISTENERACCESSCONTROLATTRIBUTEREQUEST_H_

View File

@@ -0,0 +1,53 @@
/*
* 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;
std::string getSourceItems()const;
protected:
void parse(const std::string &payload);
private:
std::string accessControlStatus_;
std::string sourceItems_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELISTENERACCESSCONTROLATTRIBUTERESULT_H_

View File

@@ -34,8 +34,10 @@ public:
void setAccess_key_id(const std::string &access_key_id); void setAccess_key_id(const std::string &access_key_id);
long getResourceOwnerId() const; long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId); void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const; bool getIncludeReservedData() const;
void setAccessKeyId(const std::string &accessKeyId); void setIncludeReservedData(bool includeReservedData);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const; std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount); void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const; std::string getOwnerAccount() const;
@@ -50,7 +52,8 @@ public:
private: private:
std::string access_key_id_; std::string access_key_id_;
long resourceOwnerId_; long resourceOwnerId_;
std::string accessKeyId_; bool includeReservedData_;
std::string regionId_;
std::string resourceOwnerAccount_; std::string resourceOwnerAccount_;
std::string ownerAccount_; std::string ownerAccount_;
long ownerId_; long ownerId_;

View File

@@ -32,6 +32,11 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerAttributeResult : public ServiceResult class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerAttributeResult : public ServiceResult
{ {
public: public:
struct Tag
{
std::string tagKey;
std::string tagValue;
};
struct ListenerPortAndProtocal struct ListenerPortAndProtocal
{ {
int listenerPort; int listenerPort;
@@ -39,12 +44,19 @@ namespace AlibabaCloud
}; };
struct ListenerPortAndProtocol struct ListenerPortAndProtocol
{ {
std::string listenerForward;
int listenerPort; int listenerPort;
std::string description;
int forwardPort;
std::string listenerProtocol; std::string listenerProtocol;
}; };
struct BackendServer struct BackendServer
{ {
std::string type;
std::string description;
std::string serverId; std::string serverId;
std::string vpcId;
std::string serverIp;
int weight; int weight;
}; };
@@ -53,61 +65,115 @@ namespace AlibabaCloud
explicit DescribeLoadBalancerAttributeResult(const std::string &payload); explicit DescribeLoadBalancerAttributeResult(const std::string &payload);
~DescribeLoadBalancerAttributeResult(); ~DescribeLoadBalancerAttributeResult();
std::vector<ListenerPortAndProtocal> getListenerPortsAndProtocal()const; std::vector<ListenerPortAndProtocal> getListenerPortsAndProtocal()const;
std::string getEndTime()const;
std::string getAddress()const; std::string getAddress()const;
std::string getResourceGroupId()const;
std::string getSpecType()const;
std::string getInstanceChargeType()const;
std::vector<BackendServer> getBackendServers()const;
std::string getHasReservedInfo()const;
std::string getBusinessStatus()const;
std::string getLoadBalancerSpec()const;
std::string getServiceManagedMode()const;
std::string getModificationProtectionReason()const;
std::string getAssociatedCenId()const;
std::vector<Tag> getTags()const;
std::vector<std::string> getListenerPorts()const;
std::string getCloudInstanceType()const;
std::string getVSwitchId()const;
std::string getRenewalStatus()const;
std::vector<std::string> getLabels()const;
std::string getPayType()const;
std::string getInternetChargeType()const;
std::string getReservedInfoInternetChargeType()const;
std::string getVpcId()const;
std::string getDeleteProtection()const;
long getEndTimeStamp()const;
std::string getLoadBalancerStatus()const;
long getAutoReleaseTime()const;
int getRenewalDuration()const;
std::string getAssociatedCenStatus()const;
std::string getEndTime()const;
bool getSupportPrivateLink()const;
std::string getAddressIPVersion()const;
std::vector<ListenerPortAndProtocol> getListenerPortsAndProtocol()const; std::vector<ListenerPortAndProtocol> getListenerPortsAndProtocol()const;
std::string getLoadBalancerId()const; std::string getLoadBalancerId()const;
std::vector<BackendServer> getBackendServers()const; std::string getReservedInfoBandwidth()const;
std::string getLoadBalancerSpec()const; std::string getModificationProtectionStatus()const;
std::string getNetworkType()const; std::string getNetworkType()const;
int getBandwidth()const; int getBandwidth()const;
std::vector<std::string> getListenerPorts()const; bool getSpecBpsFlag()const;
std::string getMasterZoneId()const; std::string getMasterZoneId()const;
std::string getTunnelType()const;
std::string getCloudType()const;
std::string getCreateTime()const; std::string getCreateTime()const;
std::string getVSwitchId()const; long getCloudInstanceUid()const;
std::string getPayType()const; std::string getRenewalCycUnit()const;
std::string getReservedInfoActiveTime()const;
std::string getCloudInstanceId()const;
std::string getSlaveZoneId()const; std::string getSlaveZoneId()const;
std::string getInternetChargeType()const;
std::string getRegionIdAlias()const; std::string getRegionIdAlias()const;
std::string getLoadBalancerName()const; std::string getLoadBalancerName()const;
std::string getIsPublicAddress()const; std::string getReservedInfoOrderType()const;
std::string getVpcId()const;
long getEndTimeStamp()const;
std::string getRegionId()const; std::string getRegionId()const;
std::string getAddressType()const; std::string getAddressType()const;
std::string getLoadBalancerStatus()const;
long getCreateTimeStamp()const; long getCreateTimeStamp()const;
long getAutoReleaseTime()const;
protected: protected:
void parse(const std::string &payload); void parse(const std::string &payload);
private: private:
std::vector<ListenerPortAndProtocal> listenerPortsAndProtocal_; std::vector<ListenerPortAndProtocal> listenerPortsAndProtocal_;
std::string endTime_;
std::string address_; std::string address_;
std::string resourceGroupId_;
std::string specType_;
std::string instanceChargeType_;
std::vector<BackendServer> backendServers_;
std::string hasReservedInfo_;
std::string businessStatus_;
std::string loadBalancerSpec_;
std::string serviceManagedMode_;
std::string modificationProtectionReason_;
std::string associatedCenId_;
std::vector<Tag> tags_;
std::vector<std::string> listenerPorts_;
std::string cloudInstanceType_;
std::string vSwitchId_;
std::string renewalStatus_;
std::vector<std::string> labels_;
std::string payType_;
std::string internetChargeType_;
std::string reservedInfoInternetChargeType_;
std::string vpcId_;
std::string deleteProtection_;
long endTimeStamp_;
std::string loadBalancerStatus_;
long autoReleaseTime_;
int renewalDuration_;
std::string associatedCenStatus_;
std::string endTime_;
bool supportPrivateLink_;
std::string addressIPVersion_;
std::vector<ListenerPortAndProtocol> listenerPortsAndProtocol_; std::vector<ListenerPortAndProtocol> listenerPortsAndProtocol_;
std::string loadBalancerId_; std::string loadBalancerId_;
std::vector<BackendServer> backendServers_; std::string reservedInfoBandwidth_;
std::string loadBalancerSpec_; std::string modificationProtectionStatus_;
std::string networkType_; std::string networkType_;
int bandwidth_; int bandwidth_;
std::vector<std::string> listenerPorts_; bool specBpsFlag_;
std::string masterZoneId_; std::string masterZoneId_;
std::string tunnelType_;
std::string cloudType_;
std::string createTime_; std::string createTime_;
std::string vSwitchId_; long cloudInstanceUid_;
std::string payType_; std::string renewalCycUnit_;
std::string reservedInfoActiveTime_;
std::string cloudInstanceId_;
std::string slaveZoneId_; std::string slaveZoneId_;
std::string internetChargeType_;
std::string regionIdAlias_; std::string regionIdAlias_;
std::string loadBalancerName_; std::string loadBalancerName_;
std::string isPublicAddress_; std::string reservedInfoOrderType_;
std::string vpcId_;
long endTimeStamp_;
std::string regionId_; std::string regionId_;
std::string addressType_; std::string addressType_;
std::string loadBalancerStatus_;
long createTimeStamp_; long createTimeStamp_;
long autoReleaseTime_;
}; };
} }

View File

@@ -34,8 +34,8 @@ public:
void setAccess_key_id(const std::string &access_key_id); void setAccess_key_id(const std::string &access_key_id);
long getResourceOwnerId() const; long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId); void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const; std::string getRegionId() const;
void setAccessKeyId(const std::string &accessKeyId); void setRegionId(const std::string &regionId);
int getListenerPort() const; int getListenerPort() const;
void setListenerPort(int listenerPort); void setListenerPort(int listenerPort);
std::string getResourceOwnerAccount() const; std::string getResourceOwnerAccount() const;
@@ -52,7 +52,7 @@ public:
private: private:
std::string access_key_id_; std::string access_key_id_;
long resourceOwnerId_; long resourceOwnerId_;
std::string accessKeyId_; std::string regionId_;
int listenerPort_; int listenerPort_;
std::string resourceOwnerAccount_; std::string resourceOwnerAccount_;
std::string ownerAccount_; std::string ownerAccount_;

View File

@@ -32,6 +32,19 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerHTTPListenerAttributeResult : public ServiceResult class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerHTTPListenerAttributeResult : public ServiceResult
{ {
public: public:
struct Rule
{
std::string vServerGroupId;
std::string ruleId;
std::string domain;
std::string url;
std::string ruleName;
};
struct Tag
{
std::string tagKey;
std::string tagValue;
};
DescribeLoadBalancerHTTPListenerAttributeResult(); DescribeLoadBalancerHTTPListenerAttributeResult();
@@ -40,29 +53,49 @@ namespace AlibabaCloud
int getCookieTimeout()const; int getCookieTimeout()const;
int getMaxConnection()const; int getMaxConnection()const;
std::string getVServerGroupId()const; std::string getVServerGroupId()const;
std::string getDescription()const;
int getUnhealthyThreshold()const; int getUnhealthyThreshold()const;
std::string getHealthCheckURI()const;
std::string getScheduler()const; std::string getScheduler()const;
std::string getHealthCheck()const; std::string getHealthCheck()const;
int getIdleTimeout()const;
std::string getLoadBalancerId()const;
int getBackendServerPort()const; int getBackendServerPort()const;
std::string getURI()const;
std::string getXForwardedFor_SLBID()const; std::string getXForwardedFor_SLBID()const;
int getHealthCheckConnectPort()const; int getHealthCheckConnectPort()const;
std::string getXForwardedFor_SLBPORT()const;
std::string getHealthCheckMethod()const;
std::string getServiceManagedMode()const;
int getBandwidth()const; int getBandwidth()const;
std::string getSecurityStatus()const; std::string getSecurityStatus()const;
std::string getGzip()const; std::string getGzip()const;
std::string getStickySessionType()const; std::string getStickySessionType()const;
std::string getXForwardedFor_SLBIP()const; std::string getXForwardedFor_SLBIP()const;
std::string getHealthCheckHttpCode()const; std::string getHealthCheckHttpCode()const;
std::vector<Tag> getTags()const;
int getForwardCode()const;
std::string getStatus()const; std::string getStatus()const;
std::string getCookie()const; std::string getCookie()const;
int getRequestTimeout()const;
int getListenerPort()const; int getListenerPort()const;
int getHealthCheckInterval()const;
std::string getAclId()const;
std::string getHealthCheckHttpVersion()const;
int getHealthCheckTimeout()const; int getHealthCheckTimeout()const;
std::vector<Rule> getRules()const;
std::string getListenerForward()const;
std::string getStickySession()const; std::string getStickySession()const;
std::string getAclStatus()const;
int getForwardPort()const;
std::string getVpcIds()const;
int getHealthyThreshold()const; int getHealthyThreshold()const;
std::string getXForwardedFor_ClientSrcPort()const;
std::string getXForwardedFor()const; std::string getXForwardedFor()const;
std::string getHealthCheckDomain()const;
std::string getAclType()const;
std::string getXForwardedFor_proto()const; std::string getXForwardedFor_proto()const;
std::string getDomain()const; std::vector<std::string> getAclIds()const;
int getInterval()const; std::string getHealthCheckType()const;
protected: protected:
void parse(const std::string &payload); void parse(const std::string &payload);
@@ -70,29 +103,49 @@ namespace AlibabaCloud
int cookieTimeout_; int cookieTimeout_;
int maxConnection_; int maxConnection_;
std::string vServerGroupId_; std::string vServerGroupId_;
std::string description_;
int unhealthyThreshold_; int unhealthyThreshold_;
std::string healthCheckURI_;
std::string scheduler_; std::string scheduler_;
std::string healthCheck_; std::string healthCheck_;
int idleTimeout_;
std::string loadBalancerId_;
int backendServerPort_; int backendServerPort_;
std::string uRI_;
std::string xForwardedFor_SLBID_; std::string xForwardedFor_SLBID_;
int healthCheckConnectPort_; int healthCheckConnectPort_;
std::string xForwardedFor_SLBPORT_;
std::string healthCheckMethod_;
std::string serviceManagedMode_;
int bandwidth_; int bandwidth_;
std::string securityStatus_; std::string securityStatus_;
std::string gzip_; std::string gzip_;
std::string stickySessionType_; std::string stickySessionType_;
std::string xForwardedFor_SLBIP_; std::string xForwardedFor_SLBIP_;
std::string healthCheckHttpCode_; std::string healthCheckHttpCode_;
std::vector<Tag> tags_;
int forwardCode_;
std::string status_; std::string status_;
std::string cookie_; std::string cookie_;
int requestTimeout_;
int listenerPort_; int listenerPort_;
int healthCheckInterval_;
std::string aclId_;
std::string healthCheckHttpVersion_;
int healthCheckTimeout_; int healthCheckTimeout_;
std::vector<Rule> rules_;
std::string listenerForward_;
std::string stickySession_; std::string stickySession_;
std::string aclStatus_;
int forwardPort_;
std::string vpcIds_;
int healthyThreshold_; int healthyThreshold_;
std::string xForwardedFor_ClientSrcPort_;
std::string xForwardedFor_; std::string xForwardedFor_;
std::string healthCheckDomain_;
std::string aclType_;
std::string xForwardedFor_proto_; std::string xForwardedFor_proto_;
std::string domain_; std::vector<std::string> aclIds_;
int interval_; std::string healthCheckType_;
}; };
} }

View File

@@ -14,8 +14,8 @@
* limitations under the License. * limitations under the License.
*/ */
#ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBEBACKENDSERVERSREQUEST_H_ #ifndef ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPSLISTENERATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEBACKENDSERVERSREQUEST_H_ #define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPSLISTENERATTRIBUTEREQUEST_H_
#include <alibabacloud/slb/SlbExport.h> #include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h> #include <alibabacloud/core/RpcServiceRequest.h>
@@ -26,16 +26,14 @@
namespace AlibabaCloud { namespace AlibabaCloud {
namespace Slb { namespace Slb {
namespace Model { namespace Model {
class ALIBABACLOUD_SLB_EXPORT DescribeBackendServersRequest : public RpcServiceRequest { class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerHTTPSListenerAttributeRequest : public RpcServiceRequest {
public: public:
DescribeBackendServersRequest(); DescribeLoadBalancerHTTPSListenerAttributeRequest();
~DescribeBackendServersRequest(); ~DescribeLoadBalancerHTTPSListenerAttributeRequest();
std::string getAccess_key_id() const; std::string getAccess_key_id() const;
void setAccess_key_id(const std::string &access_key_id); void setAccess_key_id(const std::string &access_key_id);
long getResourceOwnerId() const; long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId); void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const; std::string getRegionId() const;
void setRegionId(const std::string &regionId); void setRegionId(const std::string &regionId);
int getListenerPort() const; int getListenerPort() const;
@@ -54,7 +52,6 @@ public:
private: private:
std::string access_key_id_; std::string access_key_id_;
long resourceOwnerId_; long resourceOwnerId_;
std::string accessKeyId_;
std::string regionId_; std::string regionId_;
int listenerPort_; int listenerPort_;
std::string resourceOwnerAccount_; std::string resourceOwnerAccount_;
@@ -66,4 +63,4 @@ private:
} // namespace Model } // namespace Model
} // namespace Slb } // namespace Slb
} // namespace AlibabaCloud } // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEBACKENDSERVERSREQUEST_H_ #endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPSLISTENERATTRIBUTEREQUEST_H_

View File

@@ -0,0 +1,205 @@
/*
* 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:
struct Rule
{
std::string vServerGroupId;
std::string ruleId;
std::string domain;
std::string url;
std::string ruleName;
};
struct DomainExtension
{
struct Certificate
{
std::string certificateId;
std::string encryptionAlgorithm;
};
struct ServerCertificate
{
std::string bindingType;
std::string certificateId;
std::string encryptionAlgorithm;
std::string standardType;
};
std::string domainExtensionId;
std::vector<DomainExtension::ServerCertificate> serverCertificates1;
std::vector<DomainExtension::Certificate> certificates;
std::string serverCertificateId;
std::string domain;
};
struct ServerCertificate2
{
std::string bindingType;
std::string certificateId;
std::string encryptionAlgorithm;
std::string standardType;
};
struct Tag
{
std::string tagKey;
std::string tagValue;
};
DescribeLoadBalancerHTTPSListenerAttributeResult();
explicit DescribeLoadBalancerHTTPSListenerAttributeResult(const std::string &payload);
~DescribeLoadBalancerHTTPSListenerAttributeResult();
int getUnhealthyThreshold()const;
std::string getHealthCheckURI()const;
std::vector<DomainExtension> getDomainExtensions()const;
std::string getHealthCheck()const;
int getBackendServerPort()const;
std::string getXForwardedFor_SLBPORT()const;
std::string getServiceManagedMode()const;
std::string getStickySessionType()const;
std::vector<Tag> getTags()const;
std::string getXForwardedFor_ClientCertSubjectDNAlias()const;
std::string getStatus()const;
std::string getCookie()const;
std::string getXForwardedFor_ClientCertClientVerifyAlias()const;
int getRequestTimeout()const;
std::string getTLSCipherPolicy()const;
int getHealthCheckInterval()const;
std::string getCACertificateId()const;
std::vector<ServerCertificate2> getServerCertificates()const;
std::string getXForwardedFor_ClientCertFingerprintAlias()const;
int getHealthCheckTimeout()const;
std::string getAclStatus()const;
std::string getVpcIds()const;
int getHealthyThreshold()const;
std::string getHealthCheckDomain()const;
std::string getAclType()const;
std::string getXForwardedFor_proto()const;
std::string getEnableHttp2()const;
std::string getHealthCheckType()const;
int getCookieTimeout()const;
int getMaxConnection()const;
std::string getVServerGroupId()const;
std::string getBackendProtocol()const;
std::string getDescription()const;
std::string getScheduler()const;
int getIdleTimeout()const;
std::string getLoadBalancerId()const;
std::string getXForwardedFor_SLBID()const;
int getHealthCheckConnectPort()const;
std::string getHealthCheckMethod()const;
int getBandwidth()const;
std::string getSecurityStatus()const;
std::string getGzip()const;
std::string getServerCertificateId()const;
std::string getXForwardedFor_SLBIP()const;
std::string getHealthCheckHttpCode()const;
int getListenerPort()const;
std::string getXForwardedFor_ClientCertSubjectDN()const;
std::string getAclId()const;
std::string getXForwardedFor_ClientCertIssuerDNAlias()const;
std::string getHealthCheckHttpVersion()const;
std::vector<Rule> getRules()const;
std::string getXForwardedFor_ClientCertIssuerDN()const;
std::string getStickySession()const;
std::string getXForwardedFor()const;
std::string getXForwardedFor_ClientSrcPort()const;
std::string getXForwardedFor_ClientCertClientVerify()const;
std::string getXForwardedFor_ClientCertFingerprint()const;
std::vector<std::string> getAclIds()const;
protected:
void parse(const std::string &payload);
private:
int unhealthyThreshold_;
std::string healthCheckURI_;
std::vector<DomainExtension> domainExtensions_;
std::string healthCheck_;
int backendServerPort_;
std::string xForwardedFor_SLBPORT_;
std::string serviceManagedMode_;
std::string stickySessionType_;
std::vector<Tag> tags_;
std::string xForwardedFor_ClientCertSubjectDNAlias_;
std::string status_;
std::string cookie_;
std::string xForwardedFor_ClientCertClientVerifyAlias_;
int requestTimeout_;
std::string tLSCipherPolicy_;
int healthCheckInterval_;
std::string cACertificateId_;
std::vector<ServerCertificate2> serverCertificates_;
std::string xForwardedFor_ClientCertFingerprintAlias_;
int healthCheckTimeout_;
std::string aclStatus_;
std::string vpcIds_;
int healthyThreshold_;
std::string healthCheckDomain_;
std::string aclType_;
std::string xForwardedFor_proto_;
std::string enableHttp2_;
std::string healthCheckType_;
int cookieTimeout_;
int maxConnection_;
std::string vServerGroupId_;
std::string backendProtocol_;
std::string description_;
std::string scheduler_;
int idleTimeout_;
std::string loadBalancerId_;
std::string xForwardedFor_SLBID_;
int healthCheckConnectPort_;
std::string healthCheckMethod_;
int bandwidth_;
std::string securityStatus_;
std::string gzip_;
std::string serverCertificateId_;
std::string xForwardedFor_SLBIP_;
std::string healthCheckHttpCode_;
int listenerPort_;
std::string xForwardedFor_ClientCertSubjectDN_;
std::string aclId_;
std::string xForwardedFor_ClientCertIssuerDNAlias_;
std::string healthCheckHttpVersion_;
std::vector<Rule> rules_;
std::string xForwardedFor_ClientCertIssuerDN_;
std::string stickySession_;
std::string xForwardedFor_;
std::string xForwardedFor_ClientSrcPort_;
std::string xForwardedFor_ClientCertClientVerify_;
std::string xForwardedFor_ClientCertFingerprint_;
std::vector<std::string> aclIds_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERHTTPSLISTENERATTRIBUTERESULT_H_

View File

@@ -0,0 +1,79 @@
/*
* 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_DESCRIBELOADBALANCERLISTENERSREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERLISTENERSREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerListenersRequest : public RpcServiceRequest {
public:
struct Tag {
std::string value;
std::string key;
};
DescribeLoadBalancerListenersRequest();
~DescribeLoadBalancerListenersRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getDescription() const;
void setDescription(const std::string &description);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getNextToken() const;
void setNextToken(const std::string &nextToken);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
int getListenerPort() const;
void setListenerPort(int listenerPort);
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 getListenerProtocol() const;
void setListenerProtocol(const std::string &listenerProtocol);
std::vector<std::string> getLoadBalancerId() const;
void setLoadBalancerId(const std::vector<std::string> &loadBalancerId);
int getMaxResults() const;
void setMaxResults(int maxResults);
private:
long resourceOwnerId_;
std::string description_;
std::string regionId_;
std::string nextToken_;
std::vector<Tag> tag_;
int listenerPort_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string listenerProtocol_;
std::vector<std::string> loadBalancerId_;
int maxResults_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERLISTENERSREQUEST_H_

View File

@@ -0,0 +1,260 @@
/*
* 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_DESCRIBELOADBALANCERLISTENERSRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERLISTENERSRESULT_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 DescribeLoadBalancerListenersResult : public ServiceResult
{
public:
struct Listener
{
struct HTTPListenerConfig
{
int cookieTimeout;
int maxConnection;
int unhealthyThreshold;
std::string healthCheckURI;
std::string healthCheck;
int idleTimeout;
std::string xForwardedFor_SLBID;
int healthCheckConnectPort;
std::string xForwardedFor_SLBPORT;
std::string healthCheckMethod;
std::string gzip;
std::string stickySessionType;
std::string xForwardedFor_SLBIP;
std::string healthCheckHttpCode;
int forwardCode;
std::string cookie;
int requestTimeout;
int healthCheckInterval;
std::string healthCheckHttpVersion;
int healthCheckTimeout;
std::string listenerForward;
std::string stickySession;
int forwardPort;
int healthyThreshold;
std::string xForwardedFor_ClientSrcPort;
std::string xForwardedFor;
std::string healthCheckDomain;
std::string xForwardedFor_proto;
std::string healthCheckType;
};
struct HTTPSListenerConfig
{
struct ServerCertificate
{
std::string bindingType;
std::string certificateId;
std::string encryptionAlgorithm;
std::string standardType;
};
int cookieTimeout;
int maxConnection;
int unhealthyThreshold;
std::string healthCheckURI;
std::string healthCheck;
int idleTimeout;
std::string xForwardedFor_SLBID;
int healthCheckConnectPort;
std::string xForwardedFor_SLBPORT;
std::string healthCheckMethod;
std::string gzip;
std::string serverCertificateId;
std::string stickySessionType;
std::string xForwardedFor_SLBIP;
std::string healthCheckHttpCode;
std::string xForwardedFor_ClientCertSubjectDNAlias;
std::string cookie;
std::string xForwardedFor_ClientCertClientVerifyAlias;
int requestTimeout;
int healthCheckInterval;
std::string tLSCipherPolicy;
std::string cACertificateId;
std::string xForwardedFor_ClientCertSubjectDN;
std::vector<ServerCertificate> serverCertificates;
std::string healthCheckHttpVersion;
std::string xForwardedFor_ClientCertFingerprintAlias;
std::string xForwardedFor_ClientCertIssuerDNAlias;
int healthCheckTimeout;
std::string xForwardedFor_ClientCertIssuerDN;
std::string stickySession;
int healthyThreshold;
std::string xForwardedFor_ClientSrcPort;
std::string xForwardedFor;
std::string healthCheckDomain;
std::string xForwardedFor_proto;
std::string enableHttp2;
std::string xForwardedFor_ClientCertClientVerify;
std::string xForwardedFor_ClientCertFingerprint;
std::string healthCheckType;
};
struct TCPListenerConfig
{
struct PortRange
{
int startPort;
int endPort;
};
int maxConnection;
int unhealthyThreshold;
std::string proxyProtocolV2Enabled;
int failoverThreshold;
std::string healthCheckURI;
std::string healthCheck;
bool masterSlaveModeEnabled;
bool healthCheckTcpFastCloseEnabled;
int connectionDrainTimeout;
int persistenceTimeout;
int healthCheckConnectPort;
std::string masterServerGroupId;
std::string healthCheckMethod;
std::string healthCheckHttpCode;
std::string slaveServerGroupId;
int establishedTimeout;
int healthCheckInterval;
std::vector<PortRange> portRanges;
int healthCheckConnectTimeout;
std::string connectionDrain;
std::string healthCheckSwitch;
int healthyThreshold;
std::string failoverStrategy;
std::string masterSlaveServerGroupId;
std::string healthCheckDomain;
std::string fullNatEnabled;
std::string healthCheckType;
};
struct TCPSListenerConfig
{
std::string cookie;
int cookieTimeout;
int healthCheckInterval;
std::string tLSCipherPolicy;
std::string cACertificateId;
int unhealthyThreshold;
std::string healthCheckURI;
std::string healthCheck;
int idleTimeout;
int healthCheckTimeout;
std::string stickySession;
int healthCheckConnectPort;
std::string healthCheckMethod;
int healthyThreshold;
std::string serverCertificateId;
std::string healthCheckDomain;
std::string stickySessionType;
std::string healthCheckHttpCode;
std::string healthCheckType;
};
struct UDPListenerConfig
{
struct PortRange2
{
int startPort;
int endPort;
};
int maxConnection;
int unhealthyThreshold;
std::string proxyProtocolV2Enabled;
int failoverThreshold;
std::string healthCheckURI;
std::string healthCheck;
bool masterSlaveModeEnabled;
int connectionDrainTimeout;
int persistenceTimeout;
int healthCheckConnectPort;
std::string masterServerGroupId;
std::string healthCheckMethod;
std::string quicVersion;
std::string healthCheckHttpCode;
std::string slaveServerGroupId;
int healthCheckInterval;
int healthCheckConnectTimeout;
std::string connectionDrain;
std::vector<PortRange2> portRanges1;
std::string healthCheckSwitch;
std::string healthCheckReq;
std::string healthCheckExp;
int healthyThreshold;
std::string failoverStrategy;
std::string masterSlaveServerGroupId;
std::string healthCheckDomain;
std::string fullNatEnabled;
std::string healthCheckType;
};
struct Tag
{
std::string tagKey;
std::string tagValue;
};
std::string status;
std::string vServerGroupId;
int listenerPort;
std::string description;
std::string backendProtocol;
HTTPSListenerConfig hTTPSListenerConfig;
std::string scheduler;
HTTPListenerConfig hTTPListenerConfig;
std::string aclId;
UDPListenerConfig uDPListenerConfig;
std::string loadBalancerId;
std::string listenerProtocol;
int backendServerPort;
std::string aclStatus;
TCPListenerConfig tCPListenerConfig;
std::string serviceManagedMode;
int bandwidth;
TCPSListenerConfig tCPSListenerConfig;
std::string aclType;
std::vector<Listener::Tag> tags;
std::vector<std::string> aclIds;
};
DescribeLoadBalancerListenersResult();
explicit DescribeLoadBalancerListenersResult(const std::string &payload);
~DescribeLoadBalancerListenersResult();
std::vector<Listener> getListeners()const;
int getTotalCount()const;
std::string getNextToken()const;
int getMaxResults()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Listener> listeners_;
int totalCount_;
std::string nextToken_;
int maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERLISTENERSRESULT_H_

View File

@@ -34,8 +34,8 @@ public:
void setAccess_key_id(const std::string &access_key_id); void setAccess_key_id(const std::string &access_key_id);
long getResourceOwnerId() const; long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId); void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const; std::string getRegionId() const;
void setAccessKeyId(const std::string &accessKeyId); void setRegionId(const std::string &regionId);
int getListenerPort() const; int getListenerPort() const;
void setListenerPort(int listenerPort); void setListenerPort(int listenerPort);
std::string getResourceOwnerAccount() const; std::string getResourceOwnerAccount() const;
@@ -52,7 +52,7 @@ public:
private: private:
std::string access_key_id_; std::string access_key_id_;
long resourceOwnerId_; long resourceOwnerId_;
std::string accessKeyId_; std::string regionId_;
int listenerPort_; int listenerPort_;
std::string resourceOwnerAccount_; std::string resourceOwnerAccount_;
std::string ownerAccount_; std::string ownerAccount_;

View File

@@ -32,57 +32,111 @@ namespace AlibabaCloud
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerTCPListenerAttributeResult : public ServiceResult class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerTCPListenerAttributeResult : public ServiceResult
{ {
public: public:
struct PortRange
{
int startPort;
int endPort;
};
struct Tag
{
std::string tagKey;
std::string tagValue;
};
DescribeLoadBalancerTCPListenerAttributeResult(); DescribeLoadBalancerTCPListenerAttributeResult();
explicit DescribeLoadBalancerTCPListenerAttributeResult(const std::string &payload); explicit DescribeLoadBalancerTCPListenerAttributeResult(const std::string &payload);
~DescribeLoadBalancerTCPListenerAttributeResult(); ~DescribeLoadBalancerTCPListenerAttributeResult();
std::string getStatus()const;
int getMaxConnection()const; int getMaxConnection()const;
std::string getVServerGroupId()const; std::string getVServerGroupId()const;
int getListenerPort()const; std::string getDescription()const;
int getConnectTimeout()const;
int getConnectPort()const;
std::string getSynProxy()const; std::string getSynProxy()const;
int getUnhealthyThreshold()const; int getUnhealthyThreshold()const;
bool getProxyProtocolV2Enabled()const;
int getFailoverThreshold()const;
std::string getHealthCheckURI()const; std::string getHealthCheckURI()const;
std::string getScheduler()const; std::string getScheduler()const;
std::string getHealthCheck()const; std::string getHealthCheck()const;
std::string getLoadBalancerId()const;
std::string getWorkingServerGroupId()const;
int getBackendServerPort()const; int getBackendServerPort()const;
bool getMasterSlaveModeEnabled()const;
bool getHealthCheckTcpFastCloseEnabled()const;
int getConnectionDrainTimeout()const;
int getPersistenceTimeout()const; int getPersistenceTimeout()const;
int getHealthCheckConnectPort()const;
std::string getMasterServerGroupId()const;
std::string getHealthCheckMethod()const;
std::string getServiceManagedMode()const;
int getBandwidth()const; int getBandwidth()const;
std::string getHealthCheckHttpCode()const;
std::string getSlaveServerGroupId()const;
std::vector<Tag> getTags()const;
int getEstablishedTimeout()const;
std::string getStatus()const;
int getListenerPort()const;
int getHealthCheckInterval()const;
std::vector<PortRange> getPortRanges()const;
std::string getAclId()const;
int getHealthCheckConnectTimeout()const;
std::string getConnectionDrain()const;
std::string getAclStatus()const;
std::string getVpcIds()const;
std::string getFailoverStrategy()const;
int getHealthyThreshold()const; int getHealthyThreshold()const;
std::string getMasterSlaveServerGroupId()const; std::string getMasterSlaveServerGroupId()const;
std::string getHealthCheckDomain()const; std::string getHealthCheckDomain()const;
std::string getHealthCheckHttpCode()const; std::string getAclType()const;
bool getFullNatEnabled()const;
std::vector<std::string> getAclIds()const;
std::string getHealthCheckType()const; std::string getHealthCheckType()const;
int getInterval()const;
int getEstablishedTimeout()const;
protected: protected:
void parse(const std::string &payload); void parse(const std::string &payload);
private: private:
std::string status_;
int maxConnection_; int maxConnection_;
std::string vServerGroupId_; std::string vServerGroupId_;
int listenerPort_; std::string description_;
int connectTimeout_;
int connectPort_;
std::string synProxy_; std::string synProxy_;
int unhealthyThreshold_; int unhealthyThreshold_;
bool proxyProtocolV2Enabled_;
int failoverThreshold_;
std::string healthCheckURI_; std::string healthCheckURI_;
std::string scheduler_; std::string scheduler_;
std::string healthCheck_; std::string healthCheck_;
std::string loadBalancerId_;
std::string workingServerGroupId_;
int backendServerPort_; int backendServerPort_;
bool masterSlaveModeEnabled_;
bool healthCheckTcpFastCloseEnabled_;
int connectionDrainTimeout_;
int persistenceTimeout_; int persistenceTimeout_;
int healthCheckConnectPort_;
std::string masterServerGroupId_;
std::string healthCheckMethod_;
std::string serviceManagedMode_;
int bandwidth_; int bandwidth_;
std::string healthCheckHttpCode_;
std::string slaveServerGroupId_;
std::vector<Tag> tags_;
int establishedTimeout_;
std::string status_;
int listenerPort_;
int healthCheckInterval_;
std::vector<PortRange> portRanges_;
std::string aclId_;
int healthCheckConnectTimeout_;
std::string connectionDrain_;
std::string aclStatus_;
std::string vpcIds_;
std::string failoverStrategy_;
int healthyThreshold_; int healthyThreshold_;
std::string masterSlaveServerGroupId_; std::string masterSlaveServerGroupId_;
std::string healthCheckDomain_; std::string healthCheckDomain_;
std::string healthCheckHttpCode_; std::string aclType_;
bool fullNatEnabled_;
std::vector<std::string> aclIds_;
std::string healthCheckType_; std::string healthCheckType_;
int interval_;
int establishedTimeout_;
}; };
} }

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_DESCRIBELOADBALANCERUDPLISTENERATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERUDPLISTENERATTRIBUTEREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancerUDPListenerAttributeRequest : public RpcServiceRequest {
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);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getListenerPort() const;
void setListenerPort(int listenerPort);
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 getTags() const;
void setTags(const std::string &tags);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string regionId_;
int listenerPort_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
std::string loadBalancerId_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERUDPLISTENERATTRIBUTEREQUEST_H_

View File

@@ -0,0 +1,147 @@
/*
* 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:
struct PortRange
{
int startPort;
int endPort;
};
struct Tag
{
std::string tagKey;
std::string tagValue;
};
DescribeLoadBalancerUDPListenerAttributeResult();
explicit DescribeLoadBalancerUDPListenerAttributeResult(const std::string &payload);
~DescribeLoadBalancerUDPListenerAttributeResult();
int getMaxConnection()const;
std::string getVServerGroupId()const;
std::string getDescription()const;
int getUnhealthyThreshold()const;
bool getProxyProtocolV2Enabled()const;
int getFailoverThreshold()const;
std::string getHealthCheckURI()const;
std::string getScheduler()const;
std::string getHealthCheck()const;
std::string getLoadBalancerId()const;
std::string getWorkingServerGroupId()const;
int getBackendServerPort()const;
bool getMasterSlaveModeEnabled()const;
int getConnectionDrainTimeout()const;
int getPersistenceTimeout()const;
int getHealthCheckConnectPort()const;
std::string getMasterServerGroupId()const;
std::string getHealthCheckMethod()const;
std::string getServiceManagedMode()const;
int getBandwidth()const;
std::string getQuicVersion()const;
std::string getHealthCheckHttpCode()const;
std::string getSlaveServerGroupId()const;
std::vector<Tag> getTags()const;
std::string getStatus()const;
int getListenerPort()const;
int getHealthCheckInterval()const;
std::vector<PortRange> getPortRanges()const;
std::string getAclId()const;
int getHealthCheckConnectTimeout()const;
std::string getConnectionDrain()const;
std::string getHealthCheckSwitch()const;
std::string getAclStatus()const;
std::string getHealthCheckReq()const;
std::string getVpcIds()const;
std::string getFailoverStrategy()const;
std::string getHealthCheckExp()const;
int getHealthyThreshold()const;
std::string getMasterSlaveServerGroupId()const;
std::string getHealthCheckDomain()const;
std::string getAclType()const;
bool getFullNatEnabled()const;
std::vector<std::string> getAclIds()const;
std::string getHealthCheckType()const;
protected:
void parse(const std::string &payload);
private:
int maxConnection_;
std::string vServerGroupId_;
std::string description_;
int unhealthyThreshold_;
bool proxyProtocolV2Enabled_;
int failoverThreshold_;
std::string healthCheckURI_;
std::string scheduler_;
std::string healthCheck_;
std::string loadBalancerId_;
std::string workingServerGroupId_;
int backendServerPort_;
bool masterSlaveModeEnabled_;
int connectionDrainTimeout_;
int persistenceTimeout_;
int healthCheckConnectPort_;
std::string masterServerGroupId_;
std::string healthCheckMethod_;
std::string serviceManagedMode_;
int bandwidth_;
std::string quicVersion_;
std::string healthCheckHttpCode_;
std::string slaveServerGroupId_;
std::vector<Tag> tags_;
std::string status_;
int listenerPort_;
int healthCheckInterval_;
std::vector<PortRange> portRanges_;
std::string aclId_;
int healthCheckConnectTimeout_;
std::string connectionDrain_;
std::string healthCheckSwitch_;
std::string aclStatus_;
std::string healthCheckReq_;
std::string vpcIds_;
std::string failoverStrategy_;
std::string healthCheckExp_;
int healthyThreshold_;
std::string masterSlaveServerGroupId_;
std::string healthCheckDomain_;
std::string aclType_;
bool fullNatEnabled_;
std::vector<std::string> aclIds_;
std::string healthCheckType_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBELOADBALANCERUDPLISTENERATTRIBUTERESULT_H_

View File

@@ -28,38 +28,28 @@ namespace Slb {
namespace Model { namespace Model {
class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancersRequest : public RpcServiceRequest { class ALIBABACLOUD_SLB_EXPORT DescribeLoadBalancersRequest : public RpcServiceRequest {
public: public:
struct Tag {
std::string value;
std::string key;
};
DescribeLoadBalancersRequest(); DescribeLoadBalancersRequest();
~DescribeLoadBalancersRequest(); ~DescribeLoadBalancersRequest();
std::string getAccess_key_id() const;
void setAccess_key_id(const std::string &access_key_id);
long getResourceOwnerId() const; long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId); void setResourceOwnerId(long resourceOwnerId);
std::string getNetworkType() const; std::string getNetworkType() const;
void setNetworkType(const std::string &networkType); void setNetworkType(const std::string &networkType);
std::string getAddressIPVersion() const;
void setAddressIPVersion(const std::string &addressIPVersion);
std::string getMasterZoneId() const; std::string getMasterZoneId() const;
void setMasterZoneId(const std::string &masterZoneId); 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; std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId); void setResourceGroupId(const std::string &resourceGroupId);
std::string getLoadBalancerName() const; std::string getLoadBalancerName() const;
void setLoadBalancerName(const std::string &loadBalancerName); 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; std::string getSlaveZoneId() const;
void setSlaveZoneId(const std::string &slaveZoneId); void setSlaveZoneId(const std::string &slaveZoneId);
std::string getAddress() const; std::vector<Tag> getTag() const;
void setAddress(const std::string &address); void setTag(const std::vector<Tag> &tag);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const; long getOwnerId() const;
void setOwnerId(long ownerId); void setOwnerId(long ownerId);
std::string getServerId() const; std::string getServerId() const;
@@ -74,27 +64,48 @@ public:
void setLoadBalancerId(const std::string &loadBalancerId); void setLoadBalancerId(const std::string &loadBalancerId);
std::string getInternetChargeType() const; std::string getInternetChargeType() const;
void setInternetChargeType(const std::string &internetChargeType); void setInternetChargeType(const std::string &internetChargeType);
std::string getAccess_key_id() const;
void setAccess_key_id(const std::string &access_key_id);
bool getSupportPrivateLink() const;
void setSupportPrivateLink(bool supportPrivateLink);
int getPageNumber() const;
void setPageNumber(int pageNumber);
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 getInstanceChargeType() const;
void setInstanceChargeType(const std::string &instanceChargeType);
std::string getFuzzy() const;
void setFuzzy(const std::string &fuzzy);
std::string getBusinessStatus() const;
void setBusinessStatus(const std::string &businessStatus);
std::string getAddress() const;
void setAddress(const std::string &address);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
bool getFilterByTagOrName() const;
void setFilterByTagOrName(bool filterByTagOrName);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
std::string getLoadBalancerStatus() const;
void setLoadBalancerStatus(const std::string &loadBalancerStatus);
std::string getVpcId() const; std::string getVpcId() const;
void setVpcId(const std::string &vpcId); void setVpcId(const std::string &vpcId);
std::string getPayType() const; std::string getPayType() const;
void setPayType(const std::string &payType); void setPayType(const std::string &payType);
private: private:
std::string access_key_id_;
long resourceOwnerId_; long resourceOwnerId_;
std::string networkType_; std::string networkType_;
std::string addressIPVersion_;
std::string masterZoneId_; std::string masterZoneId_;
int pageNumber_;
std::string accessKeyId_;
std::string resourceGroupId_; std::string resourceGroupId_;
std::string loadBalancerName_; std::string loadBalancerName_;
std::string regionId_;
int pageSize_;
std::string addressType_;
std::string slaveZoneId_; std::string slaveZoneId_;
std::string address_; std::vector<Tag> tag_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_; long ownerId_;
std::string serverId_; std::string serverId_;
std::string tags_; std::string tags_;
@@ -102,6 +113,20 @@ private:
std::string vSwitchId_; std::string vSwitchId_;
std::string loadBalancerId_; std::string loadBalancerId_;
std::string internetChargeType_; std::string internetChargeType_;
std::string access_key_id_;
bool supportPrivateLink_;
int pageNumber_;
std::string regionId_;
int pageSize_;
std::string addressType_;
std::string instanceChargeType_;
std::string fuzzy_;
std::string businessStatus_;
std::string address_;
std::string resourceOwnerAccount_;
bool filterByTagOrName_;
std::string ownerAccount_;
std::string loadBalancerStatus_;
std::string vpcId_; std::string vpcId_;
std::string payType_; std::string payType_;
}; };

View File

@@ -34,23 +34,43 @@ namespace AlibabaCloud
public: public:
struct LoadBalancer struct LoadBalancer
{ {
std::string resourceGroupId; struct Tag
{
std::string tagKey;
std::string tagValue;
};
std::string serviceManagedReason;
std::string address; std::string address;
std::string resourceGroupId;
std::string specType;
std::string instanceChargeType;
std::string addressIPVersion;
std::string loadBalancerId;
std::string businessStatus;
std::string modificationProtectionStatus;
std::string loadBalancerSpec;
std::string networkType;
std::string serviceManagedMode;
int bandwidth;
std::string modificationProtectionReason;
bool specBpsFlag;
std::vector<LoadBalancer::Tag> tags;
std::string masterZoneId;
std::string createTime; std::string createTime;
std::string vSwitchId; std::string vSwitchId;
std::string loadBalancerId;
std::string payType; std::string payType;
std::string slaveZoneId; std::string slaveZoneId;
std::vector<std::string> ineffectiveOrderList;
std::string internetChargeType; std::string internetChargeType;
std::string internetChargeTypeAlias;
std::string regionIdAlias; std::string regionIdAlias;
std::string loadBalancerName; std::string loadBalancerName;
std::string vpcId; std::string vpcId;
std::string networkType; std::string deleteProtection;
std::string regionId; std::string regionId;
std::string addressType; std::string addressType;
std::string loadBalancerStatus; std::string loadBalancerStatus;
long createTimeStamp; long createTimeStamp;
std::string masterZoneId;
}; };

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_DESCRIBEMASTERSLAVESERVERGROUPATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPATTRIBUTEREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveServerGroupAttributeRequest : public RpcServiceRequest {
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 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 getTags() const;
void setTags(const std::string &tags);
std::string getMasterSlaveServerGroupId() const;
void setMasterSlaveServerGroupId(const std::string &masterSlaveServerGroupId);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
std::string masterSlaveServerGroupId_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPATTRIBUTEREQUEST_H_

View File

@@ -0,0 +1,79 @@
/*
* 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 Tag
{
std::string tagKey;
std::string tagValue;
};
struct MasterSlaveBackendServer
{
std::string serverType;
std::string type;
std::string description;
std::string serverId;
std::string vpcId;
std::string serverIp;
int port;
int weight;
};
DescribeMasterSlaveServerGroupAttributeResult();
explicit DescribeMasterSlaveServerGroupAttributeResult(const std::string &payload);
~DescribeMasterSlaveServerGroupAttributeResult();
std::string getServiceManagedMode()const;
std::string getCreateTime()const;
std::string getMasterSlaveServerGroupId()const;
std::string getLoadBalancerId()const;
std::string getMasterSlaveServerGroupName()const;
std::vector<MasterSlaveBackendServer> getMasterSlaveBackendServers()const;
std::vector<Tag> getTags()const;
protected:
void parse(const std::string &payload);
private:
std::string serviceManagedMode_;
std::string createTime_;
std::string masterSlaveServerGroupId_;
std::string loadBalancerId_;
std::string masterSlaveServerGroupName_;
std::vector<MasterSlaveBackendServer> masterSlaveBackendServers_;
std::vector<Tag> tags_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPATTRIBUTERESULT_H_

View File

@@ -0,0 +1,76 @@
/*
* 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 <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DescribeMasterSlaveServerGroupsRequest : public RpcServiceRequest {
public:
struct Tag {
std::string value;
std::string key;
};
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);
bool getIncludeListener() const;
void setIncludeListener(bool includeListener);
std::string getDescription() const;
void setDescription(const std::string &description);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
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 getTags() const;
void setTags(const std::string &tags);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
private:
std::string access_key_id_;
long resourceOwnerId_;
bool includeListener_;
std::string description_;
std::string regionId_;
std::vector<Tag> tag_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
std::string loadBalancerId_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPSREQUEST_H_

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_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
{
struct AssociatedObjects
{
struct Listener
{
int port;
std::string protocol;
};
std::vector<Listener> listeners;
};
struct Tag
{
std::string tagKey;
std::string tagValue;
};
AssociatedObjects associatedObjects;
std::string serviceManagedMode;
std::string createTime;
std::string masterSlaveServerGroupId;
std::string masterSlaveServerGroupName;
std::vector<MasterSlaveServerGroup::Tag> tags;
};
DescribeMasterSlaveServerGroupsResult();
explicit DescribeMasterSlaveServerGroupsResult(const std::string &payload);
~DescribeMasterSlaveServerGroupsResult();
std::vector<MasterSlaveServerGroup> getMasterSlaveServerGroups()const;
protected:
void parse(const std::string &payload);
private:
std::vector<MasterSlaveServerGroup> masterSlaveServerGroups_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEMASTERSLAVESERVERGROUPSRESULT_H_

View File

@@ -34,25 +34,28 @@ public:
void setAccess_key_id(const std::string &access_key_id); void setAccess_key_id(const std::string &access_key_id);
long getResourceOwnerId() const; long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId); void setResourceOwnerId(long resourceOwnerId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const; std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount); void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const; std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount); void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const; long getOwnerId() const;
void setOwnerId(long ownerId); void setOwnerId(long ownerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getTags() const; std::string getTags() const;
void setTags(const std::string &tags); void setTags(const std::string &tags);
std::string getAcceptLanguage() const;
void setAcceptLanguage(const std::string &acceptLanguage);
private: private:
std::string access_key_id_; std::string access_key_id_;
long resourceOwnerId_; long resourceOwnerId_;
std::string regionId_;
std::string resourceOwnerAccount_; std::string resourceOwnerAccount_;
std::string ownerAccount_; std::string ownerAccount_;
long ownerId_; long ownerId_;
std::string accessKeyId_;
std::string tags_; std::string tags_;
std::string acceptLanguage_;
}; };
} // namespace Model } // namespace Model
} // namespace Slb } // namespace Slb

View File

@@ -35,6 +35,7 @@ namespace AlibabaCloud
struct Region struct Region
{ {
std::string regionId; std::string regionId;
std::string regionEndpoint;
std::string localName; std::string localName;
}; };

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_DESCRIBERULEATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBERULEATTRIBUTEREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DescribeRuleAttributeRequest : public RpcServiceRequest {
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 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 getTags() const;
void setTags(const std::string &tags);
std::string getRuleId() const;
void setRuleId(const std::string &ruleId);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string tags_;
std::string ruleId_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBERULEATTRIBUTEREQUEST_H_

View File

@@ -0,0 +1,95 @@
/*
* 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 getCookie()const;
int getCookieTimeout()const;
std::string getVServerGroupId()const;
std::string getListenerPort()const;
int getHealthCheckInterval()const;
int getUnhealthyThreshold()const;
std::string getHealthCheckURI()const;
std::string getScheduler()const;
std::string getRuleId()const;
std::string getHealthCheck()const;
std::string getLoadBalancerId()const;
int getHealthCheckTimeout()const;
std::string getUrl()const;
std::string getStickySession()const;
int getHealthCheckConnectPort()const;
std::string getServiceManagedMode()const;
int getHealthyThreshold()const;
std::string getHealthCheckDomain()const;
std::string getListenerSync()const;
std::string getStickySessionType()const;
std::string getDomain()const;
std::string getHealthCheckHttpCode()const;
std::string getRuleName()const;
protected:
void parse(const std::string &payload);
private:
std::string cookie_;
int cookieTimeout_;
std::string vServerGroupId_;
std::string listenerPort_;
int healthCheckInterval_;
int unhealthyThreshold_;
std::string healthCheckURI_;
std::string scheduler_;
std::string ruleId_;
std::string healthCheck_;
std::string loadBalancerId_;
int healthCheckTimeout_;
std::string url_;
std::string stickySession_;
int healthCheckConnectPort_;
std::string serviceManagedMode_;
int healthyThreshold_;
std::string healthCheckDomain_;
std::string listenerSync_;
std::string stickySessionType_;
std::string domain_;
std::string healthCheckHttpCode_;
std::string ruleName_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBERULEATTRIBUTERESULT_H_

View File

@@ -0,0 +1,69 @@
/*
* 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 <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DescribeRulesRequest : public RpcServiceRequest {
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);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getListenerPort() const;
void setListenerPort(int listenerPort);
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 getListenerProtocol() const;
void setListenerProtocol(const std::string &listenerProtocol);
std::string getTags() const;
void setTags(const std::string &tags);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string regionId_;
int listenerPort_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string listenerProtocol_;
std::string tags_;
std::string loadBalancerId_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBERULESREQUEST_H_

View File

@@ -0,0 +1,75 @@
/*
* 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 cookie;
int cookieTimeout;
std::string vServerGroupId;
int healthCheckInterval;
int unhealthyThreshold;
std::string healthCheckURI;
std::string scheduler;
std::string ruleId;
std::string healthCheck;
int healthCheckTimeout;
std::string url;
std::string stickySession;
int healthCheckConnectPort;
std::string serviceManagedMode;
int healthyThreshold;
std::string listenerSync;
std::string healthCheckDomain;
std::string stickySessionType;
std::string domain;
std::string healthCheckHttpCode;
std::string ruleName;
};
DescribeRulesResult();
explicit DescribeRulesResult(const std::string &payload);
~DescribeRulesResult();
std::vector<Rule> getRules()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Rule> rules_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBERULESRESULT_H_

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_DESCRIBESERVERCERTIFICATESREQUEST_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBESERVERCERTIFICATESREQUEST_H_
#include <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DescribeServerCertificatesRequest : public RpcServiceRequest {
public:
struct Tag {
std::string value;
std::string key;
};
DescribeServerCertificatesRequest();
~DescribeServerCertificatesRequest();
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 getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
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 getServerCertificateId() const;
void setServerCertificateId(const std::string &serverCertificateId);
std::string getTags() const;
void setTags(const std::string &tags);
private:
std::string access_key_id_;
long resourceOwnerId_;
std::string resourceGroupId_;
std::string regionId_;
std::vector<Tag> tag_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string serverCertificateId_;
std::string tags_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBESERVERCERTIFICATESREQUEST_H_

View File

@@ -0,0 +1,78 @@
/*
* 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
{
struct Tag
{
std::string tagKey;
std::string tagValue;
};
std::string fingerprint;
long expireTimeStamp;
std::string resourceGroupId;
std::string createTime;
std::vector<std::string> subjectAlternativeNames;
std::string standardType;
std::string aliCloudCertificateId;
std::string regionIdAlias;
std::string aliCloudCertificateName;
int isAliCloudCertificate;
int encryptionKeyLength;
std::string serverCertificateId;
std::string encryptionAlgorithm;
std::string serverCertificateName;
std::string regionId;
std::string expireTime;
std::vector<ServerCertificate::Tag> tags;
long createTimeStamp;
std::string commonName;
};
DescribeServerCertificatesResult();
explicit DescribeServerCertificatesResult(const std::string &payload);
~DescribeServerCertificatesResult();
std::vector<ServerCertificate> getServerCertificates()const;
protected:
void parse(const std::string &payload);
private:
std::vector<ServerCertificate> serverCertificates_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBESERVERCERTIFICATESRESULT_H_

View File

@@ -0,0 +1,72 @@
/*
* 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 <alibabacloud/slb/SlbExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Slb {
namespace Model {
class ALIBABACLOUD_SLB_EXPORT DescribeTagsRequest : public RpcServiceRequest {
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);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getPageSize() const;
void setPageSize(int pageSize);
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);
std::string getTags() const;
void setTags(const std::string &tags);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
private:
std::string access_key_id_;
long resourceOwnerId_;
int pageNumber_;
std::string regionId_;
int pageSize_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
bool distinctKey_;
long ownerId_;
std::string tags_;
std::string loadBalancerId_;
};
} // namespace Model
} // namespace Slb
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBETAGSREQUEST_H_

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