Supported secretmanager for kms.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-02-28 Version: 1.36.294
+- Supported secretmanager for kms.
+
 2020-02-27 Version: 1.36.293
 - Add translate api.
 

VERSION

@@ -1 +1 @@
-1.36.293
+1.36.294

kms/CMakeLists.txt

@@ -37,18 +37,24 @@ set(kms_public_header_model
 	include/alibabacloud/kms/model/CreateKeyResult.h
 	include/alibabacloud/kms/model/CreateKeyVersionRequest.h
 	include/alibabacloud/kms/model/CreateKeyVersionResult.h
+	include/alibabacloud/kms/model/CreateSecretRequest.h
+	include/alibabacloud/kms/model/CreateSecretResult.h
 	include/alibabacloud/kms/model/DecryptRequest.h
 	include/alibabacloud/kms/model/DecryptResult.h
 	include/alibabacloud/kms/model/DeleteAliasRequest.h
 	include/alibabacloud/kms/model/DeleteAliasResult.h
 	include/alibabacloud/kms/model/DeleteKeyMaterialRequest.h
 	include/alibabacloud/kms/model/DeleteKeyMaterialResult.h
+	include/alibabacloud/kms/model/DeleteSecretRequest.h
+	include/alibabacloud/kms/model/DeleteSecretResult.h
 	include/alibabacloud/kms/model/DescribeKeyRequest.h
 	include/alibabacloud/kms/model/DescribeKeyResult.h
 	include/alibabacloud/kms/model/DescribeKeyVersionRequest.h
 	include/alibabacloud/kms/model/DescribeKeyVersionResult.h
 	include/alibabacloud/kms/model/DescribeRegionsRequest.h
 	include/alibabacloud/kms/model/DescribeRegionsResult.h
+	include/alibabacloud/kms/model/DescribeSecretRequest.h
+	include/alibabacloud/kms/model/DescribeSecretResult.h
 	include/alibabacloud/kms/model/DescribeServiceRequest.h
 	include/alibabacloud/kms/model/DescribeServiceResult.h
 	include/alibabacloud/kms/model/DisableKeyRequest.h
@@ -65,6 +71,10 @@ set(kms_public_header_model
 	include/alibabacloud/kms/model/GetParametersForImportResult.h
 	include/alibabacloud/kms/model/GetPublicKeyRequest.h
 	include/alibabacloud/kms/model/GetPublicKeyResult.h
+	include/alibabacloud/kms/model/GetRandomPasswordRequest.h
+	include/alibabacloud/kms/model/GetRandomPasswordResult.h
+	include/alibabacloud/kms/model/GetSecretValueRequest.h
+	include/alibabacloud/kms/model/GetSecretValueResult.h
 	include/alibabacloud/kms/model/ImportKeyMaterialRequest.h
 	include/alibabacloud/kms/model/ImportKeyMaterialResult.h
 	include/alibabacloud/kms/model/ListAliasesRequest.h
@@ -77,6 +87,14 @@ set(kms_public_header_model
 	include/alibabacloud/kms/model/ListKeysResult.h
 	include/alibabacloud/kms/model/ListResourceTagsRequest.h
 	include/alibabacloud/kms/model/ListResourceTagsResult.h
+	include/alibabacloud/kms/model/ListSecretVersionIdsRequest.h
+	include/alibabacloud/kms/model/ListSecretVersionIdsResult.h
+	include/alibabacloud/kms/model/ListSecretsRequest.h
+	include/alibabacloud/kms/model/ListSecretsResult.h
+	include/alibabacloud/kms/model/PutSecretValueRequest.h
+	include/alibabacloud/kms/model/PutSecretValueResult.h
+	include/alibabacloud/kms/model/RestoreSecretRequest.h
+	include/alibabacloud/kms/model/RestoreSecretResult.h
 	include/alibabacloud/kms/model/ScheduleKeyDeletionRequest.h
 	include/alibabacloud/kms/model/ScheduleKeyDeletionResult.h
 	include/alibabacloud/kms/model/TagResourceRequest.h
@@ -88,7 +106,11 @@ set(kms_public_header_model
 	include/alibabacloud/kms/model/UpdateKeyDescriptionRequest.h
 	include/alibabacloud/kms/model/UpdateKeyDescriptionResult.h
 	include/alibabacloud/kms/model/UpdateRotationPolicyRequest.h
-	include/alibabacloud/kms/model/UpdateRotationPolicyResult.h )
+	include/alibabacloud/kms/model/UpdateRotationPolicyResult.h
+	include/alibabacloud/kms/model/UpdateSecretRequest.h
+	include/alibabacloud/kms/model/UpdateSecretResult.h
+	include/alibabacloud/kms/model/UpdateSecretVersionStageRequest.h
+	include/alibabacloud/kms/model/UpdateSecretVersionStageResult.h )
 
 set(kms_src 
 	src/KmsClient.cc
@@ -108,18 +130,24 @@ set(kms_src
 	src/model/CreateKeyResult.cc
 	src/model/CreateKeyVersionRequest.cc
 	src/model/CreateKeyVersionResult.cc
+	src/model/CreateSecretRequest.cc
+	src/model/CreateSecretResult.cc
 	src/model/DecryptRequest.cc
 	src/model/DecryptResult.cc
 	src/model/DeleteAliasRequest.cc
 	src/model/DeleteAliasResult.cc
 	src/model/DeleteKeyMaterialRequest.cc
 	src/model/DeleteKeyMaterialResult.cc
+	src/model/DeleteSecretRequest.cc
+	src/model/DeleteSecretResult.cc
 	src/model/DescribeKeyRequest.cc
 	src/model/DescribeKeyResult.cc
 	src/model/DescribeKeyVersionRequest.cc
 	src/model/DescribeKeyVersionResult.cc
 	src/model/DescribeRegionsRequest.cc
 	src/model/DescribeRegionsResult.cc
+	src/model/DescribeSecretRequest.cc
+	src/model/DescribeSecretResult.cc
 	src/model/DescribeServiceRequest.cc
 	src/model/DescribeServiceResult.cc
 	src/model/DisableKeyRequest.cc
@@ -136,6 +164,10 @@ set(kms_src
 	src/model/GetParametersForImportResult.cc
 	src/model/GetPublicKeyRequest.cc
 	src/model/GetPublicKeyResult.cc
+	src/model/GetRandomPasswordRequest.cc
+	src/model/GetRandomPasswordResult.cc
+	src/model/GetSecretValueRequest.cc
+	src/model/GetSecretValueResult.cc
 	src/model/ImportKeyMaterialRequest.cc
 	src/model/ImportKeyMaterialResult.cc
 	src/model/ListAliasesRequest.cc
@@ -148,6 +180,14 @@ set(kms_src
 	src/model/ListKeysResult.cc
 	src/model/ListResourceTagsRequest.cc
 	src/model/ListResourceTagsResult.cc
+	src/model/ListSecretVersionIdsRequest.cc
+	src/model/ListSecretVersionIdsResult.cc
+	src/model/ListSecretsRequest.cc
+	src/model/ListSecretsResult.cc
+	src/model/PutSecretValueRequest.cc
+	src/model/PutSecretValueResult.cc
+	src/model/RestoreSecretRequest.cc
+	src/model/RestoreSecretResult.cc
 	src/model/ScheduleKeyDeletionRequest.cc
 	src/model/ScheduleKeyDeletionResult.cc
 	src/model/TagResourceRequest.cc
@@ -159,7 +199,11 @@ set(kms_src
 	src/model/UpdateKeyDescriptionRequest.cc
 	src/model/UpdateKeyDescriptionResult.cc
 	src/model/UpdateRotationPolicyRequest.cc
-	src/model/UpdateRotationPolicyResult.cc )
+	src/model/UpdateRotationPolicyResult.cc
+	src/model/UpdateSecretRequest.cc
+	src/model/UpdateSecretResult.cc
+	src/model/UpdateSecretVersionStageRequest.cc
+	src/model/UpdateSecretVersionStageResult.cc )
 
 add_library(kms ${LIB_TYPE}
 	${kms_public_header}

kms/include/alibabacloud/kms/KmsClient.h

@@ -38,18 +38,24 @@
 #include "model/CreateKeyResult.h"
 #include "model/CreateKeyVersionRequest.h"
 #include "model/CreateKeyVersionResult.h"
+#include "model/CreateSecretRequest.h"
+#include "model/CreateSecretResult.h"
 #include "model/DecryptRequest.h"
 #include "model/DecryptResult.h"
 #include "model/DeleteAliasRequest.h"
 #include "model/DeleteAliasResult.h"
 #include "model/DeleteKeyMaterialRequest.h"
 #include "model/DeleteKeyMaterialResult.h"
+#include "model/DeleteSecretRequest.h"
+#include "model/DeleteSecretResult.h"
 #include "model/DescribeKeyRequest.h"
 #include "model/DescribeKeyResult.h"
 #include "model/DescribeKeyVersionRequest.h"
 #include "model/DescribeKeyVersionResult.h"
 #include "model/DescribeRegionsRequest.h"
 #include "model/DescribeRegionsResult.h"
+#include "model/DescribeSecretRequest.h"
+#include "model/DescribeSecretResult.h"
 #include "model/DescribeServiceRequest.h"
 #include "model/DescribeServiceResult.h"
 #include "model/DisableKeyRequest.h"
@@ -66,6 +72,10 @@
 #include "model/GetParametersForImportResult.h"
 #include "model/GetPublicKeyRequest.h"
 #include "model/GetPublicKeyResult.h"
+#include "model/GetRandomPasswordRequest.h"
+#include "model/GetRandomPasswordResult.h"
+#include "model/GetSecretValueRequest.h"
+#include "model/GetSecretValueResult.h"
 #include "model/ImportKeyMaterialRequest.h"
 #include "model/ImportKeyMaterialResult.h"
 #include "model/ListAliasesRequest.h"
@@ -78,6 +88,14 @@
 #include "model/ListKeysResult.h"
 #include "model/ListResourceTagsRequest.h"
 #include "model/ListResourceTagsResult.h"
+#include "model/ListSecretVersionIdsRequest.h"
+#include "model/ListSecretVersionIdsResult.h"
+#include "model/ListSecretsRequest.h"
+#include "model/ListSecretsResult.h"
+#include "model/PutSecretValueRequest.h"
+#include "model/PutSecretValueResult.h"
+#include "model/RestoreSecretRequest.h"
+#include "model/RestoreSecretResult.h"
 #include "model/ScheduleKeyDeletionRequest.h"
 #include "model/ScheduleKeyDeletionResult.h"
 #include "model/TagResourceRequest.h"
@@ -90,6 +108,10 @@
 #include "model/UpdateKeyDescriptionResult.h"
 #include "model/UpdateRotationPolicyRequest.h"
 #include "model/UpdateRotationPolicyResult.h"
+#include "model/UpdateSecretRequest.h"
+#include "model/UpdateSecretResult.h"
+#include "model/UpdateSecretVersionStageRequest.h"
+#include "model/UpdateSecretVersionStageResult.h"
 
 
 namespace AlibabaCloud
@@ -123,6 +145,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateKeyVersionResult> CreateKeyVersionOutcome;
 			typedef std::future<CreateKeyVersionOutcome> CreateKeyVersionOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::CreateKeyVersionRequest&, const CreateKeyVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateKeyVersionAsyncHandler;
+			typedef Outcome<Error, Model::CreateSecretResult> CreateSecretOutcome;
+			typedef std::future<CreateSecretOutcome> CreateSecretOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::CreateSecretRequest&, const CreateSecretOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateSecretAsyncHandler;
 			typedef Outcome<Error, Model::DecryptResult> DecryptOutcome;
 			typedef std::future<DecryptOutcome> DecryptOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::DecryptRequest&, const DecryptOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DecryptAsyncHandler;
@@ -132,6 +157,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteKeyMaterialResult> DeleteKeyMaterialOutcome;
 			typedef std::future<DeleteKeyMaterialOutcome> DeleteKeyMaterialOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::DeleteKeyMaterialRequest&, const DeleteKeyMaterialOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteKeyMaterialAsyncHandler;
+			typedef Outcome<Error, Model::DeleteSecretResult> DeleteSecretOutcome;
+			typedef std::future<DeleteSecretOutcome> DeleteSecretOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::DeleteSecretRequest&, const DeleteSecretOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSecretAsyncHandler;
 			typedef Outcome<Error, Model::DescribeKeyResult> DescribeKeyOutcome;
 			typedef std::future<DescribeKeyOutcome> DescribeKeyOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::DescribeKeyRequest&, const DescribeKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeKeyAsyncHandler;
@@ -141,6 +169,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
 			typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeSecretResult> DescribeSecretOutcome;
+			typedef std::future<DescribeSecretOutcome> DescribeSecretOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::DescribeSecretRequest&, const DescribeSecretOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSecretAsyncHandler;
 			typedef Outcome<Error, Model::DescribeServiceResult> DescribeServiceOutcome;
 			typedef std::future<DescribeServiceOutcome> DescribeServiceOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::DescribeServiceRequest&, const DescribeServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeServiceAsyncHandler;
@@ -165,6 +196,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetPublicKeyResult> GetPublicKeyOutcome;
 			typedef std::future<GetPublicKeyOutcome> GetPublicKeyOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::GetPublicKeyRequest&, const GetPublicKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPublicKeyAsyncHandler;
+			typedef Outcome<Error, Model::GetRandomPasswordResult> GetRandomPasswordOutcome;
+			typedef std::future<GetRandomPasswordOutcome> GetRandomPasswordOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::GetRandomPasswordRequest&, const GetRandomPasswordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetRandomPasswordAsyncHandler;
+			typedef Outcome<Error, Model::GetSecretValueResult> GetSecretValueOutcome;
+			typedef std::future<GetSecretValueOutcome> GetSecretValueOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::GetSecretValueRequest&, const GetSecretValueOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetSecretValueAsyncHandler;
 			typedef Outcome<Error, Model::ImportKeyMaterialResult> ImportKeyMaterialOutcome;
 			typedef std::future<ImportKeyMaterialOutcome> ImportKeyMaterialOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::ImportKeyMaterialRequest&, const ImportKeyMaterialOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImportKeyMaterialAsyncHandler;
@@ -183,6 +220,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListResourceTagsResult> ListResourceTagsOutcome;
 			typedef std::future<ListResourceTagsOutcome> ListResourceTagsOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::ListResourceTagsRequest&, const ListResourceTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListResourceTagsAsyncHandler;
+			typedef Outcome<Error, Model::ListSecretVersionIdsResult> ListSecretVersionIdsOutcome;
+			typedef std::future<ListSecretVersionIdsOutcome> ListSecretVersionIdsOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::ListSecretVersionIdsRequest&, const ListSecretVersionIdsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSecretVersionIdsAsyncHandler;
+			typedef Outcome<Error, Model::ListSecretsResult> ListSecretsOutcome;
+			typedef std::future<ListSecretsOutcome> ListSecretsOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::ListSecretsRequest&, const ListSecretsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSecretsAsyncHandler;
+			typedef Outcome<Error, Model::PutSecretValueResult> PutSecretValueOutcome;
+			typedef std::future<PutSecretValueOutcome> PutSecretValueOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::PutSecretValueRequest&, const PutSecretValueOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PutSecretValueAsyncHandler;
+			typedef Outcome<Error, Model::RestoreSecretResult> RestoreSecretOutcome;
+			typedef std::future<RestoreSecretOutcome> RestoreSecretOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::RestoreSecretRequest&, const RestoreSecretOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestoreSecretAsyncHandler;
 			typedef Outcome<Error, Model::ScheduleKeyDeletionResult> ScheduleKeyDeletionOutcome;
 			typedef std::future<ScheduleKeyDeletionOutcome> ScheduleKeyDeletionOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::ScheduleKeyDeletionRequest&, const ScheduleKeyDeletionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ScheduleKeyDeletionAsyncHandler;
@@ -201,6 +250,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateRotationPolicyResult> UpdateRotationPolicyOutcome;
 			typedef std::future<UpdateRotationPolicyOutcome> UpdateRotationPolicyOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::UpdateRotationPolicyRequest&, const UpdateRotationPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateRotationPolicyAsyncHandler;
+			typedef Outcome<Error, Model::UpdateSecretResult> UpdateSecretOutcome;
+			typedef std::future<UpdateSecretOutcome> UpdateSecretOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::UpdateSecretRequest&, const UpdateSecretOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateSecretAsyncHandler;
+			typedef Outcome<Error, Model::UpdateSecretVersionStageResult> UpdateSecretVersionStageOutcome;
+			typedef std::future<UpdateSecretVersionStageOutcome> UpdateSecretVersionStageOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::UpdateSecretVersionStageRequest&, const UpdateSecretVersionStageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateSecretVersionStageAsyncHandler;
 
 			KmsClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			KmsClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
@@ -230,6 +285,9 @@ namespace AlibabaCloud
 			CreateKeyVersionOutcome createKeyVersion(const Model::CreateKeyVersionRequest &request)const;
 			void createKeyVersionAsync(const Model::CreateKeyVersionRequest& request, const CreateKeyVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateKeyVersionOutcomeCallable createKeyVersionCallable(const Model::CreateKeyVersionRequest& request) const;
+			CreateSecretOutcome createSecret(const Model::CreateSecretRequest &request)const;
+			void createSecretAsync(const Model::CreateSecretRequest& request, const CreateSecretAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateSecretOutcomeCallable createSecretCallable(const Model::CreateSecretRequest& request) const;
 			DecryptOutcome decrypt(const Model::DecryptRequest &request)const;
 			void decryptAsync(const Model::DecryptRequest& request, const DecryptAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DecryptOutcomeCallable decryptCallable(const Model::DecryptRequest& request) const;
@@ -239,6 +297,9 @@ namespace AlibabaCloud
 			DeleteKeyMaterialOutcome deleteKeyMaterial(const Model::DeleteKeyMaterialRequest &request)const;
 			void deleteKeyMaterialAsync(const Model::DeleteKeyMaterialRequest& request, const DeleteKeyMaterialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteKeyMaterialOutcomeCallable deleteKeyMaterialCallable(const Model::DeleteKeyMaterialRequest& request) const;
+			DeleteSecretOutcome deleteSecret(const Model::DeleteSecretRequest &request)const;
+			void deleteSecretAsync(const Model::DeleteSecretRequest& request, const DeleteSecretAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteSecretOutcomeCallable deleteSecretCallable(const Model::DeleteSecretRequest& request) const;
 			DescribeKeyOutcome describeKey(const Model::DescribeKeyRequest &request)const;
 			void describeKeyAsync(const Model::DescribeKeyRequest& request, const DescribeKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeKeyOutcomeCallable describeKeyCallable(const Model::DescribeKeyRequest& request) const;
@@ -248,6 +309,9 @@ namespace AlibabaCloud
 			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;
+			DescribeSecretOutcome describeSecret(const Model::DescribeSecretRequest &request)const;
+			void describeSecretAsync(const Model::DescribeSecretRequest& request, const DescribeSecretAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeSecretOutcomeCallable describeSecretCallable(const Model::DescribeSecretRequest& request) const;
 			DescribeServiceOutcome describeService(const Model::DescribeServiceRequest &request)const;
 			void describeServiceAsync(const Model::DescribeServiceRequest& request, const DescribeServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeServiceOutcomeCallable describeServiceCallable(const Model::DescribeServiceRequest& request) const;
@@ -272,6 +336,12 @@ namespace AlibabaCloud
 			GetPublicKeyOutcome getPublicKey(const Model::GetPublicKeyRequest &request)const;
 			void getPublicKeyAsync(const Model::GetPublicKeyRequest& request, const GetPublicKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetPublicKeyOutcomeCallable getPublicKeyCallable(const Model::GetPublicKeyRequest& request) const;
+			GetRandomPasswordOutcome getRandomPassword(const Model::GetRandomPasswordRequest &request)const;
+			void getRandomPasswordAsync(const Model::GetRandomPasswordRequest& request, const GetRandomPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetRandomPasswordOutcomeCallable getRandomPasswordCallable(const Model::GetRandomPasswordRequest& request) const;
+			GetSecretValueOutcome getSecretValue(const Model::GetSecretValueRequest &request)const;
+			void getSecretValueAsync(const Model::GetSecretValueRequest& request, const GetSecretValueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetSecretValueOutcomeCallable getSecretValueCallable(const Model::GetSecretValueRequest& request) const;
 			ImportKeyMaterialOutcome importKeyMaterial(const Model::ImportKeyMaterialRequest &request)const;
 			void importKeyMaterialAsync(const Model::ImportKeyMaterialRequest& request, const ImportKeyMaterialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ImportKeyMaterialOutcomeCallable importKeyMaterialCallable(const Model::ImportKeyMaterialRequest& request) const;
@@ -290,6 +360,18 @@ namespace AlibabaCloud
 			ListResourceTagsOutcome listResourceTags(const Model::ListResourceTagsRequest &request)const;
 			void listResourceTagsAsync(const Model::ListResourceTagsRequest& request, const ListResourceTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListResourceTagsOutcomeCallable listResourceTagsCallable(const Model::ListResourceTagsRequest& request) const;
+			ListSecretVersionIdsOutcome listSecretVersionIds(const Model::ListSecretVersionIdsRequest &request)const;
+			void listSecretVersionIdsAsync(const Model::ListSecretVersionIdsRequest& request, const ListSecretVersionIdsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListSecretVersionIdsOutcomeCallable listSecretVersionIdsCallable(const Model::ListSecretVersionIdsRequest& request) const;
+			ListSecretsOutcome listSecrets(const Model::ListSecretsRequest &request)const;
+			void listSecretsAsync(const Model::ListSecretsRequest& request, const ListSecretsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListSecretsOutcomeCallable listSecretsCallable(const Model::ListSecretsRequest& request) const;
+			PutSecretValueOutcome putSecretValue(const Model::PutSecretValueRequest &request)const;
+			void putSecretValueAsync(const Model::PutSecretValueRequest& request, const PutSecretValueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PutSecretValueOutcomeCallable putSecretValueCallable(const Model::PutSecretValueRequest& request) const;
+			RestoreSecretOutcome restoreSecret(const Model::RestoreSecretRequest &request)const;
+			void restoreSecretAsync(const Model::RestoreSecretRequest& request, const RestoreSecretAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RestoreSecretOutcomeCallable restoreSecretCallable(const Model::RestoreSecretRequest& request) const;
 			ScheduleKeyDeletionOutcome scheduleKeyDeletion(const Model::ScheduleKeyDeletionRequest &request)const;
 			void scheduleKeyDeletionAsync(const Model::ScheduleKeyDeletionRequest& request, const ScheduleKeyDeletionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ScheduleKeyDeletionOutcomeCallable scheduleKeyDeletionCallable(const Model::ScheduleKeyDeletionRequest& request) const;
@@ -308,6 +390,12 @@ namespace AlibabaCloud
 			UpdateRotationPolicyOutcome updateRotationPolicy(const Model::UpdateRotationPolicyRequest &request)const;
 			void updateRotationPolicyAsync(const Model::UpdateRotationPolicyRequest& request, const UpdateRotationPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateRotationPolicyOutcomeCallable updateRotationPolicyCallable(const Model::UpdateRotationPolicyRequest& request) const;
+			UpdateSecretOutcome updateSecret(const Model::UpdateSecretRequest &request)const;
+			void updateSecretAsync(const Model::UpdateSecretRequest& request, const UpdateSecretAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateSecretOutcomeCallable updateSecretCallable(const Model::UpdateSecretRequest& request) const;
+			UpdateSecretVersionStageOutcome updateSecretVersionStage(const Model::UpdateSecretVersionStageRequest &request)const;
+			void updateSecretVersionStageAsync(const Model::UpdateSecretVersionStageRequest& request, const UpdateSecretVersionStageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateSecretVersionStageOutcomeCallable updateSecretVersionStageCallable(const Model::UpdateSecretVersionStageRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

kms/include/alibabacloud/kms/model/CreateSecretRequest.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_KMS_MODEL_CREATESECRETREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_CREATESECRETREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/kms/KmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Kms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_KMS_EXPORT CreateSecretRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateSecretRequest();
+				~CreateSecretRequest();
+
+				std::string getVersionId()const;
+				void setVersionId(const std::string& versionId);
+				std::string getSecretData()const;
+				void setSecretData(const std::string& secretData);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::string getSecretName()const;
+				void setSecretName(const std::string& secretName);
+				std::string getEncryptionKeyId()const;
+				void setEncryptionKeyId(const std::string& encryptionKeyId);
+				std::string getSecretDataType()const;
+				void setSecretDataType(const std::string& secretDataType);
+				std::string getTags()const;
+				void setTags(const std::string& tags);
+
+            private:
+				std::string versionId_;
+				std::string secretData_;
+				std::string description_;
+				std::string secretName_;
+				std::string encryptionKeyId_;
+				std::string secretDataType_;
+				std::string tags_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_CREATESECRETREQUEST_H_

kms/include/alibabacloud/kms/model/CreateSecretResult.h

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

kms/include/alibabacloud/kms/model/DeleteSecretRequest.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_KMS_MODEL_DELETESECRETREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_DELETESECRETREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/kms/KmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Kms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_KMS_EXPORT DeleteSecretRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteSecretRequest();
+				~DeleteSecretRequest();
+
+				std::string getForceDeleteWithoutRecovery()const;
+				void setForceDeleteWithoutRecovery(const std::string& forceDeleteWithoutRecovery);
+				std::string getRecoveryWindowInDays()const;
+				void setRecoveryWindowInDays(const std::string& recoveryWindowInDays);
+				std::string getSecretName()const;
+				void setSecretName(const std::string& secretName);
+
+            private:
+				std::string forceDeleteWithoutRecovery_;
+				std::string recoveryWindowInDays_;
+				std::string secretName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_DELETESECRETREQUEST_H_

kms/include/alibabacloud/kms/model/DeleteSecretResult.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_KMS_MODEL_DELETESECRETRESULT_H_
+#define ALIBABACLOUD_KMS_MODEL_DELETESECRETRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/kms/KmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Kms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_KMS_EXPORT DeleteSecretResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteSecretResult();
+				explicit DeleteSecretResult(const std::string &payload);
+				~DeleteSecretResult();
+				std::string getSecretName()const;
+				std::string getPlannedDeleteTime()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string secretName_;
+				std::string plannedDeleteTime_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_DELETESECRETRESULT_H_

kms/include/alibabacloud/kms/model/DescribeSecretRequest.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_KMS_MODEL_DESCRIBESECRETREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_DESCRIBESECRETREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/kms/KmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Kms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_KMS_EXPORT DescribeSecretRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeSecretRequest();
+				~DescribeSecretRequest();
+
+				std::string getSecretName()const;
+				void setSecretName(const std::string& secretName);
+				std::string getFetchTags()const;
+				void setFetchTags(const std::string& fetchTags);
+
+            private:
+				std::string secretName_;
+				std::string fetchTags_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_DESCRIBESECRETREQUEST_H_

kms/include/alibabacloud/kms/model/DescribeSecretResult.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_KMS_MODEL_DESCRIBESECRETRESULT_H_
+#define ALIBABACLOUD_KMS_MODEL_DESCRIBESECRETRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/kms/KmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Kms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_KMS_EXPORT DescribeSecretResult : public ServiceResult
+			{
+			public:
+				struct Tag
+				{
+					std::string tagKey;
+					std::string tagValue;
+				};
+
+
+				DescribeSecretResult();
+				explicit DescribeSecretResult(const std::string &payload);
+				~DescribeSecretResult();
+				std::string getSecretName()const;
+				std::string getDescription()const;
+				std::string getCreateTime()const;
+				std::string getUpdateTime()const;
+				std::string getPlannedDeleteTime()const;
+				std::string getArn()const;
+				std::vector<Tag> getTags()const;
+				std::string getEncryptionKeyId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string secretName_;
+				std::string description_;
+				std::string createTime_;
+				std::string updateTime_;
+				std::string plannedDeleteTime_;
+				std::string arn_;
+				std::vector<Tag> tags_;
+				std::string encryptionKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_DESCRIBESECRETRESULT_H_

kms/include/alibabacloud/kms/model/DescribeServiceResult.h

@@ -36,17 +36,25 @@ namespace AlibabaCloud
 				{
 					std::string type;
 				};
+				struct KeySpec
+				{
+					std::vector<std::string> supportedProtectionLevels;
+					std::vector<std::string> usages;
+					std::string name;
+				};
 
 
 				DescribeServiceResult();
 				explicit DescribeServiceResult(const std::string &payload);
 				~DescribeServiceResult();
 				std::vector<ProtectionLevel> getProtectionLevels()const;
+				std::vector<KeySpec> getKeySpecs()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
 				std::vector<ProtectionLevel> protectionLevels_;
+				std::vector<KeySpec> keySpecs_;
 
 			};
 		}

kms/include/alibabacloud/kms/model/GetRandomPasswordRequest.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_KMS_MODEL_GETRANDOMPASSWORDREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_GETRANDOMPASSWORDREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/kms/KmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Kms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_KMS_EXPORT GetRandomPasswordRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetRandomPasswordRequest();
+				~GetRandomPasswordRequest();
+
+				std::string getExcludeLowercase()const;
+				void setExcludeLowercase(const std::string& excludeLowercase);
+				std::string getExcludeCharacters()const;
+				void setExcludeCharacters(const std::string& excludeCharacters);
+				std::string getPasswordLength()const;
+				void setPasswordLength(const std::string& passwordLength);
+				std::string getExcludePunctuation()const;
+				void setExcludePunctuation(const std::string& excludePunctuation);
+				std::string getExcludeUppercase()const;
+				void setExcludeUppercase(const std::string& excludeUppercase);
+				std::string getRequireEachIncludedType()const;
+				void setRequireEachIncludedType(const std::string& requireEachIncludedType);
+				std::string getExcludeNumbers()const;
+				void setExcludeNumbers(const std::string& excludeNumbers);
+
+            private:
+				std::string excludeLowercase_;
+				std::string excludeCharacters_;
+				std::string passwordLength_;
+				std::string excludePunctuation_;
+				std::string excludeUppercase_;
+				std::string requireEachIncludedType_;
+				std::string excludeNumbers_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_GETRANDOMPASSWORDREQUEST_H_

kms/include/alibabacloud/kms/model/GetRandomPasswordResult.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_KMS_MODEL_GETRANDOMPASSWORDRESULT_H_
+#define ALIBABACLOUD_KMS_MODEL_GETRANDOMPASSWORDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/kms/KmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Kms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_KMS_EXPORT GetRandomPasswordResult : public ServiceResult
+			{
+			public:
+
+
+				GetRandomPasswordResult();
+				explicit GetRandomPasswordResult(const std::string &payload);
+				~GetRandomPasswordResult();
+				std::string getRandomPassword()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string randomPassword_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_GETRANDOMPASSWORDRESULT_H_

kms/include/alibabacloud/kms/model/GetSecretValueRequest.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_KMS_MODEL_GETSECRETVALUEREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_GETSECRETVALUEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/kms/KmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Kms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_KMS_EXPORT GetSecretValueRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetSecretValueRequest();
+				~GetSecretValueRequest();
+
+				std::string getVersionId()const;
+				void setVersionId(const std::string& versionId);
+				std::string getVersionStage()const;
+				void setVersionStage(const std::string& versionStage);
+				std::string getSecretName()const;
+				void setSecretName(const std::string& secretName);
+
+            private:
+				std::string versionId_;
+				std::string versionStage_;
+				std::string secretName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_GETSECRETVALUEREQUEST_H_

kms/include/alibabacloud/kms/model/GetSecretValueResult.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_KMS_MODEL_GETSECRETVALUERESULT_H_
+#define ALIBABACLOUD_KMS_MODEL_GETSECRETVALUERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/kms/KmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Kms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_KMS_EXPORT GetSecretValueResult : public ServiceResult
+			{
+			public:
+
+
+				GetSecretValueResult();
+				explicit GetSecretValueResult(const std::string &payload);
+				~GetSecretValueResult();
+				std::string getSecretName()const;
+				std::string getVersionId()const;
+				std::string getCreateTime()const;
+				std::string getSecretDataType()const;
+				std::string getSecretData()const;
+				std::vector<std::string> getVersionStages()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string secretName_;
+				std::string versionId_;
+				std::string createTime_;
+				std::string secretDataType_;
+				std::string secretData_;
+				std::vector<std::string> versionStages_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_GETSECRETVALUERESULT_H_

kms/include/alibabacloud/kms/model/ListSecretVersionIdsRequest.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_KMS_MODEL_LISTSECRETVERSIONIDSREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_LISTSECRETVERSIONIDSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/kms/KmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Kms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_KMS_EXPORT ListSecretVersionIdsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListSecretVersionIdsRequest();
+				~ListSecretVersionIdsRequest();
+
+				std::string getIncludeDeprecated()const;
+				void setIncludeDeprecated(const std::string& includeDeprecated);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getSecretName()const;
+				void setSecretName(const std::string& secretName);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+
+            private:
+				std::string includeDeprecated_;
+				int pageSize_;
+				std::string secretName_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_LISTSECRETVERSIONIDSREQUEST_H_

kms/include/alibabacloud/kms/model/ListSecretVersionIdsResult.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_KMS_MODEL_LISTSECRETVERSIONIDSRESULT_H_
+#define ALIBABACLOUD_KMS_MODEL_LISTSECRETVERSIONIDSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/kms/KmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Kms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_KMS_EXPORT ListSecretVersionIdsResult : public ServiceResult
+			{
+			public:
+				struct VersionId
+				{
+					std::string versionId;
+					std::string createTime;
+					std::vector<std::string> versionStages;
+				};
+
+
+				ListSecretVersionIdsResult();
+				explicit ListSecretVersionIdsResult(const std::string &payload);
+				~ListSecretVersionIdsResult();
+				std::string getSecretName()const;
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<VersionId> getVersionIds()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string secretName_;
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<VersionId> versionIds_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_LISTSECRETVERSIONIDSRESULT_H_

kms/include/alibabacloud/kms/model/ListSecretsRequest.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_KMS_MODEL_LISTSECRETSREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_LISTSECRETSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/kms/KmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Kms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_KMS_EXPORT ListSecretsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListSecretsRequest();
+				~ListSecretsRequest();
+
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getFetchTags()const;
+				void setFetchTags(const std::string& fetchTags);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+
+            private:
+				int pageSize_;
+				std::string fetchTags_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_LISTSECRETSREQUEST_H_

kms/include/alibabacloud/kms/model/ListSecretsResult.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_KMS_MODEL_LISTSECRETSRESULT_H_
+#define ALIBABACLOUD_KMS_MODEL_LISTSECRETSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/kms/KmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Kms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_KMS_EXPORT ListSecretsResult : public ServiceResult
+			{
+			public:
+				struct Secret
+				{
+					struct Tag
+					{
+						std::string tagKey;
+						std::string tagValue;
+					};
+					std::string secretName;
+					std::string createTime;
+					std::string updateTime;
+					std::string plannedDeleteTime;
+					std::vector<Secret::Tag> tags;
+				};
+
+
+				ListSecretsResult();
+				explicit ListSecretsResult(const std::string &payload);
+				~ListSecretsResult();
+				int getTotalCount()const;
+				std::vector<Secret> getSecretList()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::vector<Secret> secretList_;
+				int pageSize_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_LISTSECRETSRESULT_H_

kms/include/alibabacloud/kms/model/PutSecretValueRequest.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_KMS_MODEL_PUTSECRETVALUEREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_PUTSECRETVALUEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/kms/KmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Kms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_KMS_EXPORT PutSecretValueRequest : public RpcServiceRequest
+			{
+
+			public:
+				PutSecretValueRequest();
+				~PutSecretValueRequest();
+
+				std::string getVersionId()const;
+				void setVersionId(const std::string& versionId);
+				std::string getVersionStages()const;
+				void setVersionStages(const std::string& versionStages);
+				std::string getSecretData()const;
+				void setSecretData(const std::string& secretData);
+				std::string getSecretName()const;
+				void setSecretName(const std::string& secretName);
+				std::string getSecretDataType()const;
+				void setSecretDataType(const std::string& secretDataType);
+
+            private:
+				std::string versionId_;
+				std::string versionStages_;
+				std::string secretData_;
+				std::string secretName_;
+				std::string secretDataType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_PUTSECRETVALUEREQUEST_H_

kms/include/alibabacloud/kms/model/PutSecretValueResult.h

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

kms/include/alibabacloud/kms/model/RestoreSecretRequest.h

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

kms/include/alibabacloud/kms/model/RestoreSecretResult.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_KMS_MODEL_RESTORESECRETRESULT_H_
+#define ALIBABACLOUD_KMS_MODEL_RESTORESECRETRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/kms/KmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Kms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_KMS_EXPORT RestoreSecretResult : public ServiceResult
+			{
+			public:
+
+
+				RestoreSecretResult();
+				explicit RestoreSecretResult(const std::string &payload);
+				~RestoreSecretResult();
+				std::string getSecretName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string secretName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_RESTORESECRETRESULT_H_

kms/include/alibabacloud/kms/model/TagResourceRequest.h

@@ -37,11 +37,14 @@ namespace AlibabaCloud
 
 				std::string getKeyId()const;
 				void setKeyId(const std::string& keyId);
+				std::string getSecretName()const;
+				void setSecretName(const std::string& secretName);
 				std::string getTags()const;
 				void setTags(const std::string& tags);
 
             private:
 				std::string keyId_;
+				std::string secretName_;
 				std::string tags_;
 
 			};

kms/include/alibabacloud/kms/model/UntagResourceRequest.h

@@ -39,10 +39,13 @@ namespace AlibabaCloud
 				void setTagKeys(const std::string& tagKeys);
 				std::string getKeyId()const;
 				void setKeyId(const std::string& keyId);
+				std::string getSecretName()const;
+				void setSecretName(const std::string& secretName);
 
             private:
 				std::string tagKeys_;
 				std::string keyId_;
+				std::string secretName_;
 
 			};
 		}

kms/include/alibabacloud/kms/model/UntagResourceResult.h

@@ -37,12 +37,10 @@ namespace AlibabaCloud
 				UntagResourceResult();
 				explicit UntagResourceResult(const std::string &payload);
 				~UntagResourceResult();
-				std::string getKeyId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::string keyId_;
 
 			};
 		}

kms/include/alibabacloud/kms/model/UpdateSecretRequest.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_KMS_MODEL_UPDATESECRETREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_UPDATESECRETREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/kms/KmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Kms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_KMS_EXPORT UpdateSecretRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateSecretRequest();
+				~UpdateSecretRequest();
+
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::string getSecretName()const;
+				void setSecretName(const std::string& secretName);
+
+            private:
+				std::string description_;
+				std::string secretName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_UPDATESECRETREQUEST_H_

kms/include/alibabacloud/kms/model/UpdateSecretResult.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_KMS_MODEL_UPDATESECRETRESULT_H_
+#define ALIBABACLOUD_KMS_MODEL_UPDATESECRETRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/kms/KmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Kms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_KMS_EXPORT UpdateSecretResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateSecretResult();
+				explicit UpdateSecretResult(const std::string &payload);
+				~UpdateSecretResult();
+				std::string getSecretName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string secretName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_UPDATESECRETRESULT_H_

kms/include/alibabacloud/kms/model/UpdateSecretVersionStageRequest.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_KMS_MODEL_UPDATESECRETVERSIONSTAGEREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_UPDATESECRETVERSIONSTAGEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/kms/KmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Kms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_KMS_EXPORT UpdateSecretVersionStageRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateSecretVersionStageRequest();
+				~UpdateSecretVersionStageRequest();
+
+				std::string getRemoveFromVersion()const;
+				void setRemoveFromVersion(const std::string& removeFromVersion);
+				std::string getMoveToVersion()const;
+				void setMoveToVersion(const std::string& moveToVersion);
+				std::string getVersionStage()const;
+				void setVersionStage(const std::string& versionStage);
+				std::string getSecretName()const;
+				void setSecretName(const std::string& secretName);
+
+            private:
+				std::string removeFromVersion_;
+				std::string moveToVersion_;
+				std::string versionStage_;
+				std::string secretName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_UPDATESECRETVERSIONSTAGEREQUEST_H_

kms/include/alibabacloud/kms/model/UpdateSecretVersionStageResult.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_KMS_MODEL_UPDATESECRETVERSIONSTAGERESULT_H_
+#define ALIBABACLOUD_KMS_MODEL_UPDATESECRETVERSIONSTAGERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/kms/KmsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Kms
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_KMS_EXPORT UpdateSecretVersionStageResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateSecretVersionStageResult();
+				explicit UpdateSecretVersionStageResult(const std::string &payload);
+				~UpdateSecretVersionStageResult();
+				std::string getSecretName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string secretName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_UPDATESECRETVERSIONSTAGERESULT_H_

kms/src/KmsClient.cc

@@ -339,6 +339,42 @@ KmsClient::CreateKeyVersionOutcomeCallable KmsClient::createKeyVersionCallable(c
 	return task->get_future();
 }
 
+KmsClient::CreateSecretOutcome KmsClient::createSecret(const CreateSecretRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateSecretOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateSecretOutcome(CreateSecretResult(outcome.result()));
+	else
+		return CreateSecretOutcome(outcome.error());
+}
+
+void KmsClient::createSecretAsync(const CreateSecretRequest& request, const CreateSecretAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createSecret(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::CreateSecretOutcomeCallable KmsClient::createSecretCallable(const CreateSecretRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateSecretOutcome()>>(
+			[this, request]()
+			{
+			return this->createSecret(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 KmsClient::DecryptOutcome KmsClient::decrypt(const DecryptRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -447,6 +483,42 @@ KmsClient::DeleteKeyMaterialOutcomeCallable KmsClient::deleteKeyMaterialCallable
 	return task->get_future();
 }
 
+KmsClient::DeleteSecretOutcome KmsClient::deleteSecret(const DeleteSecretRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteSecretOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteSecretOutcome(DeleteSecretResult(outcome.result()));
+	else
+		return DeleteSecretOutcome(outcome.error());
+}
+
+void KmsClient::deleteSecretAsync(const DeleteSecretRequest& request, const DeleteSecretAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteSecret(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::DeleteSecretOutcomeCallable KmsClient::deleteSecretCallable(const DeleteSecretRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteSecretOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteSecret(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 KmsClient::DescribeKeyOutcome KmsClient::describeKey(const DescribeKeyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -555,6 +627,42 @@ KmsClient::DescribeRegionsOutcomeCallable KmsClient::describeRegionsCallable(con
 	return task->get_future();
 }
 
+KmsClient::DescribeSecretOutcome KmsClient::describeSecret(const DescribeSecretRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeSecretOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeSecretOutcome(DescribeSecretResult(outcome.result()));
+	else
+		return DescribeSecretOutcome(outcome.error());
+}
+
+void KmsClient::describeSecretAsync(const DescribeSecretRequest& request, const DescribeSecretAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeSecret(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::DescribeSecretOutcomeCallable KmsClient::describeSecretCallable(const DescribeSecretRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeSecretOutcome()>>(
+			[this, request]()
+			{
+			return this->describeSecret(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 KmsClient::DescribeServiceOutcome KmsClient::describeService(const DescribeServiceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -843,6 +951,78 @@ KmsClient::GetPublicKeyOutcomeCallable KmsClient::getPublicKeyCallable(const Get
 	return task->get_future();
 }
 
+KmsClient::GetRandomPasswordOutcome KmsClient::getRandomPassword(const GetRandomPasswordRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetRandomPasswordOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetRandomPasswordOutcome(GetRandomPasswordResult(outcome.result()));
+	else
+		return GetRandomPasswordOutcome(outcome.error());
+}
+
+void KmsClient::getRandomPasswordAsync(const GetRandomPasswordRequest& request, const GetRandomPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getRandomPassword(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::GetRandomPasswordOutcomeCallable KmsClient::getRandomPasswordCallable(const GetRandomPasswordRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetRandomPasswordOutcome()>>(
+			[this, request]()
+			{
+			return this->getRandomPassword(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+KmsClient::GetSecretValueOutcome KmsClient::getSecretValue(const GetSecretValueRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetSecretValueOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetSecretValueOutcome(GetSecretValueResult(outcome.result()));
+	else
+		return GetSecretValueOutcome(outcome.error());
+}
+
+void KmsClient::getSecretValueAsync(const GetSecretValueRequest& request, const GetSecretValueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getSecretValue(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::GetSecretValueOutcomeCallable KmsClient::getSecretValueCallable(const GetSecretValueRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetSecretValueOutcome()>>(
+			[this, request]()
+			{
+			return this->getSecretValue(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 KmsClient::ImportKeyMaterialOutcome KmsClient::importKeyMaterial(const ImportKeyMaterialRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1059,6 +1239,150 @@ KmsClient::ListResourceTagsOutcomeCallable KmsClient::listResourceTagsCallable(c
 	return task->get_future();
 }
 
+KmsClient::ListSecretVersionIdsOutcome KmsClient::listSecretVersionIds(const ListSecretVersionIdsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListSecretVersionIdsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListSecretVersionIdsOutcome(ListSecretVersionIdsResult(outcome.result()));
+	else
+		return ListSecretVersionIdsOutcome(outcome.error());
+}
+
+void KmsClient::listSecretVersionIdsAsync(const ListSecretVersionIdsRequest& request, const ListSecretVersionIdsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listSecretVersionIds(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::ListSecretVersionIdsOutcomeCallable KmsClient::listSecretVersionIdsCallable(const ListSecretVersionIdsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListSecretVersionIdsOutcome()>>(
+			[this, request]()
+			{
+			return this->listSecretVersionIds(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+KmsClient::ListSecretsOutcome KmsClient::listSecrets(const ListSecretsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListSecretsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListSecretsOutcome(ListSecretsResult(outcome.result()));
+	else
+		return ListSecretsOutcome(outcome.error());
+}
+
+void KmsClient::listSecretsAsync(const ListSecretsRequest& request, const ListSecretsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listSecrets(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::ListSecretsOutcomeCallable KmsClient::listSecretsCallable(const ListSecretsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListSecretsOutcome()>>(
+			[this, request]()
+			{
+			return this->listSecrets(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+KmsClient::PutSecretValueOutcome KmsClient::putSecretValue(const PutSecretValueRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PutSecretValueOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PutSecretValueOutcome(PutSecretValueResult(outcome.result()));
+	else
+		return PutSecretValueOutcome(outcome.error());
+}
+
+void KmsClient::putSecretValueAsync(const PutSecretValueRequest& request, const PutSecretValueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, putSecretValue(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::PutSecretValueOutcomeCallable KmsClient::putSecretValueCallable(const PutSecretValueRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PutSecretValueOutcome()>>(
+			[this, request]()
+			{
+			return this->putSecretValue(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+KmsClient::RestoreSecretOutcome KmsClient::restoreSecret(const RestoreSecretRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RestoreSecretOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RestoreSecretOutcome(RestoreSecretResult(outcome.result()));
+	else
+		return RestoreSecretOutcome(outcome.error());
+}
+
+void KmsClient::restoreSecretAsync(const RestoreSecretRequest& request, const RestoreSecretAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, restoreSecret(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::RestoreSecretOutcomeCallable KmsClient::restoreSecretCallable(const RestoreSecretRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RestoreSecretOutcome()>>(
+			[this, request]()
+			{
+			return this->restoreSecret(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 KmsClient::ScheduleKeyDeletionOutcome KmsClient::scheduleKeyDeletion(const ScheduleKeyDeletionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1275,3 +1599,75 @@ KmsClient::UpdateRotationPolicyOutcomeCallable KmsClient::updateRotationPolicyCa
 	return task->get_future();
 }
 
+KmsClient::UpdateSecretOutcome KmsClient::updateSecret(const UpdateSecretRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateSecretOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateSecretOutcome(UpdateSecretResult(outcome.result()));
+	else
+		return UpdateSecretOutcome(outcome.error());
+}
+
+void KmsClient::updateSecretAsync(const UpdateSecretRequest& request, const UpdateSecretAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateSecret(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::UpdateSecretOutcomeCallable KmsClient::updateSecretCallable(const UpdateSecretRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateSecretOutcome()>>(
+			[this, request]()
+			{
+			return this->updateSecret(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+KmsClient::UpdateSecretVersionStageOutcome KmsClient::updateSecretVersionStage(const UpdateSecretVersionStageRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateSecretVersionStageOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateSecretVersionStageOutcome(UpdateSecretVersionStageResult(outcome.result()));
+	else
+		return UpdateSecretVersionStageOutcome(outcome.error());
+}
+
+void KmsClient::updateSecretVersionStageAsync(const UpdateSecretVersionStageRequest& request, const UpdateSecretVersionStageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateSecretVersionStage(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::UpdateSecretVersionStageOutcomeCallable KmsClient::updateSecretVersionStageCallable(const UpdateSecretVersionStageRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateSecretVersionStageOutcome()>>(
+			[this, request]()
+			{
+			return this->updateSecretVersionStage(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

kms/src/model/AsymmetricDecryptRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::AsymmetricDecryptRequest;
 AsymmetricDecryptRequest::AsymmetricDecryptRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "AsymmetricDecrypt")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 AsymmetricDecryptRequest::~AsymmetricDecryptRequest()
@@ -35,7 +35,7 @@ std::string AsymmetricDecryptRequest::getKeyVersionId()const
 void AsymmetricDecryptRequest::setKeyVersionId(const std::string& keyVersionId)
 {
 	keyVersionId_ = keyVersionId;
-	setCoreParameter("KeyVersionId", keyVersionId);
+	setParameter("KeyVersionId", keyVersionId);
 }
 
 std::string AsymmetricDecryptRequest::getKeyId()const
@@ -46,7 +46,7 @@ std::string AsymmetricDecryptRequest::getKeyId()const
 void AsymmetricDecryptRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 
 std::string AsymmetricDecryptRequest::getCiphertextBlob()const
@@ -57,7 +57,7 @@ std::string AsymmetricDecryptRequest::getCiphertextBlob()const
 void AsymmetricDecryptRequest::setCiphertextBlob(const std::string& ciphertextBlob)
 {
 	ciphertextBlob_ = ciphertextBlob;
-	setCoreParameter("CiphertextBlob", ciphertextBlob);
+	setParameter("CiphertextBlob", ciphertextBlob);
 }
 
 std::string AsymmetricDecryptRequest::getAlgorithm()const
@@ -68,6 +68,6 @@ std::string AsymmetricDecryptRequest::getAlgorithm()const
 void AsymmetricDecryptRequest::setAlgorithm(const std::string& algorithm)
 {
 	algorithm_ = algorithm;
-	setCoreParameter("Algorithm", algorithm);
+	setParameter("Algorithm", algorithm);
 }
 

kms/src/model/AsymmetricEncryptRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::AsymmetricEncryptRequest;
 AsymmetricEncryptRequest::AsymmetricEncryptRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "AsymmetricEncrypt")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 AsymmetricEncryptRequest::~AsymmetricEncryptRequest()
@@ -35,7 +35,7 @@ std::string AsymmetricEncryptRequest::getKeyVersionId()const
 void AsymmetricEncryptRequest::setKeyVersionId(const std::string& keyVersionId)
 {
 	keyVersionId_ = keyVersionId;
-	setCoreParameter("KeyVersionId", keyVersionId);
+	setParameter("KeyVersionId", keyVersionId);
 }
 
 std::string AsymmetricEncryptRequest::getKeyId()const
@@ -46,7 +46,7 @@ std::string AsymmetricEncryptRequest::getKeyId()const
 void AsymmetricEncryptRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 
 std::string AsymmetricEncryptRequest::getPlaintext()const
@@ -57,7 +57,7 @@ std::string AsymmetricEncryptRequest::getPlaintext()const
 void AsymmetricEncryptRequest::setPlaintext(const std::string& plaintext)
 {
 	plaintext_ = plaintext;
-	setCoreParameter("Plaintext", plaintext);
+	setParameter("Plaintext", plaintext);
 }
 
 std::string AsymmetricEncryptRequest::getAlgorithm()const
@@ -68,6 +68,6 @@ std::string AsymmetricEncryptRequest::getAlgorithm()const
 void AsymmetricEncryptRequest::setAlgorithm(const std::string& algorithm)
 {
 	algorithm_ = algorithm;
-	setCoreParameter("Algorithm", algorithm);
+	setParameter("Algorithm", algorithm);
 }
 

kms/src/model/AsymmetricSignRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::AsymmetricSignRequest;
 AsymmetricSignRequest::AsymmetricSignRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "AsymmetricSign")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 AsymmetricSignRequest::~AsymmetricSignRequest()
@@ -35,7 +35,7 @@ std::string AsymmetricSignRequest::getKeyVersionId()const
 void AsymmetricSignRequest::setKeyVersionId(const std::string& keyVersionId)
 {
 	keyVersionId_ = keyVersionId;
-	setCoreParameter("KeyVersionId", keyVersionId);
+	setParameter("KeyVersionId", keyVersionId);
 }
 
 std::string AsymmetricSignRequest::getDigest()const
@@ -46,7 +46,7 @@ std::string AsymmetricSignRequest::getDigest()const
 void AsymmetricSignRequest::setDigest(const std::string& digest)
 {
 	digest_ = digest;
-	setCoreParameter("Digest", digest);
+	setParameter("Digest", digest);
 }
 
 std::string AsymmetricSignRequest::getKeyId()const
@@ -57,7 +57,7 @@ std::string AsymmetricSignRequest::getKeyId()const
 void AsymmetricSignRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 
 std::string AsymmetricSignRequest::getAlgorithm()const
@@ -68,6 +68,6 @@ std::string AsymmetricSignRequest::getAlgorithm()const
 void AsymmetricSignRequest::setAlgorithm(const std::string& algorithm)
 {
 	algorithm_ = algorithm;
-	setCoreParameter("Algorithm", algorithm);
+	setParameter("Algorithm", algorithm);
 }
 

kms/src/model/AsymmetricVerifyRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::AsymmetricVerifyRequest;
 AsymmetricVerifyRequest::AsymmetricVerifyRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "AsymmetricVerify")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 AsymmetricVerifyRequest::~AsymmetricVerifyRequest()
@@ -35,7 +35,7 @@ std::string AsymmetricVerifyRequest::getKeyVersionId()const
 void AsymmetricVerifyRequest::setKeyVersionId(const std::string& keyVersionId)
 {
 	keyVersionId_ = keyVersionId;
-	setCoreParameter("KeyVersionId", keyVersionId);
+	setParameter("KeyVersionId", keyVersionId);
 }
 
 std::string AsymmetricVerifyRequest::getDigest()const
@@ -46,7 +46,7 @@ std::string AsymmetricVerifyRequest::getDigest()const
 void AsymmetricVerifyRequest::setDigest(const std::string& digest)
 {
 	digest_ = digest;
-	setCoreParameter("Digest", digest);
+	setParameter("Digest", digest);
 }
 
 std::string AsymmetricVerifyRequest::getKeyId()const
@@ -57,7 +57,7 @@ std::string AsymmetricVerifyRequest::getKeyId()const
 void AsymmetricVerifyRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 
 std::string AsymmetricVerifyRequest::getValue()const
@@ -68,7 +68,7 @@ std::string AsymmetricVerifyRequest::getValue()const
 void AsymmetricVerifyRequest::setValue(const std::string& value)
 {
 	value_ = value;
-	setCoreParameter("Value", value);
+	setParameter("Value", value);
 }
 
 std::string AsymmetricVerifyRequest::getAlgorithm()const
@@ -79,6 +79,6 @@ std::string AsymmetricVerifyRequest::getAlgorithm()const
 void AsymmetricVerifyRequest::setAlgorithm(const std::string& algorithm)
 {
 	algorithm_ = algorithm;
-	setCoreParameter("Algorithm", algorithm);
+	setParameter("Algorithm", algorithm);
 }
 

kms/src/model/CancelKeyDeletionRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::CancelKeyDeletionRequest;
 CancelKeyDeletionRequest::CancelKeyDeletionRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "CancelKeyDeletion")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 CancelKeyDeletionRequest::~CancelKeyDeletionRequest()
@@ -35,6 +35,6 @@ std::string CancelKeyDeletionRequest::getKeyId()const
 void CancelKeyDeletionRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 

kms/src/model/CreateAliasRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::CreateAliasRequest;
 CreateAliasRequest::CreateAliasRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "CreateAlias")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 CreateAliasRequest::~CreateAliasRequest()
@@ -35,7 +35,7 @@ std::string CreateAliasRequest::getAliasName()const
 void CreateAliasRequest::setAliasName(const std::string& aliasName)
 {
 	aliasName_ = aliasName;
-	setCoreParameter("AliasName", aliasName);
+	setParameter("AliasName", aliasName);
 }
 
 std::string CreateAliasRequest::getKeyId()const
@@ -46,6 +46,6 @@ std::string CreateAliasRequest::getKeyId()const
 void CreateAliasRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 

kms/src/model/CreateKeyRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::CreateKeyRequest;
 CreateKeyRequest::CreateKeyRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "CreateKey")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 CreateKeyRequest::~CreateKeyRequest()
@@ -35,7 +35,7 @@ std::string CreateKeyRequest::getProtectionLevel()const
 void CreateKeyRequest::setProtectionLevel(const std::string& protectionLevel)
 {
 	protectionLevel_ = protectionLevel;
-	setCoreParameter("ProtectionLevel", protectionLevel);
+	setParameter("ProtectionLevel", protectionLevel);
 }
 
 std::string CreateKeyRequest::getKeyUsage()const
@@ -46,7 +46,7 @@ std::string CreateKeyRequest::getKeyUsage()const
 void CreateKeyRequest::setKeyUsage(const std::string& keyUsage)
 {
 	keyUsage_ = keyUsage;
-	setCoreParameter("KeyUsage", keyUsage);
+	setParameter("KeyUsage", keyUsage);
 }
 
 std::string CreateKeyRequest::getOrigin()const
@@ -57,7 +57,7 @@ std::string CreateKeyRequest::getOrigin()const
 void CreateKeyRequest::setOrigin(const std::string& origin)
 {
 	origin_ = origin;
-	setCoreParameter("Origin", origin);
+	setParameter("Origin", origin);
 }
 
 std::string CreateKeyRequest::getDescription()const
@@ -68,7 +68,7 @@ std::string CreateKeyRequest::getDescription()const
 void CreateKeyRequest::setDescription(const std::string& description)
 {
 	description_ = description;
-	setCoreParameter("Description", description);
+	setParameter("Description", description);
 }
 
 std::string CreateKeyRequest::getKeySpec()const
@@ -79,7 +79,7 @@ std::string CreateKeyRequest::getKeySpec()const
 void CreateKeyRequest::setKeySpec(const std::string& keySpec)
 {
 	keySpec_ = keySpec;
-	setCoreParameter("KeySpec", keySpec);
+	setParameter("KeySpec", keySpec);
 }
 
 std::string CreateKeyRequest::getRotationInterval()const
@@ -90,7 +90,7 @@ std::string CreateKeyRequest::getRotationInterval()const
 void CreateKeyRequest::setRotationInterval(const std::string& rotationInterval)
 {
 	rotationInterval_ = rotationInterval;
-	setCoreParameter("RotationInterval", rotationInterval);
+	setParameter("RotationInterval", rotationInterval);
 }
 
 bool CreateKeyRequest::getEnableAutomaticRotation()const
@@ -101,6 +101,6 @@ bool CreateKeyRequest::getEnableAutomaticRotation()const
 void CreateKeyRequest::setEnableAutomaticRotation(bool enableAutomaticRotation)
 {
 	enableAutomaticRotation_ = enableAutomaticRotation;
-	setCoreParameter("EnableAutomaticRotation", enableAutomaticRotation ? "true" : "false");
+	setParameter("EnableAutomaticRotation", enableAutomaticRotation ? "true" : "false");
 }
 

kms/src/model/CreateKeyVersionRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::CreateKeyVersionRequest;
 CreateKeyVersionRequest::CreateKeyVersionRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "CreateKeyVersion")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 CreateKeyVersionRequest::~CreateKeyVersionRequest()
@@ -35,6 +35,6 @@ std::string CreateKeyVersionRequest::getKeyId()const
 void CreateKeyVersionRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 

kms/src/model/CreateSecretRequest.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/kms/model/CreateSecretRequest.h>
+
+using AlibabaCloud::Kms::Model::CreateSecretRequest;
+
+CreateSecretRequest::CreateSecretRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "CreateSecret")
+{
+	setMethod(HttpRequest::Method::POST);
+}
+
+CreateSecretRequest::~CreateSecretRequest()
+{}
+
+std::string CreateSecretRequest::getVersionId()const
+{
+	return versionId_;
+}
+
+void CreateSecretRequest::setVersionId(const std::string& versionId)
+{
+	versionId_ = versionId;
+	setParameter("VersionId", versionId);
+}
+
+std::string CreateSecretRequest::getSecretData()const
+{
+	return secretData_;
+}
+
+void CreateSecretRequest::setSecretData(const std::string& secretData)
+{
+	secretData_ = secretData;
+	setParameter("SecretData", secretData);
+}
+
+std::string CreateSecretRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateSecretRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+std::string CreateSecretRequest::getSecretName()const
+{
+	return secretName_;
+}
+
+void CreateSecretRequest::setSecretName(const std::string& secretName)
+{
+	secretName_ = secretName;
+	setParameter("SecretName", secretName);
+}
+
+std::string CreateSecretRequest::getEncryptionKeyId()const
+{
+	return encryptionKeyId_;
+}
+
+void CreateSecretRequest::setEncryptionKeyId(const std::string& encryptionKeyId)
+{
+	encryptionKeyId_ = encryptionKeyId;
+	setParameter("EncryptionKeyId", encryptionKeyId);
+}
+
+std::string CreateSecretRequest::getSecretDataType()const
+{
+	return secretDataType_;
+}
+
+void CreateSecretRequest::setSecretDataType(const std::string& secretDataType)
+{
+	secretDataType_ = secretDataType;
+	setParameter("SecretDataType", secretDataType);
+}
+
+std::string CreateSecretRequest::getTags()const
+{
+	return tags_;
+}
+
+void CreateSecretRequest::setTags(const std::string& tags)
+{
+	tags_ = tags;
+	setParameter("Tags", tags);
+}
+

kms/src/model/CreateSecretResult.cc

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

kms/src/model/DecryptRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::DecryptRequest;
 DecryptRequest::DecryptRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "Decrypt")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 DecryptRequest::~DecryptRequest()
@@ -35,7 +35,7 @@ std::string DecryptRequest::getEncryptionContext()const
 void DecryptRequest::setEncryptionContext(const std::string& encryptionContext)
 {
 	encryptionContext_ = encryptionContext;
-	setCoreParameter("EncryptionContext", encryptionContext);
+	setParameter("EncryptionContext", encryptionContext);
 }
 
 std::string DecryptRequest::getCiphertextBlob()const
@@ -46,6 +46,6 @@ std::string DecryptRequest::getCiphertextBlob()const
 void DecryptRequest::setCiphertextBlob(const std::string& ciphertextBlob)
 {
 	ciphertextBlob_ = ciphertextBlob;
-	setCoreParameter("CiphertextBlob", ciphertextBlob);
+	setParameter("CiphertextBlob", ciphertextBlob);
 }
 

kms/src/model/DeleteAliasRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::DeleteAliasRequest;
 DeleteAliasRequest::DeleteAliasRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "DeleteAlias")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 DeleteAliasRequest::~DeleteAliasRequest()
@@ -35,6 +35,6 @@ std::string DeleteAliasRequest::getAliasName()const
 void DeleteAliasRequest::setAliasName(const std::string& aliasName)
 {
 	aliasName_ = aliasName;
-	setCoreParameter("AliasName", aliasName);
+	setParameter("AliasName", aliasName);
 }
 

kms/src/model/DeleteKeyMaterialRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::DeleteKeyMaterialRequest;
 DeleteKeyMaterialRequest::DeleteKeyMaterialRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "DeleteKeyMaterial")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 DeleteKeyMaterialRequest::~DeleteKeyMaterialRequest()
@@ -35,6 +35,6 @@ std::string DeleteKeyMaterialRequest::getKeyId()const
 void DeleteKeyMaterialRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 

kms/src/model/DeleteSecretRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/kms/model/DeleteSecretRequest.h>
+
+using AlibabaCloud::Kms::Model::DeleteSecretRequest;
+
+DeleteSecretRequest::DeleteSecretRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "DeleteSecret")
+{
+	setMethod(HttpRequest::Method::POST);
+}
+
+DeleteSecretRequest::~DeleteSecretRequest()
+{}
+
+std::string DeleteSecretRequest::getForceDeleteWithoutRecovery()const
+{
+	return forceDeleteWithoutRecovery_;
+}
+
+void DeleteSecretRequest::setForceDeleteWithoutRecovery(const std::string& forceDeleteWithoutRecovery)
+{
+	forceDeleteWithoutRecovery_ = forceDeleteWithoutRecovery;
+	setParameter("ForceDeleteWithoutRecovery", forceDeleteWithoutRecovery);
+}
+
+std::string DeleteSecretRequest::getRecoveryWindowInDays()const
+{
+	return recoveryWindowInDays_;
+}
+
+void DeleteSecretRequest::setRecoveryWindowInDays(const std::string& recoveryWindowInDays)
+{
+	recoveryWindowInDays_ = recoveryWindowInDays;
+	setParameter("RecoveryWindowInDays", recoveryWindowInDays);
+}
+
+std::string DeleteSecretRequest::getSecretName()const
+{
+	return secretName_;
+}
+
+void DeleteSecretRequest::setSecretName(const std::string& secretName)
+{
+	secretName_ = secretName;
+	setParameter("SecretName", secretName);
+}
+

kms/src/model/DeleteSecretResult.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/kms/model/DeleteSecretResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Kms;
+using namespace AlibabaCloud::Kms::Model;
+
+DeleteSecretResult::DeleteSecretResult() :
+	ServiceResult()
+{}
+
+DeleteSecretResult::DeleteSecretResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteSecretResult::~DeleteSecretResult()
+{}
+
+void DeleteSecretResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["SecretName"].isNull())
+		secretName_ = value["SecretName"].asString();
+	if(!value["PlannedDeleteTime"].isNull())
+		plannedDeleteTime_ = value["PlannedDeleteTime"].asString();
+
+}
+
+std::string DeleteSecretResult::getSecretName()const
+{
+	return secretName_;
+}
+
+std::string DeleteSecretResult::getPlannedDeleteTime()const
+{
+	return plannedDeleteTime_;
+}
+

kms/src/model/DescribeKeyRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::DescribeKeyRequest;
 DescribeKeyRequest::DescribeKeyRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "DescribeKey")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 DescribeKeyRequest::~DescribeKeyRequest()
@@ -35,6 +35,6 @@ std::string DescribeKeyRequest::getKeyId()const
 void DescribeKeyRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 

kms/src/model/DescribeKeyVersionRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::DescribeKeyVersionRequest;
 DescribeKeyVersionRequest::DescribeKeyVersionRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "DescribeKeyVersion")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 DescribeKeyVersionRequest::~DescribeKeyVersionRequest()
@@ -35,7 +35,7 @@ std::string DescribeKeyVersionRequest::getKeyVersionId()const
 void DescribeKeyVersionRequest::setKeyVersionId(const std::string& keyVersionId)
 {
 	keyVersionId_ = keyVersionId;
-	setCoreParameter("KeyVersionId", keyVersionId);
+	setParameter("KeyVersionId", keyVersionId);
 }
 
 std::string DescribeKeyVersionRequest::getKeyId()const
@@ -46,6 +46,6 @@ std::string DescribeKeyVersionRequest::getKeyId()const
 void DescribeKeyVersionRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 

kms/src/model/DescribeRegionsRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::DescribeRegionsRequest;
 DescribeRegionsRequest::DescribeRegionsRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "DescribeRegions")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 DescribeRegionsRequest::~DescribeRegionsRequest()

kms/src/model/DescribeSecretRequest.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/kms/model/DescribeSecretRequest.h>
+
+using AlibabaCloud::Kms::Model::DescribeSecretRequest;
+
+DescribeSecretRequest::DescribeSecretRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "DescribeSecret")
+{
+	setMethod(HttpRequest::Method::POST);
+}
+
+DescribeSecretRequest::~DescribeSecretRequest()
+{}
+
+std::string DescribeSecretRequest::getSecretName()const
+{
+	return secretName_;
+}
+
+void DescribeSecretRequest::setSecretName(const std::string& secretName)
+{
+	secretName_ = secretName;
+	setParameter("SecretName", secretName);
+}
+
+std::string DescribeSecretRequest::getFetchTags()const
+{
+	return fetchTags_;
+}
+
+void DescribeSecretRequest::setFetchTags(const std::string& fetchTags)
+{
+	fetchTags_ = fetchTags;
+	setParameter("FetchTags", fetchTags);
+}
+

kms/src/model/DescribeSecretResult.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/kms/model/DescribeSecretResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Kms;
+using namespace AlibabaCloud::Kms::Model;
+
+DescribeSecretResult::DescribeSecretResult() :
+	ServiceResult()
+{}
+
+DescribeSecretResult::DescribeSecretResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeSecretResult::~DescribeSecretResult()
+{}
+
+void DescribeSecretResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTagsNode = value["Tags"]["Tag"];
+	for (auto valueTagsTag : allTagsNode)
+	{
+		Tag tagsObject;
+		if(!valueTagsTag["TagKey"].isNull())
+			tagsObject.tagKey = valueTagsTag["TagKey"].asString();
+		if(!valueTagsTag["TagValue"].isNull())
+			tagsObject.tagValue = valueTagsTag["TagValue"].asString();
+		tags_.push_back(tagsObject);
+	}
+	if(!value["Arn"].isNull())
+		arn_ = value["Arn"].asString();
+	if(!value["SecretName"].isNull())
+		secretName_ = value["SecretName"].asString();
+	if(!value["EncryptionKeyId"].isNull())
+		encryptionKeyId_ = value["EncryptionKeyId"].asString();
+	if(!value["Description"].isNull())
+		description_ = value["Description"].asString();
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["UpdateTime"].isNull())
+		updateTime_ = value["UpdateTime"].asString();
+	if(!value["PlannedDeleteTime"].isNull())
+		plannedDeleteTime_ = value["PlannedDeleteTime"].asString();
+
+}
+
+std::string DescribeSecretResult::getSecretName()const
+{
+	return secretName_;
+}
+
+std::string DescribeSecretResult::getDescription()const
+{
+	return description_;
+}
+
+std::string DescribeSecretResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+std::string DescribeSecretResult::getUpdateTime()const
+{
+	return updateTime_;
+}
+
+std::string DescribeSecretResult::getPlannedDeleteTime()const
+{
+	return plannedDeleteTime_;
+}
+
+std::string DescribeSecretResult::getArn()const
+{
+	return arn_;
+}
+
+std::vector<DescribeSecretResult::Tag> DescribeSecretResult::getTags()const
+{
+	return tags_;
+}
+
+std::string DescribeSecretResult::getEncryptionKeyId()const
+{
+	return encryptionKeyId_;
+}
+

kms/src/model/DescribeServiceRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::DescribeServiceRequest;
 DescribeServiceRequest::DescribeServiceRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "DescribeService")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 DescribeServiceRequest::~DescribeServiceRequest()

kms/src/model/DescribeServiceResult.cc

@@ -47,6 +47,20 @@ void DescribeServiceResult::parse(const std::string &payload)
 			protectionLevelsObject.type = valueProtectionLevelsProtectionLevel["Type"].asString();
 		protectionLevels_.push_back(protectionLevelsObject);
 	}
+	auto allKeySpecsNode = value["KeySpecs"]["KeySpec"];
+	for (auto valueKeySpecsKeySpec : allKeySpecsNode)
+	{
+		KeySpec keySpecsObject;
+		if(!valueKeySpecsKeySpec["Name"].isNull())
+			keySpecsObject.name = valueKeySpecsKeySpec["Name"].asString();
+		auto allSupportedProtectionLevels = value["SupportedProtectionLevels"]["SupportedProtectionLevel"];
+		for (auto value : allSupportedProtectionLevels)
+			keySpecsObject.supportedProtectionLevels.push_back(value.asString());
+		auto allUsages = value["Usages"]["Usage"];
+		for (auto value : allUsages)
+			keySpecsObject.usages.push_back(value.asString());
+		keySpecs_.push_back(keySpecsObject);
+	}
 
 }
 
@@ -55,3 +69,8 @@ std::vector<DescribeServiceResult::ProtectionLevel> DescribeServiceResult::getPr
 	return protectionLevels_;
 }
 
+std::vector<DescribeServiceResult::KeySpec> DescribeServiceResult::getKeySpecs()const
+{
+	return keySpecs_;
+}
+

kms/src/model/DisableKeyRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::DisableKeyRequest;
 DisableKeyRequest::DisableKeyRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "DisableKey")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 DisableKeyRequest::~DisableKeyRequest()
@@ -35,6 +35,6 @@ std::string DisableKeyRequest::getKeyId()const
 void DisableKeyRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 

kms/src/model/EnableKeyRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::EnableKeyRequest;
 EnableKeyRequest::EnableKeyRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "EnableKey")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 EnableKeyRequest::~EnableKeyRequest()
@@ -35,6 +35,6 @@ std::string EnableKeyRequest::getKeyId()const
 void EnableKeyRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 

kms/src/model/EncryptRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::EncryptRequest;
 EncryptRequest::EncryptRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "Encrypt")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 EncryptRequest::~EncryptRequest()
@@ -35,7 +35,7 @@ std::string EncryptRequest::getEncryptionContext()const
 void EncryptRequest::setEncryptionContext(const std::string& encryptionContext)
 {
 	encryptionContext_ = encryptionContext;
-	setCoreParameter("EncryptionContext", encryptionContext);
+	setParameter("EncryptionContext", encryptionContext);
 }
 
 std::string EncryptRequest::getKeyId()const
@@ -46,7 +46,7 @@ std::string EncryptRequest::getKeyId()const
 void EncryptRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 
 std::string EncryptRequest::getPlaintext()const
@@ -57,6 +57,6 @@ std::string EncryptRequest::getPlaintext()const
 void EncryptRequest::setPlaintext(const std::string& plaintext)
 {
 	plaintext_ = plaintext;
-	setCoreParameter("Plaintext", plaintext);
+	setParameter("Plaintext", plaintext);
 }
 

kms/src/model/GenerateDataKeyRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::GenerateDataKeyRequest;
 GenerateDataKeyRequest::GenerateDataKeyRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "GenerateDataKey")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 GenerateDataKeyRequest::~GenerateDataKeyRequest()
@@ -35,7 +35,7 @@ std::string GenerateDataKeyRequest::getEncryptionContext()const
 void GenerateDataKeyRequest::setEncryptionContext(const std::string& encryptionContext)
 {
 	encryptionContext_ = encryptionContext;
-	setCoreParameter("EncryptionContext", encryptionContext);
+	setParameter("EncryptionContext", encryptionContext);
 }
 
 std::string GenerateDataKeyRequest::getKeyId()const
@@ -46,7 +46,7 @@ std::string GenerateDataKeyRequest::getKeyId()const
 void GenerateDataKeyRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 
 std::string GenerateDataKeyRequest::getKeySpec()const
@@ -57,7 +57,7 @@ std::string GenerateDataKeyRequest::getKeySpec()const
 void GenerateDataKeyRequest::setKeySpec(const std::string& keySpec)
 {
 	keySpec_ = keySpec;
-	setCoreParameter("KeySpec", keySpec);
+	setParameter("KeySpec", keySpec);
 }
 
 int GenerateDataKeyRequest::getNumberOfBytes()const
@@ -68,6 +68,6 @@ int GenerateDataKeyRequest::getNumberOfBytes()const
 void GenerateDataKeyRequest::setNumberOfBytes(int numberOfBytes)
 {
 	numberOfBytes_ = numberOfBytes;
-	setCoreParameter("NumberOfBytes", std::to_string(numberOfBytes));
+	setParameter("NumberOfBytes", std::to_string(numberOfBytes));
 }
 

kms/src/model/GenerateDataKeyWithoutPlaintextRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::GenerateDataKeyWithoutPlaintextRequest;
 GenerateDataKeyWithoutPlaintextRequest::GenerateDataKeyWithoutPlaintextRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "GenerateDataKeyWithoutPlaintext")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 GenerateDataKeyWithoutPlaintextRequest::~GenerateDataKeyWithoutPlaintextRequest()
@@ -35,7 +35,7 @@ std::string GenerateDataKeyWithoutPlaintextRequest::getEncryptionContext()const
 void GenerateDataKeyWithoutPlaintextRequest::setEncryptionContext(const std::string& encryptionContext)
 {
 	encryptionContext_ = encryptionContext;
-	setCoreParameter("EncryptionContext", encryptionContext);
+	setParameter("EncryptionContext", encryptionContext);
 }
 
 std::string GenerateDataKeyWithoutPlaintextRequest::getKeyId()const
@@ -46,7 +46,7 @@ std::string GenerateDataKeyWithoutPlaintextRequest::getKeyId()const
 void GenerateDataKeyWithoutPlaintextRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 
 std::string GenerateDataKeyWithoutPlaintextRequest::getKeySpec()const
@@ -57,7 +57,7 @@ std::string GenerateDataKeyWithoutPlaintextRequest::getKeySpec()const
 void GenerateDataKeyWithoutPlaintextRequest::setKeySpec(const std::string& keySpec)
 {
 	keySpec_ = keySpec;
-	setCoreParameter("KeySpec", keySpec);
+	setParameter("KeySpec", keySpec);
 }
 
 int GenerateDataKeyWithoutPlaintextRequest::getNumberOfBytes()const
@@ -68,6 +68,6 @@ int GenerateDataKeyWithoutPlaintextRequest::getNumberOfBytes()const
 void GenerateDataKeyWithoutPlaintextRequest::setNumberOfBytes(int numberOfBytes)
 {
 	numberOfBytes_ = numberOfBytes;
-	setCoreParameter("NumberOfBytes", std::to_string(numberOfBytes));
+	setParameter("NumberOfBytes", std::to_string(numberOfBytes));
 }
 

kms/src/model/GetParametersForImportRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::GetParametersForImportRequest;
 GetParametersForImportRequest::GetParametersForImportRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "GetParametersForImport")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 GetParametersForImportRequest::~GetParametersForImportRequest()
@@ -35,7 +35,7 @@ std::string GetParametersForImportRequest::getKeyId()const
 void GetParametersForImportRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 
 std::string GetParametersForImportRequest::getWrappingAlgorithm()const
@@ -46,7 +46,7 @@ std::string GetParametersForImportRequest::getWrappingAlgorithm()const
 void GetParametersForImportRequest::setWrappingAlgorithm(const std::string& wrappingAlgorithm)
 {
 	wrappingAlgorithm_ = wrappingAlgorithm;
-	setCoreParameter("WrappingAlgorithm", wrappingAlgorithm);
+	setParameter("WrappingAlgorithm", wrappingAlgorithm);
 }
 
 std::string GetParametersForImportRequest::getWrappingKeySpec()const
@@ -57,6 +57,6 @@ std::string GetParametersForImportRequest::getWrappingKeySpec()const
 void GetParametersForImportRequest::setWrappingKeySpec(const std::string& wrappingKeySpec)
 {
 	wrappingKeySpec_ = wrappingKeySpec;
-	setCoreParameter("WrappingKeySpec", wrappingKeySpec);
+	setParameter("WrappingKeySpec", wrappingKeySpec);
 }
 

kms/src/model/GetPublicKeyRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::GetPublicKeyRequest;
 GetPublicKeyRequest::GetPublicKeyRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "GetPublicKey")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 GetPublicKeyRequest::~GetPublicKeyRequest()
@@ -35,7 +35,7 @@ std::string GetPublicKeyRequest::getKeyVersionId()const
 void GetPublicKeyRequest::setKeyVersionId(const std::string& keyVersionId)
 {
 	keyVersionId_ = keyVersionId;
-	setCoreParameter("KeyVersionId", keyVersionId);
+	setParameter("KeyVersionId", keyVersionId);
 }
 
 std::string GetPublicKeyRequest::getKeyId()const
@@ -46,6 +46,6 @@ std::string GetPublicKeyRequest::getKeyId()const
 void GetPublicKeyRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 

kms/src/model/GetRandomPasswordRequest.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/kms/model/GetRandomPasswordRequest.h>
+
+using AlibabaCloud::Kms::Model::GetRandomPasswordRequest;
+
+GetRandomPasswordRequest::GetRandomPasswordRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "GetRandomPassword")
+{
+	setMethod(HttpRequest::Method::POST);
+}
+
+GetRandomPasswordRequest::~GetRandomPasswordRequest()
+{}
+
+std::string GetRandomPasswordRequest::getExcludeLowercase()const
+{
+	return excludeLowercase_;
+}
+
+void GetRandomPasswordRequest::setExcludeLowercase(const std::string& excludeLowercase)
+{
+	excludeLowercase_ = excludeLowercase;
+	setParameter("ExcludeLowercase", excludeLowercase);
+}
+
+std::string GetRandomPasswordRequest::getExcludeCharacters()const
+{
+	return excludeCharacters_;
+}
+
+void GetRandomPasswordRequest::setExcludeCharacters(const std::string& excludeCharacters)
+{
+	excludeCharacters_ = excludeCharacters;
+	setParameter("ExcludeCharacters", excludeCharacters);
+}
+
+std::string GetRandomPasswordRequest::getPasswordLength()const
+{
+	return passwordLength_;
+}
+
+void GetRandomPasswordRequest::setPasswordLength(const std::string& passwordLength)
+{
+	passwordLength_ = passwordLength;
+	setParameter("PasswordLength", passwordLength);
+}
+
+std::string GetRandomPasswordRequest::getExcludePunctuation()const
+{
+	return excludePunctuation_;
+}
+
+void GetRandomPasswordRequest::setExcludePunctuation(const std::string& excludePunctuation)
+{
+	excludePunctuation_ = excludePunctuation;
+	setParameter("ExcludePunctuation", excludePunctuation);
+}
+
+std::string GetRandomPasswordRequest::getExcludeUppercase()const
+{
+	return excludeUppercase_;
+}
+
+void GetRandomPasswordRequest::setExcludeUppercase(const std::string& excludeUppercase)
+{
+	excludeUppercase_ = excludeUppercase;
+	setParameter("ExcludeUppercase", excludeUppercase);
+}
+
+std::string GetRandomPasswordRequest::getRequireEachIncludedType()const
+{
+	return requireEachIncludedType_;
+}
+
+void GetRandomPasswordRequest::setRequireEachIncludedType(const std::string& requireEachIncludedType)
+{
+	requireEachIncludedType_ = requireEachIncludedType;
+	setParameter("RequireEachIncludedType", requireEachIncludedType);
+}
+
+std::string GetRandomPasswordRequest::getExcludeNumbers()const
+{
+	return excludeNumbers_;
+}
+
+void GetRandomPasswordRequest::setExcludeNumbers(const std::string& excludeNumbers)
+{
+	excludeNumbers_ = excludeNumbers;
+	setParameter("ExcludeNumbers", excludeNumbers);
+}
+

kms/src/model/GetRandomPasswordResult.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/kms/model/GetRandomPasswordResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Kms;
+using namespace AlibabaCloud::Kms::Model;
+
+GetRandomPasswordResult::GetRandomPasswordResult() :
+	ServiceResult()
+{}
+
+GetRandomPasswordResult::GetRandomPasswordResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetRandomPasswordResult::~GetRandomPasswordResult()
+{}
+
+void GetRandomPasswordResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["RandomPassword"].isNull())
+		randomPassword_ = value["RandomPassword"].asString();
+
+}
+
+std::string GetRandomPasswordResult::getRandomPassword()const
+{
+	return randomPassword_;
+}
+

kms/src/model/GetSecretValueRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/kms/model/GetSecretValueRequest.h>
+
+using AlibabaCloud::Kms::Model::GetSecretValueRequest;
+
+GetSecretValueRequest::GetSecretValueRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "GetSecretValue")
+{
+	setMethod(HttpRequest::Method::POST);
+}
+
+GetSecretValueRequest::~GetSecretValueRequest()
+{}
+
+std::string GetSecretValueRequest::getVersionId()const
+{
+	return versionId_;
+}
+
+void GetSecretValueRequest::setVersionId(const std::string& versionId)
+{
+	versionId_ = versionId;
+	setParameter("VersionId", versionId);
+}
+
+std::string GetSecretValueRequest::getVersionStage()const
+{
+	return versionStage_;
+}
+
+void GetSecretValueRequest::setVersionStage(const std::string& versionStage)
+{
+	versionStage_ = versionStage;
+	setParameter("VersionStage", versionStage);
+}
+
+std::string GetSecretValueRequest::getSecretName()const
+{
+	return secretName_;
+}
+
+void GetSecretValueRequest::setSecretName(const std::string& secretName)
+{
+	secretName_ = secretName;
+	setParameter("SecretName", secretName);
+}
+

kms/src/model/GetSecretValueResult.cc

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/kms/model/GetSecretValueResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Kms;
+using namespace AlibabaCloud::Kms::Model;
+
+GetSecretValueResult::GetSecretValueResult() :
+	ServiceResult()
+{}
+
+GetSecretValueResult::GetSecretValueResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetSecretValueResult::~GetSecretValueResult()
+{}
+
+void GetSecretValueResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allVersionStages = value["VersionStages"]["VersionStage"];
+	for (const auto &item : allVersionStages)
+		versionStages_.push_back(item.asString());
+	if(!value["SecretName"].isNull())
+		secretName_ = value["SecretName"].asString();
+	if(!value["VersionId"].isNull())
+		versionId_ = value["VersionId"].asString();
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["SecretData"].isNull())
+		secretData_ = value["SecretData"].asString();
+	if(!value["SecretDataType"].isNull())
+		secretDataType_ = value["SecretDataType"].asString();
+
+}
+
+std::string GetSecretValueResult::getSecretName()const
+{
+	return secretName_;
+}
+
+std::string GetSecretValueResult::getVersionId()const
+{
+	return versionId_;
+}
+
+std::string GetSecretValueResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+std::string GetSecretValueResult::getSecretDataType()const
+{
+	return secretDataType_;
+}
+
+std::string GetSecretValueResult::getSecretData()const
+{
+	return secretData_;
+}
+
+std::vector<std::string> GetSecretValueResult::getVersionStages()const
+{
+	return versionStages_;
+}
+

kms/src/model/ImportKeyMaterialRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::ImportKeyMaterialRequest;
 ImportKeyMaterialRequest::ImportKeyMaterialRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "ImportKeyMaterial")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 ImportKeyMaterialRequest::~ImportKeyMaterialRequest()
@@ -35,7 +35,7 @@ std::string ImportKeyMaterialRequest::getImportToken()const
 void ImportKeyMaterialRequest::setImportToken(const std::string& importToken)
 {
 	importToken_ = importToken;
-	setCoreParameter("ImportToken", importToken);
+	setParameter("ImportToken", importToken);
 }
 
 std::string ImportKeyMaterialRequest::getEncryptedKeyMaterial()const
@@ -46,7 +46,7 @@ std::string ImportKeyMaterialRequest::getEncryptedKeyMaterial()const
 void ImportKeyMaterialRequest::setEncryptedKeyMaterial(const std::string& encryptedKeyMaterial)
 {
 	encryptedKeyMaterial_ = encryptedKeyMaterial;
-	setCoreParameter("EncryptedKeyMaterial", encryptedKeyMaterial);
+	setParameter("EncryptedKeyMaterial", encryptedKeyMaterial);
 }
 
 long ImportKeyMaterialRequest::getKeyMaterialExpireUnix()const
@@ -57,7 +57,7 @@ long ImportKeyMaterialRequest::getKeyMaterialExpireUnix()const
 void ImportKeyMaterialRequest::setKeyMaterialExpireUnix(long keyMaterialExpireUnix)
 {
 	keyMaterialExpireUnix_ = keyMaterialExpireUnix;
-	setCoreParameter("KeyMaterialExpireUnix", std::to_string(keyMaterialExpireUnix));
+	setParameter("KeyMaterialExpireUnix", std::to_string(keyMaterialExpireUnix));
 }
 
 std::string ImportKeyMaterialRequest::getKeyId()const
@@ -68,6 +68,6 @@ std::string ImportKeyMaterialRequest::getKeyId()const
 void ImportKeyMaterialRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 

kms/src/model/ListAliasesByKeyIdRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::ListAliasesByKeyIdRequest;
 ListAliasesByKeyIdRequest::ListAliasesByKeyIdRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "ListAliasesByKeyId")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 ListAliasesByKeyIdRequest::~ListAliasesByKeyIdRequest()
@@ -35,7 +35,7 @@ int ListAliasesByKeyIdRequest::getPageSize()const
 void ListAliasesByKeyIdRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setCoreParameter("PageSize", std::to_string(pageSize));
+	setParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string ListAliasesByKeyIdRequest::getKeyId()const
@@ -46,7 +46,7 @@ std::string ListAliasesByKeyIdRequest::getKeyId()const
 void ListAliasesByKeyIdRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 
 int ListAliasesByKeyIdRequest::getPageNumber()const
@@ -57,6 +57,6 @@ int ListAliasesByKeyIdRequest::getPageNumber()const
 void ListAliasesByKeyIdRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setCoreParameter("PageNumber", std::to_string(pageNumber));
+	setParameter("PageNumber", std::to_string(pageNumber));
 }
 

kms/src/model/ListAliasesRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::ListAliasesRequest;
 ListAliasesRequest::ListAliasesRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "ListAliases")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 ListAliasesRequest::~ListAliasesRequest()
@@ -35,7 +35,7 @@ int ListAliasesRequest::getPageSize()const
 void ListAliasesRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setCoreParameter("PageSize", std::to_string(pageSize));
+	setParameter("PageSize", std::to_string(pageSize));
 }
 
 int ListAliasesRequest::getPageNumber()const
@@ -46,6 +46,6 @@ int ListAliasesRequest::getPageNumber()const
 void ListAliasesRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setCoreParameter("PageNumber", std::to_string(pageNumber));
+	setParameter("PageNumber", std::to_string(pageNumber));
 }
 

kms/src/model/ListKeyVersionsRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::ListKeyVersionsRequest;
 ListKeyVersionsRequest::ListKeyVersionsRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "ListKeyVersions")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 ListKeyVersionsRequest::~ListKeyVersionsRequest()
@@ -35,7 +35,7 @@ int ListKeyVersionsRequest::getPageSize()const
 void ListKeyVersionsRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setCoreParameter("PageSize", std::to_string(pageSize));
+	setParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string ListKeyVersionsRequest::getKeyId()const
@@ -46,7 +46,7 @@ std::string ListKeyVersionsRequest::getKeyId()const
 void ListKeyVersionsRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 
 int ListKeyVersionsRequest::getPageNumber()const
@@ -57,6 +57,6 @@ int ListKeyVersionsRequest::getPageNumber()const
 void ListKeyVersionsRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setCoreParameter("PageNumber", std::to_string(pageNumber));
+	setParameter("PageNumber", std::to_string(pageNumber));
 }
 

kms/src/model/ListKeysRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::ListKeysRequest;
 ListKeysRequest::ListKeysRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "ListKeys")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 ListKeysRequest::~ListKeysRequest()
@@ -35,7 +35,7 @@ int ListKeysRequest::getPageSize()const
 void ListKeysRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setCoreParameter("PageSize", std::to_string(pageSize));
+	setParameter("PageSize", std::to_string(pageSize));
 }
 
 int ListKeysRequest::getPageNumber()const
@@ -46,6 +46,6 @@ int ListKeysRequest::getPageNumber()const
 void ListKeysRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setCoreParameter("PageNumber", std::to_string(pageNumber));
+	setParameter("PageNumber", std::to_string(pageNumber));
 }
 

kms/src/model/ListResourceTagsRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::ListResourceTagsRequest;
 ListResourceTagsRequest::ListResourceTagsRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "ListResourceTags")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 ListResourceTagsRequest::~ListResourceTagsRequest()
@@ -35,6 +35,6 @@ std::string ListResourceTagsRequest::getKeyId()const
 void ListResourceTagsRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 

kms/src/model/ListSecretVersionIdsRequest.cc

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/kms/model/ListSecretVersionIdsRequest.h>
+
+using AlibabaCloud::Kms::Model::ListSecretVersionIdsRequest;
+
+ListSecretVersionIdsRequest::ListSecretVersionIdsRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "ListSecretVersionIds")
+{
+	setMethod(HttpRequest::Method::POST);
+}
+
+ListSecretVersionIdsRequest::~ListSecretVersionIdsRequest()
+{}
+
+std::string ListSecretVersionIdsRequest::getIncludeDeprecated()const
+{
+	return includeDeprecated_;
+}
+
+void ListSecretVersionIdsRequest::setIncludeDeprecated(const std::string& includeDeprecated)
+{
+	includeDeprecated_ = includeDeprecated;
+	setParameter("IncludeDeprecated", includeDeprecated);
+}
+
+int ListSecretVersionIdsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListSecretVersionIdsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string ListSecretVersionIdsRequest::getSecretName()const
+{
+	return secretName_;
+}
+
+void ListSecretVersionIdsRequest::setSecretName(const std::string& secretName)
+{
+	secretName_ = secretName;
+	setParameter("SecretName", secretName);
+}
+
+int ListSecretVersionIdsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListSecretVersionIdsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+

kms/src/model/ListSecretVersionIdsResult.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/kms/model/ListSecretVersionIdsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Kms;
+using namespace AlibabaCloud::Kms::Model;
+
+ListSecretVersionIdsResult::ListSecretVersionIdsResult() :
+	ServiceResult()
+{}
+
+ListSecretVersionIdsResult::ListSecretVersionIdsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListSecretVersionIdsResult::~ListSecretVersionIdsResult()
+{}
+
+void ListSecretVersionIdsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allVersionIdsNode = value["VersionIds"]["VersionId"];
+	for (auto valueVersionIdsVersionId : allVersionIdsNode)
+	{
+		VersionId versionIdsObject;
+		if(!valueVersionIdsVersionId["CreateTime"].isNull())
+			versionIdsObject.createTime = valueVersionIdsVersionId["CreateTime"].asString();
+		if(!valueVersionIdsVersionId["VersionId"].isNull())
+			versionIdsObject.versionId = valueVersionIdsVersionId["VersionId"].asString();
+		auto allVersionStages = value["VersionStages"]["VersionStage"];
+		for (auto value : allVersionStages)
+			versionIdsObject.versionStages.push_back(value.asString());
+		versionIds_.push_back(versionIdsObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["SecretName"].isNull())
+		secretName_ = value["SecretName"].asString();
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+std::string ListSecretVersionIdsResult::getSecretName()const
+{
+	return secretName_;
+}
+
+int ListSecretVersionIdsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int ListSecretVersionIdsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int ListSecretVersionIdsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<ListSecretVersionIdsResult::VersionId> ListSecretVersionIdsResult::getVersionIds()const
+{
+	return versionIds_;
+}
+

kms/src/model/ListSecretsRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/kms/model/ListSecretsRequest.h>
+
+using AlibabaCloud::Kms::Model::ListSecretsRequest;
+
+ListSecretsRequest::ListSecretsRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "ListSecrets")
+{
+	setMethod(HttpRequest::Method::POST);
+}
+
+ListSecretsRequest::~ListSecretsRequest()
+{}
+
+int ListSecretsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListSecretsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string ListSecretsRequest::getFetchTags()const
+{
+	return fetchTags_;
+}
+
+void ListSecretsRequest::setFetchTags(const std::string& fetchTags)
+{
+	fetchTags_ = fetchTags;
+	setParameter("FetchTags", fetchTags);
+}
+
+int ListSecretsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListSecretsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+

kms/src/model/ListSecretsResult.cc

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/kms/model/ListSecretsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Kms;
+using namespace AlibabaCloud::Kms::Model;
+
+ListSecretsResult::ListSecretsResult() :
+	ServiceResult()
+{}
+
+ListSecretsResult::ListSecretsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListSecretsResult::~ListSecretsResult()
+{}
+
+void ListSecretsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allSecretListNode = value["SecretList"]["Secret"];
+	for (auto valueSecretListSecret : allSecretListNode)
+	{
+		Secret secretListObject;
+		if(!valueSecretListSecret["SecretName"].isNull())
+			secretListObject.secretName = valueSecretListSecret["SecretName"].asString();
+		if(!valueSecretListSecret["CreateTime"].isNull())
+			secretListObject.createTime = valueSecretListSecret["CreateTime"].asString();
+		if(!valueSecretListSecret["UpdateTime"].isNull())
+			secretListObject.updateTime = valueSecretListSecret["UpdateTime"].asString();
+		if(!valueSecretListSecret["PlannedDeleteTime"].isNull())
+			secretListObject.plannedDeleteTime = valueSecretListSecret["PlannedDeleteTime"].asString();
+		auto allTagsNode = allSecretListNode["Tags"]["Tag"];
+		for (auto allSecretListNodeTagsTag : allTagsNode)
+		{
+			Secret::Tag tagsObject;
+			if(!allSecretListNodeTagsTag["TagKey"].isNull())
+				tagsObject.tagKey = allSecretListNodeTagsTag["TagKey"].asString();
+			if(!allSecretListNodeTagsTag["TagValue"].isNull())
+				tagsObject.tagValue = allSecretListNodeTagsTag["TagValue"].asString();
+			secretListObject.tags.push_back(tagsObject);
+		}
+		secretList_.push_back(secretListObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+int ListSecretsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::vector<ListSecretsResult::Secret> ListSecretsResult::getSecretList()const
+{
+	return secretList_;
+}
+
+int ListSecretsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int ListSecretsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

kms/src/model/PutSecretValueRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/kms/model/PutSecretValueRequest.h>
+
+using AlibabaCloud::Kms::Model::PutSecretValueRequest;
+
+PutSecretValueRequest::PutSecretValueRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "PutSecretValue")
+{
+	setMethod(HttpRequest::Method::POST);
+}
+
+PutSecretValueRequest::~PutSecretValueRequest()
+{}
+
+std::string PutSecretValueRequest::getVersionId()const
+{
+	return versionId_;
+}
+
+void PutSecretValueRequest::setVersionId(const std::string& versionId)
+{
+	versionId_ = versionId;
+	setParameter("VersionId", versionId);
+}
+
+std::string PutSecretValueRequest::getVersionStages()const
+{
+	return versionStages_;
+}
+
+void PutSecretValueRequest::setVersionStages(const std::string& versionStages)
+{
+	versionStages_ = versionStages;
+	setParameter("VersionStages", versionStages);
+}
+
+std::string PutSecretValueRequest::getSecretData()const
+{
+	return secretData_;
+}
+
+void PutSecretValueRequest::setSecretData(const std::string& secretData)
+{
+	secretData_ = secretData;
+	setParameter("SecretData", secretData);
+}
+
+std::string PutSecretValueRequest::getSecretName()const
+{
+	return secretName_;
+}
+
+void PutSecretValueRequest::setSecretName(const std::string& secretName)
+{
+	secretName_ = secretName;
+	setParameter("SecretName", secretName);
+}
+
+std::string PutSecretValueRequest::getSecretDataType()const
+{
+	return secretDataType_;
+}
+
+void PutSecretValueRequest::setSecretDataType(const std::string& secretDataType)
+{
+	secretDataType_ = secretDataType;
+	setParameter("SecretDataType", secretDataType);
+}
+

kms/src/model/PutSecretValueResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/kms/model/PutSecretValueResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Kms;
+using namespace AlibabaCloud::Kms::Model;
+
+PutSecretValueResult::PutSecretValueResult() :
+	ServiceResult()
+{}
+
+PutSecretValueResult::PutSecretValueResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+PutSecretValueResult::~PutSecretValueResult()
+{}
+
+void PutSecretValueResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allVersionStages = value["VersionStages"]["VersionStage"];
+	for (const auto &item : allVersionStages)
+		versionStages_.push_back(item.asString());
+	if(!value["SecretName"].isNull())
+		secretName_ = value["SecretName"].asString();
+	if(!value["VersionId"].isNull())
+		versionId_ = value["VersionId"].asString();
+
+}
+
+std::string PutSecretValueResult::getSecretName()const
+{
+	return secretName_;
+}
+
+std::string PutSecretValueResult::getVersionId()const
+{
+	return versionId_;
+}
+
+std::vector<std::string> PutSecretValueResult::getVersionStages()const
+{
+	return versionStages_;
+}
+

kms/src/model/RestoreSecretRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/kms/model/RestoreSecretRequest.h>
+
+using AlibabaCloud::Kms::Model::RestoreSecretRequest;
+
+RestoreSecretRequest::RestoreSecretRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "RestoreSecret")
+{
+	setMethod(HttpRequest::Method::POST);
+}
+
+RestoreSecretRequest::~RestoreSecretRequest()
+{}
+
+std::string RestoreSecretRequest::getSecretName()const
+{
+	return secretName_;
+}
+
+void RestoreSecretRequest::setSecretName(const std::string& secretName)
+{
+	secretName_ = secretName;
+	setParameter("SecretName", secretName);
+}
+

kms/src/model/RestoreSecretResult.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/kms/model/RestoreSecretResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Kms;
+using namespace AlibabaCloud::Kms::Model;
+
+RestoreSecretResult::RestoreSecretResult() :
+	ServiceResult()
+{}
+
+RestoreSecretResult::RestoreSecretResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+RestoreSecretResult::~RestoreSecretResult()
+{}
+
+void RestoreSecretResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["SecretName"].isNull())
+		secretName_ = value["SecretName"].asString();
+
+}
+
+std::string RestoreSecretResult::getSecretName()const
+{
+	return secretName_;
+}
+

kms/src/model/ScheduleKeyDeletionRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::ScheduleKeyDeletionRequest;
 ScheduleKeyDeletionRequest::ScheduleKeyDeletionRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "ScheduleKeyDeletion")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 ScheduleKeyDeletionRequest::~ScheduleKeyDeletionRequest()
@@ -35,7 +35,7 @@ int ScheduleKeyDeletionRequest::getPendingWindowInDays()const
 void ScheduleKeyDeletionRequest::setPendingWindowInDays(int pendingWindowInDays)
 {
 	pendingWindowInDays_ = pendingWindowInDays;
-	setCoreParameter("PendingWindowInDays", std::to_string(pendingWindowInDays));
+	setParameter("PendingWindowInDays", std::to_string(pendingWindowInDays));
 }
 
 std::string ScheduleKeyDeletionRequest::getKeyId()const
@@ -46,6 +46,6 @@ std::string ScheduleKeyDeletionRequest::getKeyId()const
 void ScheduleKeyDeletionRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 

kms/src/model/TagResourceRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::TagResourceRequest;
 TagResourceRequest::TagResourceRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "TagResource")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 TagResourceRequest::~TagResourceRequest()
@@ -35,7 +35,18 @@ std::string TagResourceRequest::getKeyId()const
 void TagResourceRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
+}
+
+std::string TagResourceRequest::getSecretName()const
+{
+	return secretName_;
+}
+
+void TagResourceRequest::setSecretName(const std::string& secretName)
+{
+	secretName_ = secretName;
+	setParameter("SecretName", secretName);
 }
 
 std::string TagResourceRequest::getTags()const
@@ -46,6 +57,6 @@ std::string TagResourceRequest::getTags()const
 void TagResourceRequest::setTags(const std::string& tags)
 {
 	tags_ = tags;
-	setCoreParameter("Tags", tags);
+	setParameter("Tags", tags);
 }
 

kms/src/model/UntagResourceRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::UntagResourceRequest;
 UntagResourceRequest::UntagResourceRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "UntagResource")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 UntagResourceRequest::~UntagResourceRequest()
@@ -35,7 +35,7 @@ std::string UntagResourceRequest::getTagKeys()const
 void UntagResourceRequest::setTagKeys(const std::string& tagKeys)
 {
 	tagKeys_ = tagKeys;
-	setCoreParameter("TagKeys", tagKeys);
+	setParameter("TagKeys", tagKeys);
 }
 
 std::string UntagResourceRequest::getKeyId()const
@@ -46,6 +46,17 @@ std::string UntagResourceRequest::getKeyId()const
 void UntagResourceRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
+}
+
+std::string UntagResourceRequest::getSecretName()const
+{
+	return secretName_;
+}
+
+void UntagResourceRequest::setSecretName(const std::string& secretName)
+{
+	secretName_ = secretName;
+	setParameter("SecretName", secretName);
 }
 

kms/src/model/UntagResourceResult.cc

@@ -39,13 +39,6 @@ void UntagResourceResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["KeyId"].isNull())
-		keyId_ = value["KeyId"].asString();
 
 }
 
-std::string UntagResourceResult::getKeyId()const
-{
-	return keyId_;
-}
-

kms/src/model/UpdateAliasRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::UpdateAliasRequest;
 UpdateAliasRequest::UpdateAliasRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "UpdateAlias")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 UpdateAliasRequest::~UpdateAliasRequest()
@@ -35,7 +35,7 @@ std::string UpdateAliasRequest::getAliasName()const
 void UpdateAliasRequest::setAliasName(const std::string& aliasName)
 {
 	aliasName_ = aliasName;
-	setCoreParameter("AliasName", aliasName);
+	setParameter("AliasName", aliasName);
 }
 
 std::string UpdateAliasRequest::getKeyId()const
@@ -46,6 +46,6 @@ std::string UpdateAliasRequest::getKeyId()const
 void UpdateAliasRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 

kms/src/model/UpdateKeyDescriptionRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::UpdateKeyDescriptionRequest;
 UpdateKeyDescriptionRequest::UpdateKeyDescriptionRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "UpdateKeyDescription")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 UpdateKeyDescriptionRequest::~UpdateKeyDescriptionRequest()
@@ -35,7 +35,7 @@ std::string UpdateKeyDescriptionRequest::getKeyId()const
 void UpdateKeyDescriptionRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 
 std::string UpdateKeyDescriptionRequest::getDescription()const
@@ -46,6 +46,6 @@ std::string UpdateKeyDescriptionRequest::getDescription()const
 void UpdateKeyDescriptionRequest::setDescription(const std::string& description)
 {
 	description_ = description;
-	setCoreParameter("Description", description);
+	setParameter("Description", description);
 }
 

kms/src/model/UpdateRotationPolicyRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Kms::Model::UpdateRotationPolicyRequest;
 UpdateRotationPolicyRequest::UpdateRotationPolicyRequest() :
 	RpcServiceRequest("kms", "2016-01-20", "UpdateRotationPolicy")
 {
-	setMethod(HttpRequest::Method::Post);
+	setMethod(HttpRequest::Method::POST);
 }
 
 UpdateRotationPolicyRequest::~UpdateRotationPolicyRequest()
@@ -35,7 +35,7 @@ std::string UpdateRotationPolicyRequest::getKeyId()const
 void UpdateRotationPolicyRequest::setKeyId(const std::string& keyId)
 {
 	keyId_ = keyId;
-	setCoreParameter("KeyId", keyId);
+	setParameter("KeyId", keyId);
 }
 
 std::string UpdateRotationPolicyRequest::getRotationInterval()const
@@ -46,7 +46,7 @@ std::string UpdateRotationPolicyRequest::getRotationInterval()const
 void UpdateRotationPolicyRequest::setRotationInterval(const std::string& rotationInterval)
 {
 	rotationInterval_ = rotationInterval;
-	setCoreParameter("RotationInterval", rotationInterval);
+	setParameter("RotationInterval", rotationInterval);
 }
 
 bool UpdateRotationPolicyRequest::getEnableAutomaticRotation()const
@@ -57,6 +57,6 @@ bool UpdateRotationPolicyRequest::getEnableAutomaticRotation()const
 void UpdateRotationPolicyRequest::setEnableAutomaticRotation(bool enableAutomaticRotation)
 {
 	enableAutomaticRotation_ = enableAutomaticRotation;
-	setCoreParameter("EnableAutomaticRotation", enableAutomaticRotation ? "true" : "false");
+	setParameter("EnableAutomaticRotation", enableAutomaticRotation ? "true" : "false");
 }
 

kms/src/model/UpdateSecretRequest.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/kms/model/UpdateSecretRequest.h>
+
+using AlibabaCloud::Kms::Model::UpdateSecretRequest;
+
+UpdateSecretRequest::UpdateSecretRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "UpdateSecret")
+{
+	setMethod(HttpRequest::Method::POST);
+}
+
+UpdateSecretRequest::~UpdateSecretRequest()
+{}
+
+std::string UpdateSecretRequest::getDescription()const
+{
+	return description_;
+}
+
+void UpdateSecretRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+std::string UpdateSecretRequest::getSecretName()const
+{
+	return secretName_;
+}
+
+void UpdateSecretRequest::setSecretName(const std::string& secretName)
+{
+	secretName_ = secretName;
+	setParameter("SecretName", secretName);
+}
+

kms/src/model/UpdateSecretResult.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/kms/model/UpdateSecretResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Kms;
+using namespace AlibabaCloud::Kms::Model;
+
+UpdateSecretResult::UpdateSecretResult() :
+	ServiceResult()
+{}
+
+UpdateSecretResult::UpdateSecretResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateSecretResult::~UpdateSecretResult()
+{}
+
+void UpdateSecretResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["SecretName"].isNull())
+		secretName_ = value["SecretName"].asString();
+
+}
+
+std::string UpdateSecretResult::getSecretName()const
+{
+	return secretName_;
+}
+

kms/src/model/UpdateSecretVersionStageRequest.cc

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/kms/model/UpdateSecretVersionStageRequest.h>
+
+using AlibabaCloud::Kms::Model::UpdateSecretVersionStageRequest;
+
+UpdateSecretVersionStageRequest::UpdateSecretVersionStageRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "UpdateSecretVersionStage")
+{
+	setMethod(HttpRequest::Method::POST);
+}
+
+UpdateSecretVersionStageRequest::~UpdateSecretVersionStageRequest()
+{}
+
+std::string UpdateSecretVersionStageRequest::getRemoveFromVersion()const
+{
+	return removeFromVersion_;
+}
+
+void UpdateSecretVersionStageRequest::setRemoveFromVersion(const std::string& removeFromVersion)
+{
+	removeFromVersion_ = removeFromVersion;
+	setParameter("RemoveFromVersion", removeFromVersion);
+}
+
+std::string UpdateSecretVersionStageRequest::getMoveToVersion()const
+{
+	return moveToVersion_;
+}
+
+void UpdateSecretVersionStageRequest::setMoveToVersion(const std::string& moveToVersion)
+{
+	moveToVersion_ = moveToVersion;
+	setParameter("MoveToVersion", moveToVersion);
+}
+
+std::string UpdateSecretVersionStageRequest::getVersionStage()const
+{
+	return versionStage_;
+}
+
+void UpdateSecretVersionStageRequest::setVersionStage(const std::string& versionStage)
+{
+	versionStage_ = versionStage;
+	setParameter("VersionStage", versionStage);
+}
+
+std::string UpdateSecretVersionStageRequest::getSecretName()const
+{
+	return secretName_;
+}
+
+void UpdateSecretVersionStageRequest::setSecretName(const std::string& secretName)
+{
+	secretName_ = secretName;
+	setParameter("SecretName", secretName);
+}
+

kms/src/model/UpdateSecretVersionStageResult.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/kms/model/UpdateSecretVersionStageResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Kms;
+using namespace AlibabaCloud::Kms::Model;
+
+UpdateSecretVersionStageResult::UpdateSecretVersionStageResult() :
+	ServiceResult()
+{}
+
+UpdateSecretVersionStageResult::UpdateSecretVersionStageResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateSecretVersionStageResult::~UpdateSecretVersionStageResult()
+{}
+
+void UpdateSecretVersionStageResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["SecretName"].isNull())
+		secretName_ = value["SecretName"].asString();
+
+}
+
+std::string UpdateSecretVersionStageResult::getSecretName()const
+{
+	return secretName_;
+}
+