Generated 2018-08-28 for Tag.

VERSION

@@ -1 +1 @@
-1.36.1993
+1.36.1994

tag/CMakeLists.txt

@@ -21,20 +21,60 @@ set(tag_public_header
 	include/alibabacloud/tag/TagExport.h )
 
 set(tag_public_header_model 
+	include/alibabacloud/tag/model/AttachPolicyRequest.h
+	include/alibabacloud/tag/model/AttachPolicyResult.h
+	include/alibabacloud/tag/model/CheckCreatedByEnabledRequest.h
+	include/alibabacloud/tag/model/CheckCreatedByEnabledResult.h
+	include/alibabacloud/tag/model/CloseCreatedByRequest.h
+	include/alibabacloud/tag/model/CloseCreatedByResult.h
+	include/alibabacloud/tag/model/CreatePolicyRequest.h
+	include/alibabacloud/tag/model/CreatePolicyResult.h
 	include/alibabacloud/tag/model/CreateTagsRequest.h
 	include/alibabacloud/tag/model/CreateTagsResult.h
+	include/alibabacloud/tag/model/DeletePolicyRequest.h
+	include/alibabacloud/tag/model/DeletePolicyResult.h
 	include/alibabacloud/tag/model/DeleteTagRequest.h
 	include/alibabacloud/tag/model/DeleteTagResult.h
 	include/alibabacloud/tag/model/DescribeRegionsRequest.h
 	include/alibabacloud/tag/model/DescribeRegionsResult.h
+	include/alibabacloud/tag/model/DetachPolicyRequest.h
+	include/alibabacloud/tag/model/DetachPolicyResult.h
+	include/alibabacloud/tag/model/DisablePolicyTypeRequest.h
+	include/alibabacloud/tag/model/DisablePolicyTypeResult.h
+	include/alibabacloud/tag/model/EnablePolicyTypeRequest.h
+	include/alibabacloud/tag/model/EnablePolicyTypeResult.h
+	include/alibabacloud/tag/model/GenerateConfigRuleReportRequest.h
+	include/alibabacloud/tag/model/GenerateConfigRuleReportResult.h
+	include/alibabacloud/tag/model/GetConfigRuleReportRequest.h
+	include/alibabacloud/tag/model/GetConfigRuleReportResult.h
+	include/alibabacloud/tag/model/GetEffectivePolicyRequest.h
+	include/alibabacloud/tag/model/GetEffectivePolicyResult.h
+	include/alibabacloud/tag/model/GetPolicyRequest.h
+	include/alibabacloud/tag/model/GetPolicyResult.h
+	include/alibabacloud/tag/model/GetPolicyEnableStatusRequest.h
+	include/alibabacloud/tag/model/GetPolicyEnableStatusResult.h
+	include/alibabacloud/tag/model/ListConfigRulesForTargetRequest.h
+	include/alibabacloud/tag/model/ListConfigRulesForTargetResult.h
+	include/alibabacloud/tag/model/ListPoliciesRequest.h
+	include/alibabacloud/tag/model/ListPoliciesResult.h
+	include/alibabacloud/tag/model/ListPoliciesForTargetRequest.h
+	include/alibabacloud/tag/model/ListPoliciesForTargetResult.h
 	include/alibabacloud/tag/model/ListResourcesByTagRequest.h
 	include/alibabacloud/tag/model/ListResourcesByTagResult.h
+	include/alibabacloud/tag/model/ListSupportResourceTypesRequest.h
+	include/alibabacloud/tag/model/ListSupportResourceTypesResult.h
 	include/alibabacloud/tag/model/ListTagKeysRequest.h
 	include/alibabacloud/tag/model/ListTagKeysResult.h
 	include/alibabacloud/tag/model/ListTagResourcesRequest.h
 	include/alibabacloud/tag/model/ListTagResourcesResult.h
 	include/alibabacloud/tag/model/ListTagValuesRequest.h
 	include/alibabacloud/tag/model/ListTagValuesResult.h
+	include/alibabacloud/tag/model/ListTargetsForPolicyRequest.h
+	include/alibabacloud/tag/model/ListTargetsForPolicyResult.h
+	include/alibabacloud/tag/model/ModifyPolicyRequest.h
+	include/alibabacloud/tag/model/ModifyPolicyResult.h
+	include/alibabacloud/tag/model/OpenCreatedByRequest.h
+	include/alibabacloud/tag/model/OpenCreatedByResult.h
 	include/alibabacloud/tag/model/TagResourcesRequest.h
 	include/alibabacloud/tag/model/TagResourcesResult.h
 	include/alibabacloud/tag/model/UntagResourcesRequest.h
@@ -42,20 +82,60 @@ set(tag_public_header_model
 
 set(tag_src 
 	src/TagClient.cc
+	src/model/AttachPolicyRequest.cc
+	src/model/AttachPolicyResult.cc
+	src/model/CheckCreatedByEnabledRequest.cc
+	src/model/CheckCreatedByEnabledResult.cc
+	src/model/CloseCreatedByRequest.cc
+	src/model/CloseCreatedByResult.cc
+	src/model/CreatePolicyRequest.cc
+	src/model/CreatePolicyResult.cc
 	src/model/CreateTagsRequest.cc
 	src/model/CreateTagsResult.cc
+	src/model/DeletePolicyRequest.cc
+	src/model/DeletePolicyResult.cc
 	src/model/DeleteTagRequest.cc
 	src/model/DeleteTagResult.cc
 	src/model/DescribeRegionsRequest.cc
 	src/model/DescribeRegionsResult.cc
+	src/model/DetachPolicyRequest.cc
+	src/model/DetachPolicyResult.cc
+	src/model/DisablePolicyTypeRequest.cc
+	src/model/DisablePolicyTypeResult.cc
+	src/model/EnablePolicyTypeRequest.cc
+	src/model/EnablePolicyTypeResult.cc
+	src/model/GenerateConfigRuleReportRequest.cc
+	src/model/GenerateConfigRuleReportResult.cc
+	src/model/GetConfigRuleReportRequest.cc
+	src/model/GetConfigRuleReportResult.cc
+	src/model/GetEffectivePolicyRequest.cc
+	src/model/GetEffectivePolicyResult.cc
+	src/model/GetPolicyRequest.cc
+	src/model/GetPolicyResult.cc
+	src/model/GetPolicyEnableStatusRequest.cc
+	src/model/GetPolicyEnableStatusResult.cc
+	src/model/ListConfigRulesForTargetRequest.cc
+	src/model/ListConfigRulesForTargetResult.cc
+	src/model/ListPoliciesRequest.cc
+	src/model/ListPoliciesResult.cc
+	src/model/ListPoliciesForTargetRequest.cc
+	src/model/ListPoliciesForTargetResult.cc
 	src/model/ListResourcesByTagRequest.cc
 	src/model/ListResourcesByTagResult.cc
+	src/model/ListSupportResourceTypesRequest.cc
+	src/model/ListSupportResourceTypesResult.cc
 	src/model/ListTagKeysRequest.cc
 	src/model/ListTagKeysResult.cc
 	src/model/ListTagResourcesRequest.cc
 	src/model/ListTagResourcesResult.cc
 	src/model/ListTagValuesRequest.cc
 	src/model/ListTagValuesResult.cc
+	src/model/ListTargetsForPolicyRequest.cc
+	src/model/ListTargetsForPolicyResult.cc
+	src/model/ModifyPolicyRequest.cc
+	src/model/ModifyPolicyResult.cc
+	src/model/OpenCreatedByRequest.cc
+	src/model/OpenCreatedByResult.cc
 	src/model/TagResourcesRequest.cc
 	src/model/TagResourcesResult.cc
 	src/model/UntagResourcesRequest.cc

tag/include/alibabacloud/tag/TagClient.h

@@ -22,20 +22,60 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RpcServiceClient.h>
 #include "TagExport.h"
+#include "model/AttachPolicyRequest.h"
+#include "model/AttachPolicyResult.h"
+#include "model/CheckCreatedByEnabledRequest.h"
+#include "model/CheckCreatedByEnabledResult.h"
+#include "model/CloseCreatedByRequest.h"
+#include "model/CloseCreatedByResult.h"
+#include "model/CreatePolicyRequest.h"
+#include "model/CreatePolicyResult.h"
 #include "model/CreateTagsRequest.h"
 #include "model/CreateTagsResult.h"
+#include "model/DeletePolicyRequest.h"
+#include "model/DeletePolicyResult.h"
 #include "model/DeleteTagRequest.h"
 #include "model/DeleteTagResult.h"
 #include "model/DescribeRegionsRequest.h"
 #include "model/DescribeRegionsResult.h"
+#include "model/DetachPolicyRequest.h"
+#include "model/DetachPolicyResult.h"
+#include "model/DisablePolicyTypeRequest.h"
+#include "model/DisablePolicyTypeResult.h"
+#include "model/EnablePolicyTypeRequest.h"
+#include "model/EnablePolicyTypeResult.h"
+#include "model/GenerateConfigRuleReportRequest.h"
+#include "model/GenerateConfigRuleReportResult.h"
+#include "model/GetConfigRuleReportRequest.h"
+#include "model/GetConfigRuleReportResult.h"
+#include "model/GetEffectivePolicyRequest.h"
+#include "model/GetEffectivePolicyResult.h"
+#include "model/GetPolicyRequest.h"
+#include "model/GetPolicyResult.h"
+#include "model/GetPolicyEnableStatusRequest.h"
+#include "model/GetPolicyEnableStatusResult.h"
+#include "model/ListConfigRulesForTargetRequest.h"
+#include "model/ListConfigRulesForTargetResult.h"
+#include "model/ListPoliciesRequest.h"
+#include "model/ListPoliciesResult.h"
+#include "model/ListPoliciesForTargetRequest.h"
+#include "model/ListPoliciesForTargetResult.h"
 #include "model/ListResourcesByTagRequest.h"
 #include "model/ListResourcesByTagResult.h"
+#include "model/ListSupportResourceTypesRequest.h"
+#include "model/ListSupportResourceTypesResult.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/ListTargetsForPolicyRequest.h"
+#include "model/ListTargetsForPolicyResult.h"
+#include "model/ModifyPolicyRequest.h"
+#include "model/ModifyPolicyResult.h"
+#include "model/OpenCreatedByRequest.h"
+#include "model/OpenCreatedByResult.h"
 #include "model/TagResourcesRequest.h"
 #include "model/TagResourcesResult.h"
 #include "model/UntagResourcesRequest.h"
@@ -49,18 +89,69 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_TAG_EXPORT TagClient : public RpcServiceClient
 		{
 		public:
+			typedef Outcome<Error, Model::AttachPolicyResult> AttachPolicyOutcome;
+			typedef std::future<AttachPolicyOutcome> AttachPolicyOutcomeCallable;
+			typedef std::function<void(const TagClient*, const Model::AttachPolicyRequest&, const AttachPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachPolicyAsyncHandler;
+			typedef Outcome<Error, Model::CheckCreatedByEnabledResult> CheckCreatedByEnabledOutcome;
+			typedef std::future<CheckCreatedByEnabledOutcome> CheckCreatedByEnabledOutcomeCallable;
+			typedef std::function<void(const TagClient*, const Model::CheckCreatedByEnabledRequest&, const CheckCreatedByEnabledOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckCreatedByEnabledAsyncHandler;
+			typedef Outcome<Error, Model::CloseCreatedByResult> CloseCreatedByOutcome;
+			typedef std::future<CloseCreatedByOutcome> CloseCreatedByOutcomeCallable;
+			typedef std::function<void(const TagClient*, const Model::CloseCreatedByRequest&, const CloseCreatedByOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CloseCreatedByAsyncHandler;
+			typedef Outcome<Error, Model::CreatePolicyResult> CreatePolicyOutcome;
+			typedef std::future<CreatePolicyOutcome> CreatePolicyOutcomeCallable;
+			typedef std::function<void(const TagClient*, const Model::CreatePolicyRequest&, const CreatePolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreatePolicyAsyncHandler;
 			typedef Outcome<Error, Model::CreateTagsResult> CreateTagsOutcome;
 			typedef std::future<CreateTagsOutcome> CreateTagsOutcomeCallable;
 			typedef std::function<void(const TagClient*, const Model::CreateTagsRequest&, const CreateTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateTagsAsyncHandler;
+			typedef Outcome<Error, Model::DeletePolicyResult> DeletePolicyOutcome;
+			typedef std::future<DeletePolicyOutcome> DeletePolicyOutcomeCallable;
+			typedef std::function<void(const TagClient*, const Model::DeletePolicyRequest&, const DeletePolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeletePolicyAsyncHandler;
 			typedef Outcome<Error, Model::DeleteTagResult> DeleteTagOutcome;
 			typedef std::future<DeleteTagOutcome> DeleteTagOutcomeCallable;
 			typedef std::function<void(const TagClient*, const Model::DeleteTagRequest&, const DeleteTagOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTagAsyncHandler;
 			typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
 			typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
 			typedef std::function<void(const TagClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
+			typedef Outcome<Error, Model::DetachPolicyResult> DetachPolicyOutcome;
+			typedef std::future<DetachPolicyOutcome> DetachPolicyOutcomeCallable;
+			typedef std::function<void(const TagClient*, const Model::DetachPolicyRequest&, const DetachPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachPolicyAsyncHandler;
+			typedef Outcome<Error, Model::DisablePolicyTypeResult> DisablePolicyTypeOutcome;
+			typedef std::future<DisablePolicyTypeOutcome> DisablePolicyTypeOutcomeCallable;
+			typedef std::function<void(const TagClient*, const Model::DisablePolicyTypeRequest&, const DisablePolicyTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisablePolicyTypeAsyncHandler;
+			typedef Outcome<Error, Model::EnablePolicyTypeResult> EnablePolicyTypeOutcome;
+			typedef std::future<EnablePolicyTypeOutcome> EnablePolicyTypeOutcomeCallable;
+			typedef std::function<void(const TagClient*, const Model::EnablePolicyTypeRequest&, const EnablePolicyTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnablePolicyTypeAsyncHandler;
+			typedef Outcome<Error, Model::GenerateConfigRuleReportResult> GenerateConfigRuleReportOutcome;
+			typedef std::future<GenerateConfigRuleReportOutcome> GenerateConfigRuleReportOutcomeCallable;
+			typedef std::function<void(const TagClient*, const Model::GenerateConfigRuleReportRequest&, const GenerateConfigRuleReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateConfigRuleReportAsyncHandler;
+			typedef Outcome<Error, Model::GetConfigRuleReportResult> GetConfigRuleReportOutcome;
+			typedef std::future<GetConfigRuleReportOutcome> GetConfigRuleReportOutcomeCallable;
+			typedef std::function<void(const TagClient*, const Model::GetConfigRuleReportRequest&, const GetConfigRuleReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetConfigRuleReportAsyncHandler;
+			typedef Outcome<Error, Model::GetEffectivePolicyResult> GetEffectivePolicyOutcome;
+			typedef std::future<GetEffectivePolicyOutcome> GetEffectivePolicyOutcomeCallable;
+			typedef std::function<void(const TagClient*, const Model::GetEffectivePolicyRequest&, const GetEffectivePolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetEffectivePolicyAsyncHandler;
+			typedef Outcome<Error, Model::GetPolicyResult> GetPolicyOutcome;
+			typedef std::future<GetPolicyOutcome> GetPolicyOutcomeCallable;
+			typedef std::function<void(const TagClient*, const Model::GetPolicyRequest&, const GetPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPolicyAsyncHandler;
+			typedef Outcome<Error, Model::GetPolicyEnableStatusResult> GetPolicyEnableStatusOutcome;
+			typedef std::future<GetPolicyEnableStatusOutcome> GetPolicyEnableStatusOutcomeCallable;
+			typedef std::function<void(const TagClient*, const Model::GetPolicyEnableStatusRequest&, const GetPolicyEnableStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPolicyEnableStatusAsyncHandler;
+			typedef Outcome<Error, Model::ListConfigRulesForTargetResult> ListConfigRulesForTargetOutcome;
+			typedef std::future<ListConfigRulesForTargetOutcome> ListConfigRulesForTargetOutcomeCallable;
+			typedef std::function<void(const TagClient*, const Model::ListConfigRulesForTargetRequest&, const ListConfigRulesForTargetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListConfigRulesForTargetAsyncHandler;
+			typedef Outcome<Error, Model::ListPoliciesResult> ListPoliciesOutcome;
+			typedef std::future<ListPoliciesOutcome> ListPoliciesOutcomeCallable;
+			typedef std::function<void(const TagClient*, const Model::ListPoliciesRequest&, const ListPoliciesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListPoliciesAsyncHandler;
+			typedef Outcome<Error, Model::ListPoliciesForTargetResult> ListPoliciesForTargetOutcome;
+			typedef std::future<ListPoliciesForTargetOutcome> ListPoliciesForTargetOutcomeCallable;
+			typedef std::function<void(const TagClient*, const Model::ListPoliciesForTargetRequest&, const ListPoliciesForTargetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListPoliciesForTargetAsyncHandler;
 			typedef Outcome<Error, Model::ListResourcesByTagResult> ListResourcesByTagOutcome;
 			typedef std::future<ListResourcesByTagOutcome> ListResourcesByTagOutcomeCallable;
 			typedef std::function<void(const TagClient*, const Model::ListResourcesByTagRequest&, const ListResourcesByTagOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListResourcesByTagAsyncHandler;
+			typedef Outcome<Error, Model::ListSupportResourceTypesResult> ListSupportResourceTypesOutcome;
+			typedef std::future<ListSupportResourceTypesOutcome> ListSupportResourceTypesOutcomeCallable;
+			typedef std::function<void(const TagClient*, const Model::ListSupportResourceTypesRequest&, const ListSupportResourceTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSupportResourceTypesAsyncHandler;
 			typedef Outcome<Error, Model::ListTagKeysResult> ListTagKeysOutcome;
 			typedef std::future<ListTagKeysOutcome> ListTagKeysOutcomeCallable;
 			typedef std::function<void(const TagClient*, const Model::ListTagKeysRequest&, const ListTagKeysOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagKeysAsyncHandler;
@@ -70,6 +161,15 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListTagValuesResult> ListTagValuesOutcome;
 			typedef std::future<ListTagValuesOutcome> ListTagValuesOutcomeCallable;
 			typedef std::function<void(const TagClient*, const Model::ListTagValuesRequest&, const ListTagValuesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagValuesAsyncHandler;
+			typedef Outcome<Error, Model::ListTargetsForPolicyResult> ListTargetsForPolicyOutcome;
+			typedef std::future<ListTargetsForPolicyOutcome> ListTargetsForPolicyOutcomeCallable;
+			typedef std::function<void(const TagClient*, const Model::ListTargetsForPolicyRequest&, const ListTargetsForPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTargetsForPolicyAsyncHandler;
+			typedef Outcome<Error, Model::ModifyPolicyResult> ModifyPolicyOutcome;
+			typedef std::future<ModifyPolicyOutcome> ModifyPolicyOutcomeCallable;
+			typedef std::function<void(const TagClient*, const Model::ModifyPolicyRequest&, const ModifyPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyPolicyAsyncHandler;
+			typedef Outcome<Error, Model::OpenCreatedByResult> OpenCreatedByOutcome;
+			typedef std::future<OpenCreatedByOutcome> OpenCreatedByOutcomeCallable;
+			typedef std::function<void(const TagClient*, const Model::OpenCreatedByRequest&, const OpenCreatedByOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> OpenCreatedByAsyncHandler;
 			typedef Outcome<Error, Model::TagResourcesResult> TagResourcesOutcome;
 			typedef std::future<TagResourcesOutcome> TagResourcesOutcomeCallable;
 			typedef std::function<void(const TagClient*, const Model::TagResourcesRequest&, const TagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TagResourcesAsyncHandler;
@@ -81,18 +181,69 @@ namespace AlibabaCloud
 			TagClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			TagClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~TagClient();
+			AttachPolicyOutcome attachPolicy(const Model::AttachPolicyRequest &request)const;
+			void attachPolicyAsync(const Model::AttachPolicyRequest& request, const AttachPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AttachPolicyOutcomeCallable attachPolicyCallable(const Model::AttachPolicyRequest& request) const;
+			CheckCreatedByEnabledOutcome checkCreatedByEnabled(const Model::CheckCreatedByEnabledRequest &request)const;
+			void checkCreatedByEnabledAsync(const Model::CheckCreatedByEnabledRequest& request, const CheckCreatedByEnabledAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CheckCreatedByEnabledOutcomeCallable checkCreatedByEnabledCallable(const Model::CheckCreatedByEnabledRequest& request) const;
+			CloseCreatedByOutcome closeCreatedBy(const Model::CloseCreatedByRequest &request)const;
+			void closeCreatedByAsync(const Model::CloseCreatedByRequest& request, const CloseCreatedByAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CloseCreatedByOutcomeCallable closeCreatedByCallable(const Model::CloseCreatedByRequest& request) const;
+			CreatePolicyOutcome createPolicy(const Model::CreatePolicyRequest &request)const;
+			void createPolicyAsync(const Model::CreatePolicyRequest& request, const CreatePolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreatePolicyOutcomeCallable createPolicyCallable(const Model::CreatePolicyRequest& request) const;
 			CreateTagsOutcome createTags(const Model::CreateTagsRequest &request)const;
 			void createTagsAsync(const Model::CreateTagsRequest& request, const CreateTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateTagsOutcomeCallable createTagsCallable(const Model::CreateTagsRequest& request) const;
+			DeletePolicyOutcome deletePolicy(const Model::DeletePolicyRequest &request)const;
+			void deletePolicyAsync(const Model::DeletePolicyRequest& request, const DeletePolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeletePolicyOutcomeCallable deletePolicyCallable(const Model::DeletePolicyRequest& request) const;
 			DeleteTagOutcome deleteTag(const Model::DeleteTagRequest &request)const;
 			void deleteTagAsync(const Model::DeleteTagRequest& request, const DeleteTagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteTagOutcomeCallable deleteTagCallable(const Model::DeleteTagRequest& 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;
+			DetachPolicyOutcome detachPolicy(const Model::DetachPolicyRequest &request)const;
+			void detachPolicyAsync(const Model::DetachPolicyRequest& request, const DetachPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetachPolicyOutcomeCallable detachPolicyCallable(const Model::DetachPolicyRequest& request) const;
+			DisablePolicyTypeOutcome disablePolicyType(const Model::DisablePolicyTypeRequest &request)const;
+			void disablePolicyTypeAsync(const Model::DisablePolicyTypeRequest& request, const DisablePolicyTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DisablePolicyTypeOutcomeCallable disablePolicyTypeCallable(const Model::DisablePolicyTypeRequest& request) const;
+			EnablePolicyTypeOutcome enablePolicyType(const Model::EnablePolicyTypeRequest &request)const;
+			void enablePolicyTypeAsync(const Model::EnablePolicyTypeRequest& request, const EnablePolicyTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EnablePolicyTypeOutcomeCallable enablePolicyTypeCallable(const Model::EnablePolicyTypeRequest& request) const;
+			GenerateConfigRuleReportOutcome generateConfigRuleReport(const Model::GenerateConfigRuleReportRequest &request)const;
+			void generateConfigRuleReportAsync(const Model::GenerateConfigRuleReportRequest& request, const GenerateConfigRuleReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GenerateConfigRuleReportOutcomeCallable generateConfigRuleReportCallable(const Model::GenerateConfigRuleReportRequest& request) const;
+			GetConfigRuleReportOutcome getConfigRuleReport(const Model::GetConfigRuleReportRequest &request)const;
+			void getConfigRuleReportAsync(const Model::GetConfigRuleReportRequest& request, const GetConfigRuleReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetConfigRuleReportOutcomeCallable getConfigRuleReportCallable(const Model::GetConfigRuleReportRequest& request) const;
+			GetEffectivePolicyOutcome getEffectivePolicy(const Model::GetEffectivePolicyRequest &request)const;
+			void getEffectivePolicyAsync(const Model::GetEffectivePolicyRequest& request, const GetEffectivePolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetEffectivePolicyOutcomeCallable getEffectivePolicyCallable(const Model::GetEffectivePolicyRequest& request) const;
+			GetPolicyOutcome getPolicy(const Model::GetPolicyRequest &request)const;
+			void getPolicyAsync(const Model::GetPolicyRequest& request, const GetPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetPolicyOutcomeCallable getPolicyCallable(const Model::GetPolicyRequest& request) const;
+			GetPolicyEnableStatusOutcome getPolicyEnableStatus(const Model::GetPolicyEnableStatusRequest &request)const;
+			void getPolicyEnableStatusAsync(const Model::GetPolicyEnableStatusRequest& request, const GetPolicyEnableStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetPolicyEnableStatusOutcomeCallable getPolicyEnableStatusCallable(const Model::GetPolicyEnableStatusRequest& request) const;
+			ListConfigRulesForTargetOutcome listConfigRulesForTarget(const Model::ListConfigRulesForTargetRequest &request)const;
+			void listConfigRulesForTargetAsync(const Model::ListConfigRulesForTargetRequest& request, const ListConfigRulesForTargetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListConfigRulesForTargetOutcomeCallable listConfigRulesForTargetCallable(const Model::ListConfigRulesForTargetRequest& request) const;
+			ListPoliciesOutcome listPolicies(const Model::ListPoliciesRequest &request)const;
+			void listPoliciesAsync(const Model::ListPoliciesRequest& request, const ListPoliciesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListPoliciesOutcomeCallable listPoliciesCallable(const Model::ListPoliciesRequest& request) const;
+			ListPoliciesForTargetOutcome listPoliciesForTarget(const Model::ListPoliciesForTargetRequest &request)const;
+			void listPoliciesForTargetAsync(const Model::ListPoliciesForTargetRequest& request, const ListPoliciesForTargetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListPoliciesForTargetOutcomeCallable listPoliciesForTargetCallable(const Model::ListPoliciesForTargetRequest& request) const;
 			ListResourcesByTagOutcome listResourcesByTag(const Model::ListResourcesByTagRequest &request)const;
 			void listResourcesByTagAsync(const Model::ListResourcesByTagRequest& request, const ListResourcesByTagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListResourcesByTagOutcomeCallable listResourcesByTagCallable(const Model::ListResourcesByTagRequest& request) const;
+			ListSupportResourceTypesOutcome listSupportResourceTypes(const Model::ListSupportResourceTypesRequest &request)const;
+			void listSupportResourceTypesAsync(const Model::ListSupportResourceTypesRequest& request, const ListSupportResourceTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListSupportResourceTypesOutcomeCallable listSupportResourceTypesCallable(const Model::ListSupportResourceTypesRequest& 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;
@@ -102,6 +253,15 @@ namespace AlibabaCloud
 			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;
+			ListTargetsForPolicyOutcome listTargetsForPolicy(const Model::ListTargetsForPolicyRequest &request)const;
+			void listTargetsForPolicyAsync(const Model::ListTargetsForPolicyRequest& request, const ListTargetsForPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListTargetsForPolicyOutcomeCallable listTargetsForPolicyCallable(const Model::ListTargetsForPolicyRequest& request) const;
+			ModifyPolicyOutcome modifyPolicy(const Model::ModifyPolicyRequest &request)const;
+			void modifyPolicyAsync(const Model::ModifyPolicyRequest& request, const ModifyPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyPolicyOutcomeCallable modifyPolicyCallable(const Model::ModifyPolicyRequest& request) const;
+			OpenCreatedByOutcome openCreatedBy(const Model::OpenCreatedByRequest &request)const;
+			void openCreatedByAsync(const Model::OpenCreatedByRequest& request, const OpenCreatedByAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			OpenCreatedByOutcomeCallable openCreatedByCallable(const Model::OpenCreatedByRequest& 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;

tag/include/alibabacloud/tag/model/AttachPolicyRequest.h

@@ -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_TAG_MODEL_ATTACHPOLICYREQUEST_H_
+#define ALIBABACLOUD_TAG_MODEL_ATTACHPOLICYREQUEST_H_
+
+#include <alibabacloud/tag/TagExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Tag {
+namespace Model {
+class ALIBABACLOUD_TAG_EXPORT AttachPolicyRequest : public RpcServiceRequest {
+public:
+	AttachPolicyRequest();
+	~AttachPolicyRequest();
+	std::string getTargetId() const;
+	void setTargetId(const std::string &targetId);
+	std::string getTargetType() const;
+	void setTargetType(const std::string &targetType);
+	std::string getPolicyId() const;
+	void setPolicyId(const std::string &policyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	std::string targetId_;
+	std::string targetType_;
+	std::string policyId_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Tag
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_TAG_MODEL_ATTACHPOLICYREQUEST_H_

tag/include/alibabacloud/tag/model/AttachPolicyResult.h

@@ -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_TAG_MODEL_ATTACHPOLICYRESULT_H_
+#define ALIBABACLOUD_TAG_MODEL_ATTACHPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/tag/TagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Tag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_TAG_EXPORT AttachPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				AttachPolicyResult();
+				explicit AttachPolicyResult(const std::string &payload);
+				~AttachPolicyResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_TAG_MODEL_ATTACHPOLICYRESULT_H_

tag/include/alibabacloud/tag/model/CheckCreatedByEnabledRequest.h

@@ -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_TAG_MODEL_CHECKCREATEDBYENABLEDREQUEST_H_
+#define ALIBABACLOUD_TAG_MODEL_CHECKCREATEDBYENABLEDREQUEST_H_
+
+#include <alibabacloud/tag/TagExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Tag {
+namespace Model {
+class ALIBABACLOUD_TAG_EXPORT CheckCreatedByEnabledRequest : public RpcServiceRequest {
+public:
+	CheckCreatedByEnabledRequest();
+	~CheckCreatedByEnabledRequest();
+	std::string getResourceOwnerId() const;
+	void setResourceOwnerId(const std::string &resourceOwnerId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	std::string resourceOwnerId_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Tag
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_TAG_MODEL_CHECKCREATEDBYENABLEDREQUEST_H_

tag/include/alibabacloud/tag/model/CheckCreatedByEnabledResult.h

@@ -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_TAG_MODEL_CHECKCREATEDBYENABLEDRESULT_H_
+#define ALIBABACLOUD_TAG_MODEL_CHECKCREATEDBYENABLEDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/tag/TagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Tag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_TAG_EXPORT CheckCreatedByEnabledResult : public ServiceResult
+			{
+			public:
+
+
+				CheckCreatedByEnabledResult();
+				explicit CheckCreatedByEnabledResult(const std::string &payload);
+				~CheckCreatedByEnabledResult();
+				bool getOpenStatus()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool openStatus_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_TAG_MODEL_CHECKCREATEDBYENABLEDRESULT_H_

tag/include/alibabacloud/tag/model/CloseCreatedByRequest.h

@@ -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_TAG_MODEL_CLOSECREATEDBYREQUEST_H_
+#define ALIBABACLOUD_TAG_MODEL_CLOSECREATEDBYREQUEST_H_
+
+#include <alibabacloud/tag/TagExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Tag {
+namespace Model {
+class ALIBABACLOUD_TAG_EXPORT CloseCreatedByRequest : public RpcServiceRequest {
+public:
+	CloseCreatedByRequest();
+	~CloseCreatedByRequest();
+	std::string getResourceOwnerId() const;
+	void setResourceOwnerId(const std::string &resourceOwnerId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	std::string resourceOwnerId_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Tag
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_TAG_MODEL_CLOSECREATEDBYREQUEST_H_

tag/include/alibabacloud/tag/model/CloseCreatedByResult.h

@@ -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_TAG_MODEL_CLOSECREATEDBYRESULT_H_
+#define ALIBABACLOUD_TAG_MODEL_CLOSECREATEDBYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/tag/TagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Tag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_TAG_EXPORT CloseCreatedByResult : public ServiceResult
+			{
+			public:
+
+
+				CloseCreatedByResult();
+				explicit CloseCreatedByResult(const std::string &payload);
+				~CloseCreatedByResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_TAG_MODEL_CLOSECREATEDBYRESULT_H_

tag/include/alibabacloud/tag/model/CreatePolicyRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_TAG_MODEL_CREATEPOLICYREQUEST_H_
+#define ALIBABACLOUD_TAG_MODEL_CREATEPOLICYREQUEST_H_
+
+#include <alibabacloud/tag/TagExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Tag {
+namespace Model {
+class ALIBABACLOUD_TAG_EXPORT CreatePolicyRequest : public RpcServiceRequest {
+public:
+	CreatePolicyRequest();
+	~CreatePolicyRequest();
+	std::string getPolicyDesc() const;
+	void setPolicyDesc(const std::string &policyDesc);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getPolicyContent() const;
+	void setPolicyContent(const std::string &policyContent);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	std::string getUserType() const;
+	void setUserType(const std::string &userType);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getPolicyName() const;
+	void setPolicyName(const std::string &policyName);
+
+private:
+	std::string policyDesc_;
+	std::string regionId_;
+	std::string policyContent_;
+	bool dryRun_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	std::string userType_;
+	long ownerId_;
+	std::string policyName_;
+};
+} // namespace Model
+} // namespace Tag
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_TAG_MODEL_CREATEPOLICYREQUEST_H_

tag/include/alibabacloud/tag/model/CreatePolicyResult.h

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

tag/include/alibabacloud/tag/model/DeletePolicyRequest.h

@@ -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_TAG_MODEL_DELETEPOLICYREQUEST_H_
+#define ALIBABACLOUD_TAG_MODEL_DELETEPOLICYREQUEST_H_
+
+#include <alibabacloud/tag/TagExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Tag {
+namespace Model {
+class ALIBABACLOUD_TAG_EXPORT DeletePolicyRequest : public RpcServiceRequest {
+public:
+	DeletePolicyRequest();
+	~DeletePolicyRequest();
+	std::string getPolicyId() const;
+	void setPolicyId(const std::string &policyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	std::string policyId_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Tag
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_TAG_MODEL_DELETEPOLICYREQUEST_H_

tag/include/alibabacloud/tag/model/DeletePolicyResult.h

@@ -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_TAG_MODEL_DELETEPOLICYRESULT_H_
+#define ALIBABACLOUD_TAG_MODEL_DELETEPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/tag/TagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Tag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_TAG_EXPORT DeletePolicyResult : public ServiceResult
+			{
+			public:
+
+
+				DeletePolicyResult();
+				explicit DeletePolicyResult(const std::string &payload);
+				~DeletePolicyResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_TAG_MODEL_DELETEPOLICYRESULT_H_

tag/include/alibabacloud/tag/model/DetachPolicyRequest.h

@@ -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_TAG_MODEL_DETACHPOLICYREQUEST_H_
+#define ALIBABACLOUD_TAG_MODEL_DETACHPOLICYREQUEST_H_
+
+#include <alibabacloud/tag/TagExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Tag {
+namespace Model {
+class ALIBABACLOUD_TAG_EXPORT DetachPolicyRequest : public RpcServiceRequest {
+public:
+	DetachPolicyRequest();
+	~DetachPolicyRequest();
+	std::string getTargetId() const;
+	void setTargetId(const std::string &targetId);
+	std::string getTargetType() const;
+	void setTargetType(const std::string &targetType);
+	std::string getPolicyId() const;
+	void setPolicyId(const std::string &policyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	std::string targetId_;
+	std::string targetType_;
+	std::string policyId_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Tag
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_TAG_MODEL_DETACHPOLICYREQUEST_H_

tag/include/alibabacloud/tag/model/DetachPolicyResult.h

@@ -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_TAG_MODEL_DETACHPOLICYRESULT_H_
+#define ALIBABACLOUD_TAG_MODEL_DETACHPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/tag/TagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Tag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_TAG_EXPORT DetachPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				DetachPolicyResult();
+				explicit DetachPolicyResult(const std::string &payload);
+				~DetachPolicyResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_TAG_MODEL_DETACHPOLICYRESULT_H_

tag/include/alibabacloud/tag/model/DisablePolicyTypeRequest.h

@@ -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_TAG_MODEL_DISABLEPOLICYTYPEREQUEST_H_
+#define ALIBABACLOUD_TAG_MODEL_DISABLEPOLICYTYPEREQUEST_H_
+
+#include <alibabacloud/tag/TagExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Tag {
+namespace Model {
+class ALIBABACLOUD_TAG_EXPORT DisablePolicyTypeRequest : public RpcServiceRequest {
+public:
+	DisablePolicyTypeRequest();
+	~DisablePolicyTypeRequest();
+	std::string getResourceOwnerId() const;
+	void setResourceOwnerId(const std::string &resourceOwnerId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	std::string getUserType() const;
+	void setUserType(const std::string &userType);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getOpenType() const;
+	void setOpenType(const std::string &openType);
+
+private:
+	std::string resourceOwnerId_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	std::string userType_;
+	long ownerId_;
+	std::string openType_;
+};
+} // namespace Model
+} // namespace Tag
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_TAG_MODEL_DISABLEPOLICYTYPEREQUEST_H_

tag/include/alibabacloud/tag/model/DisablePolicyTypeResult.h

@@ -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_TAG_MODEL_DISABLEPOLICYTYPERESULT_H_
+#define ALIBABACLOUD_TAG_MODEL_DISABLEPOLICYTYPERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/tag/TagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Tag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_TAG_EXPORT DisablePolicyTypeResult : public ServiceResult
+			{
+			public:
+
+
+				DisablePolicyTypeResult();
+				explicit DisablePolicyTypeResult(const std::string &payload);
+				~DisablePolicyTypeResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_TAG_MODEL_DISABLEPOLICYTYPERESULT_H_

tag/include/alibabacloud/tag/model/EnablePolicyTypeRequest.h

@@ -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_TAG_MODEL_ENABLEPOLICYTYPEREQUEST_H_
+#define ALIBABACLOUD_TAG_MODEL_ENABLEPOLICYTYPEREQUEST_H_
+
+#include <alibabacloud/tag/TagExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Tag {
+namespace Model {
+class ALIBABACLOUD_TAG_EXPORT EnablePolicyTypeRequest : public RpcServiceRequest {
+public:
+	EnablePolicyTypeRequest();
+	~EnablePolicyTypeRequest();
+	std::string getResourceOwnerId() const;
+	void setResourceOwnerId(const std::string &resourceOwnerId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	std::string getUserType() const;
+	void setUserType(const std::string &userType);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getOpenType() const;
+	void setOpenType(const std::string &openType);
+
+private:
+	std::string resourceOwnerId_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	std::string userType_;
+	long ownerId_;
+	std::string openType_;
+};
+} // namespace Model
+} // namespace Tag
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_TAG_MODEL_ENABLEPOLICYTYPEREQUEST_H_

tag/include/alibabacloud/tag/model/EnablePolicyTypeResult.h

@@ -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_TAG_MODEL_ENABLEPOLICYTYPERESULT_H_
+#define ALIBABACLOUD_TAG_MODEL_ENABLEPOLICYTYPERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/tag/TagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Tag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_TAG_EXPORT EnablePolicyTypeResult : public ServiceResult
+			{
+			public:
+
+
+				EnablePolicyTypeResult();
+				explicit EnablePolicyTypeResult(const std::string &payload);
+				~EnablePolicyTypeResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_TAG_MODEL_ENABLEPOLICYTYPERESULT_H_

tag/include/alibabacloud/tag/model/GenerateConfigRuleReportRequest.h

@@ -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_TAG_MODEL_GENERATECONFIGRULEREPORTREQUEST_H_
+#define ALIBABACLOUD_TAG_MODEL_GENERATECONFIGRULEREPORTREQUEST_H_
+
+#include <alibabacloud/tag/TagExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Tag {
+namespace Model {
+class ALIBABACLOUD_TAG_EXPORT GenerateConfigRuleReportRequest : public RpcServiceRequest {
+public:
+	GenerateConfigRuleReportRequest();
+	~GenerateConfigRuleReportRequest();
+	std::string getTargetId() const;
+	void setTargetId(const std::string &targetId);
+	std::string getTargetType() const;
+	void setTargetType(const std::string &targetType);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	std::string getUserType() const;
+	void setUserType(const std::string &userType);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	std::string targetId_;
+	std::string targetType_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	std::string userType_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Tag
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_TAG_MODEL_GENERATECONFIGRULEREPORTREQUEST_H_

tag/include/alibabacloud/tag/model/GenerateConfigRuleReportResult.h

@@ -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_TAG_MODEL_GENERATECONFIGRULEREPORTRESULT_H_
+#define ALIBABACLOUD_TAG_MODEL_GENERATECONFIGRULEREPORTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/tag/TagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Tag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_TAG_EXPORT GenerateConfigRuleReportResult : public ServiceResult
+			{
+			public:
+
+
+				GenerateConfigRuleReportResult();
+				explicit GenerateConfigRuleReportResult(const std::string &payload);
+				~GenerateConfigRuleReportResult();
+				std::string getReportId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string reportId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_TAG_MODEL_GENERATECONFIGRULEREPORTRESULT_H_

tag/include/alibabacloud/tag/model/GetConfigRuleReportRequest.h

@@ -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_TAG_MODEL_GETCONFIGRULEREPORTREQUEST_H_
+#define ALIBABACLOUD_TAG_MODEL_GETCONFIGRULEREPORTREQUEST_H_
+
+#include <alibabacloud/tag/TagExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Tag {
+namespace Model {
+class ALIBABACLOUD_TAG_EXPORT GetConfigRuleReportRequest : public RpcServiceRequest {
+public:
+	GetConfigRuleReportRequest();
+	~GetConfigRuleReportRequest();
+	std::string getTargetId() const;
+	void setTargetId(const std::string &targetId);
+	std::string getTargetType() const;
+	void setTargetType(const std::string &targetType);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	std::string getUserType() const;
+	void setUserType(const std::string &userType);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	std::string targetId_;
+	std::string targetType_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	std::string userType_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Tag
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_TAG_MODEL_GETCONFIGRULEREPORTREQUEST_H_

tag/include/alibabacloud/tag/model/GetConfigRuleReportResult.h

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

tag/include/alibabacloud/tag/model/GetEffectivePolicyRequest.h

@@ -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_TAG_MODEL_GETEFFECTIVEPOLICYREQUEST_H_
+#define ALIBABACLOUD_TAG_MODEL_GETEFFECTIVEPOLICYREQUEST_H_
+
+#include <alibabacloud/tag/TagExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Tag {
+namespace Model {
+class ALIBABACLOUD_TAG_EXPORT GetEffectivePolicyRequest : public RpcServiceRequest {
+public:
+	GetEffectivePolicyRequest();
+	~GetEffectivePolicyRequest();
+	std::string getTargetId() const;
+	void setTargetId(const std::string &targetId);
+	std::string getTargetType() const;
+	void setTargetType(const std::string &targetType);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	std::string targetId_;
+	std::string targetType_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Tag
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_TAG_MODEL_GETEFFECTIVEPOLICYREQUEST_H_

tag/include/alibabacloud/tag/model/GetEffectivePolicyResult.h

@@ -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_TAG_MODEL_GETEFFECTIVEPOLICYRESULT_H_
+#define ALIBABACLOUD_TAG_MODEL_GETEFFECTIVEPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/tag/TagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Tag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_TAG_EXPORT GetEffectivePolicyResult : public ServiceResult
+			{
+			public:
+
+
+				GetEffectivePolicyResult();
+				explicit GetEffectivePolicyResult(const std::string &payload);
+				~GetEffectivePolicyResult();
+				std::string getEffectivePolicy()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string effectivePolicy_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_TAG_MODEL_GETEFFECTIVEPOLICYRESULT_H_

tag/include/alibabacloud/tag/model/GetPolicyEnableStatusRequest.h

@@ -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_TAG_MODEL_GETPOLICYENABLESTATUSREQUEST_H_
+#define ALIBABACLOUD_TAG_MODEL_GETPOLICYENABLESTATUSREQUEST_H_
+
+#include <alibabacloud/tag/TagExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Tag {
+namespace Model {
+class ALIBABACLOUD_TAG_EXPORT GetPolicyEnableStatusRequest : public RpcServiceRequest {
+public:
+	GetPolicyEnableStatusRequest();
+	~GetPolicyEnableStatusRequest();
+	std::string getResourceOwnerId() const;
+	void setResourceOwnerId(const std::string &resourceOwnerId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	std::string getUserType() const;
+	void setUserType(const std::string &userType);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getOpenType() const;
+	void setOpenType(const std::string &openType);
+
+private:
+	std::string resourceOwnerId_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	std::string userType_;
+	long ownerId_;
+	std::string openType_;
+};
+} // namespace Model
+} // namespace Tag
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_TAG_MODEL_GETPOLICYENABLESTATUSREQUEST_H_

tag/include/alibabacloud/tag/model/GetPolicyEnableStatusResult.h

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

tag/include/alibabacloud/tag/model/GetPolicyRequest.h

@@ -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_TAG_MODEL_GETPOLICYREQUEST_H_
+#define ALIBABACLOUD_TAG_MODEL_GETPOLICYREQUEST_H_
+
+#include <alibabacloud/tag/TagExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Tag {
+namespace Model {
+class ALIBABACLOUD_TAG_EXPORT GetPolicyRequest : public RpcServiceRequest {
+public:
+	GetPolicyRequest();
+	~GetPolicyRequest();
+	std::string getPolicyId() const;
+	void setPolicyId(const std::string &policyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	std::string policyId_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Tag
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_TAG_MODEL_GETPOLICYREQUEST_H_

tag/include/alibabacloud/tag/model/GetPolicyResult.h

@@ -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_TAG_MODEL_GETPOLICYRESULT_H_
+#define ALIBABACLOUD_TAG_MODEL_GETPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/tag/TagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Tag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_TAG_EXPORT GetPolicyResult : public ServiceResult
+			{
+			public:
+				struct Policy
+				{
+					std::string policyDesc;
+					std::string policyName;
+					std::string userType;
+					std::string policyContent;
+				};
+
+
+				GetPolicyResult();
+				explicit GetPolicyResult(const std::string &payload);
+				~GetPolicyResult();
+				Policy getPolicy()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Policy policy_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_TAG_MODEL_GETPOLICYRESULT_H_

tag/include/alibabacloud/tag/model/ListConfigRulesForTargetRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_TAG_MODEL_LISTCONFIGRULESFORTARGETREQUEST_H_
+#define ALIBABACLOUD_TAG_MODEL_LISTCONFIGRULESFORTARGETREQUEST_H_
+
+#include <alibabacloud/tag/TagExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Tag {
+namespace Model {
+class ALIBABACLOUD_TAG_EXPORT ListConfigRulesForTargetRequest : public RpcServiceRequest {
+public:
+	ListConfigRulesForTargetRequest();
+	~ListConfigRulesForTargetRequest();
+	std::string getTargetId() const;
+	void setTargetId(const std::string &targetId);
+	std::string getTargetType() const;
+	void setTargetType(const std::string &targetType);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getPolicyType() const;
+	void setPolicyType(const std::string &policyType);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	std::string getUserType() const;
+	void setUserType(const std::string &userType);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	int getMaxResult() const;
+	void setMaxResult(int maxResult);
+	std::string getTagKey() const;
+	void setTagKey(const std::string &tagKey);
+
+private:
+	std::string targetId_;
+	std::string targetType_;
+	std::string regionId_;
+	std::string nextToken_;
+	std::string resourceOwnerAccount_;
+	std::string policyType_;
+	std::string ownerAccount_;
+	std::string userType_;
+	long ownerId_;
+	int maxResult_;
+	std::string tagKey_;
+};
+} // namespace Model
+} // namespace Tag
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_TAG_MODEL_LISTCONFIGRULESFORTARGETREQUEST_H_

tag/include/alibabacloud/tag/model/ListConfigRulesForTargetResult.h

@@ -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_TAG_MODEL_LISTCONFIGRULESFORTARGETRESULT_H_
+#define ALIBABACLOUD_TAG_MODEL_LISTCONFIGRULESFORTARGETRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/tag/TagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Tag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_TAG_EXPORT ListConfigRulesForTargetResult : public ServiceResult
+			{
+			public:
+				struct DataItem
+				{
+					std::string configRuleId;
+					std::string policyType;
+					std::string tagKey;
+					std::string targetType;
+					bool remediation;
+					std::string tagValue;
+					std::string aggregatorId;
+					std::string targetId;
+				};
+
+
+				ListConfigRulesForTargetResult();
+				explicit ListConfigRulesForTargetResult(const std::string &payload);
+				~ListConfigRulesForTargetResult();
+				std::string getNextToken()const;
+				std::vector<DataItem> getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string nextToken_;
+				std::vector<DataItem> data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_TAG_MODEL_LISTCONFIGRULESFORTARGETRESULT_H_

tag/include/alibabacloud/tag/model/ListPoliciesForTargetRequest.h

@@ -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_TAG_MODEL_LISTPOLICIESFORTARGETREQUEST_H_
+#define ALIBABACLOUD_TAG_MODEL_LISTPOLICIESFORTARGETREQUEST_H_
+
+#include <alibabacloud/tag/TagExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Tag {
+namespace Model {
+class ALIBABACLOUD_TAG_EXPORT ListPoliciesForTargetRequest : public RpcServiceRequest {
+public:
+	ListPoliciesForTargetRequest();
+	~ListPoliciesForTargetRequest();
+	std::string getTargetId() const;
+	void setTargetId(const std::string &targetId);
+	std::string getTargetType() const;
+	void setTargetType(const std::string &targetType);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	int getMaxResult() const;
+	void setMaxResult(int maxResult);
+
+private:
+	std::string targetId_;
+	std::string targetType_;
+	std::string regionId_;
+	std::string nextToken_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	long ownerId_;
+	int maxResult_;
+};
+} // namespace Model
+} // namespace Tag
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_TAG_MODEL_LISTPOLICIESFORTARGETREQUEST_H_

tag/include/alibabacloud/tag/model/ListPoliciesForTargetResult.h

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

tag/include/alibabacloud/tag/model/ListPoliciesRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_TAG_MODEL_LISTPOLICIESREQUEST_H_
+#define ALIBABACLOUD_TAG_MODEL_LISTPOLICIESREQUEST_H_
+
+#include <alibabacloud/tag/TagExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Tag {
+namespace Model {
+class ALIBABACLOUD_TAG_EXPORT ListPoliciesRequest : public RpcServiceRequest {
+public:
+	ListPoliciesRequest();
+	~ListPoliciesRequest();
+	std::vector<std::string> getPolicyNames() const;
+	void setPolicyNames(const std::vector<std::string> &policyNames);
+	std::vector<std::string> getPolicyIds() const;
+	void setPolicyIds(const std::vector<std::string> &policyIds);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	std::string getUserType() const;
+	void setUserType(const std::string &userType);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	int getMaxResult() const;
+	void setMaxResult(int maxResult);
+
+private:
+	std::vector<std::string> policyNames_;
+	std::vector<std::string> policyIds_;
+	std::string regionId_;
+	std::string nextToken_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	std::string userType_;
+	long ownerId_;
+	int maxResult_;
+};
+} // namespace Model
+} // namespace Tag
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_TAG_MODEL_LISTPOLICIESREQUEST_H_

tag/include/alibabacloud/tag/model/ListPoliciesResult.h

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

tag/include/alibabacloud/tag/model/ListSupportResourceTypesRequest.h

@@ -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_TAG_MODEL_LISTSUPPORTRESOURCETYPESREQUEST_H_
+#define ALIBABACLOUD_TAG_MODEL_LISTSUPPORTRESOURCETYPESREQUEST_H_
+
+#include <alibabacloud/tag/TagExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Tag {
+namespace Model {
+class ALIBABACLOUD_TAG_EXPORT ListSupportResourceTypesRequest : public RpcServiceRequest {
+public:
+	ListSupportResourceTypesRequest();
+	~ListSupportResourceTypesRequest();
+	std::string getProductCode() const;
+	void setProductCode(const std::string &productCode);
+	std::string getSupportCode() const;
+	void setSupportCode(const std::string &supportCode);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	std::string getResourceTye() const;
+	void setResourceTye(const std::string &resourceTye);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	int getMaxResult() const;
+	void setMaxResult(int maxResult);
+	bool getShowItems() const;
+	void setShowItems(bool showItems);
+
+private:
+	std::string productCode_;
+	std::string supportCode_;
+	std::string regionId_;
+	std::string nextToken_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	std::string resourceTye_;
+	long ownerId_;
+	int maxResult_;
+	bool showItems_;
+};
+} // namespace Model
+} // namespace Tag
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_TAG_MODEL_LISTSUPPORTRESOURCETYPESREQUEST_H_

tag/include/alibabacloud/tag/model/ListSupportResourceTypesResult.h

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

tag/include/alibabacloud/tag/model/ListTargetsForPolicyRequest.h

@@ -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_TAG_MODEL_LISTTARGETSFORPOLICYREQUEST_H_
+#define ALIBABACLOUD_TAG_MODEL_LISTTARGETSFORPOLICYREQUEST_H_
+
+#include <alibabacloud/tag/TagExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Tag {
+namespace Model {
+class ALIBABACLOUD_TAG_EXPORT ListTargetsForPolicyRequest : public RpcServiceRequest {
+public:
+	ListTargetsForPolicyRequest();
+	~ListTargetsForPolicyRequest();
+	std::string getPolicyId() const;
+	void setPolicyId(const std::string &policyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	int getMaxResult() const;
+	void setMaxResult(int maxResult);
+
+private:
+	std::string policyId_;
+	std::string regionId_;
+	std::string nextToken_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	long ownerId_;
+	int maxResult_;
+};
+} // namespace Model
+} // namespace Tag
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_TAG_MODEL_LISTTARGETSFORPOLICYREQUEST_H_

tag/include/alibabacloud/tag/model/ListTargetsForPolicyResult.h

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

tag/include/alibabacloud/tag/model/ModifyPolicyRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_TAG_MODEL_MODIFYPOLICYREQUEST_H_
+#define ALIBABACLOUD_TAG_MODEL_MODIFYPOLICYREQUEST_H_
+
+#include <alibabacloud/tag/TagExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Tag {
+namespace Model {
+class ALIBABACLOUD_TAG_EXPORT ModifyPolicyRequest : public RpcServiceRequest {
+public:
+	ModifyPolicyRequest();
+	~ModifyPolicyRequest();
+	std::string getPolicyDesc() const;
+	void setPolicyDesc(const std::string &policyDesc);
+	std::string getPolicyId() const;
+	void setPolicyId(const std::string &policyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getPolicyContent() const;
+	void setPolicyContent(const std::string &policyContent);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getPolicyName() const;
+	void setPolicyName(const std::string &policyName);
+
+private:
+	std::string policyDesc_;
+	std::string policyId_;
+	std::string regionId_;
+	std::string policyContent_;
+	bool dryRun_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	long ownerId_;
+	std::string policyName_;
+};
+} // namespace Model
+} // namespace Tag
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_TAG_MODEL_MODIFYPOLICYREQUEST_H_

tag/include/alibabacloud/tag/model/ModifyPolicyResult.h

@@ -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_TAG_MODEL_MODIFYPOLICYRESULT_H_
+#define ALIBABACLOUD_TAG_MODEL_MODIFYPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/tag/TagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Tag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_TAG_EXPORT ModifyPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyPolicyResult();
+				explicit ModifyPolicyResult(const std::string &payload);
+				~ModifyPolicyResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_TAG_MODEL_MODIFYPOLICYRESULT_H_

tag/include/alibabacloud/tag/model/OpenCreatedByRequest.h

@@ -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_TAG_MODEL_OPENCREATEDBYREQUEST_H_
+#define ALIBABACLOUD_TAG_MODEL_OPENCREATEDBYREQUEST_H_
+
+#include <alibabacloud/tag/TagExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Tag {
+namespace Model {
+class ALIBABACLOUD_TAG_EXPORT OpenCreatedByRequest : public RpcServiceRequest {
+public:
+	OpenCreatedByRequest();
+	~OpenCreatedByRequest();
+	std::string getResourceOwnerId() const;
+	void setResourceOwnerId(const std::string &resourceOwnerId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	std::string resourceOwnerId_;
+	std::string regionId_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Tag
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_TAG_MODEL_OPENCREATEDBYREQUEST_H_

tag/include/alibabacloud/tag/model/OpenCreatedByResult.h

@@ -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_TAG_MODEL_OPENCREATEDBYRESULT_H_
+#define ALIBABACLOUD_TAG_MODEL_OPENCREATEDBYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/tag/TagExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Tag
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_TAG_EXPORT OpenCreatedByResult : public ServiceResult
+			{
+			public:
+
+
+				OpenCreatedByResult();
+				explicit OpenCreatedByResult(const std::string &payload);
+				~OpenCreatedByResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_TAG_MODEL_OPENCREATEDBYRESULT_H_

tag/src/TagClient.cc

@@ -51,108 +51,684 @@ TagClient::TagClient(const std::string & accessKeyId, const std::string & access
 TagClient::~TagClient()
 {}
 
+TagClient::AttachPolicyOutcome TagClient::attachPolicy(const AttachPolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AttachPolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AttachPolicyOutcome(AttachPolicyResult(outcome.result()));
+	else
+		return AttachPolicyOutcome(outcome.error());
+}
+
+void TagClient::attachPolicyAsync(const AttachPolicyRequest& request, const AttachPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, attachPolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+TagClient::AttachPolicyOutcomeCallable TagClient::attachPolicyCallable(const AttachPolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AttachPolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->attachPolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+TagClient::CheckCreatedByEnabledOutcome TagClient::checkCreatedByEnabled(const CheckCreatedByEnabledRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CheckCreatedByEnabledOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CheckCreatedByEnabledOutcome(CheckCreatedByEnabledResult(outcome.result()));
+	else
+		return CheckCreatedByEnabledOutcome(outcome.error());
+}
+
+void TagClient::checkCreatedByEnabledAsync(const CheckCreatedByEnabledRequest& request, const CheckCreatedByEnabledAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, checkCreatedByEnabled(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+TagClient::CheckCreatedByEnabledOutcomeCallable TagClient::checkCreatedByEnabledCallable(const CheckCreatedByEnabledRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CheckCreatedByEnabledOutcome()>>(
+			[this, request]()
+			{
+			return this->checkCreatedByEnabled(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+TagClient::CloseCreatedByOutcome TagClient::closeCreatedBy(const CloseCreatedByRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CloseCreatedByOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CloseCreatedByOutcome(CloseCreatedByResult(outcome.result()));
+	else
+		return CloseCreatedByOutcome(outcome.error());
+}
+
+void TagClient::closeCreatedByAsync(const CloseCreatedByRequest& request, const CloseCreatedByAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, closeCreatedBy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+TagClient::CloseCreatedByOutcomeCallable TagClient::closeCreatedByCallable(const CloseCreatedByRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CloseCreatedByOutcome()>>(
+			[this, request]()
+			{
+			return this->closeCreatedBy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+TagClient::CreatePolicyOutcome TagClient::createPolicy(const CreatePolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreatePolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreatePolicyOutcome(CreatePolicyResult(outcome.result()));
+	else
+		return CreatePolicyOutcome(outcome.error());
+}
+
+void TagClient::createPolicyAsync(const CreatePolicyRequest& request, const CreatePolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createPolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+TagClient::CreatePolicyOutcomeCallable TagClient::createPolicyCallable(const CreatePolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreatePolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->createPolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 TagClient::CreateTagsOutcome TagClient::createTags(const CreateTagsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return CreateTagsOutcome(endpointOutcome.error());
+		return CreateTagsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateTagsOutcome(CreateTagsResult(outcome.result()));
+	else
+		return CreateTagsOutcome(outcome.error());
+}
+
+void TagClient::createTagsAsync(const CreateTagsRequest& request, const CreateTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createTags(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+TagClient::CreateTagsOutcomeCallable TagClient::createTagsCallable(const CreateTagsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateTagsOutcome()>>(
+			[this, request]()
+			{
+			return this->createTags(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+TagClient::DeletePolicyOutcome TagClient::deletePolicy(const DeletePolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeletePolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeletePolicyOutcome(DeletePolicyResult(outcome.result()));
+	else
+		return DeletePolicyOutcome(outcome.error());
+}
+
+void TagClient::deletePolicyAsync(const DeletePolicyRequest& request, const DeletePolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deletePolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+TagClient::DeletePolicyOutcomeCallable TagClient::deletePolicyCallable(const DeletePolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeletePolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->deletePolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+TagClient::DeleteTagOutcome TagClient::deleteTag(const DeleteTagRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteTagOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteTagOutcome(DeleteTagResult(outcome.result()));
+	else
+		return DeleteTagOutcome(outcome.error());
+}
+
+void TagClient::deleteTagAsync(const DeleteTagRequest& request, const DeleteTagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteTag(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+TagClient::DeleteTagOutcomeCallable TagClient::deleteTagCallable(const DeleteTagRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteTagOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteTag(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+TagClient::DescribeRegionsOutcome TagClient::describeRegions(const DescribeRegionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeRegionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeRegionsOutcome(DescribeRegionsResult(outcome.result()));
+	else
+		return DescribeRegionsOutcome(outcome.error());
+}
+
+void TagClient::describeRegionsAsync(const DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeRegions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+TagClient::DescribeRegionsOutcomeCallable TagClient::describeRegionsCallable(const DescribeRegionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeRegionsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeRegions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+TagClient::DetachPolicyOutcome TagClient::detachPolicy(const DetachPolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetachPolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetachPolicyOutcome(DetachPolicyResult(outcome.result()));
+	else
+		return DetachPolicyOutcome(outcome.error());
+}
+
+void TagClient::detachPolicyAsync(const DetachPolicyRequest& request, const DetachPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detachPolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+TagClient::DetachPolicyOutcomeCallable TagClient::detachPolicyCallable(const DetachPolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetachPolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->detachPolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+TagClient::DisablePolicyTypeOutcome TagClient::disablePolicyType(const DisablePolicyTypeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DisablePolicyTypeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DisablePolicyTypeOutcome(DisablePolicyTypeResult(outcome.result()));
+	else
+		return DisablePolicyTypeOutcome(outcome.error());
+}
+
+void TagClient::disablePolicyTypeAsync(const DisablePolicyTypeRequest& request, const DisablePolicyTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, disablePolicyType(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+TagClient::DisablePolicyTypeOutcomeCallable TagClient::disablePolicyTypeCallable(const DisablePolicyTypeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DisablePolicyTypeOutcome()>>(
+			[this, request]()
+			{
+			return this->disablePolicyType(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+TagClient::EnablePolicyTypeOutcome TagClient::enablePolicyType(const EnablePolicyTypeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EnablePolicyTypeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EnablePolicyTypeOutcome(EnablePolicyTypeResult(outcome.result()));
+	else
+		return EnablePolicyTypeOutcome(outcome.error());
+}
+
+void TagClient::enablePolicyTypeAsync(const EnablePolicyTypeRequest& request, const EnablePolicyTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, enablePolicyType(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+TagClient::EnablePolicyTypeOutcomeCallable TagClient::enablePolicyTypeCallable(const EnablePolicyTypeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EnablePolicyTypeOutcome()>>(
+			[this, request]()
+			{
+			return this->enablePolicyType(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+TagClient::GenerateConfigRuleReportOutcome TagClient::generateConfigRuleReport(const GenerateConfigRuleReportRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GenerateConfigRuleReportOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GenerateConfigRuleReportOutcome(GenerateConfigRuleReportResult(outcome.result()));
+	else
+		return GenerateConfigRuleReportOutcome(outcome.error());
+}
+
+void TagClient::generateConfigRuleReportAsync(const GenerateConfigRuleReportRequest& request, const GenerateConfigRuleReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, generateConfigRuleReport(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+TagClient::GenerateConfigRuleReportOutcomeCallable TagClient::generateConfigRuleReportCallable(const GenerateConfigRuleReportRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GenerateConfigRuleReportOutcome()>>(
+			[this, request]()
+			{
+			return this->generateConfigRuleReport(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+TagClient::GetConfigRuleReportOutcome TagClient::getConfigRuleReport(const GetConfigRuleReportRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetConfigRuleReportOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return CreateTagsOutcome(CreateTagsResult(outcome.result()));
+		return GetConfigRuleReportOutcome(GetConfigRuleReportResult(outcome.result()));
 	else
-		return CreateTagsOutcome(outcome.error());
+		return GetConfigRuleReportOutcome(outcome.error());
 }
 
-void TagClient::createTagsAsync(const CreateTagsRequest& request, const CreateTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void TagClient::getConfigRuleReportAsync(const GetConfigRuleReportRequest& request, const GetConfigRuleReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, createTags(request), context);
+		handler(this, request, getConfigRuleReport(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-TagClient::CreateTagsOutcomeCallable TagClient::createTagsCallable(const CreateTagsRequest &request) const
+TagClient::GetConfigRuleReportOutcomeCallable TagClient::getConfigRuleReportCallable(const GetConfigRuleReportRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<CreateTagsOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<GetConfigRuleReportOutcome()>>(
 			[this, request]()
 			{
-			return this->createTags(request);
+			return this->getConfigRuleReport(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-TagClient::DeleteTagOutcome TagClient::deleteTag(const DeleteTagRequest &request) const
+TagClient::GetEffectivePolicyOutcome TagClient::getEffectivePolicy(const GetEffectivePolicyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return DeleteTagOutcome(endpointOutcome.error());
+		return GetEffectivePolicyOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return DeleteTagOutcome(DeleteTagResult(outcome.result()));
+		return GetEffectivePolicyOutcome(GetEffectivePolicyResult(outcome.result()));
 	else
-		return DeleteTagOutcome(outcome.error());
+		return GetEffectivePolicyOutcome(outcome.error());
 }
 
-void TagClient::deleteTagAsync(const DeleteTagRequest& request, const DeleteTagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void TagClient::getEffectivePolicyAsync(const GetEffectivePolicyRequest& request, const GetEffectivePolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, deleteTag(request), context);
+		handler(this, request, getEffectivePolicy(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-TagClient::DeleteTagOutcomeCallable TagClient::deleteTagCallable(const DeleteTagRequest &request) const
+TagClient::GetEffectivePolicyOutcomeCallable TagClient::getEffectivePolicyCallable(const GetEffectivePolicyRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<DeleteTagOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<GetEffectivePolicyOutcome()>>(
 			[this, request]()
 			{
-			return this->deleteTag(request);
+			return this->getEffectivePolicy(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
 	return task->get_future();
 }
 
-TagClient::DescribeRegionsOutcome TagClient::describeRegions(const DescribeRegionsRequest &request) const
+TagClient::GetPolicyOutcome TagClient::getPolicy(const GetPolicyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
 	if (!endpointOutcome.isSuccess())
-		return DescribeRegionsOutcome(endpointOutcome.error());
+		return GetPolicyOutcome(endpointOutcome.error());
 
 	auto outcome = makeRequest(endpointOutcome.result(), request);
 
 	if (outcome.isSuccess())
-		return DescribeRegionsOutcome(DescribeRegionsResult(outcome.result()));
+		return GetPolicyOutcome(GetPolicyResult(outcome.result()));
 	else
-		return DescribeRegionsOutcome(outcome.error());
+		return GetPolicyOutcome(outcome.error());
 }
 
-void TagClient::describeRegionsAsync(const DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+void TagClient::getPolicyAsync(const GetPolicyRequest& request, const GetPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
 {
 	auto fn = [this, request, handler, context]()
 	{
-		handler(this, request, describeRegions(request), context);
+		handler(this, request, getPolicy(request), context);
 	};
 
 	asyncExecute(new Runnable(fn));
 }
 
-TagClient::DescribeRegionsOutcomeCallable TagClient::describeRegionsCallable(const DescribeRegionsRequest &request) const
+TagClient::GetPolicyOutcomeCallable TagClient::getPolicyCallable(const GetPolicyRequest &request) const
 {
-	auto task = std::make_shared<std::packaged_task<DescribeRegionsOutcome()>>(
+	auto task = std::make_shared<std::packaged_task<GetPolicyOutcome()>>(
 			[this, request]()
 			{
-			return this->describeRegions(request);
+			return this->getPolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+TagClient::GetPolicyEnableStatusOutcome TagClient::getPolicyEnableStatus(const GetPolicyEnableStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetPolicyEnableStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetPolicyEnableStatusOutcome(GetPolicyEnableStatusResult(outcome.result()));
+	else
+		return GetPolicyEnableStatusOutcome(outcome.error());
+}
+
+void TagClient::getPolicyEnableStatusAsync(const GetPolicyEnableStatusRequest& request, const GetPolicyEnableStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getPolicyEnableStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+TagClient::GetPolicyEnableStatusOutcomeCallable TagClient::getPolicyEnableStatusCallable(const GetPolicyEnableStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetPolicyEnableStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->getPolicyEnableStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+TagClient::ListConfigRulesForTargetOutcome TagClient::listConfigRulesForTarget(const ListConfigRulesForTargetRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListConfigRulesForTargetOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListConfigRulesForTargetOutcome(ListConfigRulesForTargetResult(outcome.result()));
+	else
+		return ListConfigRulesForTargetOutcome(outcome.error());
+}
+
+void TagClient::listConfigRulesForTargetAsync(const ListConfigRulesForTargetRequest& request, const ListConfigRulesForTargetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listConfigRulesForTarget(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+TagClient::ListConfigRulesForTargetOutcomeCallable TagClient::listConfigRulesForTargetCallable(const ListConfigRulesForTargetRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListConfigRulesForTargetOutcome()>>(
+			[this, request]()
+			{
+			return this->listConfigRulesForTarget(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+TagClient::ListPoliciesOutcome TagClient::listPolicies(const ListPoliciesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListPoliciesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListPoliciesOutcome(ListPoliciesResult(outcome.result()));
+	else
+		return ListPoliciesOutcome(outcome.error());
+}
+
+void TagClient::listPoliciesAsync(const ListPoliciesRequest& request, const ListPoliciesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listPolicies(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+TagClient::ListPoliciesOutcomeCallable TagClient::listPoliciesCallable(const ListPoliciesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListPoliciesOutcome()>>(
+			[this, request]()
+			{
+			return this->listPolicies(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+TagClient::ListPoliciesForTargetOutcome TagClient::listPoliciesForTarget(const ListPoliciesForTargetRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListPoliciesForTargetOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListPoliciesForTargetOutcome(ListPoliciesForTargetResult(outcome.result()));
+	else
+		return ListPoliciesForTargetOutcome(outcome.error());
+}
+
+void TagClient::listPoliciesForTargetAsync(const ListPoliciesForTargetRequest& request, const ListPoliciesForTargetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listPoliciesForTarget(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+TagClient::ListPoliciesForTargetOutcomeCallable TagClient::listPoliciesForTargetCallable(const ListPoliciesForTargetRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListPoliciesForTargetOutcome()>>(
+			[this, request]()
+			{
+			return this->listPoliciesForTarget(request);
 			});
 
 	asyncExecute(new Runnable([task]() { (*task)(); }));
@@ -195,6 +771,42 @@ TagClient::ListResourcesByTagOutcomeCallable TagClient::listResourcesByTagCallab
 	return task->get_future();
 }
 
+TagClient::ListSupportResourceTypesOutcome TagClient::listSupportResourceTypes(const ListSupportResourceTypesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListSupportResourceTypesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListSupportResourceTypesOutcome(ListSupportResourceTypesResult(outcome.result()));
+	else
+		return ListSupportResourceTypesOutcome(outcome.error());
+}
+
+void TagClient::listSupportResourceTypesAsync(const ListSupportResourceTypesRequest& request, const ListSupportResourceTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listSupportResourceTypes(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+TagClient::ListSupportResourceTypesOutcomeCallable TagClient::listSupportResourceTypesCallable(const ListSupportResourceTypesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListSupportResourceTypesOutcome()>>(
+			[this, request]()
+			{
+			return this->listSupportResourceTypes(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 TagClient::ListTagKeysOutcome TagClient::listTagKeys(const ListTagKeysRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -303,6 +915,114 @@ TagClient::ListTagValuesOutcomeCallable TagClient::listTagValuesCallable(const L
 	return task->get_future();
 }
 
+TagClient::ListTargetsForPolicyOutcome TagClient::listTargetsForPolicy(const ListTargetsForPolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListTargetsForPolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListTargetsForPolicyOutcome(ListTargetsForPolicyResult(outcome.result()));
+	else
+		return ListTargetsForPolicyOutcome(outcome.error());
+}
+
+void TagClient::listTargetsForPolicyAsync(const ListTargetsForPolicyRequest& request, const ListTargetsForPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listTargetsForPolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+TagClient::ListTargetsForPolicyOutcomeCallable TagClient::listTargetsForPolicyCallable(const ListTargetsForPolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListTargetsForPolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->listTargetsForPolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+TagClient::ModifyPolicyOutcome TagClient::modifyPolicy(const ModifyPolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyPolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyPolicyOutcome(ModifyPolicyResult(outcome.result()));
+	else
+		return ModifyPolicyOutcome(outcome.error());
+}
+
+void TagClient::modifyPolicyAsync(const ModifyPolicyRequest& request, const ModifyPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyPolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+TagClient::ModifyPolicyOutcomeCallable TagClient::modifyPolicyCallable(const ModifyPolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyPolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyPolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+TagClient::OpenCreatedByOutcome TagClient::openCreatedBy(const OpenCreatedByRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return OpenCreatedByOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return OpenCreatedByOutcome(OpenCreatedByResult(outcome.result()));
+	else
+		return OpenCreatedByOutcome(outcome.error());
+}
+
+void TagClient::openCreatedByAsync(const OpenCreatedByRequest& request, const OpenCreatedByAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, openCreatedBy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+TagClient::OpenCreatedByOutcomeCallable TagClient::openCreatedByCallable(const OpenCreatedByRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<OpenCreatedByOutcome()>>(
+			[this, request]()
+			{
+			return this->openCreatedBy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 TagClient::TagResourcesOutcome TagClient::tagResources(const TagResourcesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

tag/src/model/AttachPolicyRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/AttachPolicyRequest.h>
+
+using AlibabaCloud::Tag::Model::AttachPolicyRequest;
+
+AttachPolicyRequest::AttachPolicyRequest()
+    : RpcServiceRequest("tag", "2018-08-28", "AttachPolicy") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AttachPolicyRequest::~AttachPolicyRequest() {}
+
+std::string AttachPolicyRequest::getTargetId() const {
+  return targetId_;
+}
+
+void AttachPolicyRequest::setTargetId(const std::string &targetId) {
+  targetId_ = targetId;
+  setParameter(std::string("TargetId"), targetId);
+}
+
+std::string AttachPolicyRequest::getTargetType() const {
+  return targetType_;
+}
+
+void AttachPolicyRequest::setTargetType(const std::string &targetType) {
+  targetType_ = targetType;
+  setParameter(std::string("TargetType"), targetType);
+}
+
+std::string AttachPolicyRequest::getPolicyId() const {
+  return policyId_;
+}
+
+void AttachPolicyRequest::setPolicyId(const std::string &policyId) {
+  policyId_ = policyId;
+  setParameter(std::string("PolicyId"), policyId);
+}
+
+std::string AttachPolicyRequest::getRegionId() const {
+  return regionId_;
+}
+
+void AttachPolicyRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string AttachPolicyRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void AttachPolicyRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string AttachPolicyRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void AttachPolicyRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long AttachPolicyRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void AttachPolicyRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

tag/src/model/AttachPolicyResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/AttachPolicyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Tag;
+using namespace AlibabaCloud::Tag::Model;
+
+AttachPolicyResult::AttachPolicyResult() :
+	ServiceResult()
+{}
+
+AttachPolicyResult::AttachPolicyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AttachPolicyResult::~AttachPolicyResult()
+{}
+
+void AttachPolicyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

tag/src/model/CheckCreatedByEnabledRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/CheckCreatedByEnabledRequest.h>
+
+using AlibabaCloud::Tag::Model::CheckCreatedByEnabledRequest;
+
+CheckCreatedByEnabledRequest::CheckCreatedByEnabledRequest()
+    : RpcServiceRequest("tag", "2018-08-28", "CheckCreatedByEnabled") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CheckCreatedByEnabledRequest::~CheckCreatedByEnabledRequest() {}
+
+std::string CheckCreatedByEnabledRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CheckCreatedByEnabledRequest::setResourceOwnerId(const std::string &resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), resourceOwnerId);
+}
+
+std::string CheckCreatedByEnabledRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CheckCreatedByEnabledRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CheckCreatedByEnabledRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CheckCreatedByEnabledRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CheckCreatedByEnabledRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CheckCreatedByEnabledRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long CheckCreatedByEnabledRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CheckCreatedByEnabledRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

tag/src/model/CheckCreatedByEnabledResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/tag/model/CheckCreatedByEnabledResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Tag;
+using namespace AlibabaCloud::Tag::Model;
+
+CheckCreatedByEnabledResult::CheckCreatedByEnabledResult() :
+	ServiceResult()
+{}
+
+CheckCreatedByEnabledResult::CheckCreatedByEnabledResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CheckCreatedByEnabledResult::~CheckCreatedByEnabledResult()
+{}
+
+void CheckCreatedByEnabledResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["OpenStatus"].isNull())
+		openStatus_ = value["OpenStatus"].asString() == "true";
+
+}
+
+bool CheckCreatedByEnabledResult::getOpenStatus()const
+{
+	return openStatus_;
+}
+

tag/src/model/CloseCreatedByRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/CloseCreatedByRequest.h>
+
+using AlibabaCloud::Tag::Model::CloseCreatedByRequest;
+
+CloseCreatedByRequest::CloseCreatedByRequest()
+    : RpcServiceRequest("tag", "2018-08-28", "CloseCreatedBy") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CloseCreatedByRequest::~CloseCreatedByRequest() {}
+
+std::string CloseCreatedByRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CloseCreatedByRequest::setResourceOwnerId(const std::string &resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), resourceOwnerId);
+}
+
+std::string CloseCreatedByRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CloseCreatedByRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CloseCreatedByRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CloseCreatedByRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CloseCreatedByRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CloseCreatedByRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long CloseCreatedByRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CloseCreatedByRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

tag/src/model/CloseCreatedByResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/CloseCreatedByResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Tag;
+using namespace AlibabaCloud::Tag::Model;
+
+CloseCreatedByResult::CloseCreatedByResult() :
+	ServiceResult()
+{}
+
+CloseCreatedByResult::CloseCreatedByResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CloseCreatedByResult::~CloseCreatedByResult()
+{}
+
+void CloseCreatedByResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

tag/src/model/CreatePolicyRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/CreatePolicyRequest.h>
+
+using AlibabaCloud::Tag::Model::CreatePolicyRequest;
+
+CreatePolicyRequest::CreatePolicyRequest()
+    : RpcServiceRequest("tag", "2018-08-28", "CreatePolicy") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreatePolicyRequest::~CreatePolicyRequest() {}
+
+std::string CreatePolicyRequest::getPolicyDesc() const {
+  return policyDesc_;
+}
+
+void CreatePolicyRequest::setPolicyDesc(const std::string &policyDesc) {
+  policyDesc_ = policyDesc;
+  setParameter(std::string("PolicyDesc"), policyDesc);
+}
+
+std::string CreatePolicyRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreatePolicyRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreatePolicyRequest::getPolicyContent() const {
+  return policyContent_;
+}
+
+void CreatePolicyRequest::setPolicyContent(const std::string &policyContent) {
+  policyContent_ = policyContent;
+  setParameter(std::string("PolicyContent"), policyContent);
+}
+
+bool CreatePolicyRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void CreatePolicyRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string CreatePolicyRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreatePolicyRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CreatePolicyRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreatePolicyRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::string CreatePolicyRequest::getUserType() const {
+  return userType_;
+}
+
+void CreatePolicyRequest::setUserType(const std::string &userType) {
+  userType_ = userType;
+  setParameter(std::string("UserType"), userType);
+}
+
+long CreatePolicyRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreatePolicyRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreatePolicyRequest::getPolicyName() const {
+  return policyName_;
+}
+
+void CreatePolicyRequest::setPolicyName(const std::string &policyName) {
+  policyName_ = policyName;
+  setParameter(std::string("PolicyName"), policyName);
+}
+

tag/src/model/CreatePolicyResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/tag/model/CreatePolicyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Tag;
+using namespace AlibabaCloud::Tag::Model;
+
+CreatePolicyResult::CreatePolicyResult() :
+	ServiceResult()
+{}
+
+CreatePolicyResult::CreatePolicyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreatePolicyResult::~CreatePolicyResult()
+{}
+
+void CreatePolicyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["PolicyId"].isNull())
+		policyId_ = value["PolicyId"].asString();
+	if(!value["PolicyName"].isNull())
+		policyName_ = value["PolicyName"].asString();
+
+}
+
+std::string CreatePolicyResult::getPolicyName()const
+{
+	return policyName_;
+}
+
+std::string CreatePolicyResult::getPolicyId()const
+{
+	return policyId_;
+}
+

tag/src/model/DeletePolicyRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/DeletePolicyRequest.h>
+
+using AlibabaCloud::Tag::Model::DeletePolicyRequest;
+
+DeletePolicyRequest::DeletePolicyRequest()
+    : RpcServiceRequest("tag", "2018-08-28", "DeletePolicy") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeletePolicyRequest::~DeletePolicyRequest() {}
+
+std::string DeletePolicyRequest::getPolicyId() const {
+  return policyId_;
+}
+
+void DeletePolicyRequest::setPolicyId(const std::string &policyId) {
+  policyId_ = policyId;
+  setParameter(std::string("PolicyId"), policyId);
+}
+
+std::string DeletePolicyRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DeletePolicyRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DeletePolicyRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DeletePolicyRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DeletePolicyRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DeletePolicyRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DeletePolicyRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DeletePolicyRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

tag/src/model/DeletePolicyResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/DeletePolicyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Tag;
+using namespace AlibabaCloud::Tag::Model;
+
+DeletePolicyResult::DeletePolicyResult() :
+	ServiceResult()
+{}
+
+DeletePolicyResult::DeletePolicyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeletePolicyResult::~DeletePolicyResult()
+{}
+
+void DeletePolicyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

tag/src/model/DetachPolicyRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/DetachPolicyRequest.h>
+
+using AlibabaCloud::Tag::Model::DetachPolicyRequest;
+
+DetachPolicyRequest::DetachPolicyRequest()
+    : RpcServiceRequest("tag", "2018-08-28", "DetachPolicy") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DetachPolicyRequest::~DetachPolicyRequest() {}
+
+std::string DetachPolicyRequest::getTargetId() const {
+  return targetId_;
+}
+
+void DetachPolicyRequest::setTargetId(const std::string &targetId) {
+  targetId_ = targetId;
+  setParameter(std::string("TargetId"), targetId);
+}
+
+std::string DetachPolicyRequest::getTargetType() const {
+  return targetType_;
+}
+
+void DetachPolicyRequest::setTargetType(const std::string &targetType) {
+  targetType_ = targetType;
+  setParameter(std::string("TargetType"), targetType);
+}
+
+std::string DetachPolicyRequest::getPolicyId() const {
+  return policyId_;
+}
+
+void DetachPolicyRequest::setPolicyId(const std::string &policyId) {
+  policyId_ = policyId;
+  setParameter(std::string("PolicyId"), policyId);
+}
+
+std::string DetachPolicyRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DetachPolicyRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DetachPolicyRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DetachPolicyRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DetachPolicyRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DetachPolicyRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DetachPolicyRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DetachPolicyRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

tag/src/model/DetachPolicyResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/DetachPolicyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Tag;
+using namespace AlibabaCloud::Tag::Model;
+
+DetachPolicyResult::DetachPolicyResult() :
+	ServiceResult()
+{}
+
+DetachPolicyResult::DetachPolicyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DetachPolicyResult::~DetachPolicyResult()
+{}
+
+void DetachPolicyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

tag/src/model/DisablePolicyTypeRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/DisablePolicyTypeRequest.h>
+
+using AlibabaCloud::Tag::Model::DisablePolicyTypeRequest;
+
+DisablePolicyTypeRequest::DisablePolicyTypeRequest()
+    : RpcServiceRequest("tag", "2018-08-28", "DisablePolicyType") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DisablePolicyTypeRequest::~DisablePolicyTypeRequest() {}
+
+std::string DisablePolicyTypeRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DisablePolicyTypeRequest::setResourceOwnerId(const std::string &resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), resourceOwnerId);
+}
+
+std::string DisablePolicyTypeRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DisablePolicyTypeRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DisablePolicyTypeRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DisablePolicyTypeRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DisablePolicyTypeRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DisablePolicyTypeRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::string DisablePolicyTypeRequest::getUserType() const {
+  return userType_;
+}
+
+void DisablePolicyTypeRequest::setUserType(const std::string &userType) {
+  userType_ = userType;
+  setParameter(std::string("UserType"), userType);
+}
+
+long DisablePolicyTypeRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DisablePolicyTypeRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DisablePolicyTypeRequest::getOpenType() const {
+  return openType_;
+}
+
+void DisablePolicyTypeRequest::setOpenType(const std::string &openType) {
+  openType_ = openType;
+  setParameter(std::string("OpenType"), openType);
+}
+

tag/src/model/DisablePolicyTypeResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/DisablePolicyTypeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Tag;
+using namespace AlibabaCloud::Tag::Model;
+
+DisablePolicyTypeResult::DisablePolicyTypeResult() :
+	ServiceResult()
+{}
+
+DisablePolicyTypeResult::DisablePolicyTypeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DisablePolicyTypeResult::~DisablePolicyTypeResult()
+{}
+
+void DisablePolicyTypeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

tag/src/model/EnablePolicyTypeRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/EnablePolicyTypeRequest.h>
+
+using AlibabaCloud::Tag::Model::EnablePolicyTypeRequest;
+
+EnablePolicyTypeRequest::EnablePolicyTypeRequest()
+    : RpcServiceRequest("tag", "2018-08-28", "EnablePolicyType") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+EnablePolicyTypeRequest::~EnablePolicyTypeRequest() {}
+
+std::string EnablePolicyTypeRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void EnablePolicyTypeRequest::setResourceOwnerId(const std::string &resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), resourceOwnerId);
+}
+
+std::string EnablePolicyTypeRequest::getRegionId() const {
+  return regionId_;
+}
+
+void EnablePolicyTypeRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string EnablePolicyTypeRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void EnablePolicyTypeRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string EnablePolicyTypeRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void EnablePolicyTypeRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::string EnablePolicyTypeRequest::getUserType() const {
+  return userType_;
+}
+
+void EnablePolicyTypeRequest::setUserType(const std::string &userType) {
+  userType_ = userType;
+  setParameter(std::string("UserType"), userType);
+}
+
+long EnablePolicyTypeRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void EnablePolicyTypeRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string EnablePolicyTypeRequest::getOpenType() const {
+  return openType_;
+}
+
+void EnablePolicyTypeRequest::setOpenType(const std::string &openType) {
+  openType_ = openType;
+  setParameter(std::string("OpenType"), openType);
+}
+

tag/src/model/EnablePolicyTypeResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/EnablePolicyTypeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Tag;
+using namespace AlibabaCloud::Tag::Model;
+
+EnablePolicyTypeResult::EnablePolicyTypeResult() :
+	ServiceResult()
+{}
+
+EnablePolicyTypeResult::EnablePolicyTypeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+EnablePolicyTypeResult::~EnablePolicyTypeResult()
+{}
+
+void EnablePolicyTypeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

tag/src/model/GenerateConfigRuleReportRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/GenerateConfigRuleReportRequest.h>
+
+using AlibabaCloud::Tag::Model::GenerateConfigRuleReportRequest;
+
+GenerateConfigRuleReportRequest::GenerateConfigRuleReportRequest()
+    : RpcServiceRequest("tag", "2018-08-28", "GenerateConfigRuleReport") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GenerateConfigRuleReportRequest::~GenerateConfigRuleReportRequest() {}
+
+std::string GenerateConfigRuleReportRequest::getTargetId() const {
+  return targetId_;
+}
+
+void GenerateConfigRuleReportRequest::setTargetId(const std::string &targetId) {
+  targetId_ = targetId;
+  setParameter(std::string("TargetId"), targetId);
+}
+
+std::string GenerateConfigRuleReportRequest::getTargetType() const {
+  return targetType_;
+}
+
+void GenerateConfigRuleReportRequest::setTargetType(const std::string &targetType) {
+  targetType_ = targetType;
+  setParameter(std::string("TargetType"), targetType);
+}
+
+std::string GenerateConfigRuleReportRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GenerateConfigRuleReportRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string GenerateConfigRuleReportRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void GenerateConfigRuleReportRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string GenerateConfigRuleReportRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void GenerateConfigRuleReportRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::string GenerateConfigRuleReportRequest::getUserType() const {
+  return userType_;
+}
+
+void GenerateConfigRuleReportRequest::setUserType(const std::string &userType) {
+  userType_ = userType;
+  setParameter(std::string("UserType"), userType);
+}
+
+long GenerateConfigRuleReportRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void GenerateConfigRuleReportRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

tag/src/model/GenerateConfigRuleReportResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/tag/model/GenerateConfigRuleReportResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Tag;
+using namespace AlibabaCloud::Tag::Model;
+
+GenerateConfigRuleReportResult::GenerateConfigRuleReportResult() :
+	ServiceResult()
+{}
+
+GenerateConfigRuleReportResult::GenerateConfigRuleReportResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GenerateConfigRuleReportResult::~GenerateConfigRuleReportResult()
+{}
+
+void GenerateConfigRuleReportResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ReportId"].isNull())
+		reportId_ = value["ReportId"].asString();
+
+}
+
+std::string GenerateConfigRuleReportResult::getReportId()const
+{
+	return reportId_;
+}
+

tag/src/model/GetConfigRuleReportRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/GetConfigRuleReportRequest.h>
+
+using AlibabaCloud::Tag::Model::GetConfigRuleReportRequest;
+
+GetConfigRuleReportRequest::GetConfigRuleReportRequest()
+    : RpcServiceRequest("tag", "2018-08-28", "GetConfigRuleReport") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetConfigRuleReportRequest::~GetConfigRuleReportRequest() {}
+
+std::string GetConfigRuleReportRequest::getTargetId() const {
+  return targetId_;
+}
+
+void GetConfigRuleReportRequest::setTargetId(const std::string &targetId) {
+  targetId_ = targetId;
+  setParameter(std::string("TargetId"), targetId);
+}
+
+std::string GetConfigRuleReportRequest::getTargetType() const {
+  return targetType_;
+}
+
+void GetConfigRuleReportRequest::setTargetType(const std::string &targetType) {
+  targetType_ = targetType;
+  setParameter(std::string("TargetType"), targetType);
+}
+
+std::string GetConfigRuleReportRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetConfigRuleReportRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string GetConfigRuleReportRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void GetConfigRuleReportRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string GetConfigRuleReportRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void GetConfigRuleReportRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::string GetConfigRuleReportRequest::getUserType() const {
+  return userType_;
+}
+
+void GetConfigRuleReportRequest::setUserType(const std::string &userType) {
+  userType_ = userType;
+  setParameter(std::string("UserType"), userType);
+}
+
+long GetConfigRuleReportRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void GetConfigRuleReportRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

tag/src/model/GetConfigRuleReportResult.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/GetConfigRuleReportResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Tag;
+using namespace AlibabaCloud::Tag::Model;
+
+GetConfigRuleReportResult::GetConfigRuleReportResult() :
+	ServiceResult()
+{}
+
+GetConfigRuleReportResult::GetConfigRuleReportResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetConfigRuleReportResult::~GetConfigRuleReportResult()
+{}
+
+void GetConfigRuleReportResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["CreatedTime"].isNull())
+		data_.createdTime = std::stol(dataNode["CreatedTime"].asString());
+	if(!dataNode["ReportId"].isNull())
+		data_.reportId = dataNode["ReportId"].asString();
+	if(!dataNode["TargetId"].isNull())
+		data_.targetId = dataNode["TargetId"].asString();
+	if(!dataNode["TargetType"].isNull())
+		data_.targetType = dataNode["TargetType"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+int GetConfigRuleReportResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+GetConfigRuleReportResult::Data GetConfigRuleReportResult::getData()const
+{
+	return data_;
+}
+
+bool GetConfigRuleReportResult::getSuccess()const
+{
+	return success_;
+}
+

tag/src/model/GetEffectivePolicyRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/GetEffectivePolicyRequest.h>
+
+using AlibabaCloud::Tag::Model::GetEffectivePolicyRequest;
+
+GetEffectivePolicyRequest::GetEffectivePolicyRequest()
+    : RpcServiceRequest("tag", "2018-08-28", "GetEffectivePolicy") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetEffectivePolicyRequest::~GetEffectivePolicyRequest() {}
+
+std::string GetEffectivePolicyRequest::getTargetId() const {
+  return targetId_;
+}
+
+void GetEffectivePolicyRequest::setTargetId(const std::string &targetId) {
+  targetId_ = targetId;
+  setParameter(std::string("TargetId"), targetId);
+}
+
+std::string GetEffectivePolicyRequest::getTargetType() const {
+  return targetType_;
+}
+
+void GetEffectivePolicyRequest::setTargetType(const std::string &targetType) {
+  targetType_ = targetType;
+  setParameter(std::string("TargetType"), targetType);
+}
+
+std::string GetEffectivePolicyRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetEffectivePolicyRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string GetEffectivePolicyRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void GetEffectivePolicyRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string GetEffectivePolicyRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void GetEffectivePolicyRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long GetEffectivePolicyRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void GetEffectivePolicyRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

tag/src/model/GetEffectivePolicyResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/tag/model/GetEffectivePolicyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Tag;
+using namespace AlibabaCloud::Tag::Model;
+
+GetEffectivePolicyResult::GetEffectivePolicyResult() :
+	ServiceResult()
+{}
+
+GetEffectivePolicyResult::GetEffectivePolicyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetEffectivePolicyResult::~GetEffectivePolicyResult()
+{}
+
+void GetEffectivePolicyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["EffectivePolicy"].isNull())
+		effectivePolicy_ = value["EffectivePolicy"].asString();
+
+}
+
+std::string GetEffectivePolicyResult::getEffectivePolicy()const
+{
+	return effectivePolicy_;
+}
+

tag/src/model/GetPolicyEnableStatusRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/GetPolicyEnableStatusRequest.h>
+
+using AlibabaCloud::Tag::Model::GetPolicyEnableStatusRequest;
+
+GetPolicyEnableStatusRequest::GetPolicyEnableStatusRequest()
+    : RpcServiceRequest("tag", "2018-08-28", "GetPolicyEnableStatus") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetPolicyEnableStatusRequest::~GetPolicyEnableStatusRequest() {}
+
+std::string GetPolicyEnableStatusRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void GetPolicyEnableStatusRequest::setResourceOwnerId(const std::string &resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), resourceOwnerId);
+}
+
+std::string GetPolicyEnableStatusRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetPolicyEnableStatusRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string GetPolicyEnableStatusRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void GetPolicyEnableStatusRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string GetPolicyEnableStatusRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void GetPolicyEnableStatusRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::string GetPolicyEnableStatusRequest::getUserType() const {
+  return userType_;
+}
+
+void GetPolicyEnableStatusRequest::setUserType(const std::string &userType) {
+  userType_ = userType;
+  setParameter(std::string("UserType"), userType);
+}
+
+long GetPolicyEnableStatusRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void GetPolicyEnableStatusRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string GetPolicyEnableStatusRequest::getOpenType() const {
+  return openType_;
+}
+
+void GetPolicyEnableStatusRequest::setOpenType(const std::string &openType) {
+  openType_ = openType;
+  setParameter(std::string("OpenType"), openType);
+}
+

tag/src/model/GetPolicyEnableStatusResult.cc

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/GetPolicyEnableStatusResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Tag;
+using namespace AlibabaCloud::Tag::Model;
+
+GetPolicyEnableStatusResult::GetPolicyEnableStatusResult() :
+	ServiceResult()
+{}
+
+GetPolicyEnableStatusResult::GetPolicyEnableStatusResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetPolicyEnableStatusResult::~GetPolicyEnableStatusResult()
+{}
+
+void GetPolicyEnableStatusResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allStatusModelsNode = value["StatusModels"]["StatusModelsItem"];
+	for (auto valueStatusModelsStatusModelsItem : allStatusModelsNode)
+	{
+		StatusModelsItem statusModelsObject;
+		if(!valueStatusModelsStatusModelsItem["Status"].isNull())
+			statusModelsObject.status = valueStatusModelsStatusModelsItem["Status"].asString();
+		if(!valueStatusModelsStatusModelsItem["UserType"].isNull())
+			statusModelsObject.userType = valueStatusModelsStatusModelsItem["UserType"].asString();
+		statusModels_.push_back(statusModelsObject);
+	}
+
+}
+
+std::vector<GetPolicyEnableStatusResult::StatusModelsItem> GetPolicyEnableStatusResult::getStatusModels()const
+{
+	return statusModels_;
+}
+

tag/src/model/GetPolicyRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/GetPolicyRequest.h>
+
+using AlibabaCloud::Tag::Model::GetPolicyRequest;
+
+GetPolicyRequest::GetPolicyRequest()
+    : RpcServiceRequest("tag", "2018-08-28", "GetPolicy") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetPolicyRequest::~GetPolicyRequest() {}
+
+std::string GetPolicyRequest::getPolicyId() const {
+  return policyId_;
+}
+
+void GetPolicyRequest::setPolicyId(const std::string &policyId) {
+  policyId_ = policyId;
+  setParameter(std::string("PolicyId"), policyId);
+}
+
+std::string GetPolicyRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetPolicyRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string GetPolicyRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void GetPolicyRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string GetPolicyRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void GetPolicyRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long GetPolicyRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void GetPolicyRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

tag/src/model/GetPolicyResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/tag/model/GetPolicyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Tag;
+using namespace AlibabaCloud::Tag::Model;
+
+GetPolicyResult::GetPolicyResult() :
+	ServiceResult()
+{}
+
+GetPolicyResult::GetPolicyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetPolicyResult::~GetPolicyResult()
+{}
+
+void GetPolicyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto policyNode = value["Policy"];
+	if(!policyNode["PolicyName"].isNull())
+		policy_.policyName = policyNode["PolicyName"].asString();
+	if(!policyNode["PolicyDesc"].isNull())
+		policy_.policyDesc = policyNode["PolicyDesc"].asString();
+	if(!policyNode["PolicyContent"].isNull())
+		policy_.policyContent = policyNode["PolicyContent"].asString();
+	if(!policyNode["UserType"].isNull())
+		policy_.userType = policyNode["UserType"].asString();
+
+}
+
+GetPolicyResult::Policy GetPolicyResult::getPolicy()const
+{
+	return policy_;
+}
+

tag/src/model/ListConfigRulesForTargetRequest.cc

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/ListConfigRulesForTargetRequest.h>
+
+using AlibabaCloud::Tag::Model::ListConfigRulesForTargetRequest;
+
+ListConfigRulesForTargetRequest::ListConfigRulesForTargetRequest()
+    : RpcServiceRequest("tag", "2018-08-28", "ListConfigRulesForTarget") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListConfigRulesForTargetRequest::~ListConfigRulesForTargetRequest() {}
+
+std::string ListConfigRulesForTargetRequest::getTargetId() const {
+  return targetId_;
+}
+
+void ListConfigRulesForTargetRequest::setTargetId(const std::string &targetId) {
+  targetId_ = targetId;
+  setParameter(std::string("TargetId"), targetId);
+}
+
+std::string ListConfigRulesForTargetRequest::getTargetType() const {
+  return targetType_;
+}
+
+void ListConfigRulesForTargetRequest::setTargetType(const std::string &targetType) {
+  targetType_ = targetType;
+  setParameter(std::string("TargetType"), targetType);
+}
+
+std::string ListConfigRulesForTargetRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ListConfigRulesForTargetRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string ListConfigRulesForTargetRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void ListConfigRulesForTargetRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::string ListConfigRulesForTargetRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void ListConfigRulesForTargetRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string ListConfigRulesForTargetRequest::getPolicyType() const {
+  return policyType_;
+}
+
+void ListConfigRulesForTargetRequest::setPolicyType(const std::string &policyType) {
+  policyType_ = policyType;
+  setParameter(std::string("PolicyType"), policyType);
+}
+
+std::string ListConfigRulesForTargetRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void ListConfigRulesForTargetRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::string ListConfigRulesForTargetRequest::getUserType() const {
+  return userType_;
+}
+
+void ListConfigRulesForTargetRequest::setUserType(const std::string &userType) {
+  userType_ = userType;
+  setParameter(std::string("UserType"), userType);
+}
+
+long ListConfigRulesForTargetRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void ListConfigRulesForTargetRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+int ListConfigRulesForTargetRequest::getMaxResult() const {
+  return maxResult_;
+}
+
+void ListConfigRulesForTargetRequest::setMaxResult(int maxResult) {
+  maxResult_ = maxResult;
+  setParameter(std::string("MaxResult"), std::to_string(maxResult));
+}
+
+std::string ListConfigRulesForTargetRequest::getTagKey() const {
+  return tagKey_;
+}
+
+void ListConfigRulesForTargetRequest::setTagKey(const std::string &tagKey) {
+  tagKey_ = tagKey;
+  setParameter(std::string("TagKey"), tagKey);
+}
+

tag/src/model/ListConfigRulesForTargetResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/tag/model/ListConfigRulesForTargetResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Tag;
+using namespace AlibabaCloud::Tag::Model;
+
+ListConfigRulesForTargetResult::ListConfigRulesForTargetResult() :
+	ServiceResult()
+{}
+
+ListConfigRulesForTargetResult::ListConfigRulesForTargetResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListConfigRulesForTargetResult::~ListConfigRulesForTargetResult()
+{}
+
+void ListConfigRulesForTargetResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["DataItem"];
+	for (auto valueDataDataItem : allDataNode)
+	{
+		DataItem dataObject;
+		if(!valueDataDataItem["AggregatorId"].isNull())
+			dataObject.aggregatorId = valueDataDataItem["AggregatorId"].asString();
+		if(!valueDataDataItem["ConfigRuleId"].isNull())
+			dataObject.configRuleId = valueDataDataItem["ConfigRuleId"].asString();
+		if(!valueDataDataItem["PolicyType"].isNull())
+			dataObject.policyType = valueDataDataItem["PolicyType"].asString();
+		if(!valueDataDataItem["Remediation"].isNull())
+			dataObject.remediation = valueDataDataItem["Remediation"].asString() == "true";
+		if(!valueDataDataItem["TagKey"].isNull())
+			dataObject.tagKey = valueDataDataItem["TagKey"].asString();
+		if(!valueDataDataItem["TagValue"].isNull())
+			dataObject.tagValue = valueDataDataItem["TagValue"].asString();
+		if(!valueDataDataItem["TargetId"].isNull())
+			dataObject.targetId = valueDataDataItem["TargetId"].asString();
+		if(!valueDataDataItem["TargetType"].isNull())
+			dataObject.targetType = valueDataDataItem["TargetType"].asString();
+		data_.push_back(dataObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+
+}
+
+std::string ListConfigRulesForTargetResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::vector<ListConfigRulesForTargetResult::DataItem> ListConfigRulesForTargetResult::getData()const
+{
+	return data_;
+}
+

tag/src/model/ListPoliciesForTargetRequest.cc

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/ListPoliciesForTargetRequest.h>
+
+using AlibabaCloud::Tag::Model::ListPoliciesForTargetRequest;
+
+ListPoliciesForTargetRequest::ListPoliciesForTargetRequest()
+    : RpcServiceRequest("tag", "2018-08-28", "ListPoliciesForTarget") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListPoliciesForTargetRequest::~ListPoliciesForTargetRequest() {}
+
+std::string ListPoliciesForTargetRequest::getTargetId() const {
+  return targetId_;
+}
+
+void ListPoliciesForTargetRequest::setTargetId(const std::string &targetId) {
+  targetId_ = targetId;
+  setParameter(std::string("TargetId"), targetId);
+}
+
+std::string ListPoliciesForTargetRequest::getTargetType() const {
+  return targetType_;
+}
+
+void ListPoliciesForTargetRequest::setTargetType(const std::string &targetType) {
+  targetType_ = targetType;
+  setParameter(std::string("TargetType"), targetType);
+}
+
+std::string ListPoliciesForTargetRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ListPoliciesForTargetRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string ListPoliciesForTargetRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void ListPoliciesForTargetRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::string ListPoliciesForTargetRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void ListPoliciesForTargetRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string ListPoliciesForTargetRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void ListPoliciesForTargetRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long ListPoliciesForTargetRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void ListPoliciesForTargetRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+int ListPoliciesForTargetRequest::getMaxResult() const {
+  return maxResult_;
+}
+
+void ListPoliciesForTargetRequest::setMaxResult(int maxResult) {
+  maxResult_ = maxResult;
+  setParameter(std::string("MaxResult"), std::to_string(maxResult));
+}
+

tag/src/model/ListPoliciesForTargetResult.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/ListPoliciesForTargetResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Tag;
+using namespace AlibabaCloud::Tag::Model;
+
+ListPoliciesForTargetResult::ListPoliciesForTargetResult() :
+	ServiceResult()
+{}
+
+ListPoliciesForTargetResult::ListPoliciesForTargetResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListPoliciesForTargetResult::~ListPoliciesForTargetResult()
+{}
+
+void ListPoliciesForTargetResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["DataItem"];
+	for (auto valueDataDataItem : allDataNode)
+	{
+		DataItem dataObject;
+		if(!valueDataDataItem["PolicyContent"].isNull())
+			dataObject.policyContent = valueDataDataItem["PolicyContent"].asString();
+		if(!valueDataDataItem["PolicyDesc"].isNull())
+			dataObject.policyDesc = valueDataDataItem["PolicyDesc"].asString();
+		if(!valueDataDataItem["PolicyId"].isNull())
+			dataObject.policyId = valueDataDataItem["PolicyId"].asString();
+		if(!valueDataDataItem["PolicyName"].isNull())
+			dataObject.policyName = valueDataDataItem["PolicyName"].asString();
+		if(!valueDataDataItem["UserType"].isNull())
+			dataObject.userType = valueDataDataItem["UserType"].asString();
+		data_.push_back(dataObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+
+}
+
+std::string ListPoliciesForTargetResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::vector<ListPoliciesForTargetResult::DataItem> ListPoliciesForTargetResult::getData()const
+{
+	return data_;
+}
+

tag/src/model/ListPoliciesRequest.cc

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/ListPoliciesRequest.h>
+
+using AlibabaCloud::Tag::Model::ListPoliciesRequest;
+
+ListPoliciesRequest::ListPoliciesRequest()
+    : RpcServiceRequest("tag", "2018-08-28", "ListPolicies") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListPoliciesRequest::~ListPoliciesRequest() {}
+
+std::vector<std::string> ListPoliciesRequest::getPolicyNames() const {
+  return policyNames_;
+}
+
+void ListPoliciesRequest::setPolicyNames(const std::vector<std::string> &policyNames) {
+  policyNames_ = policyNames;
+}
+
+std::vector<std::string> ListPoliciesRequest::getPolicyIds() const {
+  return policyIds_;
+}
+
+void ListPoliciesRequest::setPolicyIds(const std::vector<std::string> &policyIds) {
+  policyIds_ = policyIds;
+}
+
+std::string ListPoliciesRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ListPoliciesRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string ListPoliciesRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void ListPoliciesRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::string ListPoliciesRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void ListPoliciesRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string ListPoliciesRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void ListPoliciesRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::string ListPoliciesRequest::getUserType() const {
+  return userType_;
+}
+
+void ListPoliciesRequest::setUserType(const std::string &userType) {
+  userType_ = userType;
+  setParameter(std::string("UserType"), userType);
+}
+
+long ListPoliciesRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void ListPoliciesRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+int ListPoliciesRequest::getMaxResult() const {
+  return maxResult_;
+}
+
+void ListPoliciesRequest::setMaxResult(int maxResult) {
+  maxResult_ = maxResult;
+  setParameter(std::string("MaxResult"), std::to_string(maxResult));
+}
+

tag/src/model/ListPoliciesResult.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/ListPoliciesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Tag;
+using namespace AlibabaCloud::Tag::Model;
+
+ListPoliciesResult::ListPoliciesResult() :
+	ServiceResult()
+{}
+
+ListPoliciesResult::ListPoliciesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListPoliciesResult::~ListPoliciesResult()
+{}
+
+void ListPoliciesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allPolicyListNode = value["PolicyList"]["Policy"];
+	for (auto valuePolicyListPolicy : allPolicyListNode)
+	{
+		Policy policyListObject;
+		if(!valuePolicyListPolicy["PolicyContent"].isNull())
+			policyListObject.policyContent = valuePolicyListPolicy["PolicyContent"].asString();
+		if(!valuePolicyListPolicy["PolicyDesc"].isNull())
+			policyListObject.policyDesc = valuePolicyListPolicy["PolicyDesc"].asString();
+		if(!valuePolicyListPolicy["PolicyId"].isNull())
+			policyListObject.policyId = valuePolicyListPolicy["PolicyId"].asString();
+		if(!valuePolicyListPolicy["PolicyName"].isNull())
+			policyListObject.policyName = valuePolicyListPolicy["PolicyName"].asString();
+		if(!valuePolicyListPolicy["UserType"].isNull())
+			policyListObject.userType = valuePolicyListPolicy["UserType"].asString();
+		policyList_.push_back(policyListObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+
+}
+
+std::string ListPoliciesResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::vector<ListPoliciesResult::Policy> ListPoliciesResult::getPolicyList()const
+{
+	return policyList_;
+}
+

tag/src/model/ListResourcesByTagResult.cc

@@ -49,12 +49,12 @@ void ListResourcesByTagResult::parse(const std::string &payload)
 		for (auto valueResourcesTagResourceTagsTag : allTagsNode)
 		{
 			TagResource::Tag tagsObject;
+			if(!valueResourcesTagResourceTagsTag["Category"].isNull())
+				tagsObject.category = valueResourcesTagResourceTagsTag["Category"].asString();
 			if(!valueResourcesTagResourceTagsTag["Key"].isNull())
 				tagsObject.key = valueResourcesTagResourceTagsTag["Key"].asString();
 			if(!valueResourcesTagResourceTagsTag["Value"].isNull())
 				tagsObject.value = valueResourcesTagResourceTagsTag["Value"].asString();
-			if(!valueResourcesTagResourceTagsTag["Category"].isNull())
-				tagsObject.category = valueResourcesTagResourceTagsTag["Category"].asString();
 			resourcesObject.tags.push_back(tagsObject);
 		}
 		resources_.push_back(resourcesObject);

tag/src/model/ListSupportResourceTypesRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/ListSupportResourceTypesRequest.h>
+
+using AlibabaCloud::Tag::Model::ListSupportResourceTypesRequest;
+
+ListSupportResourceTypesRequest::ListSupportResourceTypesRequest()
+    : RpcServiceRequest("tag", "2018-08-28", "ListSupportResourceTypes") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListSupportResourceTypesRequest::~ListSupportResourceTypesRequest() {}
+
+std::string ListSupportResourceTypesRequest::getProductCode() const {
+  return productCode_;
+}
+
+void ListSupportResourceTypesRequest::setProductCode(const std::string &productCode) {
+  productCode_ = productCode;
+  setParameter(std::string("ProductCode"), productCode);
+}
+
+std::string ListSupportResourceTypesRequest::getSupportCode() const {
+  return supportCode_;
+}
+
+void ListSupportResourceTypesRequest::setSupportCode(const std::string &supportCode) {
+  supportCode_ = supportCode;
+  setParameter(std::string("SupportCode"), supportCode);
+}
+
+std::string ListSupportResourceTypesRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ListSupportResourceTypesRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string ListSupportResourceTypesRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void ListSupportResourceTypesRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::string ListSupportResourceTypesRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void ListSupportResourceTypesRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string ListSupportResourceTypesRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void ListSupportResourceTypesRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::string ListSupportResourceTypesRequest::getResourceTye() const {
+  return resourceTye_;
+}
+
+void ListSupportResourceTypesRequest::setResourceTye(const std::string &resourceTye) {
+  resourceTye_ = resourceTye;
+  setParameter(std::string("ResourceTye"), resourceTye);
+}
+
+long ListSupportResourceTypesRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void ListSupportResourceTypesRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+int ListSupportResourceTypesRequest::getMaxResult() const {
+  return maxResult_;
+}
+
+void ListSupportResourceTypesRequest::setMaxResult(int maxResult) {
+  maxResult_ = maxResult;
+  setParameter(std::string("MaxResult"), std::to_string(maxResult));
+}
+
+bool ListSupportResourceTypesRequest::getShowItems() const {
+  return showItems_;
+}
+
+void ListSupportResourceTypesRequest::setShowItems(bool showItems) {
+  showItems_ = showItems;
+  setParameter(std::string("ShowItems"), showItems ? "true" : "false");
+}
+

tag/src/model/ListSupportResourceTypesResult.cc

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/ListSupportResourceTypesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Tag;
+using namespace AlibabaCloud::Tag::Model;
+
+ListSupportResourceTypesResult::ListSupportResourceTypesResult() :
+	ServiceResult()
+{}
+
+ListSupportResourceTypesResult::ListSupportResourceTypesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListSupportResourceTypesResult::~ListSupportResourceTypesResult()
+{}
+
+void ListSupportResourceTypesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allSupportResourceTypesNode = value["SupportResourceTypes"]["SupportResourceType"];
+	for (auto valueSupportResourceTypesSupportResourceType : allSupportResourceTypesNode)
+	{
+		SupportResourceType supportResourceTypesObject;
+		if(!valueSupportResourceTypesSupportResourceType["ArnTemplate"].isNull())
+			supportResourceTypesObject.arnTemplate = valueSupportResourceTypesSupportResourceType["ArnTemplate"].asString();
+		if(!valueSupportResourceTypesSupportResourceType["ProductCode"].isNull())
+			supportResourceTypesObject.productCode = valueSupportResourceTypesSupportResourceType["ProductCode"].asString();
+		if(!valueSupportResourceTypesSupportResourceType["ResourceType"].isNull())
+			supportResourceTypesObject.resourceType = valueSupportResourceTypesSupportResourceType["ResourceType"].asString();
+		auto allSupportItemsNode = valueSupportResourceTypesSupportResourceType["SupportItems"]["SupportItemsItem"];
+		for (auto valueSupportResourceTypesSupportResourceTypeSupportItemsSupportItemsItem : allSupportItemsNode)
+		{
+			SupportResourceType::SupportItemsItem supportItemsObject;
+			if(!valueSupportResourceTypesSupportResourceTypeSupportItemsSupportItemsItem["Support"].isNull())
+				supportItemsObject.support = valueSupportResourceTypesSupportResourceTypeSupportItemsSupportItemsItem["Support"].asString() == "true";
+			if(!valueSupportResourceTypesSupportResourceTypeSupportItemsSupportItemsItem["SupportCode"].isNull())
+				supportItemsObject.supportCode = valueSupportResourceTypesSupportResourceTypeSupportItemsSupportItemsItem["SupportCode"].asString();
+			auto allSupportDetails = value["SupportDetails"]["SupportDetails"];
+			for (auto value : allSupportDetails)
+				supportItemsObject.supportDetails.push_back(value.asString());
+			supportResourceTypesObject.supportItems.push_back(supportItemsObject);
+		}
+		supportResourceTypes_.push_back(supportResourceTypesObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+
+}
+
+std::string ListSupportResourceTypesResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::vector<ListSupportResourceTypesResult::SupportResourceType> ListSupportResourceTypesResult::getSupportResourceTypes()const
+{
+	return supportResourceTypes_;
+}
+

tag/src/model/ListTargetsForPolicyRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/ListTargetsForPolicyRequest.h>
+
+using AlibabaCloud::Tag::Model::ListTargetsForPolicyRequest;
+
+ListTargetsForPolicyRequest::ListTargetsForPolicyRequest()
+    : RpcServiceRequest("tag", "2018-08-28", "ListTargetsForPolicy") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListTargetsForPolicyRequest::~ListTargetsForPolicyRequest() {}
+
+std::string ListTargetsForPolicyRequest::getPolicyId() const {
+  return policyId_;
+}
+
+void ListTargetsForPolicyRequest::setPolicyId(const std::string &policyId) {
+  policyId_ = policyId;
+  setParameter(std::string("PolicyId"), policyId);
+}
+
+std::string ListTargetsForPolicyRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ListTargetsForPolicyRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string ListTargetsForPolicyRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void ListTargetsForPolicyRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::string ListTargetsForPolicyRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void ListTargetsForPolicyRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string ListTargetsForPolicyRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void ListTargetsForPolicyRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long ListTargetsForPolicyRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void ListTargetsForPolicyRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+int ListTargetsForPolicyRequest::getMaxResult() const {
+  return maxResult_;
+}
+
+void ListTargetsForPolicyRequest::setMaxResult(int maxResult) {
+  maxResult_ = maxResult;
+  setParameter(std::string("MaxResult"), std::to_string(maxResult));
+}
+

tag/src/model/ListTargetsForPolicyResult.cc

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/ListTargetsForPolicyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Tag;
+using namespace AlibabaCloud::Tag::Model;
+
+ListTargetsForPolicyResult::ListTargetsForPolicyResult() :
+	ServiceResult()
+{}
+
+ListTargetsForPolicyResult::ListTargetsForPolicyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListTargetsForPolicyResult::~ListTargetsForPolicyResult()
+{}
+
+void ListTargetsForPolicyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTargetsNode = value["Targets"]["Target"];
+	for (auto valueTargetsTarget : allTargetsNode)
+	{
+		Target targetsObject;
+		if(!valueTargetsTarget["TargetId"].isNull())
+			targetsObject.targetId = valueTargetsTarget["TargetId"].asString();
+		if(!valueTargetsTarget["TargetType"].isNull())
+			targetsObject.targetType = std::stoi(valueTargetsTarget["TargetType"].asString());
+		targets_.push_back(targetsObject);
+	}
+	if(!value["IsRd"].isNull())
+		isRd_ = value["IsRd"].asString() == "true";
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["RdId"].isNull())
+		rdId_ = value["RdId"].asString();
+
+}
+
+std::string ListTargetsForPolicyResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::vector<ListTargetsForPolicyResult::Target> ListTargetsForPolicyResult::getTargets()const
+{
+	return targets_;
+}
+
+std::string ListTargetsForPolicyResult::getRdId()const
+{
+	return rdId_;
+}
+
+bool ListTargetsForPolicyResult::getIsRd()const
+{
+	return isRd_;
+}
+

tag/src/model/ModifyPolicyRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/ModifyPolicyRequest.h>
+
+using AlibabaCloud::Tag::Model::ModifyPolicyRequest;
+
+ModifyPolicyRequest::ModifyPolicyRequest()
+    : RpcServiceRequest("tag", "2018-08-28", "ModifyPolicy") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ModifyPolicyRequest::~ModifyPolicyRequest() {}
+
+std::string ModifyPolicyRequest::getPolicyDesc() const {
+  return policyDesc_;
+}
+
+void ModifyPolicyRequest::setPolicyDesc(const std::string &policyDesc) {
+  policyDesc_ = policyDesc;
+  setParameter(std::string("PolicyDesc"), policyDesc);
+}
+
+std::string ModifyPolicyRequest::getPolicyId() const {
+  return policyId_;
+}
+
+void ModifyPolicyRequest::setPolicyId(const std::string &policyId) {
+  policyId_ = policyId;
+  setParameter(std::string("PolicyId"), policyId);
+}
+
+std::string ModifyPolicyRequest::getRegionId() const {
+  return regionId_;
+}
+
+void ModifyPolicyRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string ModifyPolicyRequest::getPolicyContent() const {
+  return policyContent_;
+}
+
+void ModifyPolicyRequest::setPolicyContent(const std::string &policyContent) {
+  policyContent_ = policyContent;
+  setParameter(std::string("PolicyContent"), policyContent);
+}
+
+bool ModifyPolicyRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void ModifyPolicyRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string ModifyPolicyRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void ModifyPolicyRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string ModifyPolicyRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void ModifyPolicyRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long ModifyPolicyRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void ModifyPolicyRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string ModifyPolicyRequest::getPolicyName() const {
+  return policyName_;
+}
+
+void ModifyPolicyRequest::setPolicyName(const std::string &policyName) {
+  policyName_ = policyName;
+  setParameter(std::string("PolicyName"), policyName);
+}
+

tag/src/model/ModifyPolicyResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/ModifyPolicyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Tag;
+using namespace AlibabaCloud::Tag::Model;
+
+ModifyPolicyResult::ModifyPolicyResult() :
+	ServiceResult()
+{}
+
+ModifyPolicyResult::ModifyPolicyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ModifyPolicyResult::~ModifyPolicyResult()
+{}
+
+void ModifyPolicyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

tag/src/model/OpenCreatedByRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/OpenCreatedByRequest.h>
+
+using AlibabaCloud::Tag::Model::OpenCreatedByRequest;
+
+OpenCreatedByRequest::OpenCreatedByRequest()
+    : RpcServiceRequest("tag", "2018-08-28", "OpenCreatedBy") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+OpenCreatedByRequest::~OpenCreatedByRequest() {}
+
+std::string OpenCreatedByRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void OpenCreatedByRequest::setResourceOwnerId(const std::string &resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), resourceOwnerId);
+}
+
+std::string OpenCreatedByRequest::getRegionId() const {
+  return regionId_;
+}
+
+void OpenCreatedByRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string OpenCreatedByRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void OpenCreatedByRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string OpenCreatedByRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void OpenCreatedByRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long OpenCreatedByRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void OpenCreatedByRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

tag/src/model/OpenCreatedByResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/tag/model/OpenCreatedByResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Tag;
+using namespace AlibabaCloud::Tag::Model;
+
+OpenCreatedByResult::OpenCreatedByResult() :
+	ServiceResult()
+{}
+
+OpenCreatedByResult::OpenCreatedByResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+OpenCreatedByResult::~OpenCreatedByResult()
+{}
+
+void OpenCreatedByResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+