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

Counters and Parameters are changed to Map in ListExections and StartExecution.

Browse Source
This commit is contained in:
sdk-team
2020-04-01 16:07:28 +08:00
parent 773c9d68dd
commit 2efc5c0610
106 changed files with 8469 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

246
oos/include/alibabacloud/oos/OosClient.h Normal file
View File

@@ -0,0 +1,246 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_OOSCLIENT_H_
#define ALIBABACLOUD_OOS_OOSCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "OosExport.h"
#include "model/CancelExecutionRequest.h"
#include "model/CancelExecutionResult.h"
#include "model/CreateTemplateRequest.h"
#include "model/CreateTemplateResult.h"
#include "model/DeleteExecutionsRequest.h"
#include "model/DeleteExecutionsResult.h"
#include "model/DeleteTemplateRequest.h"
#include "model/DeleteTemplateResult.h"
#include "model/DeleteTemplatesRequest.h"
#include "model/DeleteTemplatesResult.h"
#include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h"
#include "model/GenerateExecutionPolicyRequest.h"
#include "model/GenerateExecutionPolicyResult.h"
#include "model/GetExecutionTemplateRequest.h"
#include "model/GetExecutionTemplateResult.h"
#include "model/GetTemplateRequest.h"
#include "model/GetTemplateResult.h"
#include "model/ListActionsRequest.h"
#include "model/ListActionsResult.h"
#include "model/ListExecutionLogsRequest.h"
#include "model/ListExecutionLogsResult.h"
#include "model/ListExecutionRiskyTasksRequest.h"
#include "model/ListExecutionRiskyTasksResult.h"
#include "model/ListExecutionsRequest.h"
#include "model/ListExecutionsResult.h"
#include "model/ListTagKeysRequest.h"
#include "model/ListTagKeysResult.h"
#include "model/ListTagResourcesRequest.h"
#include "model/ListTagResourcesResult.h"
#include "model/ListTagValuesRequest.h"
#include "model/ListTagValuesResult.h"
#include "model/ListTaskExecutionsRequest.h"
#include "model/ListTaskExecutionsResult.h"
#include "model/ListTemplatesRequest.h"
#include "model/ListTemplatesResult.h"
#include "model/NotifyExecutionRequest.h"
#include "model/NotifyExecutionResult.h"
#include "model/StartExecutionRequest.h"
#include "model/StartExecutionResult.h"
#include "model/TagResourcesRequest.h"
#include "model/TagResourcesResult.h"
#include "model/TriggerExecutionRequest.h"
#include "model/TriggerExecutionResult.h"
#include "model/UntagResourcesRequest.h"
#include "model/UntagResourcesResult.h"
#include "model/UpdateTemplateRequest.h"
#include "model/UpdateTemplateResult.h"
#include "model/ValidateTemplateContentRequest.h"
#include "model/ValidateTemplateContentResult.h"
namespace AlibabaCloud
{
namespace Oos
{
class ALIBABACLOUD_OOS_EXPORT OosClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::CancelExecutionResult> CancelExecutionOutcome;
typedef std::future<CancelExecutionOutcome> CancelExecutionOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::CancelExecutionRequest&, const CancelExecutionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CancelExecutionAsyncHandler;
typedef Outcome<Error, Model::CreateTemplateResult> CreateTemplateOutcome;
typedef std::future<CreateTemplateOutcome> CreateTemplateOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::CreateTemplateRequest&, const CreateTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateTemplateAsyncHandler;
typedef Outcome<Error, Model::DeleteExecutionsResult> DeleteExecutionsOutcome;
typedef std::future<DeleteExecutionsOutcome> DeleteExecutionsOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::DeleteExecutionsRequest&, const DeleteExecutionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteExecutionsAsyncHandler;
typedef Outcome<Error, Model::DeleteTemplateResult> DeleteTemplateOutcome;
typedef std::future<DeleteTemplateOutcome> DeleteTemplateOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::DeleteTemplateRequest&, const DeleteTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTemplateAsyncHandler;
typedef Outcome<Error, Model::DeleteTemplatesResult> DeleteTemplatesOutcome;
typedef std::future<DeleteTemplatesOutcome> DeleteTemplatesOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::DeleteTemplatesRequest&, const DeleteTemplatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTemplatesAsyncHandler;
typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
typedef Outcome<Error, Model::GenerateExecutionPolicyResult> GenerateExecutionPolicyOutcome;
typedef std::future<GenerateExecutionPolicyOutcome> GenerateExecutionPolicyOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::GenerateExecutionPolicyRequest&, const GenerateExecutionPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateExecutionPolicyAsyncHandler;
typedef Outcome<Error, Model::GetExecutionTemplateResult> GetExecutionTemplateOutcome;
typedef std::future<GetExecutionTemplateOutcome> GetExecutionTemplateOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::GetExecutionTemplateRequest&, const GetExecutionTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetExecutionTemplateAsyncHandler;
typedef Outcome<Error, Model::GetTemplateResult> GetTemplateOutcome;
typedef std::future<GetTemplateOutcome> GetTemplateOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::GetTemplateRequest&, const GetTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTemplateAsyncHandler;
typedef Outcome<Error, Model::ListActionsResult> ListActionsOutcome;
typedef std::future<ListActionsOutcome> ListActionsOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::ListActionsRequest&, const ListActionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListActionsAsyncHandler;
typedef Outcome<Error, Model::ListExecutionLogsResult> ListExecutionLogsOutcome;
typedef std::future<ListExecutionLogsOutcome> ListExecutionLogsOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::ListExecutionLogsRequest&, const ListExecutionLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListExecutionLogsAsyncHandler;
typedef Outcome<Error, Model::ListExecutionRiskyTasksResult> ListExecutionRiskyTasksOutcome;
typedef std::future<ListExecutionRiskyTasksOutcome> ListExecutionRiskyTasksOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::ListExecutionRiskyTasksRequest&, const ListExecutionRiskyTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListExecutionRiskyTasksAsyncHandler;
typedef Outcome<Error, Model::ListExecutionsResult> ListExecutionsOutcome;
typedef std::future<ListExecutionsOutcome> ListExecutionsOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::ListExecutionsRequest&, const ListExecutionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListExecutionsAsyncHandler;
typedef Outcome<Error, Model::ListTagKeysResult> ListTagKeysOutcome;
typedef std::future<ListTagKeysOutcome> ListTagKeysOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::ListTagKeysRequest&, const ListTagKeysOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagKeysAsyncHandler;
typedef Outcome<Error, Model::ListTagResourcesResult> ListTagResourcesOutcome;
typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
typedef Outcome<Error, Model::ListTagValuesResult> ListTagValuesOutcome;
typedef std::future<ListTagValuesOutcome> ListTagValuesOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::ListTagValuesRequest&, const ListTagValuesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagValuesAsyncHandler;
typedef Outcome<Error, Model::ListTaskExecutionsResult> ListTaskExecutionsOutcome;
typedef std::future<ListTaskExecutionsOutcome> ListTaskExecutionsOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::ListTaskExecutionsRequest&, const ListTaskExecutionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTaskExecutionsAsyncHandler;
typedef Outcome<Error, Model::ListTemplatesResult> ListTemplatesOutcome;
typedef std::future<ListTemplatesOutcome> ListTemplatesOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::ListTemplatesRequest&, const ListTemplatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTemplatesAsyncHandler;
typedef Outcome<Error, Model::NotifyExecutionResult> NotifyExecutionOutcome;
typedef std::future<NotifyExecutionOutcome> NotifyExecutionOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::NotifyExecutionRequest&, const NotifyExecutionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> NotifyExecutionAsyncHandler;
typedef Outcome<Error, Model::StartExecutionResult> StartExecutionOutcome;
typedef std::future<StartExecutionOutcome> StartExecutionOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::StartExecutionRequest&, const StartExecutionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartExecutionAsyncHandler;
typedef Outcome<Error, Model::TagResourcesResult> TagResourcesOutcome;
typedef std::future<TagResourcesOutcome> TagResourcesOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::TagResourcesRequest&, const TagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TagResourcesAsyncHandler;
typedef Outcome<Error, Model::TriggerExecutionResult> TriggerExecutionOutcome;
typedef std::future<TriggerExecutionOutcome> TriggerExecutionOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::TriggerExecutionRequest&, const TriggerExecutionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TriggerExecutionAsyncHandler;
typedef Outcome<Error, Model::UntagResourcesResult> UntagResourcesOutcome;
typedef std::future<UntagResourcesOutcome> UntagResourcesOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::UntagResourcesRequest&, const UntagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UntagResourcesAsyncHandler;
typedef Outcome<Error, Model::UpdateTemplateResult> UpdateTemplateOutcome;
typedef std::future<UpdateTemplateOutcome> UpdateTemplateOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::UpdateTemplateRequest&, const UpdateTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateTemplateAsyncHandler;
typedef Outcome<Error, Model::ValidateTemplateContentResult> ValidateTemplateContentOutcome;
typedef std::future<ValidateTemplateContentOutcome> ValidateTemplateContentOutcomeCallable;
typedef std::function<void(const OosClient*, const Model::ValidateTemplateContentRequest&, const ValidateTemplateContentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ValidateTemplateContentAsyncHandler;
OosClient(const Credentials &credentials, const ClientConfiguration &configuration);
OosClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
OosClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~OosClient();
CancelExecutionOutcome cancelExecution(const Model::CancelExecutionRequest &request)const;
void cancelExecutionAsync(const Model::CancelExecutionRequest& request, const CancelExecutionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CancelExecutionOutcomeCallable cancelExecutionCallable(const Model::CancelExecutionRequest& request) const;
CreateTemplateOutcome createTemplate(const Model::CreateTemplateRequest &request)const;
void createTemplateAsync(const Model::CreateTemplateRequest& request, const CreateTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateTemplateOutcomeCallable createTemplateCallable(const Model::CreateTemplateRequest& request) const;
DeleteExecutionsOutcome deleteExecutions(const Model::DeleteExecutionsRequest &request)const;
void deleteExecutionsAsync(const Model::DeleteExecutionsRequest& request, const DeleteExecutionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteExecutionsOutcomeCallable deleteExecutionsCallable(const Model::DeleteExecutionsRequest& request) const;
DeleteTemplateOutcome deleteTemplate(const Model::DeleteTemplateRequest &request)const;
void deleteTemplateAsync(const Model::DeleteTemplateRequest& request, const DeleteTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteTemplateOutcomeCallable deleteTemplateCallable(const Model::DeleteTemplateRequest& request) const;
DeleteTemplatesOutcome deleteTemplates(const Model::DeleteTemplatesRequest &request)const;
void deleteTemplatesAsync(const Model::DeleteTemplatesRequest& request, const DeleteTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteTemplatesOutcomeCallable deleteTemplatesCallable(const Model::DeleteTemplatesRequest& 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;
GenerateExecutionPolicyOutcome generateExecutionPolicy(const Model::GenerateExecutionPolicyRequest &request)const;
void generateExecutionPolicyAsync(const Model::GenerateExecutionPolicyRequest& request, const GenerateExecutionPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GenerateExecutionPolicyOutcomeCallable generateExecutionPolicyCallable(const Model::GenerateExecutionPolicyRequest& request) const;
GetExecutionTemplateOutcome getExecutionTemplate(const Model::GetExecutionTemplateRequest &request)const;
void getExecutionTemplateAsync(const Model::GetExecutionTemplateRequest& request, const GetExecutionTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetExecutionTemplateOutcomeCallable getExecutionTemplateCallable(const Model::GetExecutionTemplateRequest& 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;
ListActionsOutcome listActions(const Model::ListActionsRequest &request)const;
void listActionsAsync(const Model::ListActionsRequest& request, const ListActionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListActionsOutcomeCallable listActionsCallable(const Model::ListActionsRequest& request) const;
ListExecutionLogsOutcome listExecutionLogs(const Model::ListExecutionLogsRequest &request)const;
void listExecutionLogsAsync(const Model::ListExecutionLogsRequest& request, const ListExecutionLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListExecutionLogsOutcomeCallable listExecutionLogsCallable(const Model::ListExecutionLogsRequest& request) const;
ListExecutionRiskyTasksOutcome listExecutionRiskyTasks(const Model::ListExecutionRiskyTasksRequest &request)const;
void listExecutionRiskyTasksAsync(const Model::ListExecutionRiskyTasksRequest& request, const ListExecutionRiskyTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListExecutionRiskyTasksOutcomeCallable listExecutionRiskyTasksCallable(const Model::ListExecutionRiskyTasksRequest& request) const;
ListExecutionsOutcome listExecutions(const Model::ListExecutionsRequest &request)const;
void listExecutionsAsync(const Model::ListExecutionsRequest& request, const ListExecutionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListExecutionsOutcomeCallable listExecutionsCallable(const Model::ListExecutionsRequest& request) const;
ListTagKeysOutcome listTagKeys(const Model::ListTagKeysRequest &request)const;
void listTagKeysAsync(const Model::ListTagKeysRequest& request, const ListTagKeysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTagKeysOutcomeCallable listTagKeysCallable(const Model::ListTagKeysRequest& request) const;
ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const;
void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const;
ListTagValuesOutcome listTagValues(const Model::ListTagValuesRequest &request)const;
void listTagValuesAsync(const Model::ListTagValuesRequest& request, const ListTagValuesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTagValuesOutcomeCallable listTagValuesCallable(const Model::ListTagValuesRequest& request) const;
ListTaskExecutionsOutcome listTaskExecutions(const Model::ListTaskExecutionsRequest &request)const;
void listTaskExecutionsAsync(const Model::ListTaskExecutionsRequest& request, const ListTaskExecutionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTaskExecutionsOutcomeCallable listTaskExecutionsCallable(const Model::ListTaskExecutionsRequest& request) const;
ListTemplatesOutcome listTemplates(const Model::ListTemplatesRequest &request)const;
void listTemplatesAsync(const Model::ListTemplatesRequest& request, const ListTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTemplatesOutcomeCallable listTemplatesCallable(const Model::ListTemplatesRequest& request) const;
NotifyExecutionOutcome notifyExecution(const Model::NotifyExecutionRequest &request)const;
void notifyExecutionAsync(const Model::NotifyExecutionRequest& request, const NotifyExecutionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
NotifyExecutionOutcomeCallable notifyExecutionCallable(const Model::NotifyExecutionRequest& request) const;
StartExecutionOutcome startExecution(const Model::StartExecutionRequest &request)const;
void startExecutionAsync(const Model::StartExecutionRequest& request, const StartExecutionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartExecutionOutcomeCallable startExecutionCallable(const Model::StartExecutionRequest& request) const;
TagResourcesOutcome tagResources(const Model::TagResourcesRequest &request)const;
void tagResourcesAsync(const Model::TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TagResourcesOutcomeCallable tagResourcesCallable(const Model::TagResourcesRequest& request) const;
TriggerExecutionOutcome triggerExecution(const Model::TriggerExecutionRequest &request)const;
void triggerExecutionAsync(const Model::TriggerExecutionRequest& request, const TriggerExecutionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TriggerExecutionOutcomeCallable triggerExecutionCallable(const Model::TriggerExecutionRequest& request) const;
UntagResourcesOutcome untagResources(const Model::UntagResourcesRequest &request)const;
void untagResourcesAsync(const Model::UntagResourcesRequest& request, const UntagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UntagResourcesOutcomeCallable untagResourcesCallable(const Model::UntagResourcesRequest& request) const;
UpdateTemplateOutcome updateTemplate(const Model::UpdateTemplateRequest &request)const;
void updateTemplateAsync(const Model::UpdateTemplateRequest& request, const UpdateTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateTemplateOutcomeCallable updateTemplateCallable(const Model::UpdateTemplateRequest& request) const;
ValidateTemplateContentOutcome validateTemplateContent(const Model::ValidateTemplateContentRequest &request)const;
void validateTemplateContentAsync(const Model::ValidateTemplateContentRequest& request, const ValidateTemplateContentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ValidateTemplateContentOutcomeCallable validateTemplateContentCallable(const Model::ValidateTemplateContentRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_OOS_OOSCLIENT_H_

32
oos/include/alibabacloud/oos/OosExport.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_OOS_OOSEXPORT_H_
#define ALIBABACLOUD_OOS_OOSEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_OOS_LIBRARY)
# define ALIBABACLOUD_OOS_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_OOS_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_OOS_EXPORT
#endif
#endif // !ALIBABACLOUD_OOS_OOSEXPORT_H_

51
oos/include/alibabacloud/oos/model/CancelExecutionRequest.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_OOS_MODEL_CANCELEXECUTIONREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_CANCELEXECUTIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT CancelExecutionRequest : public RpcServiceRequest
{
public:
CancelExecutionRequest();
~CancelExecutionRequest();
std::string getExecutionId()const;
void setExecutionId(const std::string& executionId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string executionId_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_CANCELEXECUTIONREQUEST_H_

49
oos/include/alibabacloud/oos/model/CancelExecutionResult.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_OOS_MODEL_CANCELEXECUTIONRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_CANCELEXECUTIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT CancelExecutionResult : public ServiceResult
{
public:
CancelExecutionResult();
explicit CancelExecutionResult(const std::string &payload);
~CancelExecutionResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_CANCELEXECUTIONRESULT_H_

57
oos/include/alibabacloud/oos/model/CreateTemplateRequest.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_OOS_MODEL_CREATETEMPLATEREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_CREATETEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT CreateTemplateRequest : public RpcServiceRequest
{
public:
CreateTemplateRequest();
~CreateTemplateRequest();
std::string getContent()const;
void setContent(const std::string& content);
std::map<std::string, std::string> getTags()const;
void setTags(const std::map<std::string, std::string>& tags);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getTemplateName()const;
void setTemplateName(const std::string& templateName);
private:
std::string content_;
std::map<std::string, std::string> tags_;
std::string regionId_;
std::string templateName_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_CREATETEMPLATEREQUEST_H_

67
oos/include/alibabacloud/oos/model/CreateTemplateResult.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_CREATETEMPLATERESULT_H_
#define ALIBABACLOUD_OOS_MODEL_CREATETEMPLATERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT CreateTemplateResult : public ServiceResult
{
public:
struct _Template
{
std::string createdBy;
std::string description;
std::string templateFormat;
std::string updatedDate;
std::string templateVersion;
std::string hash;
std::string updatedBy;
bool hasTrigger;
std::string createdDate;
std::string templateName;
std::string templateId;
std::string tags;
std::string shareType;
};
CreateTemplateResult();
explicit CreateTemplateResult(const std::string &payload);
~CreateTemplateResult();
_Template get_Template()const;
protected:
void parse(const std::string &payload);
private:
_Template _template_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_CREATETEMPLATERESULT_H_

51
oos/include/alibabacloud/oos/model/DeleteExecutionsRequest.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_OOS_MODEL_DELETEEXECUTIONSREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_DELETEEXECUTIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT DeleteExecutionsRequest : public RpcServiceRequest
{
public:
DeleteExecutionsRequest();
~DeleteExecutionsRequest();
std::string getExecutionIds()const;
void setExecutionIds(const std::string& executionIds);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string executionIds_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_DELETEEXECUTIONSREQUEST_H_

49
oos/include/alibabacloud/oos/model/DeleteExecutionsResult.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_OOS_MODEL_DELETEEXECUTIONSRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_DELETEEXECUTIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT DeleteExecutionsResult : public ServiceResult
{
public:
DeleteExecutionsResult();
explicit DeleteExecutionsResult(const std::string &payload);
~DeleteExecutionsResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_DELETEEXECUTIONSRESULT_H_

54
oos/include/alibabacloud/oos/model/DeleteTemplateRequest.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_OOS_MODEL_DELETETEMPLATEREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_DELETETEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT DeleteTemplateRequest : public RpcServiceRequest
{
public:
DeleteTemplateRequest();
~DeleteTemplateRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getAutoDeleteExecutions()const;
void setAutoDeleteExecutions(bool autoDeleteExecutions);
std::string getTemplateName()const;
void setTemplateName(const std::string& templateName);
private:
std::string regionId_;
bool autoDeleteExecutions_;
std::string templateName_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_DELETETEMPLATEREQUEST_H_

49
oos/include/alibabacloud/oos/model/DeleteTemplateResult.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_OOS_MODEL_DELETETEMPLATERESULT_H_
#define ALIBABACLOUD_OOS_MODEL_DELETETEMPLATERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT DeleteTemplateResult : public ServiceResult
{
public:
DeleteTemplateResult();
explicit DeleteTemplateResult(const std::string &payload);
~DeleteTemplateResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_DELETETEMPLATERESULT_H_

54
oos/include/alibabacloud/oos/model/DeleteTemplatesRequest.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_OOS_MODEL_DELETETEMPLATESREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_DELETETEMPLATESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT DeleteTemplatesRequest : public RpcServiceRequest
{
public:
DeleteTemplatesRequest();
~DeleteTemplatesRequest();
std::string getTemplateNames()const;
void setTemplateNames(const std::string& templateNames);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getAutoDeleteExecutions()const;
void setAutoDeleteExecutions(bool autoDeleteExecutions);
private:
std::string templateNames_;
std::string regionId_;
bool autoDeleteExecutions_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_DELETETEMPLATESREQUEST_H_

49
oos/include/alibabacloud/oos/model/DeleteTemplatesResult.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_OOS_MODEL_DELETETEMPLATESRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_DELETETEMPLATESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT DeleteTemplatesResult : public ServiceResult
{
public:
DeleteTemplatesResult();
explicit DeleteTemplatesResult(const std::string &payload);
~DeleteTemplatesResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_DELETETEMPLATESRESULT_H_

51
oos/include/alibabacloud/oos/model/DescribeRegionsRequest.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_OOS_MODEL_DESCRIBEREGIONSREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_DESCRIBEREGIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT DescribeRegionsRequest : public RpcServiceRequest
{
public:
DescribeRegionsRequest();
~DescribeRegionsRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getAcceptLanguage()const;
void setAcceptLanguage(const std::string& acceptLanguage);
private:
std::string regionId_;
std::string acceptLanguage_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_DESCRIBEREGIONSREQUEST_H_

57
oos/include/alibabacloud/oos/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_OOS_MODEL_DESCRIBEREGIONSRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_DESCRIBEREGIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_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_OOS_MODEL_DESCRIBEREGIONSRESULT_H_

51
oos/include/alibabacloud/oos/model/GenerateExecutionPolicyRequest.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_OOS_MODEL_GENERATEEXECUTIONPOLICYREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_GENERATEEXECUTIONPOLICYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT GenerateExecutionPolicyRequest : public RpcServiceRequest
{
public:
GenerateExecutionPolicyRequest();
~GenerateExecutionPolicyRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getTemplateName()const;
void setTemplateName(const std::string& templateName);
private:
std::string regionId_;
std::string templateName_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_GENERATEEXECUTIONPOLICYREQUEST_H_

51
oos/include/alibabacloud/oos/model/GenerateExecutionPolicyResult.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_OOS_MODEL_GENERATEEXECUTIONPOLICYRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_GENERATEEXECUTIONPOLICYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT GenerateExecutionPolicyResult : public ServiceResult
{
public:
GenerateExecutionPolicyResult();
explicit GenerateExecutionPolicyResult(const std::string &payload);
~GenerateExecutionPolicyResult();
std::string getPolicy()const;
protected:
void parse(const std::string &payload);
private:
std::string policy_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_GENERATEEXECUTIONPOLICYRESULT_H_

51
oos/include/alibabacloud/oos/model/GetExecutionTemplateRequest.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_OOS_MODEL_GETEXECUTIONTEMPLATEREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_GETEXECUTIONTEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT GetExecutionTemplateRequest : public RpcServiceRequest
{
public:
GetExecutionTemplateRequest();
~GetExecutionTemplateRequest();
std::string getExecutionId()const;
void setExecutionId(const std::string& executionId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string executionId_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_GETEXECUTIONTEMPLATEREQUEST_H_

68
oos/include/alibabacloud/oos/model/GetExecutionTemplateResult.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_GETEXECUTIONTEMPLATERESULT_H_
#define ALIBABACLOUD_OOS_MODEL_GETEXECUTIONTEMPLATERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT GetExecutionTemplateResult : public ServiceResult
{
public:
struct _Template
{
std::string updatedBy;
std::string createdBy;
std::string description;
std::string templateFormat;
std::string updatedDate;
std::string createdDate;
std::string templateName;
std::string templateVersion;
std::string hash;
std::string templateId;
std::string tags;
std::string shareType;
};
GetExecutionTemplateResult();
explicit GetExecutionTemplateResult(const std::string &payload);
~GetExecutionTemplateResult();
_Template get_Template()const;
std::string getContent()const;
protected:
void parse(const std::string &payload);
private:
_Template _template_;
std::string content_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_GETEXECUTIONTEMPLATERESULT_H_

54
oos/include/alibabacloud/oos/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_OOS_MODEL_GETTEMPLATEREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_GETTEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT GetTemplateRequest : public RpcServiceRequest
{
public:
GetTemplateRequest();
~GetTemplateRequest();
std::string getTemplateVersion()const;
void setTemplateVersion(const std::string& templateVersion);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getTemplateName()const;
void setTemplateName(const std::string& templateName);
private:
std::string templateVersion_;
std::string regionId_;
std::string templateName_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_GETTEMPLATEREQUEST_H_

69
oos/include/alibabacloud/oos/model/GetTemplateResult.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_OOS_MODEL_GETTEMPLATERESULT_H_
#define ALIBABACLOUD_OOS_MODEL_GETTEMPLATERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT GetTemplateResult : public ServiceResult
{
public:
struct _Template
{
std::string createdBy;
std::string description;
std::string templateFormat;
std::string updatedDate;
std::string templateVersion;
std::string hash;
std::string updatedBy;
bool hasTrigger;
std::string createdDate;
std::string templateName;
std::string templateId;
std::string tags;
std::string shareType;
};
GetTemplateResult();
explicit GetTemplateResult(const std::string &payload);
~GetTemplateResult();
_Template get_Template()const;
std::string getContent()const;
protected:
void parse(const std::string &payload);
private:
_Template _template_;
std::string content_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_GETTEMPLATERESULT_H_

57
oos/include/alibabacloud/oos/model/ListActionsRequest.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_OOS_MODEL_LISTACTIONSREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_LISTACTIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListActionsRequest : public RpcServiceRequest
{
public:
ListActionsRequest();
~ListActionsRequest();
std::string getOOSActionName()const;
void setOOSActionName(const std::string& oOSActionName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
int getMaxResults()const;
void setMaxResults(int maxResults);
private:
std::string oOSActionName_;
std::string regionId_;
std::string nextToken_;
int maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTACTIONSREQUEST_H_

64
oos/include/alibabacloud/oos/model/ListActionsResult.h Normal file
View File

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

63
oos/include/alibabacloud/oos/model/ListExecutionLogsRequest.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_OOS_MODEL_LISTEXECUTIONLOGSREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONLOGSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListExecutionLogsRequest : public RpcServiceRequest
{
public:
ListExecutionLogsRequest();
~ListExecutionLogsRequest();
std::string getExecutionId()const;
void setExecutionId(const std::string& executionId);
std::string getLogType()const;
void setLogType(const std::string& logType);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
int getMaxResults()const;
void setMaxResults(int maxResults);
std::string getTaskExecutionId()const;
void setTaskExecutionId(const std::string& taskExecutionId);
private:
std::string executionId_;
std::string logType_;
std::string regionId_;
std::string nextToken_;
int maxResults_;
std::string taskExecutionId_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONLOGSREQUEST_H_

64
oos/include/alibabacloud/oos/model/ListExecutionLogsResult.h Normal file
View File

@@ -0,0 +1,64 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONLOGSRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONLOGSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListExecutionLogsResult : public ServiceResult
{
public:
struct ExecutionLog
{
std::string message;
std::string logType;
std::string timestamp;
std::string taskExecutionId;
};
ListExecutionLogsResult();
explicit ListExecutionLogsResult(const std::string &payload);
~ListExecutionLogsResult();
std::string getNextToken()const;
std::vector<ExecutionLog> getExecutionLogs()const;
int getMaxResults()const;
bool getIsTruncated()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
std::vector<ExecutionLog> executionLogs_;
int maxResults_;
bool isTruncated_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONLOGSRESULT_H_

51
oos/include/alibabacloud/oos/model/ListExecutionRiskyTasksRequest.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_OOS_MODEL_LISTEXECUTIONRISKYTASKSREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONRISKYTASKSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListExecutionRiskyTasksRequest : public RpcServiceRequest
{
public:
ListExecutionRiskyTasksRequest();
~ListExecutionRiskyTasksRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getTemplateName()const;
void setTemplateName(const std::string& templateName);
private:
std::string regionId_;
std::string templateName_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONRISKYTASKSREQUEST_H_

58
oos/include/alibabacloud/oos/model/ListExecutionRiskyTasksResult.h Normal file
View File

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

102
oos/include/alibabacloud/oos/model/ListExecutionsRequest.h Normal file
View File

@@ -0,0 +1,102 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONSREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListExecutionsRequest : public RpcServiceRequest
{
public:
ListExecutionsRequest();
~ListExecutionsRequest();
std::string getExecutedBy()const;
void setExecutedBy(const std::string& executedBy);
bool getIncludeChildExecution()const;
void setIncludeChildExecution(bool includeChildExecution);
std::string getMode()const;
void setMode(const std::string& mode);
std::string getExecutionId()const;
void setExecutionId(const std::string& executionId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getRamRole()const;
void setRamRole(const std::string& ramRole);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
std::string getTemplateName()const;
void setTemplateName(const std::string& templateName);
std::string getEndDateBefore()const;
void setEndDateBefore(const std::string& endDateBefore);
std::string getSortOrder()const;
void setSortOrder(const std::string& sortOrder);
std::string getStartDateAfter()const;
void setStartDateAfter(const std::string& startDateAfter);
std::string getStartDateBefore()const;
void setStartDateBefore(const std::string& startDateBefore);
std::map<std::string, std::string> getTags()const;
void setTags(const std::map<std::string, std::string>& tags);
std::string getParentExecutionId()const;
void setParentExecutionId(const std::string& parentExecutionId);
std::string getEndDateAfter()const;
void setEndDateAfter(const std::string& endDateAfter);
int getMaxResults()const;
void setMaxResults(int maxResults);
std::string getSortField()const;
void setSortField(const std::string& sortField);
std::string getCategory()const;
void setCategory(const std::string& category);
std::string getStatus()const;
void setStatus(const std::string& status);
private:
std::string executedBy_;
bool includeChildExecution_;
std::string mode_;
std::string executionId_;
std::string regionId_;
std::string ramRole_;
std::string nextToken_;
std::string templateName_;
std::string endDateBefore_;
std::string sortOrder_;
std::string startDateAfter_;
std::string startDateBefore_;
std::map<std::string, std::string> tags_;
std::string parentExecutionId_;
std::string endDateAfter_;
int maxResults_;
std::string sortField_;
std::string category_;
std::string status_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONSREQUEST_H_

89
oos/include/alibabacloud/oos/model/ListExecutionsResult.h Normal file
View File

@@ -0,0 +1,89 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONSRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListExecutionsResult : public ServiceResult
{
public:
struct Execution
{
struct CurrentTask
{
std::string taskName;
std::string taskAction;
std::string taskExecutionId;
};
std::vector<Execution::CurrentTask> currentTasks;
std::string parentExecutionId;
std::string category;
std::string description;
std::string templateVersion;
std::string createDate;
std::string startDate;
std::string updateDate;
std::string templateName;
std::string templateId;
std::string executedBy;
std::string tags;
std::string status;
std::string parameters;
std::string statusReason;
bool isParent;
std::string mode;
std::string endDate;
std::string waitingStatus;
std::string statusMessage;
std::string safetyCheck;
std::string outputs;
std::string ramRole;
std::string counters;
std::string executionId;
};
ListExecutionsResult();
explicit ListExecutionsResult(const std::string &payload);
~ListExecutionsResult();
std::vector<Execution> getExecutions()const;
std::string getNextToken()const;
int getMaxResults()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Execution> executions_;
std::string nextToken_;
int maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTEXECUTIONSRESULT_H_

57
oos/include/alibabacloud/oos/model/ListTagKeysRequest.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_OOS_MODEL_LISTTAGKEYSREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_LISTTAGKEYSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListTagKeysRequest : public RpcServiceRequest
{
public:
ListTagKeysRequest();
~ListTagKeysRequest();
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
int getMaxResults()const;
void setMaxResults(int maxResults);
private:
std::string resourceType_;
std::string regionId_;
std::string nextToken_;
int maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTTAGKEYSREQUEST_H_

55
oos/include/alibabacloud/oos/model/ListTagKeysResult.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_OOS_MODEL_LISTTAGKEYSRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_LISTTAGKEYSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListTagKeysResult : public ServiceResult
{
public:
ListTagKeysResult();
explicit ListTagKeysResult(const std::string &payload);
~ListTagKeysResult();
std::string getNextToken()const;
std::vector<std::string> getKeys()const;
int getMaxResults()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
std::vector<std::string> keys_;
int maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTTAGKEYSRESULT_H_

60
oos/include/alibabacloud/oos/model/ListTagResourcesRequest.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_OOS_MODEL_LISTTAGRESOURCESREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_LISTTAGRESOURCESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListTagResourcesRequest : public RpcServiceRequest
{
public:
ListTagResourcesRequest();
~ListTagResourcesRequest();
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
std::map<std::string, std::string> getTags()const;
void setTags(const std::map<std::string, std::string>& tags);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
std::map<std::string, std::string> getResourceIds()const;
void setResourceIds(const std::map<std::string, std::string>& resourceIds);
private:
std::string resourceType_;
std::map<std::string, std::string> tags_;
std::string regionId_;
std::string nextToken_;
std::map<std::string, std::string> resourceIds_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTTAGRESOURCESREQUEST_H_

60
oos/include/alibabacloud/oos/model/ListTagResourcesResult.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_OOS_MODEL_LISTTAGRESOURCESRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_LISTTAGRESOURCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListTagResourcesResult : public ServiceResult
{
public:
struct TagResource
{
std::string resourceId;
std::string tagKey;
std::string resourceType;
std::string tagValue;
};
ListTagResourcesResult();
explicit ListTagResourcesResult(const std::string &payload);
~ListTagResourcesResult();
std::string getNextToken()const;
std::vector<TagResource> getTagResources()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
std::vector<TagResource> tagResources_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTTAGRESOURCESRESULT_H_

60
oos/include/alibabacloud/oos/model/ListTagValuesRequest.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_OOS_MODEL_LISTTAGVALUESREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_LISTTAGVALUESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListTagValuesRequest : public RpcServiceRequest
{
public:
ListTagValuesRequest();
~ListTagValuesRequest();
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
int getMaxResults()const;
void setMaxResults(int maxResults);
std::string getKey()const;
void setKey(const std::string& key);
private:
std::string resourceType_;
std::string regionId_;
std::string nextToken_;
int maxResults_;
std::string key_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTTAGVALUESREQUEST_H_

55
oos/include/alibabacloud/oos/model/ListTagValuesResult.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_OOS_MODEL_LISTTAGVALUESRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_LISTTAGVALUESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListTagValuesResult : public ServiceResult
{
public:
ListTagValuesResult();
explicit ListTagValuesResult(const std::string &payload);
~ListTagValuesResult();
std::string getNextToken()const;
int getMaxResults()const;
std::vector<std::string> getValues()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
int maxResults_;
std::vector<std::string> values_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTTAGVALUESRESULT_H_

93
oos/include/alibabacloud/oos/model/ListTaskExecutionsRequest.h Normal file
View File

@@ -0,0 +1,93 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_LISTTASKEXECUTIONSREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_LISTTASKEXECUTIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListTaskExecutionsRequest : public RpcServiceRequest
{
public:
ListTaskExecutionsRequest();
~ListTaskExecutionsRequest();
std::string getTaskName()const;
void setTaskName(const std::string& taskName);
bool getIncludeChildTaskExecution()const;
void setIncludeChildTaskExecution(bool includeChildTaskExecution);
std::string getExecutionId()const;
void setExecutionId(const std::string& executionId);
std::string getParentTaskExecutionId()const;
void setParentTaskExecutionId(const std::string& parentTaskExecutionId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
std::string getEndDateBefore()const;
void setEndDateBefore(const std::string& endDateBefore);
std::string getSortOrder()const;
void setSortOrder(const std::string& sortOrder);
std::string getStartDateAfter()const;
void setStartDateAfter(const std::string& startDateAfter);
std::string getStartDateBefore()const;
void setStartDateBefore(const std::string& startDateBefore);
std::string getEndDateAfter()const;
void setEndDateAfter(const std::string& endDateAfter);
int getMaxResults()const;
void setMaxResults(int maxResults);
std::string getTaskExecutionId()const;
void setTaskExecutionId(const std::string& taskExecutionId);
std::string getSortField()const;
void setSortField(const std::string& sortField);
std::string getTaskAction()const;
void setTaskAction(const std::string& taskAction);
std::string getStatus()const;
void setStatus(const std::string& status);
private:
std::string taskName_;
bool includeChildTaskExecution_;
std::string executionId_;
std::string parentTaskExecutionId_;
std::string regionId_;
std::string nextToken_;
std::string endDateBefore_;
std::string sortOrder_;
std::string startDateAfter_;
std::string startDateBefore_;
std::string endDateAfter_;
int maxResults_;
std::string taskExecutionId_;
std::string sortField_;
std::string taskAction_;
std::string status_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTTASKEXECUTIONSREQUEST_H_

77
oos/include/alibabacloud/oos/model/ListTaskExecutionsResult.h Normal file
View File

@@ -0,0 +1,77 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_LISTTASKEXECUTIONSRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_LISTTASKEXECUTIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListTaskExecutionsResult : public ServiceResult
{
public:
struct TaskExecution
{
std::string status;
std::string loop;
int loopBatchNumber;
std::string taskAction;
std::string childExecutionId;
std::string extraData;
std::string properties;
std::string endDate;
std::string createDate;
std::string statusMessage;
std::string startDate;
std::string updateDate;
std::string loopItem;
std::string taskName;
std::string parentTaskExecutionId;
std::string outputs;
std::string taskExecutionId;
std::string templateId;
std::string executionId;
};
ListTaskExecutionsResult();
explicit ListTaskExecutionsResult(const std::string &payload);
~ListTaskExecutionsResult();
std::string getNextToken()const;
int getMaxResults()const;
std::vector<TaskExecution> getTaskExecutions()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
int maxResults_;
std::vector<TaskExecution> taskExecutions_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTTASKEXECUTIONSRESULT_H_

87
oos/include/alibabacloud/oos/model/ListTemplatesRequest.h Normal file
View File

@@ -0,0 +1,87 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_LISTTEMPLATESREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_LISTTEMPLATESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListTemplatesRequest : public RpcServiceRequest
{
public:
ListTemplatesRequest();
~ListTemplatesRequest();
std::string getCreatedDateBefore()const;
void setCreatedDateBefore(const std::string& createdDateBefore);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getCreatedBy()const;
void setCreatedBy(const std::string& createdBy);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
std::string getTemplateName()const;
void setTemplateName(const std::string& templateName);
std::string getSortOrder()const;
void setSortOrder(const std::string& sortOrder);
std::string getShareType()const;
void setShareType(const std::string& shareType);
bool getHasTrigger()const;
void setHasTrigger(bool hasTrigger);
std::string getCreatedDateAfter()const;
void setCreatedDateAfter(const std::string& createdDateAfter);
std::map<std::string, std::string> getTags()const;
void setTags(const std::map<std::string, std::string>& tags);
int getMaxResults()const;
void setMaxResults(int maxResults);
std::string getTemplateFormat()const;
void setTemplateFormat(const std::string& templateFormat);
std::string getSortField()const;
void setSortField(const std::string& sortField);
std::string getCategory()const;
void setCategory(const std::string& category);
private:
std::string createdDateBefore_;
std::string regionId_;
std::string createdBy_;
std::string nextToken_;
std::string templateName_;
std::string sortOrder_;
std::string shareType_;
bool hasTrigger_;
std::string createdDateAfter_;
std::map<std::string, std::string> tags_;
int maxResults_;
std::string templateFormat_;
std::string sortField_;
std::string category_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTTEMPLATESREQUEST_H_

74
oos/include/alibabacloud/oos/model/ListTemplatesResult.h Normal file
View File

@@ -0,0 +1,74 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_LISTTEMPLATESRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_LISTTEMPLATESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ListTemplatesResult : public ServiceResult
{
public:
struct _Template
{
std::string createdBy;
std::string description;
std::string category;
std::string templateFormat;
std::string updatedDate;
int popularity;
std::string templateVersion;
std::string hash;
std::string updatedBy;
bool hasTrigger;
int totalExecutionCount;
std::string createdDate;
std::string templateName;
std::string templateId;
std::string tags;
std::string shareType;
};
ListTemplatesResult();
explicit ListTemplatesResult(const std::string &payload);
~ListTemplatesResult();
std::string getNextToken()const;
int getMaxResults()const;
std::vector<_Template> getTemplates()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
int maxResults_;
std::vector<_Template> templates_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_LISTTEMPLATESRESULT_H_

75
oos/include/alibabacloud/oos/model/NotifyExecutionRequest.h Normal file
View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_NOTIFYEXECUTIONREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_NOTIFYEXECUTIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT NotifyExecutionRequest : public RpcServiceRequest
{
public:
NotifyExecutionRequest();
~NotifyExecutionRequest();
std::string getTaskName()const;
void setTaskName(const std::string& taskName);
std::string getExecutionId()const;
void setExecutionId(const std::string& executionId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNotifyType()const;
void setNotifyType(const std::string& notifyType);
std::string getExecutionStatus()const;
void setExecutionStatus(const std::string& executionStatus);
std::string getNotifyNote()const;
void setNotifyNote(const std::string& notifyNote);
std::string getLoopItem()const;
void setLoopItem(const std::string& loopItem);
std::string getTaskExecutionIds()const;
void setTaskExecutionIds(const std::string& taskExecutionIds);
std::string getTaskExecutionId()const;
void setTaskExecutionId(const std::string& taskExecutionId);
std::string getParameters()const;
void setParameters(const std::string& parameters);
private:
std::string taskName_;
std::string executionId_;
std::string regionId_;
std::string notifyType_;
std::string executionStatus_;
std::string notifyNote_;
std::string loopItem_;
std::string taskExecutionIds_;
std::string taskExecutionId_;
std::string parameters_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_NOTIFYEXECUTIONREQUEST_H_

49
oos/include/alibabacloud/oos/model/NotifyExecutionResult.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_OOS_MODEL_NOTIFYEXECUTIONRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_NOTIFYEXECUTIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT NotifyExecutionResult : public ServiceResult
{
public:
NotifyExecutionResult();
explicit NotifyExecutionResult(const std::string &payload);
~NotifyExecutionResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_NOTIFYEXECUTIONRESULT_H_

78
oos/include/alibabacloud/oos/model/StartExecutionRequest.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_STARTEXECUTIONREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_STARTEXECUTIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT StartExecutionRequest : public RpcServiceRequest
{
public:
StartExecutionRequest();
~StartExecutionRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getMode()const;
void setMode(const std::string& mode);
std::string getTemplateVersion()const;
void setTemplateVersion(const std::string& templateVersion);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getTemplateName()const;
void setTemplateName(const std::string& templateName);
std::string getLoopMode()const;
void setLoopMode(const std::string& loopMode);
std::string getSafetyCheck()const;
void setSafetyCheck(const std::string& safetyCheck);
std::map<std::string, std::string> getTags()const;
void setTags(const std::map<std::string, std::string>& tags);
std::string getParentExecutionId()const;
void setParentExecutionId(const std::string& parentExecutionId);
std::string getParameters()const;
void setParameters(const std::string& parameters);
private:
std::string clientToken_;
std::string description_;
std::string mode_;
std::string templateVersion_;
std::string regionId_;
std::string templateName_;
std::string loopMode_;
std::string safetyCheck_;
std::map<std::string, std::string> tags_;
std::string parentExecutionId_;
std::string parameters_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_STARTEXECUTIONREQUEST_H_

83
oos/include/alibabacloud/oos/model/StartExecutionResult.h Normal file
View File

@@ -0,0 +1,83 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_STARTEXECUTIONRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_STARTEXECUTIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT StartExecutionResult : public ServiceResult
{
public:
struct Execution
{
struct CurrentTask
{
std::string taskName;
std::string taskAction;
std::string taskExecutionId;
};
std::vector<CurrentTask> currentTasks;
std::string status;
std::string parentExecutionId;
std::string loopMode;
std::string parameters;
std::string description;
bool isParent;
std::string mode;
std::string templateVersion;
std::string endDate;
std::string createDate;
std::string statusMessage;
std::string startDate;
std::string updateDate;
std::string safetyCheck;
std::string outputs;
std::string ramRole;
std::string templateName;
std::string counters;
std::string templateId;
std::string executedBy;
std::string tags;
std::string executionId;
};
StartExecutionResult();
explicit StartExecutionResult(const std::string &payload);
~StartExecutionResult();
Execution getExecution()const;
protected:
void parse(const std::string &payload);
private:
Execution execution_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_STARTEXECUTIONRESULT_H_

57
oos/include/alibabacloud/oos/model/TagResourcesRequest.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_OOS_MODEL_TAGRESOURCESREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_TAGRESOURCESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT TagResourcesRequest : public RpcServiceRequest
{
public:
TagResourcesRequest();
~TagResourcesRequest();
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
std::map<std::string, std::string> getTags()const;
void setTags(const std::map<std::string, std::string>& tags);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::map<std::string, std::string> getResourceIds()const;
void setResourceIds(const std::map<std::string, std::string>& resourceIds);
private:
std::string resourceType_;
std::map<std::string, std::string> tags_;
std::string regionId_;
std::map<std::string, std::string> resourceIds_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_TAGRESOURCESREQUEST_H_

49
oos/include/alibabacloud/oos/model/TagResourcesResult.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_OOS_MODEL_TAGRESOURCESRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_TAGRESOURCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT TagResourcesResult : public ServiceResult
{
public:
TagResourcesResult();
explicit TagResourcesResult(const std::string &payload);
~TagResourcesResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_TAGRESOURCESRESULT_H_

60
oos/include/alibabacloud/oos/model/TriggerExecutionRequest.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_OOS_MODEL_TRIGGEREXECUTIONREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_TRIGGEREXECUTIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT TriggerExecutionRequest : public RpcServiceRequest
{
public:
TriggerExecutionRequest();
~TriggerExecutionRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getType()const;
void setType(const std::string& type);
std::string getContent()const;
void setContent(const std::string& content);
std::string getExecutionId()const;
void setExecutionId(const std::string& executionId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string clientToken_;
std::string type_;
std::string content_;
std::string executionId_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_TRIGGEREXECUTIONREQUEST_H_

49
oos/include/alibabacloud/oos/model/TriggerExecutionResult.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_OOS_MODEL_TRIGGEREXECUTIONRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_TRIGGEREXECUTIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT TriggerExecutionResult : public ServiceResult
{
public:
TriggerExecutionResult();
explicit TriggerExecutionResult(const std::string &payload);
~TriggerExecutionResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_TRIGGEREXECUTIONRESULT_H_

60
oos/include/alibabacloud/oos/model/UntagResourcesRequest.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_OOS_MODEL_UNTAGRESOURCESREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_UNTAGRESOURCESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT UntagResourcesRequest : public RpcServiceRequest
{
public:
UntagResourcesRequest();
~UntagResourcesRequest();
bool getAll()const;
void setAll(bool all);
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::map<std::string, std::string> getTagKeys()const;
void setTagKeys(const std::map<std::string, std::string>& tagKeys);
std::map<std::string, std::string> getResourceIds()const;
void setResourceIds(const std::map<std::string, std::string>& resourceIds);
private:
bool all_;
std::string resourceType_;
std::string regionId_;
std::map<std::string, std::string> tagKeys_;
std::map<std::string, std::string> resourceIds_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_UNTAGRESOURCESREQUEST_H_

49
oos/include/alibabacloud/oos/model/UntagResourcesResult.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_OOS_MODEL_UNTAGRESOURCESRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_UNTAGRESOURCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT UntagResourcesResult : public ServiceResult
{
public:
UntagResourcesResult();
explicit UntagResourcesResult(const std::string &payload);
~UntagResourcesResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_UNTAGRESOURCESRESULT_H_

57
oos/include/alibabacloud/oos/model/UpdateTemplateRequest.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_OOS_MODEL_UPDATETEMPLATEREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_UPDATETEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT UpdateTemplateRequest : public RpcServiceRequest
{
public:
UpdateTemplateRequest();
~UpdateTemplateRequest();
std::string getContent()const;
void setContent(const std::string& content);
std::map<std::string, std::string> getTags()const;
void setTags(const std::map<std::string, std::string>& tags);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getTemplateName()const;
void setTemplateName(const std::string& templateName);
private:
std::string content_;
std::map<std::string, std::string> tags_;
std::string regionId_;
std::string templateName_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_UPDATETEMPLATEREQUEST_H_

67
oos/include/alibabacloud/oos/model/UpdateTemplateResult.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OOS_MODEL_UPDATETEMPLATERESULT_H_
#define ALIBABACLOUD_OOS_MODEL_UPDATETEMPLATERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT UpdateTemplateResult : public ServiceResult
{
public:
struct _Template
{
std::string createdBy;
std::string description;
std::string templateFormat;
std::string updatedDate;
std::string templateVersion;
std::string hash;
std::string updatedBy;
bool hasTrigger;
std::string createdDate;
std::string templateName;
std::string templateId;
std::string tags;
std::string shareType;
};
UpdateTemplateResult();
explicit UpdateTemplateResult(const std::string &payload);
~UpdateTemplateResult();
_Template get_Template()const;
protected:
void parse(const std::string &payload);
private:
_Template _template_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_UPDATETEMPLATERESULT_H_

51
oos/include/alibabacloud/oos/model/ValidateTemplateContentRequest.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_OOS_MODEL_VALIDATETEMPLATECONTENTREQUEST_H_
#define ALIBABACLOUD_OOS_MODEL_VALIDATETEMPLATECONTENTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ValidateTemplateContentRequest : public RpcServiceRequest
{
public:
ValidateTemplateContentRequest();
~ValidateTemplateContentRequest();
std::string getContent()const;
void setContent(const std::string& content);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string content_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_VALIDATETEMPLATECONTENTREQUEST_H_

65
oos/include/alibabacloud/oos/model/ValidateTemplateContentResult.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_OOS_MODEL_VALIDATETEMPLATECONTENTRESULT_H_
#define ALIBABACLOUD_OOS_MODEL_VALIDATETEMPLATECONTENTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oos/OosExport.h>
namespace AlibabaCloud
{
namespace Oos
{
namespace Model
{
class ALIBABACLOUD_OOS_EXPORT ValidateTemplateContentResult : public ServiceResult
{
public:
struct Task
{
std::string type;
std::string description;
std::string outputs;
std::string properties;
std::string name;
};
ValidateTemplateContentResult();
explicit ValidateTemplateContentResult(const std::string &payload);
~ValidateTemplateContentResult();
std::vector<Task> getTasks()const;
std::string getParameters()const;
std::string getRamRole()const;
std::string getOutputs()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Task> tasks_;
std::string parameters_;
std::string ramRole_;
std::string outputs_;
};
}
}
}
#endif // !ALIBABACLOUD_OOS_MODEL_VALIDATETEMPLATECONTENTRESULT_H_