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

Release Apis of Version 2019-09-10.

Browse Source
This commit is contained in:
sdk-team
2019-08-30 14:14:51 +08:00
parent 586250dbe5
commit 695aa4ad06
109 changed files with 8467 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

254
ros/include/alibabacloud/ros/ROSClient.h Normal file
View File

@@ -0,0 +1,254 @@
/*
* 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_ROS_ROSCLIENT_H_
#define ALIBABACLOUD_ROS_ROSCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "ROSExport.h"
#include "model/ListStacksRequest.h"
#include "model/ListStacksResult.h"
#include "model/GetChangeSetRequest.h"
#include "model/GetChangeSetResult.h"
#include "model/ValidateTemplateRequest.h"
#include "model/ValidateTemplateResult.h"
#include "model/UpdateStackRequest.h"
#include "model/UpdateStackResult.h"
#include "model/GetStackResourceRequest.h"
#include "model/GetStackResourceResult.h"
#include "model/ListResourceTypesRequest.h"
#include "model/ListResourceTypesResult.h"
#include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h"
#include "model/GetResourceTypeTemplateRequest.h"
#include "model/GetResourceTypeTemplateResult.h"
#include "model/CreateStackRequest.h"
#include "model/CreateStackResult.h"
#include "model/DeleteStackRequest.h"
#include "model/DeleteStackResult.h"
#include "model/GetTemplateEstimateCostRequest.h"
#include "model/GetTemplateEstimateCostResult.h"
#include "model/ContinueCreateStackRequest.h"
#include "model/ContinueCreateStackResult.h"
#include "model/GetResourceTypeRequest.h"
#include "model/GetResourceTypeResult.h"
#include "model/DeleteChangeSetRequest.h"
#include "model/DeleteChangeSetResult.h"
#include "model/PreviewStackRequest.h"
#include "model/PreviewStackResult.h"
#include "model/SignalResourceRequest.h"
#include "model/SignalResourceResult.h"
#include "model/ExecuteChangeSetRequest.h"
#include "model/ExecuteChangeSetResult.h"
#include "model/SetStackPolicyRequest.h"
#include "model/SetStackPolicyResult.h"
#include "model/CreateChangeSetRequest.h"
#include "model/CreateChangeSetResult.h"
#include "model/GetTemplateRequest.h"
#include "model/GetTemplateResult.h"
#include "model/ListStackEventsRequest.h"
#include "model/ListStackEventsResult.h"
#include "model/GetStackRequest.h"
#include "model/GetStackResult.h"
#include "model/GetStackPolicyRequest.h"
#include "model/GetStackPolicyResult.h"
#include "model/CancelUpdateStackRequest.h"
#include "model/CancelUpdateStackResult.h"
#include "model/ListStackResourcesRequest.h"
#include "model/ListStackResourcesResult.h"
#include "model/ListChangeSetsRequest.h"
#include "model/ListChangeSetsResult.h"
namespace AlibabaCloud
{
namespace ROS
{
class ALIBABACLOUD_ROS_EXPORT ROSClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::ListStacksResult> ListStacksOutcome;
typedef std::future<ListStacksOutcome> ListStacksOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::ListStacksRequest&, const ListStacksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListStacksAsyncHandler;
typedef Outcome<Error, Model::GetChangeSetResult> GetChangeSetOutcome;
typedef std::future<GetChangeSetOutcome> GetChangeSetOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::GetChangeSetRequest&, const GetChangeSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetChangeSetAsyncHandler;
typedef Outcome<Error, Model::ValidateTemplateResult> ValidateTemplateOutcome;
typedef std::future<ValidateTemplateOutcome> ValidateTemplateOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::ValidateTemplateRequest&, const ValidateTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ValidateTemplateAsyncHandler;
typedef Outcome<Error, Model::UpdateStackResult> UpdateStackOutcome;
typedef std::future<UpdateStackOutcome> UpdateStackOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::UpdateStackRequest&, const UpdateStackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateStackAsyncHandler;
typedef Outcome<Error, Model::GetStackResourceResult> GetStackResourceOutcome;
typedef std::future<GetStackResourceOutcome> GetStackResourceOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::GetStackResourceRequest&, const GetStackResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetStackResourceAsyncHandler;
typedef Outcome<Error, Model::ListResourceTypesResult> ListResourceTypesOutcome;
typedef std::future<ListResourceTypesOutcome> ListResourceTypesOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::ListResourceTypesRequest&, const ListResourceTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListResourceTypesAsyncHandler;
typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
typedef Outcome<Error, Model::GetResourceTypeTemplateResult> GetResourceTypeTemplateOutcome;
typedef std::future<GetResourceTypeTemplateOutcome> GetResourceTypeTemplateOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::GetResourceTypeTemplateRequest&, const GetResourceTypeTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetResourceTypeTemplateAsyncHandler;
typedef Outcome<Error, Model::CreateStackResult> CreateStackOutcome;
typedef std::future<CreateStackOutcome> CreateStackOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::CreateStackRequest&, const CreateStackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateStackAsyncHandler;
typedef Outcome<Error, Model::DeleteStackResult> DeleteStackOutcome;
typedef std::future<DeleteStackOutcome> DeleteStackOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::DeleteStackRequest&, const DeleteStackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteStackAsyncHandler;
typedef Outcome<Error, Model::GetTemplateEstimateCostResult> GetTemplateEstimateCostOutcome;
typedef std::future<GetTemplateEstimateCostOutcome> GetTemplateEstimateCostOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::GetTemplateEstimateCostRequest&, const GetTemplateEstimateCostOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTemplateEstimateCostAsyncHandler;
typedef Outcome<Error, Model::ContinueCreateStackResult> ContinueCreateStackOutcome;
typedef std::future<ContinueCreateStackOutcome> ContinueCreateStackOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::ContinueCreateStackRequest&, const ContinueCreateStackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ContinueCreateStackAsyncHandler;
typedef Outcome<Error, Model::GetResourceTypeResult> GetResourceTypeOutcome;
typedef std::future<GetResourceTypeOutcome> GetResourceTypeOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::GetResourceTypeRequest&, const GetResourceTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetResourceTypeAsyncHandler;
typedef Outcome<Error, Model::DeleteChangeSetResult> DeleteChangeSetOutcome;
typedef std::future<DeleteChangeSetOutcome> DeleteChangeSetOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::DeleteChangeSetRequest&, const DeleteChangeSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteChangeSetAsyncHandler;
typedef Outcome<Error, Model::PreviewStackResult> PreviewStackOutcome;
typedef std::future<PreviewStackOutcome> PreviewStackOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::PreviewStackRequest&, const PreviewStackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PreviewStackAsyncHandler;
typedef Outcome<Error, Model::SignalResourceResult> SignalResourceOutcome;
typedef std::future<SignalResourceOutcome> SignalResourceOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::SignalResourceRequest&, const SignalResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SignalResourceAsyncHandler;
typedef Outcome<Error, Model::ExecuteChangeSetResult> ExecuteChangeSetOutcome;
typedef std::future<ExecuteChangeSetOutcome> ExecuteChangeSetOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::ExecuteChangeSetRequest&, const ExecuteChangeSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExecuteChangeSetAsyncHandler;
typedef Outcome<Error, Model::SetStackPolicyResult> SetStackPolicyOutcome;
typedef std::future<SetStackPolicyOutcome> SetStackPolicyOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::SetStackPolicyRequest&, const SetStackPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetStackPolicyAsyncHandler;
typedef Outcome<Error, Model::CreateChangeSetResult> CreateChangeSetOutcome;
typedef std::future<CreateChangeSetOutcome> CreateChangeSetOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::CreateChangeSetRequest&, const CreateChangeSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateChangeSetAsyncHandler;
typedef Outcome<Error, Model::GetTemplateResult> GetTemplateOutcome;
typedef std::future<GetTemplateOutcome> GetTemplateOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::GetTemplateRequest&, const GetTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTemplateAsyncHandler;
typedef Outcome<Error, Model::ListStackEventsResult> ListStackEventsOutcome;
typedef std::future<ListStackEventsOutcome> ListStackEventsOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::ListStackEventsRequest&, const ListStackEventsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListStackEventsAsyncHandler;
typedef Outcome<Error, Model::GetStackResult> GetStackOutcome;
typedef std::future<GetStackOutcome> GetStackOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::GetStackRequest&, const GetStackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetStackAsyncHandler;
typedef Outcome<Error, Model::GetStackPolicyResult> GetStackPolicyOutcome;
typedef std::future<GetStackPolicyOutcome> GetStackPolicyOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::GetStackPolicyRequest&, const GetStackPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetStackPolicyAsyncHandler;
typedef Outcome<Error, Model::CancelUpdateStackResult> CancelUpdateStackOutcome;
typedef std::future<CancelUpdateStackOutcome> CancelUpdateStackOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::CancelUpdateStackRequest&, const CancelUpdateStackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CancelUpdateStackAsyncHandler;
typedef Outcome<Error, Model::ListStackResourcesResult> ListStackResourcesOutcome;
typedef std::future<ListStackResourcesOutcome> ListStackResourcesOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::ListStackResourcesRequest&, const ListStackResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListStackResourcesAsyncHandler;
typedef Outcome<Error, Model::ListChangeSetsResult> ListChangeSetsOutcome;
typedef std::future<ListChangeSetsOutcome> ListChangeSetsOutcomeCallable;
typedef std::function<void(const ROSClient*, const Model::ListChangeSetsRequest&, const ListChangeSetsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListChangeSetsAsyncHandler;
ROSClient(const Credentials &credentials, const ClientConfiguration &configuration);
ROSClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
ROSClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~ROSClient();
ListStacksOutcome listStacks(const Model::ListStacksRequest &request)const;
void listStacksAsync(const Model::ListStacksRequest& request, const ListStacksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListStacksOutcomeCallable listStacksCallable(const Model::ListStacksRequest& request) const;
GetChangeSetOutcome getChangeSet(const Model::GetChangeSetRequest &request)const;
void getChangeSetAsync(const Model::GetChangeSetRequest& request, const GetChangeSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetChangeSetOutcomeCallable getChangeSetCallable(const Model::GetChangeSetRequest& request) const;
ValidateTemplateOutcome validateTemplate(const Model::ValidateTemplateRequest &request)const;
void validateTemplateAsync(const Model::ValidateTemplateRequest& request, const ValidateTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ValidateTemplateOutcomeCallable validateTemplateCallable(const Model::ValidateTemplateRequest& request) const;
UpdateStackOutcome updateStack(const Model::UpdateStackRequest &request)const;
void updateStackAsync(const Model::UpdateStackRequest& request, const UpdateStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateStackOutcomeCallable updateStackCallable(const Model::UpdateStackRequest& request) const;
GetStackResourceOutcome getStackResource(const Model::GetStackResourceRequest &request)const;
void getStackResourceAsync(const Model::GetStackResourceRequest& request, const GetStackResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetStackResourceOutcomeCallable getStackResourceCallable(const Model::GetStackResourceRequest& request) const;
ListResourceTypesOutcome listResourceTypes(const Model::ListResourceTypesRequest &request)const;
void listResourceTypesAsync(const Model::ListResourceTypesRequest& request, const ListResourceTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListResourceTypesOutcomeCallable listResourceTypesCallable(const Model::ListResourceTypesRequest& 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;
GetResourceTypeTemplateOutcome getResourceTypeTemplate(const Model::GetResourceTypeTemplateRequest &request)const;
void getResourceTypeTemplateAsync(const Model::GetResourceTypeTemplateRequest& request, const GetResourceTypeTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetResourceTypeTemplateOutcomeCallable getResourceTypeTemplateCallable(const Model::GetResourceTypeTemplateRequest& request) const;
CreateStackOutcome createStack(const Model::CreateStackRequest &request)const;
void createStackAsync(const Model::CreateStackRequest& request, const CreateStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateStackOutcomeCallable createStackCallable(const Model::CreateStackRequest& request) const;
DeleteStackOutcome deleteStack(const Model::DeleteStackRequest &request)const;
void deleteStackAsync(const Model::DeleteStackRequest& request, const DeleteStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteStackOutcomeCallable deleteStackCallable(const Model::DeleteStackRequest& request) const;
GetTemplateEstimateCostOutcome getTemplateEstimateCost(const Model::GetTemplateEstimateCostRequest &request)const;
void getTemplateEstimateCostAsync(const Model::GetTemplateEstimateCostRequest& request, const GetTemplateEstimateCostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetTemplateEstimateCostOutcomeCallable getTemplateEstimateCostCallable(const Model::GetTemplateEstimateCostRequest& request) const;
ContinueCreateStackOutcome continueCreateStack(const Model::ContinueCreateStackRequest &request)const;
void continueCreateStackAsync(const Model::ContinueCreateStackRequest& request, const ContinueCreateStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ContinueCreateStackOutcomeCallable continueCreateStackCallable(const Model::ContinueCreateStackRequest& request) const;
GetResourceTypeOutcome getResourceType(const Model::GetResourceTypeRequest &request)const;
void getResourceTypeAsync(const Model::GetResourceTypeRequest& request, const GetResourceTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetResourceTypeOutcomeCallable getResourceTypeCallable(const Model::GetResourceTypeRequest& request) const;
DeleteChangeSetOutcome deleteChangeSet(const Model::DeleteChangeSetRequest &request)const;
void deleteChangeSetAsync(const Model::DeleteChangeSetRequest& request, const DeleteChangeSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteChangeSetOutcomeCallable deleteChangeSetCallable(const Model::DeleteChangeSetRequest& request) const;
PreviewStackOutcome previewStack(const Model::PreviewStackRequest &request)const;
void previewStackAsync(const Model::PreviewStackRequest& request, const PreviewStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
PreviewStackOutcomeCallable previewStackCallable(const Model::PreviewStackRequest& request) const;
SignalResourceOutcome signalResource(const Model::SignalResourceRequest &request)const;
void signalResourceAsync(const Model::SignalResourceRequest& request, const SignalResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SignalResourceOutcomeCallable signalResourceCallable(const Model::SignalResourceRequest& request) const;
ExecuteChangeSetOutcome executeChangeSet(const Model::ExecuteChangeSetRequest &request)const;
void executeChangeSetAsync(const Model::ExecuteChangeSetRequest& request, const ExecuteChangeSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ExecuteChangeSetOutcomeCallable executeChangeSetCallable(const Model::ExecuteChangeSetRequest& request) const;
SetStackPolicyOutcome setStackPolicy(const Model::SetStackPolicyRequest &request)const;
void setStackPolicyAsync(const Model::SetStackPolicyRequest& request, const SetStackPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetStackPolicyOutcomeCallable setStackPolicyCallable(const Model::SetStackPolicyRequest& request) const;
CreateChangeSetOutcome createChangeSet(const Model::CreateChangeSetRequest &request)const;
void createChangeSetAsync(const Model::CreateChangeSetRequest& request, const CreateChangeSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateChangeSetOutcomeCallable createChangeSetCallable(const Model::CreateChangeSetRequest& request) const;
GetTemplateOutcome getTemplate(const Model::GetTemplateRequest &request)const;
void getTemplateAsync(const Model::GetTemplateRequest& request, const GetTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetTemplateOutcomeCallable getTemplateCallable(const Model::GetTemplateRequest& request) const;
ListStackEventsOutcome listStackEvents(const Model::ListStackEventsRequest &request)const;
void listStackEventsAsync(const Model::ListStackEventsRequest& request, const ListStackEventsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListStackEventsOutcomeCallable listStackEventsCallable(const Model::ListStackEventsRequest& request) const;
GetStackOutcome getStack(const Model::GetStackRequest &request)const;
void getStackAsync(const Model::GetStackRequest& request, const GetStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetStackOutcomeCallable getStackCallable(const Model::GetStackRequest& request) const;
GetStackPolicyOutcome getStackPolicy(const Model::GetStackPolicyRequest &request)const;
void getStackPolicyAsync(const Model::GetStackPolicyRequest& request, const GetStackPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetStackPolicyOutcomeCallable getStackPolicyCallable(const Model::GetStackPolicyRequest& request) const;
CancelUpdateStackOutcome cancelUpdateStack(const Model::CancelUpdateStackRequest &request)const;
void cancelUpdateStackAsync(const Model::CancelUpdateStackRequest& request, const CancelUpdateStackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CancelUpdateStackOutcomeCallable cancelUpdateStackCallable(const Model::CancelUpdateStackRequest& request) const;
ListStackResourcesOutcome listStackResources(const Model::ListStackResourcesRequest &request)const;
void listStackResourcesAsync(const Model::ListStackResourcesRequest& request, const ListStackResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListStackResourcesOutcomeCallable listStackResourcesCallable(const Model::ListStackResourcesRequest& request) const;
ListChangeSetsOutcome listChangeSets(const Model::ListChangeSetsRequest &request)const;
void listChangeSetsAsync(const Model::ListChangeSetsRequest& request, const ListChangeSetsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListChangeSetsOutcomeCallable listChangeSetsCallable(const Model::ListChangeSetsRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_ROS_ROSCLIENT_H_

32
ros/include/alibabacloud/ros/ROSExport.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_ROS_ROSEXPORT_H_
#define ALIBABACLOUD_ROS_ROSEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_ROS_LIBRARY)
# define ALIBABACLOUD_ROS_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_ROS_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_ROS_EXPORT
#endif
#endif // !ALIBABACLOUD_ROS_ROSEXPORT_H_

54
ros/include/alibabacloud/ros/model/CancelUpdateStackRequest.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_ROS_MODEL_CANCELUPDATESTACKREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_CANCELUPDATESTACKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT CancelUpdateStackRequest : public RpcServiceRequest
{
public:
CancelUpdateStackRequest();
~CancelUpdateStackRequest();
std::string getCancelType()const;
void setCancelType(const std::string& cancelType);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getStackId()const;
void setStackId(const std::string& stackId);
private:
std::string cancelType_;
std::string regionId_;
std::string stackId_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_CANCELUPDATESTACKREQUEST_H_

49
ros/include/alibabacloud/ros/model/CancelUpdateStackResult.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_ROS_MODEL_CANCELUPDATESTACKRESULT_H_
#define ALIBABACLOUD_ROS_MODEL_CANCELUPDATESTACKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT CancelUpdateStackResult : public ServiceResult
{
public:
CancelUpdateStackResult();
explicit CancelUpdateStackResult(const std::string &payload);
~CancelUpdateStackResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_CANCELUPDATESTACKRESULT_H_

54
ros/include/alibabacloud/ros/model/ContinueCreateStackRequest.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_ROS_MODEL_CONTINUECREATESTACKREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_CONTINUECREATESTACKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT ContinueCreateStackRequest : public RpcServiceRequest
{
public:
ContinueCreateStackRequest();
~ContinueCreateStackRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getStackId()const;
void setStackId(const std::string& stackId);
std::vector<std::string> getRecreatingResources()const;
void setRecreatingResources(const std::vector<std::string>& recreatingResources);
private:
std::string regionId_;
std::string stackId_;
std::vector<std::string> recreatingResources_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_CONTINUECREATESTACKREQUEST_H_

51
ros/include/alibabacloud/ros/model/ContinueCreateStackResult.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_ROS_MODEL_CONTINUECREATESTACKRESULT_H_
#define ALIBABACLOUD_ROS_MODEL_CONTINUECREATESTACKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT ContinueCreateStackResult : public ServiceResult
{
public:
ContinueCreateStackResult();
explicit ContinueCreateStackResult(const std::string &payload);
~ContinueCreateStackResult();
std::string getStackId()const;
protected:
void parse(const std::string &payload);
private:
std::string stackId_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_CONTINUECREATESTACKRESULT_H_

116
ros/include/alibabacloud/ros/model/CreateChangeSetRequest.h Normal file
View File

@@ -0,0 +1,116 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ROS_MODEL_CREATECHANGESETREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_CREATECHANGESETREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT CreateChangeSetRequest : public RpcServiceRequest
{
struct Parameters
{
std::string parameterValue;
std::string parameterKey;
};
public:
CreateChangeSetRequest();
~CreateChangeSetRequest();
std::string getStackPolicyDuringUpdateURL()const;
void setStackPolicyDuringUpdateURL(const std::string& stackPolicyDuringUpdateURL);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getTemplateBody()const;
void setTemplateBody(const std::string& templateBody);
std::string getStackId()const;
void setStackId(const std::string& stackId);
std::string getChangeSetType()const;
void setChangeSetType(const std::string& changeSetType);
std::string getDescription()const;
void setDescription(const std::string& description);
bool getDisableRollback()const;
void setDisableRollback(bool disableRollback);
std::string getUpdateAllowPolicy()const;
void setUpdateAllowPolicy(const std::string& updateAllowPolicy);
long getTimeoutInMinutes()const;
void setTimeoutInMinutes(long timeoutInMinutes);
bool getUsePreviousParameters()const;
void setUsePreviousParameters(bool usePreviousParameters);
std::string getTemplateURL()const;
void setTemplateURL(const std::string& templateURL);
std::string getOrderSource()const;
void setOrderSource(const std::string& orderSource);
std::string getActivityId()const;
void setActivityId(const std::string& activityId);
std::string getStackPolicyDuringUpdateBody()const;
void setStackPolicyDuringUpdateBody(const std::string& stackPolicyDuringUpdateBody);
std::vector<std::string> getNotificationURLs()const;
void setNotificationURLs(const std::vector<std::string>& notificationURLs);
std::string getStackPolicyURL()const;
void setStackPolicyURL(const std::string& stackPolicyURL);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getChangeSetName()const;
void setChangeSetName(const std::string& changeSetName);
std::string getStackName()const;
void setStackName(const std::string& stackName);
std::vector<Parameters> getParameters()const;
void setParameters(const std::vector<Parameters>& parameters);
std::string getStackPolicyBody()const;
void setStackPolicyBody(const std::string& stackPolicyBody);
std::string getChannelId()const;
void setChannelId(const std::string& channelId);
private:
std::string stackPolicyDuringUpdateURL_;
std::string clientToken_;
std::string templateBody_;
std::string stackId_;
std::string changeSetType_;
std::string description_;
bool disableRollback_;
std::string updateAllowPolicy_;
long timeoutInMinutes_;
bool usePreviousParameters_;
std::string templateURL_;
std::string orderSource_;
std::string activityId_;
std::string stackPolicyDuringUpdateBody_;
std::vector<std::string> notificationURLs_;
std::string stackPolicyURL_;
std::string regionId_;
std::string changeSetName_;
std::string stackName_;
std::vector<Parameters> parameters_;
std::string stackPolicyBody_;
std::string channelId_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_CREATECHANGESETREQUEST_H_

53
ros/include/alibabacloud/ros/model/CreateChangeSetResult.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_ROS_MODEL_CREATECHANGESETRESULT_H_
#define ALIBABACLOUD_ROS_MODEL_CREATECHANGESETRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT CreateChangeSetResult : public ServiceResult
{
public:
CreateChangeSetResult();
explicit CreateChangeSetResult(const std::string &payload);
~CreateChangeSetResult();
std::string getChangeSetId()const;
std::string getStackId()const;
protected:
void parse(const std::string &payload);
private:
std::string changeSetId_;
std::string stackId_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_CREATECHANGESETRESULT_H_

92
ros/include/alibabacloud/ros/model/CreateStackRequest.h Normal file
View File

@@ -0,0 +1,92 @@
/*
* 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_ROS_MODEL_CREATESTACKREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_CREATESTACKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT CreateStackRequest : public RpcServiceRequest
{
struct Parameters
{
std::string parameterValue;
std::string parameterKey;
};
public:
CreateStackRequest();
~CreateStackRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getTemplateBody()const;
void setTemplateBody(const std::string& templateBody);
bool getDisableRollback()const;
void setDisableRollback(bool disableRollback);
long getTimeoutInMinutes()const;
void setTimeoutInMinutes(long timeoutInMinutes);
std::string getOrderSource()const;
void setOrderSource(const std::string& orderSource);
std::string getTemplateURL()const;
void setTemplateURL(const std::string& templateURL);
std::string getActivityId()const;
void setActivityId(const std::string& activityId);
std::vector<std::string> getNotificationURLs()const;
void setNotificationURLs(const std::vector<std::string>& notificationURLs);
std::string getStackPolicyURL()const;
void setStackPolicyURL(const std::string& stackPolicyURL);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getStackName()const;
void setStackName(const std::string& stackName);
std::vector<Parameters> getParameters()const;
void setParameters(const std::vector<Parameters>& parameters);
std::string getStackPolicyBody()const;
void setStackPolicyBody(const std::string& stackPolicyBody);
std::string getChannelId()const;
void setChannelId(const std::string& channelId);
private:
std::string clientToken_;
std::string templateBody_;
bool disableRollback_;
long timeoutInMinutes_;
std::string orderSource_;
std::string templateURL_;
std::string activityId_;
std::vector<std::string> notificationURLs_;
std::string stackPolicyURL_;
std::string regionId_;
std::string stackName_;
std::vector<Parameters> parameters_;
std::string stackPolicyBody_;
std::string channelId_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_CREATESTACKREQUEST_H_

51
ros/include/alibabacloud/ros/model/CreateStackResult.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_ROS_MODEL_CREATESTACKRESULT_H_
#define ALIBABACLOUD_ROS_MODEL_CREATESTACKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT CreateStackResult : public ServiceResult
{
public:
CreateStackResult();
explicit CreateStackResult(const std::string &payload);
~CreateStackResult();
std::string getStackId()const;
protected:
void parse(const std::string &payload);
private:
std::string stackId_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_CREATESTACKRESULT_H_

51
ros/include/alibabacloud/ros/model/DeleteChangeSetRequest.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_ROS_MODEL_DELETECHANGESETREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_DELETECHANGESETREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT DeleteChangeSetRequest : public RpcServiceRequest
{
public:
DeleteChangeSetRequest();
~DeleteChangeSetRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getChangeSetId()const;
void setChangeSetId(const std::string& changeSetId);
private:
std::string regionId_;
std::string changeSetId_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_DELETECHANGESETREQUEST_H_

49
ros/include/alibabacloud/ros/model/DeleteChangeSetResult.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_ROS_MODEL_DELETECHANGESETRESULT_H_
#define ALIBABACLOUD_ROS_MODEL_DELETECHANGESETRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT DeleteChangeSetResult : public ServiceResult
{
public:
DeleteChangeSetResult();
explicit DeleteChangeSetResult(const std::string &payload);
~DeleteChangeSetResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_DELETECHANGESETRESULT_H_

54
ros/include/alibabacloud/ros/model/DeleteStackRequest.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_ROS_MODEL_DELETESTACKREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_DELETESTACKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT DeleteStackRequest : public RpcServiceRequest
{
public:
DeleteStackRequest();
~DeleteStackRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getRetainAllResources()const;
void setRetainAllResources(bool retainAllResources);
std::string getStackId()const;
void setStackId(const std::string& stackId);
private:
std::string regionId_;
bool retainAllResources_;
std::string stackId_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_DELETESTACKREQUEST_H_

49
ros/include/alibabacloud/ros/model/DeleteStackResult.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_ROS_MODEL_DELETESTACKRESULT_H_
#define ALIBABACLOUD_ROS_MODEL_DELETESTACKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT DeleteStackResult : public ServiceResult
{
public:
DeleteStackResult();
explicit DeleteStackResult(const std::string &payload);
~DeleteStackResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_DELETESTACKRESULT_H_

48
ros/include/alibabacloud/ros/model/DescribeRegionsRequest.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_ROS_MODEL_DESCRIBEREGIONSREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_DESCRIBEREGIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT DescribeRegionsRequest : public RpcServiceRequest
{
public:
DescribeRegionsRequest();
~DescribeRegionsRequest();
std::string getAcceptLanguage()const;
void setAcceptLanguage(const std::string& acceptLanguage);
private:
std::string acceptLanguage_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_DESCRIBEREGIONSREQUEST_H_

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

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ROS_MODEL_DESCRIBEREGIONSRESULT_H_
#define ALIBABACLOUD_ROS_MODEL_DESCRIBEREGIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT DescribeRegionsResult : public ServiceResult
{
public:
struct Region
{
std::string regionId;
std::string regionEndpoint;
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_ROS_MODEL_DESCRIBEREGIONSRESULT_H_

51
ros/include/alibabacloud/ros/model/ExecuteChangeSetRequest.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_ROS_MODEL_EXECUTECHANGESETREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_EXECUTECHANGESETREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT ExecuteChangeSetRequest : public RpcServiceRequest
{
public:
ExecuteChangeSetRequest();
~ExecuteChangeSetRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getChangeSetId()const;
void setChangeSetId(const std::string& changeSetId);
private:
std::string regionId_;
std::string changeSetId_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_EXECUTECHANGESETREQUEST_H_

49
ros/include/alibabacloud/ros/model/ExecuteChangeSetResult.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_ROS_MODEL_EXECUTECHANGESETRESULT_H_
#define ALIBABACLOUD_ROS_MODEL_EXECUTECHANGESETRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT ExecuteChangeSetResult : public ServiceResult
{
public:
ExecuteChangeSetResult();
explicit ExecuteChangeSetResult(const std::string &payload);
~ExecuteChangeSetResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_EXECUTECHANGESETRESULT_H_

54
ros/include/alibabacloud/ros/model/GetChangeSetRequest.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_ROS_MODEL_GETCHANGESETREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_GETCHANGESETREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT GetChangeSetRequest : public RpcServiceRequest
{
public:
GetChangeSetRequest();
~GetChangeSetRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getChangeSetId()const;
void setChangeSetId(const std::string& changeSetId);
bool getShowTemplate()const;
void setShowTemplate(bool showTemplate);
private:
std::string regionId_;
std::string changeSetId_;
bool showTemplate_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_GETCHANGESETREQUEST_H_

84
ros/include/alibabacloud/ros/model/GetChangeSetResult.h Normal file
View File

@@ -0,0 +1,84 @@
/*
* 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_ROS_MODEL_GETCHANGESETRESULT_H_
#define ALIBABACLOUD_ROS_MODEL_GETCHANGESETRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT GetChangeSetResult : public ServiceResult
{
public:
struct Parameter
{
std::string parameterValue;
std::string parameterKey;
};
GetChangeSetResult();
explicit GetChangeSetResult(const std::string &payload);
~GetChangeSetResult();
std::vector<std::string> getChanges()const;
std::string getStatus()const;
std::vector<Parameter> getParameters()const;
std::string getDescription()const;
std::string getCreateTime()const;
std::string getTemplateBody()const;
std::string getChangeSetName()const;
std::string getChangeSetId()const;
std::string getExecutionStatus()const;
std::string getChangeSetType()const;
std::string getRegionId()const;
bool getDisableRollback()const;
std::string getStackName()const;
std::string getStackId()const;
int getTimeoutInMinutes()const;
protected:
void parse(const std::string &payload);
private:
std::vector<std::string> changes_;
std::string status_;
std::vector<Parameter> parameters_;
std::string description_;
std::string createTime_;
std::string templateBody_;
std::string changeSetName_;
std::string changeSetId_;
std::string executionStatus_;
std::string changeSetType_;
std::string regionId_;
bool disableRollback_;
std::string stackName_;
std::string stackId_;
int timeoutInMinutes_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_GETCHANGESETRESULT_H_

48
ros/include/alibabacloud/ros/model/GetResourceTypeRequest.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_ROS_MODEL_GETRESOURCETYPEREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_GETRESOURCETYPEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT GetResourceTypeRequest : public RpcServiceRequest
{
public:
GetResourceTypeRequest();
~GetResourceTypeRequest();
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
private:
std::string resourceType_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_GETRESOURCETYPEREQUEST_H_

55
ros/include/alibabacloud/ros/model/GetResourceTypeResult.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_ROS_MODEL_GETRESOURCETYPERESULT_H_
#define ALIBABACLOUD_ROS_MODEL_GETRESOURCETYPERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT GetResourceTypeResult : public ServiceResult
{
public:
GetResourceTypeResult();
explicit GetResourceTypeResult(const std::string &payload);
~GetResourceTypeResult();
std::string getAttributes()const;
std::string getResourceType()const;
std::string getProperties()const;
protected:
void parse(const std::string &payload);
private:
std::string attributes_;
std::string resourceType_;
std::string properties_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_GETRESOURCETYPERESULT_H_

48
ros/include/alibabacloud/ros/model/GetResourceTypeTemplateRequest.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_ROS_MODEL_GETRESOURCETYPETEMPLATEREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_GETRESOURCETYPETEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT GetResourceTypeTemplateRequest : public RpcServiceRequest
{
public:
GetResourceTypeTemplateRequest();
~GetResourceTypeTemplateRequest();
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
private:
std::string resourceType_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_GETRESOURCETYPETEMPLATEREQUEST_H_

51
ros/include/alibabacloud/ros/model/GetResourceTypeTemplateResult.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_ROS_MODEL_GETRESOURCETYPETEMPLATERESULT_H_
#define ALIBABACLOUD_ROS_MODEL_GETRESOURCETYPETEMPLATERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT GetResourceTypeTemplateResult : public ServiceResult
{
public:
GetResourceTypeTemplateResult();
explicit GetResourceTypeTemplateResult(const std::string &payload);
~GetResourceTypeTemplateResult();
std::string getTemplateBody()const;
protected:
void parse(const std::string &payload);
private:
std::string templateBody_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_GETRESOURCETYPETEMPLATERESULT_H_

51
ros/include/alibabacloud/ros/model/GetStackPolicyRequest.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_ROS_MODEL_GETSTACKPOLICYREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_GETSTACKPOLICYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT GetStackPolicyRequest : public RpcServiceRequest
{
public:
GetStackPolicyRequest();
~GetStackPolicyRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getStackId()const;
void setStackId(const std::string& stackId);
private:
std::string regionId_;
std::string stackId_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_GETSTACKPOLICYREQUEST_H_

51
ros/include/alibabacloud/ros/model/GetStackPolicyResult.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_ROS_MODEL_GETSTACKPOLICYRESULT_H_
#define ALIBABACLOUD_ROS_MODEL_GETSTACKPOLICYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT GetStackPolicyResult : public ServiceResult
{
public:
GetStackPolicyResult();
explicit GetStackPolicyResult(const std::string &payload);
~GetStackPolicyResult();
std::string getStackPolicyBody()const;
protected:
void parse(const std::string &payload);
private:
std::string stackPolicyBody_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_GETSTACKPOLICYRESULT_H_

54
ros/include/alibabacloud/ros/model/GetStackRequest.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_ROS_MODEL_GETSTACKREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_GETSTACKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT GetStackRequest : public RpcServiceRequest
{
public:
GetStackRequest();
~GetStackRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getStackId()const;
void setStackId(const std::string& stackId);
private:
std::string regionId_;
std::string clientToken_;
std::string stackId_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_GETSTACKREQUEST_H_

60
ros/include/alibabacloud/ros/model/GetStackResourceRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ROS_MODEL_GETSTACKRESOURCEREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_GETSTACKRESOURCEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT GetStackResourceRequest : public RpcServiceRequest
{
public:
GetStackResourceRequest();
~GetStackResourceRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getStackId()const;
void setStackId(const std::string& stackId);
std::string getLogicalResourceId()const;
void setLogicalResourceId(const std::string& logicalResourceId);
bool getShowResourceAttributes()const;
void setShowResourceAttributes(bool showResourceAttributes);
private:
std::string clientToken_;
std::string regionId_;
std::string stackId_;
std::string logicalResourceId_;
bool showResourceAttributes_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_GETSTACKRESOURCEREQUEST_H_

73
ros/include/alibabacloud/ros/model/GetStackResourceResult.h Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ROS_MODEL_GETSTACKRESOURCERESULT_H_
#define ALIBABACLOUD_ROS_MODEL_GETSTACKRESOURCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT GetStackResourceResult : public ServiceResult
{
public:
GetStackResourceResult();
explicit GetStackResourceResult(const std::string &payload);
~GetStackResourceResult();
std::string getStatus()const;
std::string getLogicalResourceId()const;
std::string getDescription()const;
std::string getPhysicalResourceId()const;
std::string getStatusReason()const;
std::string getCreateTime()const;
std::string getMetadata()const;
std::string getUpdateTime()const;
std::string getResourceType()const;
std::vector<std::string> getResourceAttributes()const;
std::string getStackName()const;
std::string getStackId()const;
protected:
void parse(const std::string &payload);
private:
std::string status_;
std::string logicalResourceId_;
std::string description_;
std::string physicalResourceId_;
std::string statusReason_;
std::string createTime_;
std::string metadata_;
std::string updateTime_;
std::string resourceType_;
std::vector<std::string> resourceAttributes_;
std::string stackName_;
std::string stackId_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_GETSTACKRESOURCERESULT_H_

84
ros/include/alibabacloud/ros/model/GetStackResult.h Normal file
View File

@@ -0,0 +1,84 @@
/*
* 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_ROS_MODEL_GETSTACKRESULT_H_
#define ALIBABACLOUD_ROS_MODEL_GETSTACKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT GetStackResult : public ServiceResult
{
public:
struct Parameter
{
std::string parameterValue;
std::string parameterKey;
};
GetStackResult();
explicit GetStackResult(const std::string &payload);
~GetStackResult();
std::string getStatus()const;
std::vector<Parameter> getParameters()const;
std::string getDescription()const;
std::string getStatusReason()const;
std::string getParentStackId()const;
std::string getCreateTime()const;
std::string getTemplateDescription()const;
std::vector<std::string> getOutputs()const;
std::string getUpdateTime()const;
std::string getRegionId()const;
std::vector<std::string> getNotificationURLs()const;
bool getDisableRollback()const;
std::string getStackName()const;
std::string getStackId()const;
int getTimeoutInMinutes()const;
protected:
void parse(const std::string &payload);
private:
std::string status_;
std::vector<Parameter> parameters_;
std::string description_;
std::string statusReason_;
std::string parentStackId_;
std::string createTime_;
std::string templateDescription_;
std::vector<std::string> outputs_;
std::string updateTime_;
std::string regionId_;
std::vector<std::string> notificationURLs_;
bool disableRollback_;
std::string stackName_;
std::string stackId_;
int timeoutInMinutes_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_GETSTACKRESULT_H_

65
ros/include/alibabacloud/ros/model/GetTemplateEstimateCostRequest.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ROS_MODEL_GETTEMPLATEESTIMATECOSTREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_GETTEMPLATEESTIMATECOSTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT GetTemplateEstimateCostRequest : public RpcServiceRequest
{
struct Parameters
{
std::string parameterValue;
std::string parameterKey;
};
public:
GetTemplateEstimateCostRequest();
~GetTemplateEstimateCostRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getTemplateBody()const;
void setTemplateBody(const std::string& templateBody);
std::vector<Parameters> getParameters()const;
void setParameters(const std::vector<Parameters>& parameters);
std::string getTemplateURL()const;
void setTemplateURL(const std::string& templateURL);
private:
std::string regionId_;
std::string clientToken_;
std::string templateBody_;
std::vector<Parameters> parameters_;
std::string templateURL_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_GETTEMPLATEESTIMATECOSTREQUEST_H_

51
ros/include/alibabacloud/ros/model/GetTemplateEstimateCostResult.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_ROS_MODEL_GETTEMPLATEESTIMATECOSTRESULT_H_
#define ALIBABACLOUD_ROS_MODEL_GETTEMPLATEESTIMATECOSTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT GetTemplateEstimateCostResult : public ServiceResult
{
public:
GetTemplateEstimateCostResult();
explicit GetTemplateEstimateCostResult(const std::string &payload);
~GetTemplateEstimateCostResult();
std::string getResources()const;
protected:
void parse(const std::string &payload);
private:
std::string resources_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_GETTEMPLATEESTIMATECOSTRESULT_H_

54
ros/include/alibabacloud/ros/model/GetTemplateRequest.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_ROS_MODEL_GETTEMPLATEREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_GETTEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT GetTemplateRequest : public RpcServiceRequest
{
public:
GetTemplateRequest();
~GetTemplateRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getStackId()const;
void setStackId(const std::string& stackId);
std::string getChangeSetId()const;
void setChangeSetId(const std::string& changeSetId);
private:
std::string regionId_;
std::string stackId_;
std::string changeSetId_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_GETTEMPLATEREQUEST_H_

51
ros/include/alibabacloud/ros/model/GetTemplateResult.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_ROS_MODEL_GETTEMPLATERESULT_H_
#define ALIBABACLOUD_ROS_MODEL_GETTEMPLATERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT GetTemplateResult : public ServiceResult
{
public:
GetTemplateResult();
explicit GetTemplateResult(const std::string &payload);
~GetTemplateResult();
std::string getTemplateBody()const;
protected:
void parse(const std::string &payload);
private:
std::string templateBody_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_GETTEMPLATERESULT_H_

66
ros/include/alibabacloud/ros/model/ListChangeSetsRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ROS_MODEL_LISTCHANGESETSREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_LISTCHANGESETSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT ListChangeSetsRequest : public RpcServiceRequest
{
public:
ListChangeSetsRequest();
~ListChangeSetsRequest();
std::vector<std::string> getExecutionStatus()const;
void setExecutionStatus(const std::vector<std::string>& executionStatus);
std::vector<std::string> getChangeSetName()const;
void setChangeSetName(const std::vector<std::string>& changeSetName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getStackId()const;
void setStackId(const std::string& stackId);
long getPageSize()const;
void setPageSize(long pageSize);
long getPageNumber()const;
void setPageNumber(long pageNumber);
std::vector<std::string> getStatus()const;
void setStatus(const std::vector<std::string>& status);
private:
std::vector<std::string> executionStatus_;
std::vector<std::string> changeSetName_;
std::string regionId_;
std::string stackId_;
long pageSize_;
long pageNumber_;
std::vector<std::string> status_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_LISTCHANGESETSREQUEST_H_

70
ros/include/alibabacloud/ros/model/ListChangeSetsResult.h Normal file
View File

@@ -0,0 +1,70 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ROS_MODEL_LISTCHANGESETSRESULT_H_
#define ALIBABACLOUD_ROS_MODEL_LISTCHANGESETSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT ListChangeSetsResult : public ServiceResult
{
public:
struct ChangeSet
{
std::string status;
std::string changeSetId;
std::string description;
std::string executionStatus;
std::string createTime;
std::string changeSetType;
std::string regionId;
std::string changeSetName;
std::string stackName;
std::string stackId;
};
ListChangeSetsResult();
explicit ListChangeSetsResult(const std::string &payload);
~ListChangeSetsResult();
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<ChangeSet> getChangeSets()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
int pageSize_;
int pageNumber_;
std::vector<ChangeSet> changeSets_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_LISTCHANGESETSRESULT_H_

45
ros/include/alibabacloud/ros/model/ListResourceTypesRequest.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_ROS_MODEL_LISTRESOURCETYPESREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_LISTRESOURCETYPESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT ListResourceTypesRequest : public RpcServiceRequest
{
public:
ListResourceTypesRequest();
~ListResourceTypesRequest();
private:
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_LISTRESOURCETYPESREQUEST_H_

51
ros/include/alibabacloud/ros/model/ListResourceTypesResult.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_ROS_MODEL_LISTRESOURCETYPESRESULT_H_
#define ALIBABACLOUD_ROS_MODEL_LISTRESOURCETYPESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT ListResourceTypesResult : public ServiceResult
{
public:
ListResourceTypesResult();
explicit ListResourceTypesResult(const std::string &payload);
~ListResourceTypesResult();
std::vector<std::string> getResourceTypes()const;
protected:
void parse(const std::string &payload);
private:
std::vector<std::string> resourceTypes_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_LISTRESOURCETYPESRESULT_H_

66
ros/include/alibabacloud/ros/model/ListStackEventsRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ROS_MODEL_LISTSTACKEVENTSREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_LISTSTACKEVENTSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT ListStackEventsRequest : public RpcServiceRequest
{
public:
ListStackEventsRequest();
~ListStackEventsRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getStackId()const;
void setStackId(const std::string& stackId);
long getPageSize()const;
void setPageSize(long pageSize);
std::vector<std::string> getLogicalResourceId()const;
void setLogicalResourceId(const std::vector<std::string>& logicalResourceId);
std::vector<std::string> getResourceType()const;
void setResourceType(const std::vector<std::string>& resourceType);
long getPageNumber()const;
void setPageNumber(long pageNumber);
std::vector<std::string> getStatus()const;
void setStatus(const std::vector<std::string>& status);
private:
std::string regionId_;
std::string stackId_;
long pageSize_;
std::vector<std::string> logicalResourceId_;
std::vector<std::string> resourceType_;
long pageNumber_;
std::vector<std::string> status_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_LISTSTACKEVENTSREQUEST_H_

69
ros/include/alibabacloud/ros/model/ListStackEventsResult.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ROS_MODEL_LISTSTACKEVENTSRESULT_H_
#define ALIBABACLOUD_ROS_MODEL_LISTSTACKEVENTSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT ListStackEventsResult : public ServiceResult
{
public:
struct Event
{
std::string status;
std::string logicalResourceId;
std::string physicalResourceId;
std::string statusReason;
std::string createTime;
std::string eventId;
std::string resourceType;
std::string stackName;
std::string stackId;
};
ListStackEventsResult();
explicit ListStackEventsResult(const std::string &payload);
~ListStackEventsResult();
int getTotalCount()const;
int getPageSize()const;
std::vector<Event> getEvents()const;
int getPageNumber()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
int pageSize_;
std::vector<Event> events_;
int pageNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_LISTSTACKEVENTSRESULT_H_

51
ros/include/alibabacloud/ros/model/ListStackResourcesRequest.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_ROS_MODEL_LISTSTACKRESOURCESREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_LISTSTACKRESOURCESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT ListStackResourcesRequest : public RpcServiceRequest
{
public:
ListStackResourcesRequest();
~ListStackResourcesRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getStackId()const;
void setStackId(const std::string& stackId);
private:
std::string regionId_;
std::string stackId_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_LISTSTACKRESOURCESREQUEST_H_

63
ros/include/alibabacloud/ros/model/ListStackResourcesResult.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_ROS_MODEL_LISTSTACKRESOURCESRESULT_H_
#define ALIBABACLOUD_ROS_MODEL_LISTSTACKRESOURCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT ListStackResourcesResult : public ServiceResult
{
public:
struct Resource
{
std::string status;
std::string logicalResourceId;
std::string physicalResourceId;
std::string statusReason;
std::string createTime;
std::string updateTime;
std::string resourceType;
std::string stackName;
std::string stackId;
};
ListStackResourcesResult();
explicit ListStackResourcesResult(const std::string &payload);
~ListStackResourcesResult();
std::vector<Resource> getResources()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Resource> resources_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_LISTSTACKRESOURCESRESULT_H_

66
ros/include/alibabacloud/ros/model/ListStacksRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ROS_MODEL_LISTSTACKSREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_LISTSTACKSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT ListStacksRequest : public RpcServiceRequest
{
public:
ListStacksRequest();
~ListStacksRequest();
std::string getParentStackId()const;
void setParentStackId(const std::string& parentStackId);
bool getShowNestedStack()const;
void setShowNestedStack(bool showNestedStack);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
long getPageSize()const;
void setPageSize(long pageSize);
std::vector<std::string> getStackName()const;
void setStackName(const std::vector<std::string>& stackName);
long getPageNumber()const;
void setPageNumber(long pageNumber);
std::vector<std::string> getStatus()const;
void setStatus(const std::vector<std::string>& status);
private:
std::string parentStackId_;
bool showNestedStack_;
std::string regionId_;
long pageSize_;
std::vector<std::string> stackName_;
long pageNumber_;
std::vector<std::string> status_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_LISTSTACKSREQUEST_H_

70
ros/include/alibabacloud/ros/model/ListStacksResult.h Normal file
View File

@@ -0,0 +1,70 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ROS_MODEL_LISTSTACKSRESULT_H_
#define ALIBABACLOUD_ROS_MODEL_LISTSTACKSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT ListStacksResult : public ServiceResult
{
public:
struct Stack
{
std::string status;
std::string statusReason;
std::string parentStackId;
std::string createTime;
std::string updateTime;
std::string regionId;
bool disableRollback;
std::string stackName;
std::string stackId;
int timeoutInMinutes;
};
ListStacksResult();
explicit ListStacksResult(const std::string &payload);
~ListStacksResult();
int getTotalCount()const;
int getPageSize()const;
int getPageNumber()const;
std::vector<Stack> getStacks()const;
protected:
void parse(const std::string &payload);
private:
int totalCount_;
int pageSize_;
int pageNumber_;
std::vector<Stack> stacks_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_LISTSTACKSRESULT_H_

80
ros/include/alibabacloud/ros/model/PreviewStackRequest.h Normal file
View File

@@ -0,0 +1,80 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ROS_MODEL_PREVIEWSTACKREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_PREVIEWSTACKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT PreviewStackRequest : public RpcServiceRequest
{
struct Parameters
{
std::string parameterValue;
std::string parameterKey;
};
public:
PreviewStackRequest();
~PreviewStackRequest();
std::string getStackPolicyURL()const;
void setStackPolicyURL(const std::string& stackPolicyURL);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getTemplateBody()const;
void setTemplateBody(const std::string& templateBody);
bool getDisableRollback()const;
void setDisableRollback(bool disableRollback);
std::string getStackName()const;
void setStackName(const std::string& stackName);
std::vector<Parameters> getParameters()const;
void setParameters(const std::vector<Parameters>& parameters);
std::string getStackPolicyBody()const;
void setStackPolicyBody(const std::string& stackPolicyBody);
long getTimeoutInMinutes()const;
void setTimeoutInMinutes(long timeoutInMinutes);
std::string getTemplateURL()const;
void setTemplateURL(const std::string& templateURL);
private:
std::string stackPolicyURL_;
std::string regionId_;
std::string clientToken_;
std::string templateBody_;
bool disableRollback_;
std::string stackName_;
std::vector<Parameters> parameters_;
std::string stackPolicyBody_;
long timeoutInMinutes_;
std::string templateURL_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_PREVIEWSTACKREQUEST_H_

51
ros/include/alibabacloud/ros/model/PreviewStackResult.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_ROS_MODEL_PREVIEWSTACKRESULT_H_
#define ALIBABACLOUD_ROS_MODEL_PREVIEWSTACKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT PreviewStackResult : public ServiceResult
{
public:
PreviewStackResult();
explicit PreviewStackResult(const std::string &payload);
~PreviewStackResult();
std::string getStack()const;
protected:
void parse(const std::string &payload);
private:
std::string stack_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_PREVIEWSTACKRESULT_H_

57
ros/include/alibabacloud/ros/model/SetStackPolicyRequest.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_ROS_MODEL_SETSTACKPOLICYREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_SETSTACKPOLICYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT SetStackPolicyRequest : public RpcServiceRequest
{
public:
SetStackPolicyRequest();
~SetStackPolicyRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getStackPolicyURL()const;
void setStackPolicyURL(const std::string& stackPolicyURL);
std::string getStackId()const;
void setStackId(const std::string& stackId);
std::string getStackPolicyBody()const;
void setStackPolicyBody(const std::string& stackPolicyBody);
private:
std::string regionId_;
std::string stackPolicyURL_;
std::string stackId_;
std::string stackPolicyBody_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_SETSTACKPOLICYREQUEST_H_

49
ros/include/alibabacloud/ros/model/SetStackPolicyResult.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_ROS_MODEL_SETSTACKPOLICYRESULT_H_
#define ALIBABACLOUD_ROS_MODEL_SETSTACKPOLICYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT SetStackPolicyResult : public ServiceResult
{
public:
SetStackPolicyResult();
explicit SetStackPolicyResult(const std::string &payload);
~SetStackPolicyResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_SETSTACKPOLICYRESULT_H_

66
ros/include/alibabacloud/ros/model/SignalResourceRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ROS_MODEL_SIGNALRESOURCEREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_SIGNALRESOURCEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT SignalResourceRequest : public RpcServiceRequest
{
public:
SignalResourceRequest();
~SignalResourceRequest();
std::string getData()const;
void setData(const std::string& data);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getStackId()const;
void setStackId(const std::string& stackId);
std::string getLogicalResourceId()const;
void setLogicalResourceId(const std::string& logicalResourceId);
std::string getUniqueId()const;
void setUniqueId(const std::string& uniqueId);
std::string getStatus()const;
void setStatus(const std::string& status);
private:
std::string data_;
std::string regionId_;
std::string clientToken_;
std::string stackId_;
std::string logicalResourceId_;
std::string uniqueId_;
std::string status_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_SIGNALRESOURCEREQUEST_H_

49
ros/include/alibabacloud/ros/model/SignalResourceResult.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_ROS_MODEL_SIGNALRESOURCERESULT_H_
#define ALIBABACLOUD_ROS_MODEL_SIGNALRESOURCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT SignalResourceResult : public ServiceResult
{
public:
SignalResourceResult();
explicit SignalResourceResult(const std::string &payload);
~SignalResourceResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_SIGNALRESOURCERESULT_H_

95
ros/include/alibabacloud/ros/model/UpdateStackRequest.h Normal file
View File

@@ -0,0 +1,95 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ROS_MODEL_UPDATESTACKREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_UPDATESTACKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT UpdateStackRequest : public RpcServiceRequest
{
struct Parameters
{
std::string parameterValue;
std::string parameterKey;
};
public:
UpdateStackRequest();
~UpdateStackRequest();
std::string getStackPolicyDuringUpdateURL()const;
void setStackPolicyDuringUpdateURL(const std::string& stackPolicyDuringUpdateURL);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getTemplateBody()const;
void setTemplateBody(const std::string& templateBody);
std::string getStackId()const;
void setStackId(const std::string& stackId);
bool getDisableRollback()const;
void setDisableRollback(bool disableRollback);
bool getEnableRecover()const;
void setEnableRecover(bool enableRecover);
std::string getUpdateAllowPolicy()const;
void setUpdateAllowPolicy(const std::string& updateAllowPolicy);
long getTimeoutInMinutes()const;
void setTimeoutInMinutes(long timeoutInMinutes);
bool getUsePreviousParameters()const;
void setUsePreviousParameters(bool usePreviousParameters);
std::string getTemplateURL()const;
void setTemplateURL(const std::string& templateURL);
std::string getStackPolicyDuringUpdateBody()const;
void setStackPolicyDuringUpdateBody(const std::string& stackPolicyDuringUpdateBody);
std::string getStackPolicyURL()const;
void setStackPolicyURL(const std::string& stackPolicyURL);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::vector<Parameters> getParameters()const;
void setParameters(const std::vector<Parameters>& parameters);
std::string getStackPolicyBody()const;
void setStackPolicyBody(const std::string& stackPolicyBody);
private:
std::string stackPolicyDuringUpdateURL_;
std::string clientToken_;
std::string templateBody_;
std::string stackId_;
bool disableRollback_;
bool enableRecover_;
std::string updateAllowPolicy_;
long timeoutInMinutes_;
bool usePreviousParameters_;
std::string templateURL_;
std::string stackPolicyDuringUpdateBody_;
std::string stackPolicyURL_;
std::string regionId_;
std::vector<Parameters> parameters_;
std::string stackPolicyBody_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_UPDATESTACKREQUEST_H_

51
ros/include/alibabacloud/ros/model/UpdateStackResult.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_ROS_MODEL_UPDATESTACKRESULT_H_
#define ALIBABACLOUD_ROS_MODEL_UPDATESTACKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT UpdateStackResult : public ServiceResult
{
public:
UpdateStackResult();
explicit UpdateStackResult(const std::string &payload);
~UpdateStackResult();
std::string getStackId()const;
protected:
void parse(const std::string &payload);
private:
std::string stackId_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_UPDATESTACKRESULT_H_

54
ros/include/alibabacloud/ros/model/ValidateTemplateRequest.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_ROS_MODEL_VALIDATETEMPLATEREQUEST_H_
#define ALIBABACLOUD_ROS_MODEL_VALIDATETEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT ValidateTemplateRequest : public RpcServiceRequest
{
public:
ValidateTemplateRequest();
~ValidateTemplateRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getTemplateBody()const;
void setTemplateBody(const std::string& templateBody);
std::string getTemplateURL()const;
void setTemplateURL(const std::string& templateURL);
private:
std::string regionId_;
std::string templateBody_;
std::string templateURL_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_VALIDATETEMPLATEREQUEST_H_

53
ros/include/alibabacloud/ros/model/ValidateTemplateResult.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_ROS_MODEL_VALIDATETEMPLATERESULT_H_
#define ALIBABACLOUD_ROS_MODEL_VALIDATETEMPLATERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ros/ROSExport.h>
namespace AlibabaCloud
{
namespace ROS
{
namespace Model
{
class ALIBABACLOUD_ROS_EXPORT ValidateTemplateResult : public ServiceResult
{
public:
ValidateTemplateResult();
explicit ValidateTemplateResult(const std::string &payload);
~ValidateTemplateResult();
std::vector<std::string> getParameters()const;
std::string getDescription()const;
protected:
void parse(const std::string &payload);
private:
std::vector<std::string> parameters_;
std::string description_;
};
}
}
}
#endif // !ALIBABACLOUD_ROS_MODEL_VALIDATETEMPLATERESULT_H_