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

UpdateHubClusterFeature support ArgoCDHAEnabled.

Browse Source
This commit is contained in:
sdk-team
2023-08-10 06:14:52 +00:00
parent 4fdd237980
commit cd34c91d00
97 changed files with 6985 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

230
adcp/include/alibabacloud/adcp/AdcpClient.h Normal file
View File

@@ -0,0 +1,230 @@
/*
* 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_ADCP_ADCPCLIENT_H_
#define ALIBABACLOUD_ADCP_ADCPCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "AdcpExport.h"
#include "model/AttachClusterToHubRequest.h"
#include "model/AttachClusterToHubResult.h"
#include "model/CreateHubClusterRequest.h"
#include "model/CreateHubClusterResult.h"
#include "model/DeleteHubClusterRequest.h"
#include "model/DeleteHubClusterResult.h"
#include "model/DeletePolicyInstanceRequest.h"
#include "model/DeletePolicyInstanceResult.h"
#include "model/DeleteUserPermissionRequest.h"
#include "model/DeleteUserPermissionResult.h"
#include "model/DeployPolicyInstanceRequest.h"
#include "model/DeployPolicyInstanceResult.h"
#include "model/DescribeHubClusterDetailsRequest.h"
#include "model/DescribeHubClusterDetailsResult.h"
#include "model/DescribeHubClusterKubeconfigRequest.h"
#include "model/DescribeHubClusterKubeconfigResult.h"
#include "model/DescribeHubClusterLogsRequest.h"
#include "model/DescribeHubClusterLogsResult.h"
#include "model/DescribeHubClustersRequest.h"
#include "model/DescribeHubClustersResult.h"
#include "model/DescribeManagedClustersRequest.h"
#include "model/DescribeManagedClustersResult.h"
#include "model/DescribePoliciesRequest.h"
#include "model/DescribePoliciesResult.h"
#include "model/DescribePolicyDetailsRequest.h"
#include "model/DescribePolicyDetailsResult.h"
#include "model/DescribePolicyGovernanceInClusterRequest.h"
#include "model/DescribePolicyGovernanceInClusterResult.h"
#include "model/DescribePolicyInstancesRequest.h"
#include "model/DescribePolicyInstancesResult.h"
#include "model/DescribePolicyInstancesStatusRequest.h"
#include "model/DescribePolicyInstancesStatusResult.h"
#include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h"
#include "model/DescribeUserPermissionsRequest.h"
#include "model/DescribeUserPermissionsResult.h"
#include "model/DetachClusterFromHubRequest.h"
#include "model/DetachClusterFromHubResult.h"
#include "model/GrantUserPermissionRequest.h"
#include "model/GrantUserPermissionResult.h"
#include "model/GrantUserPermissionsRequest.h"
#include "model/GrantUserPermissionsResult.h"
#include "model/UpdateHubClusterFeatureRequest.h"
#include "model/UpdateHubClusterFeatureResult.h"
#include "model/UpdateUserPermissionRequest.h"
#include "model/UpdateUserPermissionResult.h"
namespace AlibabaCloud
{
namespace Adcp
{
class ALIBABACLOUD_ADCP_EXPORT AdcpClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::AttachClusterToHubResult> AttachClusterToHubOutcome;
typedef std::future<AttachClusterToHubOutcome> AttachClusterToHubOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::AttachClusterToHubRequest&, const AttachClusterToHubOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachClusterToHubAsyncHandler;
typedef Outcome<Error, Model::CreateHubClusterResult> CreateHubClusterOutcome;
typedef std::future<CreateHubClusterOutcome> CreateHubClusterOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::CreateHubClusterRequest&, const CreateHubClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateHubClusterAsyncHandler;
typedef Outcome<Error, Model::DeleteHubClusterResult> DeleteHubClusterOutcome;
typedef std::future<DeleteHubClusterOutcome> DeleteHubClusterOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::DeleteHubClusterRequest&, const DeleteHubClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteHubClusterAsyncHandler;
typedef Outcome<Error, Model::DeletePolicyInstanceResult> DeletePolicyInstanceOutcome;
typedef std::future<DeletePolicyInstanceOutcome> DeletePolicyInstanceOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::DeletePolicyInstanceRequest&, const DeletePolicyInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeletePolicyInstanceAsyncHandler;
typedef Outcome<Error, Model::DeleteUserPermissionResult> DeleteUserPermissionOutcome;
typedef std::future<DeleteUserPermissionOutcome> DeleteUserPermissionOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::DeleteUserPermissionRequest&, const DeleteUserPermissionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteUserPermissionAsyncHandler;
typedef Outcome<Error, Model::DeployPolicyInstanceResult> DeployPolicyInstanceOutcome;
typedef std::future<DeployPolicyInstanceOutcome> DeployPolicyInstanceOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::DeployPolicyInstanceRequest&, const DeployPolicyInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeployPolicyInstanceAsyncHandler;
typedef Outcome<Error, Model::DescribeHubClusterDetailsResult> DescribeHubClusterDetailsOutcome;
typedef std::future<DescribeHubClusterDetailsOutcome> DescribeHubClusterDetailsOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::DescribeHubClusterDetailsRequest&, const DescribeHubClusterDetailsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeHubClusterDetailsAsyncHandler;
typedef Outcome<Error, Model::DescribeHubClusterKubeconfigResult> DescribeHubClusterKubeconfigOutcome;
typedef std::future<DescribeHubClusterKubeconfigOutcome> DescribeHubClusterKubeconfigOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::DescribeHubClusterKubeconfigRequest&, const DescribeHubClusterKubeconfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeHubClusterKubeconfigAsyncHandler;
typedef Outcome<Error, Model::DescribeHubClusterLogsResult> DescribeHubClusterLogsOutcome;
typedef std::future<DescribeHubClusterLogsOutcome> DescribeHubClusterLogsOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::DescribeHubClusterLogsRequest&, const DescribeHubClusterLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeHubClusterLogsAsyncHandler;
typedef Outcome<Error, Model::DescribeHubClustersResult> DescribeHubClustersOutcome;
typedef std::future<DescribeHubClustersOutcome> DescribeHubClustersOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::DescribeHubClustersRequest&, const DescribeHubClustersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeHubClustersAsyncHandler;
typedef Outcome<Error, Model::DescribeManagedClustersResult> DescribeManagedClustersOutcome;
typedef std::future<DescribeManagedClustersOutcome> DescribeManagedClustersOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::DescribeManagedClustersRequest&, const DescribeManagedClustersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeManagedClustersAsyncHandler;
typedef Outcome<Error, Model::DescribePoliciesResult> DescribePoliciesOutcome;
typedef std::future<DescribePoliciesOutcome> DescribePoliciesOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::DescribePoliciesRequest&, const DescribePoliciesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePoliciesAsyncHandler;
typedef Outcome<Error, Model::DescribePolicyDetailsResult> DescribePolicyDetailsOutcome;
typedef std::future<DescribePolicyDetailsOutcome> DescribePolicyDetailsOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::DescribePolicyDetailsRequest&, const DescribePolicyDetailsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePolicyDetailsAsyncHandler;
typedef Outcome<Error, Model::DescribePolicyGovernanceInClusterResult> DescribePolicyGovernanceInClusterOutcome;
typedef std::future<DescribePolicyGovernanceInClusterOutcome> DescribePolicyGovernanceInClusterOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::DescribePolicyGovernanceInClusterRequest&, const DescribePolicyGovernanceInClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePolicyGovernanceInClusterAsyncHandler;
typedef Outcome<Error, Model::DescribePolicyInstancesResult> DescribePolicyInstancesOutcome;
typedef std::future<DescribePolicyInstancesOutcome> DescribePolicyInstancesOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::DescribePolicyInstancesRequest&, const DescribePolicyInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePolicyInstancesAsyncHandler;
typedef Outcome<Error, Model::DescribePolicyInstancesStatusResult> DescribePolicyInstancesStatusOutcome;
typedef std::future<DescribePolicyInstancesStatusOutcome> DescribePolicyInstancesStatusOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::DescribePolicyInstancesStatusRequest&, const DescribePolicyInstancesStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePolicyInstancesStatusAsyncHandler;
typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
typedef Outcome<Error, Model::DescribeUserPermissionsResult> DescribeUserPermissionsOutcome;
typedef std::future<DescribeUserPermissionsOutcome> DescribeUserPermissionsOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::DescribeUserPermissionsRequest&, const DescribeUserPermissionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeUserPermissionsAsyncHandler;
typedef Outcome<Error, Model::DetachClusterFromHubResult> DetachClusterFromHubOutcome;
typedef std::future<DetachClusterFromHubOutcome> DetachClusterFromHubOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::DetachClusterFromHubRequest&, const DetachClusterFromHubOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachClusterFromHubAsyncHandler;
typedef Outcome<Error, Model::GrantUserPermissionResult> GrantUserPermissionOutcome;
typedef std::future<GrantUserPermissionOutcome> GrantUserPermissionOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::GrantUserPermissionRequest&, const GrantUserPermissionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GrantUserPermissionAsyncHandler;
typedef Outcome<Error, Model::GrantUserPermissionsResult> GrantUserPermissionsOutcome;
typedef std::future<GrantUserPermissionsOutcome> GrantUserPermissionsOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::GrantUserPermissionsRequest&, const GrantUserPermissionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GrantUserPermissionsAsyncHandler;
typedef Outcome<Error, Model::UpdateHubClusterFeatureResult> UpdateHubClusterFeatureOutcome;
typedef std::future<UpdateHubClusterFeatureOutcome> UpdateHubClusterFeatureOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::UpdateHubClusterFeatureRequest&, const UpdateHubClusterFeatureOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateHubClusterFeatureAsyncHandler;
typedef Outcome<Error, Model::UpdateUserPermissionResult> UpdateUserPermissionOutcome;
typedef std::future<UpdateUserPermissionOutcome> UpdateUserPermissionOutcomeCallable;
typedef std::function<void(const AdcpClient*, const Model::UpdateUserPermissionRequest&, const UpdateUserPermissionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateUserPermissionAsyncHandler;
AdcpClient(const Credentials &credentials, const ClientConfiguration &configuration);
AdcpClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
AdcpClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~AdcpClient();
AttachClusterToHubOutcome attachClusterToHub(const Model::AttachClusterToHubRequest &request)const;
void attachClusterToHubAsync(const Model::AttachClusterToHubRequest& request, const AttachClusterToHubAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AttachClusterToHubOutcomeCallable attachClusterToHubCallable(const Model::AttachClusterToHubRequest& request) const;
CreateHubClusterOutcome createHubCluster(const Model::CreateHubClusterRequest &request)const;
void createHubClusterAsync(const Model::CreateHubClusterRequest& request, const CreateHubClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateHubClusterOutcomeCallable createHubClusterCallable(const Model::CreateHubClusterRequest& request) const;
DeleteHubClusterOutcome deleteHubCluster(const Model::DeleteHubClusterRequest &request)const;
void deleteHubClusterAsync(const Model::DeleteHubClusterRequest& request, const DeleteHubClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteHubClusterOutcomeCallable deleteHubClusterCallable(const Model::DeleteHubClusterRequest& request) const;
DeletePolicyInstanceOutcome deletePolicyInstance(const Model::DeletePolicyInstanceRequest &request)const;
void deletePolicyInstanceAsync(const Model::DeletePolicyInstanceRequest& request, const DeletePolicyInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeletePolicyInstanceOutcomeCallable deletePolicyInstanceCallable(const Model::DeletePolicyInstanceRequest& request) const;
DeleteUserPermissionOutcome deleteUserPermission(const Model::DeleteUserPermissionRequest &request)const;
void deleteUserPermissionAsync(const Model::DeleteUserPermissionRequest& request, const DeleteUserPermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteUserPermissionOutcomeCallable deleteUserPermissionCallable(const Model::DeleteUserPermissionRequest& request) const;
DeployPolicyInstanceOutcome deployPolicyInstance(const Model::DeployPolicyInstanceRequest &request)const;
void deployPolicyInstanceAsync(const Model::DeployPolicyInstanceRequest& request, const DeployPolicyInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeployPolicyInstanceOutcomeCallable deployPolicyInstanceCallable(const Model::DeployPolicyInstanceRequest& request) const;
DescribeHubClusterDetailsOutcome describeHubClusterDetails(const Model::DescribeHubClusterDetailsRequest &request)const;
void describeHubClusterDetailsAsync(const Model::DescribeHubClusterDetailsRequest& request, const DescribeHubClusterDetailsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeHubClusterDetailsOutcomeCallable describeHubClusterDetailsCallable(const Model::DescribeHubClusterDetailsRequest& request) const;
DescribeHubClusterKubeconfigOutcome describeHubClusterKubeconfig(const Model::DescribeHubClusterKubeconfigRequest &request)const;
void describeHubClusterKubeconfigAsync(const Model::DescribeHubClusterKubeconfigRequest& request, const DescribeHubClusterKubeconfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeHubClusterKubeconfigOutcomeCallable describeHubClusterKubeconfigCallable(const Model::DescribeHubClusterKubeconfigRequest& request) const;
DescribeHubClusterLogsOutcome describeHubClusterLogs(const Model::DescribeHubClusterLogsRequest &request)const;
void describeHubClusterLogsAsync(const Model::DescribeHubClusterLogsRequest& request, const DescribeHubClusterLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeHubClusterLogsOutcomeCallable describeHubClusterLogsCallable(const Model::DescribeHubClusterLogsRequest& request) const;
DescribeHubClustersOutcome describeHubClusters(const Model::DescribeHubClustersRequest &request)const;
void describeHubClustersAsync(const Model::DescribeHubClustersRequest& request, const DescribeHubClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeHubClustersOutcomeCallable describeHubClustersCallable(const Model::DescribeHubClustersRequest& request) const;
DescribeManagedClustersOutcome describeManagedClusters(const Model::DescribeManagedClustersRequest &request)const;
void describeManagedClustersAsync(const Model::DescribeManagedClustersRequest& request, const DescribeManagedClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeManagedClustersOutcomeCallable describeManagedClustersCallable(const Model::DescribeManagedClustersRequest& request) const;
DescribePoliciesOutcome describePolicies(const Model::DescribePoliciesRequest &request)const;
void describePoliciesAsync(const Model::DescribePoliciesRequest& request, const DescribePoliciesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribePoliciesOutcomeCallable describePoliciesCallable(const Model::DescribePoliciesRequest& request) const;
DescribePolicyDetailsOutcome describePolicyDetails(const Model::DescribePolicyDetailsRequest &request)const;
void describePolicyDetailsAsync(const Model::DescribePolicyDetailsRequest& request, const DescribePolicyDetailsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribePolicyDetailsOutcomeCallable describePolicyDetailsCallable(const Model::DescribePolicyDetailsRequest& request) const;
DescribePolicyGovernanceInClusterOutcome describePolicyGovernanceInCluster(const Model::DescribePolicyGovernanceInClusterRequest &request)const;
void describePolicyGovernanceInClusterAsync(const Model::DescribePolicyGovernanceInClusterRequest& request, const DescribePolicyGovernanceInClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribePolicyGovernanceInClusterOutcomeCallable describePolicyGovernanceInClusterCallable(const Model::DescribePolicyGovernanceInClusterRequest& request) const;
DescribePolicyInstancesOutcome describePolicyInstances(const Model::DescribePolicyInstancesRequest &request)const;
void describePolicyInstancesAsync(const Model::DescribePolicyInstancesRequest& request, const DescribePolicyInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribePolicyInstancesOutcomeCallable describePolicyInstancesCallable(const Model::DescribePolicyInstancesRequest& request) const;
DescribePolicyInstancesStatusOutcome describePolicyInstancesStatus(const Model::DescribePolicyInstancesStatusRequest &request)const;
void describePolicyInstancesStatusAsync(const Model::DescribePolicyInstancesStatusRequest& request, const DescribePolicyInstancesStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribePolicyInstancesStatusOutcomeCallable describePolicyInstancesStatusCallable(const Model::DescribePolicyInstancesStatusRequest& request) const;
DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
DescribeUserPermissionsOutcome describeUserPermissions(const Model::DescribeUserPermissionsRequest &request)const;
void describeUserPermissionsAsync(const Model::DescribeUserPermissionsRequest& request, const DescribeUserPermissionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeUserPermissionsOutcomeCallable describeUserPermissionsCallable(const Model::DescribeUserPermissionsRequest& request) const;
DetachClusterFromHubOutcome detachClusterFromHub(const Model::DetachClusterFromHubRequest &request)const;
void detachClusterFromHubAsync(const Model::DetachClusterFromHubRequest& request, const DetachClusterFromHubAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetachClusterFromHubOutcomeCallable detachClusterFromHubCallable(const Model::DetachClusterFromHubRequest& request) const;
GrantUserPermissionOutcome grantUserPermission(const Model::GrantUserPermissionRequest &request)const;
void grantUserPermissionAsync(const Model::GrantUserPermissionRequest& request, const GrantUserPermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GrantUserPermissionOutcomeCallable grantUserPermissionCallable(const Model::GrantUserPermissionRequest& request) const;
GrantUserPermissionsOutcome grantUserPermissions(const Model::GrantUserPermissionsRequest &request)const;
void grantUserPermissionsAsync(const Model::GrantUserPermissionsRequest& request, const GrantUserPermissionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GrantUserPermissionsOutcomeCallable grantUserPermissionsCallable(const Model::GrantUserPermissionsRequest& request) const;
UpdateHubClusterFeatureOutcome updateHubClusterFeature(const Model::UpdateHubClusterFeatureRequest &request)const;
void updateHubClusterFeatureAsync(const Model::UpdateHubClusterFeatureRequest& request, const UpdateHubClusterFeatureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateHubClusterFeatureOutcomeCallable updateHubClusterFeatureCallable(const Model::UpdateHubClusterFeatureRequest& request) const;
UpdateUserPermissionOutcome updateUserPermission(const Model::UpdateUserPermissionRequest &request)const;
void updateUserPermissionAsync(const Model::UpdateUserPermissionRequest& request, const UpdateUserPermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateUserPermissionOutcomeCallable updateUserPermissionCallable(const Model::UpdateUserPermissionRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_ADCP_ADCPCLIENT_H_

32
adcp/include/alibabacloud/adcp/AdcpExport.h Normal file
View File

@@ -0,0 +1,32 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADCP_ADCPEXPORT_H_
#define ALIBABACLOUD_ADCP_ADCPEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_ADCP_LIBRARY)
# define ALIBABACLOUD_ADCP_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_ADCP_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_ADCP_EXPORT
#endif
#endif // !ALIBABACLOUD_ADCP_ADCPEXPORT_H_

48
adcp/include/alibabacloud/adcp/model/AttachClusterToHubRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* 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_ADCP_MODEL_ATTACHCLUSTERTOHUBREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_ATTACHCLUSTERTOHUBREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT AttachClusterToHubRequest : public RpcServiceRequest {
public:
AttachClusterToHubRequest();
~AttachClusterToHubRequest();
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
std::string getClusterIds() const;
void setClusterIds(const std::string &clusterIds);
bool getAttachToMesh() const;
void setAttachToMesh(bool attachToMesh);
private:
std::string clusterId_;
std::string clusterIds_;
bool attachToMesh_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_ATTACHCLUSTERTOHUBREQUEST_H_

55
adcp/include/alibabacloud/adcp/model/AttachClusterToHubResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADCP_MODEL_ATTACHCLUSTERTOHUBRESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_ATTACHCLUSTERTOHUBRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT AttachClusterToHubResult : public ServiceResult
{
public:
AttachClusterToHubResult();
explicit AttachClusterToHubResult(const std::string &payload);
~AttachClusterToHubResult();
std::string getTaskId()const;
std::string getClusterId()const;
std::vector<std::string> getManagedClusterIds()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
std::string clusterId_;
std::vector<std::string> managedClusterIds_;
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_ATTACHCLUSTERTOHUBRESULT_H_

121
adcp/include/alibabacloud/adcp/model/CreateHubClusterRequest.h Normal file
View File

@@ -0,0 +1,121 @@
/*
* 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_ADCP_MODEL_CREATEHUBCLUSTERREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_CREATEHUBCLUSTERREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT CreateHubClusterRequest : public RpcServiceRequest {
public:
struct WorkflowUnits {
std::string regionId;
std::string vpcId;
struct VSwitchesItem {
std::string vswitchId;
std::string zoneId;
};
VSwitchesItem vSwitchesItem;
std::vector<VSwitchesItem> vSwitches;
};
CreateHubClusterRequest();
~CreateHubClusterRequest();
std::string getAuditLogProject() const;
void setAuditLogProject(const std::string &auditLogProject);
std::string getLoadBalancerSpec() const;
void setLoadBalancerSpec(const std::string &loadBalancerSpec);
std::string getKubernetesVersion() const;
void setKubernetesVersion(const std::string &kubernetesVersion);
std::string getProfile() const;
void setProfile(const std::string &profile);
std::string getVSwitches() const;
void setVSwitches(const std::string &vSwitches);
std::string getControlPlaneLogProject() const;
void setControlPlaneLogProject(const std::string &controlPlaneLogProject);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
std::string getClusterSpec() const;
void setClusterSpec(const std::string &clusterSpec);
std::string getName() const;
void setName(const std::string &name);
std::string getClusterDomain() const;
void setClusterDomain(const std::string &clusterDomain);
std::string getControlPlaneLogTTL() const;
void setControlPlaneLogTTL(const std::string &controlPlaneLogTTL);
std::vector<WorkflowUnits> getWorkflowUnits() const;
void setWorkflowUnits(const std::vector<WorkflowUnits> &workflowUnits);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getAuditLogStoreTTL() const;
void setAuditLogStoreTTL(const std::string &auditLogStoreTTL);
std::string getIPStack() const;
void setIPStack(const std::string &iPStack);
bool getControlPlaneLogEnabled() const;
void setControlPlaneLogEnabled(bool controlPlaneLogEnabled);
bool getArgoServerEnabled() const;
void setArgoServerEnabled(bool argoServerEnabled);
std::string getWorkflowScheduleMode() const;
void setWorkflowScheduleMode(const std::string &workflowScheduleMode);
bool getApiServerPublicEip() const;
void setApiServerPublicEip(bool apiServerPublicEip);
bool getAuditLogEnabled() const;
void setAuditLogEnabled(bool auditLogEnabled);
std::string getSecurityGroupIDs() const;
void setSecurityGroupIDs(const std::string &securityGroupIDs);
std::string getPriceLimit() const;
void setPriceLimit(const std::string &priceLimit);
bool getIsEnterpriseSecurityGroup() const;
void setIsEnterpriseSecurityGroup(bool isEnterpriseSecurityGroup);
std::string getVpcId() const;
void setVpcId(const std::string &vpcId);
private:
std::string auditLogProject_;
std::string loadBalancerSpec_;
std::string kubernetesVersion_;
std::string profile_;
std::string vSwitches_;
std::string controlPlaneLogProject_;
std::string loadBalancerId_;
std::string clusterSpec_;
std::string name_;
std::string clusterDomain_;
std::string controlPlaneLogTTL_;
std::vector<WorkflowUnits> workflowUnits_;
std::string regionId_;
std::string auditLogStoreTTL_;
std::string iPStack_;
bool controlPlaneLogEnabled_;
bool argoServerEnabled_;
std::string workflowScheduleMode_;
bool apiServerPublicEip_;
bool auditLogEnabled_;
std::string securityGroupIDs_;
std::string priceLimit_;
bool isEnterpriseSecurityGroup_;
std::string vpcId_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_CREATEHUBCLUSTERREQUEST_H_

53
adcp/include/alibabacloud/adcp/model/CreateHubClusterResult.h Normal file
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_ADCP_MODEL_CREATEHUBCLUSTERRESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_CREATEHUBCLUSTERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT CreateHubClusterResult : public ServiceResult
{
public:
CreateHubClusterResult();
explicit CreateHubClusterResult(const std::string &payload);
~CreateHubClusterResult();
std::string getTaskId()const;
std::string getClusterId()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
std::string clusterId_;
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_CREATEHUBCLUSTERRESULT_H_

48
adcp/include/alibabacloud/adcp/model/DeleteHubClusterRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* 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_ADCP_MODEL_DELETEHUBCLUSTERREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_DELETEHUBCLUSTERREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT DeleteHubClusterRequest : public RpcServiceRequest {
public:
DeleteHubClusterRequest();
~DeleteHubClusterRequest();
std::vector<std::string> getRetainResources() const;
void setRetainResources(const std::vector<std::string> &retainResources);
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
bool getForce() const;
void setForce(bool force);
private:
std::vector<std::string> retainResources_;
std::string clusterId_;
bool force_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_DELETEHUBCLUSTERREQUEST_H_

53
adcp/include/alibabacloud/adcp/model/DeleteHubClusterResult.h Normal file
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_ADCP_MODEL_DELETEHUBCLUSTERRESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_DELETEHUBCLUSTERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT DeleteHubClusterResult : public ServiceResult
{
public:
DeleteHubClusterResult();
explicit DeleteHubClusterResult(const std::string &payload);
~DeleteHubClusterResult();
std::string getTaskId()const;
std::string getClusterId()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
std::string clusterId_;
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_DELETEHUBCLUSTERRESULT_H_

48
adcp/include/alibabacloud/adcp/model/DeletePolicyInstanceRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* 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_ADCP_MODEL_DELETEPOLICYINSTANCEREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_DELETEPOLICYINSTANCEREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT DeletePolicyInstanceRequest : public RpcServiceRequest {
public:
DeletePolicyInstanceRequest();
~DeletePolicyInstanceRequest();
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
std::vector<std::string> getClusterIds() const;
void setClusterIds(const std::vector<std::string> &clusterIds);
std::string getPolicyName() const;
void setPolicyName(const std::string &policyName);
private:
std::string clusterId_;
std::vector<std::string> clusterIds_;
std::string policyName_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_DELETEPOLICYINSTANCEREQUEST_H_

49
adcp/include/alibabacloud/adcp/model/DeletePolicyInstanceResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADCP_MODEL_DELETEPOLICYINSTANCERESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_DELETEPOLICYINSTANCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT DeletePolicyInstanceResult : public ServiceResult
{
public:
DeletePolicyInstanceResult();
explicit DeletePolicyInstanceResult(const std::string &payload);
~DeletePolicyInstanceResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_DELETEPOLICYINSTANCERESULT_H_

45
adcp/include/alibabacloud/adcp/model/DeleteUserPermissionRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* 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_ADCP_MODEL_DELETEUSERPERMISSIONREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_DELETEUSERPERMISSIONREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT DeleteUserPermissionRequest : public RpcServiceRequest {
public:
DeleteUserPermissionRequest();
~DeleteUserPermissionRequest();
std::string getUserId() const;
void setUserId(const std::string &userId);
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
private:
std::string userId_;
std::string clusterId_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_DELETEUSERPERMISSIONREQUEST_H_

49
adcp/include/alibabacloud/adcp/model/DeleteUserPermissionResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADCP_MODEL_DELETEUSERPERMISSIONRESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_DELETEUSERPERMISSIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT DeleteUserPermissionResult : public ServiceResult
{
public:
DeleteUserPermissionResult();
explicit DeleteUserPermissionResult(const std::string &payload);
~DeleteUserPermissionResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_DELETEUSERPERMISSIONRESULT_H_

54
adcp/include/alibabacloud/adcp/model/DeployPolicyInstanceRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* 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_ADCP_MODEL_DEPLOYPOLICYINSTANCEREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_DEPLOYPOLICYINSTANCEREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT DeployPolicyInstanceRequest : public RpcServiceRequest {
public:
DeployPolicyInstanceRequest();
~DeployPolicyInstanceRequest();
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
std::string getPolicyAction() const;
void setPolicyAction(const std::string &policyAction);
std::vector<std::string> getClusterIds() const;
void setClusterIds(const std::vector<std::string> &clusterIds);
std::string getPolicyName() const;
void setPolicyName(const std::string &policyName);
std::vector<std::string> getNamespaces() const;
void setNamespaces(const std::vector<std::string> &namespaces);
private:
std::string clusterId_;
std::string policyAction_;
std::vector<std::string> clusterIds_;
std::string policyName_;
std::vector<std::string> namespaces_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_DEPLOYPOLICYINSTANCEREQUEST_H_

49
adcp/include/alibabacloud/adcp/model/DeployPolicyInstanceResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADCP_MODEL_DEPLOYPOLICYINSTANCERESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_DEPLOYPOLICYINSTANCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT DeployPolicyInstanceResult : public ServiceResult
{
public:
DeployPolicyInstanceResult();
explicit DeployPolicyInstanceResult(const std::string &payload);
~DeployPolicyInstanceResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_DEPLOYPOLICYINSTANCERESULT_H_

42
adcp/include/alibabacloud/adcp/model/DescribeHubClusterDetailsRequest.h Normal file
View File

@@ -0,0 +1,42 @@
/*
* 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_ADCP_MODEL_DESCRIBEHUBCLUSTERDETAILSREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERDETAILSREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT DescribeHubClusterDetailsRequest : public RpcServiceRequest {
public:
DescribeHubClusterDetailsRequest();
~DescribeHubClusterDetailsRequest();
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
private:
std::string clusterId_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERDETAILSREQUEST_H_

130
adcp/include/alibabacloud/adcp/model/DescribeHubClusterDetailsResult.h Normal file
View File

@@ -0,0 +1,130 @@
/*
* 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_ADCP_MODEL_DESCRIBEHUBCLUSTERDETAILSRESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERDETAILSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT DescribeHubClusterDetailsResult : public ServiceResult
{
public:
struct Cluster
{
struct Endpoints
{
std::string intranetApiServerEndpoint;
std::string publicApiServerEndpoint;
};
struct ClusterInfo
{
std::string version;
std::string clusterId;
std::string state;
std::string creationTime;
std::string updateTime;
std::string regionId;
std::string clusterSpec;
std::string errorMessage;
std::string profile;
std::string name;
};
struct Network
{
std::string iPStack;
std::string vpcId;
std::string clusterDomain;
std::vector<std::string> vSwitches;
std::vector<std::string> securityGroupIDs;
};
struct ApiServer
{
std::string apiServerEipId;
bool enabledPublic;
std::string loadBalancerId;
};
struct MeshConfig
{
std::string meshId;
bool enableMesh;
};
struct LogConfig
{
std::string logStoreTTL;
bool enableLog;
std::string logProject;
};
struct WorkflowConfig
{
struct WorkflowUnit
{
struct VSwitch
{
std::string zoneId;
std::string vswitchId;
};
std::string vpcId;
std::vector<WorkflowUnit::VSwitch> vSwitches1;
std::string regionId;
};
std::vector<WorkflowUnit> workflowUnits;
std::string priceLimit;
bool argoServerEnabled;
std::string workflowScheduleMode;
};
struct Condition
{
std::string status;
std::string type;
std::string message;
std::string reason;
};
Endpoints endpoints;
WorkflowConfig workflowConfig;
ClusterInfo clusterInfo;
ApiServer apiServer;
MeshConfig meshConfig;
Network network;
std::vector<Condition> conditions;
LogConfig logConfig;
};
DescribeHubClusterDetailsResult();
explicit DescribeHubClusterDetailsResult(const std::string &payload);
~DescribeHubClusterDetailsResult();
Cluster getCluster()const;
protected:
void parse(const std::string &payload);
private:
Cluster cluster_;
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERDETAILSRESULT_H_

45
adcp/include/alibabacloud/adcp/model/DescribeHubClusterKubeconfigRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* 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_ADCP_MODEL_DESCRIBEHUBCLUSTERKUBECONFIGREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERKUBECONFIGREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT DescribeHubClusterKubeconfigRequest : public RpcServiceRequest {
public:
DescribeHubClusterKubeconfigRequest();
~DescribeHubClusterKubeconfigRequest();
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
bool getPrivateIpAddress() const;
void setPrivateIpAddress(bool privateIpAddress);
private:
std::string clusterId_;
bool privateIpAddress_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERKUBECONFIGREQUEST_H_

51
adcp/include/alibabacloud/adcp/model/DescribeHubClusterKubeconfigResult.h Normal file
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_ADCP_MODEL_DESCRIBEHUBCLUSTERKUBECONFIGRESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERKUBECONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT DescribeHubClusterKubeconfigResult : public ServiceResult
{
public:
DescribeHubClusterKubeconfigResult();
explicit DescribeHubClusterKubeconfigResult(const std::string &payload);
~DescribeHubClusterKubeconfigResult();
std::string getKubeconfig()const;
protected:
void parse(const std::string &payload);
private:
std::string kubeconfig_;
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERKUBECONFIGRESULT_H_

42
adcp/include/alibabacloud/adcp/model/DescribeHubClusterLogsRequest.h Normal file
View File

@@ -0,0 +1,42 @@
/*
* 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_ADCP_MODEL_DESCRIBEHUBCLUSTERLOGSREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERLOGSREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT DescribeHubClusterLogsRequest : public RpcServiceRequest {
public:
DescribeHubClusterLogsRequest();
~DescribeHubClusterLogsRequest();
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
private:
std::string clusterId_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERLOGSREQUEST_H_

58
adcp/include/alibabacloud/adcp/model/DescribeHubClusterLogsResult.h Normal file
View File

@@ -0,0 +1,58 @@
/*
* 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_ADCP_MODEL_DESCRIBEHUBCLUSTERLOGSRESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERLOGSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT DescribeHubClusterLogsResult : public ServiceResult
{
public:
struct Log
{
std::string clusterId;
std::string creationTime;
std::string clusterLog;
std::string logLevel;
};
DescribeHubClusterLogsResult();
explicit DescribeHubClusterLogsResult(const std::string &payload);
~DescribeHubClusterLogsResult();
std::vector<Log> getLogs()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Log> logs_;
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERLOGSRESULT_H_

42
adcp/include/alibabacloud/adcp/model/DescribeHubClustersRequest.h Normal file
View File

@@ -0,0 +1,42 @@
/*
* 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_ADCP_MODEL_DESCRIBEHUBCLUSTERSREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERSREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT DescribeHubClustersRequest : public RpcServiceRequest {
public:
DescribeHubClustersRequest();
~DescribeHubClustersRequest();
std::string getProfile() const;
void setProfile(const std::string &profile);
private:
std::string profile_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERSREQUEST_H_

110
adcp/include/alibabacloud/adcp/model/DescribeHubClustersResult.h Normal file
View File

@@ -0,0 +1,110 @@
/*
* 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_ADCP_MODEL_DESCRIBEHUBCLUSTERSRESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT DescribeHubClustersResult : public ServiceResult
{
public:
struct Cluster
{
struct Endpoints
{
std::string intranetApiServerEndpoint;
std::string publicApiServerEndpoint;
};
struct ClusterInfo
{
std::string version;
std::string clusterId;
std::string state;
std::string creationTime;
std::string updateTime;
std::string regionId;
std::string clusterSpec;
std::string errorMessage;
std::string profile;
std::string name;
};
struct Network
{
std::string vpcId;
std::string clusterDomain;
std::vector<std::string> vSwitches;
std::vector<std::string> securityGroupIDs;
};
struct ApiServer
{
std::string apiServerEipId;
bool enabledPublic;
std::string loadBalancerId;
};
struct MeshConfig
{
std::string meshId;
bool enableMesh;
};
struct LogConfig
{
std::string logStoreTTL;
bool enableLog;
std::string logProject;
};
struct Condition
{
std::string status;
std::string type;
std::string message;
std::string reason;
};
Endpoints endpoints;
ClusterInfo clusterInfo;
ApiServer apiServer;
MeshConfig meshConfig;
Network network;
std::vector<Cluster::Condition> conditions;
LogConfig logConfig;
};
DescribeHubClustersResult();
explicit DescribeHubClustersResult(const std::string &payload);
~DescribeHubClustersResult();
std::vector<Cluster> getClusters()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Cluster> clusters_;
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEHUBCLUSTERSRESULT_H_

42
adcp/include/alibabacloud/adcp/model/DescribeManagedClustersRequest.h Normal file
View File

@@ -0,0 +1,42 @@
/*
* 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_ADCP_MODEL_DESCRIBEMANAGEDCLUSTERSREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEMANAGEDCLUSTERSREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT DescribeManagedClustersRequest : public RpcServiceRequest {
public:
DescribeManagedClustersRequest();
~DescribeManagedClustersRequest();
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
private:
std::string clusterId_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEMANAGEDCLUSTERSREQUEST_H_

83
adcp/include/alibabacloud/adcp/model/DescribeManagedClustersResult.h Normal file
View File

@@ -0,0 +1,83 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADCP_MODEL_DESCRIBEMANAGEDCLUSTERSRESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEMANAGEDCLUSTERSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT DescribeManagedClustersResult : public ServiceResult
{
public:
struct Cluster
{
struct Cluster1
{
std::string updated;
std::string resourceGroupId;
std::string clusterID;
std::string initVersion;
std::string currentVersion;
std::string vSwitchID;
std::string clusterType;
std::string clusterSpec;
std::string profile;
std::string name;
std::string created;
std::string vpcID;
std::string state;
std::string region;
};
struct Status
{
std::string message;
std::string state;
};
struct MeshStatus
{
bool inMesh;
};
Status status;
Cluster1 cluster1;
MeshStatus meshStatus;
};
DescribeManagedClustersResult();
explicit DescribeManagedClustersResult(const std::string &payload);
~DescribeManagedClustersResult();
std::vector<Cluster> getClusters()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Cluster> clusters_;
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEMANAGEDCLUSTERSRESULT_H_

39
adcp/include/alibabacloud/adcp/model/DescribePoliciesRequest.h Normal file
View File

@@ -0,0 +1,39 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICIESREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICIESREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT DescribePoliciesRequest : public RpcServiceRequest {
public:
DescribePoliciesRequest();
~DescribePoliciesRequest();
private:
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICIESREQUEST_H_

56
adcp/include/alibabacloud/adcp/model/DescribePoliciesResult.h Normal file
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_ADCP_MODEL_DESCRIBEPOLICIESRESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICIESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT DescribePoliciesResult : public ServiceResult
{
public:
struct Policy
{
std::vector<std::string> names;
std::string category;
};
DescribePoliciesResult();
explicit DescribePoliciesResult(const std::string &payload);
~DescribePoliciesResult();
std::vector<Policy> getPolicies()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Policy> policies_;
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICIESRESULT_H_

42
adcp/include/alibabacloud/adcp/model/DescribePolicyDetailsRequest.h Normal file
View File

@@ -0,0 +1,42 @@
/*
* 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_ADCP_MODEL_DESCRIBEPOLICYDETAILSREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYDETAILSREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT DescribePolicyDetailsRequest : public RpcServiceRequest {
public:
DescribePolicyDetailsRequest();
~DescribePolicyDetailsRequest();
std::string getPolicyName() const;
void setPolicyName(const std::string &policyName);
private:
std::string policyName_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYDETAILSREQUEST_H_

63
adcp/include/alibabacloud/adcp/model/DescribePolicyDetailsResult.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYDETAILSRESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYDETAILSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT DescribePolicyDetailsResult : public ServiceResult
{
public:
struct Policy
{
int noConfig;
std::string action;
std::string category;
std::string description;
std::string _template;
std::string updated;
std::string severity;
std::string name;
std::string created;
};
DescribePolicyDetailsResult();
explicit DescribePolicyDetailsResult(const std::string &payload);
~DescribePolicyDetailsResult();
Policy getPolicy()const;
protected:
void parse(const std::string &payload);
private:
Policy policy_;
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYDETAILSRESULT_H_

42
adcp/include/alibabacloud/adcp/model/DescribePolicyGovernanceInClusterRequest.h Normal file
View File

@@ -0,0 +1,42 @@
/*
* 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_ADCP_MODEL_DESCRIBEPOLICYGOVERNANCEINCLUSTERREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYGOVERNANCEINCLUSTERREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT DescribePolicyGovernanceInClusterRequest : public RpcServiceRequest {
public:
DescribePolicyGovernanceInClusterRequest();
~DescribePolicyGovernanceInClusterRequest();
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
private:
std::string clusterId_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYGOVERNANCEINCLUSTERREQUEST_H_

125
adcp/include/alibabacloud/adcp/model/DescribePolicyGovernanceInClusterResult.h Normal file
View File

@@ -0,0 +1,125 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYGOVERNANCEINCLUSTERRESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYGOVERNANCEINCLUSTERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT DescribePolicyGovernanceInClusterResult : public ServiceResult
{
public:
struct PolicyGovernance
{
struct Cluster
{
std::string clusterId;
std::string state;
std::string regionId;
std::string clusterType;
std::string clusterSpec;
std::string profile;
std::string name;
};
struct PolicyGovernance1
{
struct AdmitLog
{
std::string progress;
std::string logStore;
std::string count;
std::vector<std::string> logs;
std::string logProject;
};
struct Violation
{
struct TotalViolations
{
struct DenySeverity
{
long violations;
std::string severity;
};
struct WarnSeverity
{
std::string violations;
std::string severity;
};
std::vector<DenySeverity> deny;
std::vector<WarnSeverity> warn;
};
struct Violations
{
struct DenyViolations
{
std::string policyDescription;
long violations;
std::string policyName;
std::string severity;
};
struct WarnViolations
{
std::string policyDescription;
long violations;
std::string policyName;
std::string severity;
};
std::vector<WarnViolations> warn3;
std::vector<DenyViolations> deny2;
};
Violations violations;
TotalViolations totalViolations;
};
struct State
{
long totalCount;
long enabledCount;
std::string severity;
};
Violation violation;
AdmitLog admitLog;
std::vector<State> onState;
};
PolicyGovernance1 policyGovernance1;
Cluster cluster;
};
DescribePolicyGovernanceInClusterResult();
explicit DescribePolicyGovernanceInClusterResult(const std::string &payload);
~DescribePolicyGovernanceInClusterResult();
std::vector<PolicyGovernance> getPolicyGovernances()const;
protected:
void parse(const std::string &payload);
private:
std::vector<PolicyGovernance> policyGovernances_;
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYGOVERNANCEINCLUSTERRESULT_H_

45
adcp/include/alibabacloud/adcp/model/DescribePolicyInstancesRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* 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_ADCP_MODEL_DESCRIBEPOLICYINSTANCESREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT DescribePolicyInstancesRequest : public RpcServiceRequest {
public:
DescribePolicyInstancesRequest();
~DescribePolicyInstancesRequest();
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
std::string getPolicyName() const;
void setPolicyName(const std::string &policyName);
private:
std::string clusterId_;
std::string policyName_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESREQUEST_H_

64
adcp/include/alibabacloud/adcp/model/DescribePolicyInstancesResult.h Normal file
View File

@@ -0,0 +1,64 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESRESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT DescribePolicyInstancesResult : public ServiceResult
{
public:
struct Policy
{
std::string instanceName;
std::string policyParameters;
std::string policyDescription;
std::string clusterId;
std::string policyName;
std::string policyCategory;
std::string policySeverity;
long totalViolations;
std::string policyAction;
std::string policyScope;
};
DescribePolicyInstancesResult();
explicit DescribePolicyInstancesResult(const std::string &payload);
~DescribePolicyInstancesResult();
std::vector<Policy> getPolicies()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Policy> policies_;
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESRESULT_H_

42
adcp/include/alibabacloud/adcp/model/DescribePolicyInstancesStatusRequest.h Normal file
View File

@@ -0,0 +1,42 @@
/*
* 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_ADCP_MODEL_DESCRIBEPOLICYINSTANCESSTATUSREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESSTATUSREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT DescribePolicyInstancesStatusRequest : public RpcServiceRequest {
public:
DescribePolicyInstancesStatusRequest();
~DescribePolicyInstancesStatusRequest();
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
private:
std::string clusterId_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESSTATUSREQUEST_H_

75
adcp/include/alibabacloud/adcp/model/DescribePolicyInstancesStatusResult.h Normal file
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_ADCP_MODEL_DESCRIBEPOLICYINSTANCESSTATUSRESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESSTATUSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT DescribePolicyInstancesStatusResult : public ServiceResult
{
public:
struct Policies
{
struct PolicyInstance
{
struct PolicyCluster
{
std::string status;
std::string clusterId;
};
std::string policyDescription;
std::vector<PolicyInstance::PolicyCluster> policyClusters;
std::string policyName;
std::string policyCategory;
long policyInstancesCount;
std::string policySeverity;
};
struct SeverityInfoItem
{
std::string severityType;
std::string severityCount;
};
std::vector<SeverityInfoItem> severityInfo;
std::vector<PolicyInstance> policyInstances;
};
DescribePolicyInstancesStatusResult();
explicit DescribePolicyInstancesStatusResult(const std::string &payload);
~DescribePolicyInstancesStatusResult();
Policies getPolicies()const;
protected:
void parse(const std::string &payload);
private:
Policies policies_;
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEPOLICYINSTANCESSTATUSRESULT_H_

42
adcp/include/alibabacloud/adcp/model/DescribeRegionsRequest.h Normal file
View File

@@ -0,0 +1,42 @@
/*
* 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_ADCP_MODEL_DESCRIBEREGIONSREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEREGIONSREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT DescribeRegionsRequest : public RpcServiceRequest {
public:
DescribeRegionsRequest();
~DescribeRegionsRequest();
std::string getLanguage() const;
void setLanguage(const std::string &language);
private:
std::string language_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEREGIONSREQUEST_H_

58
adcp/include/alibabacloud/adcp/model/DescribeRegionsResult.h Normal file
View File

@@ -0,0 +1,58 @@
/*
* 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_ADCP_MODEL_DESCRIBEREGIONSRESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEREGIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT DescribeRegionsResult : public ServiceResult
{
public:
struct Region
{
std::string regionId;
std::string regionEndpoint;
std::string regionVpcEndpoint;
std::string localName;
};
DescribeRegionsResult();
explicit DescribeRegionsResult(const std::string &payload);
~DescribeRegionsResult();
std::vector<Region> getRegions()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Region> regions_;
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEREGIONSRESULT_H_

42
adcp/include/alibabacloud/adcp/model/DescribeUserPermissionsRequest.h Normal file
View File

@@ -0,0 +1,42 @@
/*
* 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_ADCP_MODEL_DESCRIBEUSERPERMISSIONSREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEUSERPERMISSIONSREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT DescribeUserPermissionsRequest : public RpcServiceRequest {
public:
DescribeUserPermissionsRequest();
~DescribeUserPermissionsRequest();
std::string getUserId() const;
void setUserId(const std::string &userId);
private:
std::string userId_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEUSERPERMISSIONSREQUEST_H_

58
adcp/include/alibabacloud/adcp/model/DescribeUserPermissionsResult.h Normal file
View File

@@ -0,0 +1,58 @@
/*
* 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_ADCP_MODEL_DESCRIBEUSERPERMISSIONSRESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_DESCRIBEUSERPERMISSIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT DescribeUserPermissionsResult : public ServiceResult
{
public:
struct Permission
{
std::string roleName;
std::string resourceId;
std::string roleType;
std::string resourceType;
};
DescribeUserPermissionsResult();
explicit DescribeUserPermissionsResult(const std::string &payload);
~DescribeUserPermissionsResult();
std::vector<Permission> getPermissions()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Permission> permissions_;
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_DESCRIBEUSERPERMISSIONSRESULT_H_

48
adcp/include/alibabacloud/adcp/model/DetachClusterFromHubRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* 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_ADCP_MODEL_DETACHCLUSTERFROMHUBREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_DETACHCLUSTERFROMHUBREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT DetachClusterFromHubRequest : public RpcServiceRequest {
public:
DetachClusterFromHubRequest();
~DetachClusterFromHubRequest();
bool getDetachFromMesh() const;
void setDetachFromMesh(bool detachFromMesh);
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
std::string getClusterIds() const;
void setClusterIds(const std::string &clusterIds);
private:
bool detachFromMesh_;
std::string clusterId_;
std::string clusterIds_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_DETACHCLUSTERFROMHUBREQUEST_H_

55
adcp/include/alibabacloud/adcp/model/DetachClusterFromHubResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADCP_MODEL_DETACHCLUSTERFROMHUBRESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_DETACHCLUSTERFROMHUBRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT DetachClusterFromHubResult : public ServiceResult
{
public:
DetachClusterFromHubResult();
explicit DetachClusterFromHubResult(const std::string &payload);
~DetachClusterFromHubResult();
std::string getTaskId()const;
std::string getClusterId()const;
std::vector<std::string> getManagedClusterIds()const;
protected:
void parse(const std::string &payload);
private:
std::string taskId_;
std::string clusterId_;
std::vector<std::string> managedClusterIds_;
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_DETACHCLUSTERFROMHUBRESULT_H_

57
adcp/include/alibabacloud/adcp/model/GrantUserPermissionRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT GrantUserPermissionRequest : public RpcServiceRequest {
public:
GrantUserPermissionRequest();
~GrantUserPermissionRequest();
std::string getUserId() const;
void setUserId(const std::string &userId);
bool getIsRamRole() const;
void setIsRamRole(bool isRamRole);
std::string getRoleType() const;
void setRoleType(const std::string &roleType);
std::string getRoleName() const;
void setRoleName(const std::string &roleName);
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
std::string get_Namespace() const;
void set_Namespace(const std::string &_namespace);
private:
std::string userId_;
bool isRamRole_;
std::string roleType_;
std::string roleName_;
std::string clusterId_;
std::string _namespace_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONREQUEST_H_

49
adcp/include/alibabacloud/adcp/model/GrantUserPermissionResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONRESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT GrantUserPermissionResult : public ServiceResult
{
public:
GrantUserPermissionResult();
explicit GrantUserPermissionResult(const std::string &payload);
~GrantUserPermissionResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONRESULT_H_

52
adcp/include/alibabacloud/adcp/model/GrantUserPermissionsRequest.h Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONSREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONSREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT GrantUserPermissionsRequest : public RpcServiceRequest {
public:
struct Permissions {
bool isRamRole;
std::string roleName;
std::string _namespace;
std::string roleType;
std::string clusterId;
};
GrantUserPermissionsRequest();
~GrantUserPermissionsRequest();
std::string getUserId() const;
void setUserId(const std::string &userId);
std::vector<Permissions> getPermissions() const;
void setPermissions(const std::vector<Permissions> &permissions);
private:
std::string userId_;
std::vector<Permissions> permissions_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONSREQUEST_H_

49
adcp/include/alibabacloud/adcp/model/GrantUserPermissionsResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONSRESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT GrantUserPermissionsResult : public ServiceResult
{
public:
GrantUserPermissionsResult();
explicit GrantUserPermissionsResult(const std::string &payload);
~GrantUserPermissionsResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_GRANTUSERPERMISSIONSRESULT_H_

87
adcp/include/alibabacloud/adcp/model/UpdateHubClusterFeatureRequest.h Normal file
View File

@@ -0,0 +1,87 @@
/*
* 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_ADCP_MODEL_UPDATEHUBCLUSTERFEATUREREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_UPDATEHUBCLUSTERFEATUREREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT UpdateHubClusterFeatureRequest : public RpcServiceRequest {
public:
UpdateHubClusterFeatureRequest();
~UpdateHubClusterFeatureRequest();
std::vector<std::string> getAccessControlList() const;
void setAccessControlList(const std::vector<std::string> &accessControlList);
bool getMonitorEnabled() const;
void setMonitorEnabled(bool monitorEnabled);
bool getDeletionProtection() const;
void setDeletionProtection(bool deletionProtection);
bool getEnableMesh() const;
void setEnableMesh(bool enableMesh);
bool getArgoCDHAEnabled() const;
void setArgoCDHAEnabled(bool argoCDHAEnabled);
bool getArgoCDEnabled() const;
void setArgoCDEnabled(bool argoCDEnabled);
std::vector<std::string> getVSwitches() const;
void setVSwitches(const std::vector<std::string> &vSwitches);
std::string getName() const;
void setName(const std::string &name);
bool getPublicAccessEnabled() const;
void setPublicAccessEnabled(bool publicAccessEnabled);
bool getPublicApiServerEnabled() const;
void setPublicApiServerEnabled(bool publicApiServerEnabled);
bool getArgoServerEnabled() const;
void setArgoServerEnabled(bool argoServerEnabled);
std::string getWorkflowScheduleMode() const;
void setWorkflowScheduleMode(const std::string &workflowScheduleMode);
bool getAuditLogEnabled() const;
void setAuditLogEnabled(bool auditLogEnabled);
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
std::string getPriceLimit() const;
void setPriceLimit(const std::string &priceLimit);
std::string getApiServerEipId() const;
void setApiServerEipId(const std::string &apiServerEipId);
private:
std::vector<std::string> accessControlList_;
bool monitorEnabled_;
bool deletionProtection_;
bool enableMesh_;
bool argoCDHAEnabled_;
bool argoCDEnabled_;
std::vector<std::string> vSwitches_;
std::string name_;
bool publicAccessEnabled_;
bool publicApiServerEnabled_;
bool argoServerEnabled_;
std::string workflowScheduleMode_;
bool auditLogEnabled_;
std::string clusterId_;
std::string priceLimit_;
std::string apiServerEipId_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_UPDATEHUBCLUSTERFEATUREREQUEST_H_

49
adcp/include/alibabacloud/adcp/model/UpdateHubClusterFeatureResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADCP_MODEL_UPDATEHUBCLUSTERFEATURERESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_UPDATEHUBCLUSTERFEATURERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT UpdateHubClusterFeatureResult : public ServiceResult
{
public:
UpdateHubClusterFeatureResult();
explicit UpdateHubClusterFeatureResult(const std::string &payload);
~UpdateHubClusterFeatureResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_UPDATEHUBCLUSTERFEATURERESULT_H_

54
adcp/include/alibabacloud/adcp/model/UpdateUserPermissionRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* 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_ADCP_MODEL_UPDATEUSERPERMISSIONREQUEST_H_
#define ALIBABACLOUD_ADCP_MODEL_UPDATEUSERPERMISSIONREQUEST_H_
#include <alibabacloud/adcp/AdcpExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Adcp {
namespace Model {
class ALIBABACLOUD_ADCP_EXPORT UpdateUserPermissionRequest : public RpcServiceRequest {
public:
UpdateUserPermissionRequest();
~UpdateUserPermissionRequest();
std::string getUserId() const;
void setUserId(const std::string &userId);
std::string getRoleType() const;
void setRoleType(const std::string &roleType);
std::string getRoleName() const;
void setRoleName(const std::string &roleName);
std::string getClusterId() const;
void setClusterId(const std::string &clusterId);
std::string get_Namespace() const;
void set_Namespace(const std::string &_namespace);
private:
std::string userId_;
std::string roleType_;
std::string roleName_;
std::string clusterId_;
std::string _namespace_;
};
} // namespace Model
} // namespace Adcp
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ADCP_MODEL_UPDATEUSERPERMISSIONREQUEST_H_

49
adcp/include/alibabacloud/adcp/model/UpdateUserPermissionResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ADCP_MODEL_UPDATEUSERPERMISSIONRESULT_H_
#define ALIBABACLOUD_ADCP_MODEL_UPDATEUSERPERMISSIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/adcp/AdcpExport.h>
namespace AlibabaCloud
{
namespace Adcp
{
namespace Model
{
class ALIBABACLOUD_ADCP_EXPORT UpdateUserPermissionResult : public ServiceResult
{
public:
UpdateUserPermissionResult();
explicit UpdateUserPermissionResult(const std::string &payload);
~UpdateUserPermissionResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ADCP_MODEL_UPDATEUSERPERMISSIONRESULT_H_