Add Certificate Manager Api.

CHANGELOG

@@ -1,3 +1,6 @@
+2020-11-27 Version: patch
+- Add Certificate Manager Api.
+
 2020-11-27 Version: patch
 - Support taskList.
 

kms/CMakeLists.txt

@@ -31,8 +31,18 @@ set(kms_public_header_model
 	include/alibabacloud/kms/model/AsymmetricVerifyResult.h
 	include/alibabacloud/kms/model/CancelKeyDeletionRequest.h
 	include/alibabacloud/kms/model/CancelKeyDeletionResult.h
+	include/alibabacloud/kms/model/CertificatePrivateKeyDecryptRequest.h
+	include/alibabacloud/kms/model/CertificatePrivateKeyDecryptResult.h
+	include/alibabacloud/kms/model/CertificatePrivateKeySignRequest.h
+	include/alibabacloud/kms/model/CertificatePrivateKeySignResult.h
+	include/alibabacloud/kms/model/CertificatePublicKeyEncryptRequest.h
+	include/alibabacloud/kms/model/CertificatePublicKeyEncryptResult.h
+	include/alibabacloud/kms/model/CertificatePublicKeyVerifyRequest.h
+	include/alibabacloud/kms/model/CertificatePublicKeyVerifyResult.h
 	include/alibabacloud/kms/model/CreateAliasRequest.h
 	include/alibabacloud/kms/model/CreateAliasResult.h
+	include/alibabacloud/kms/model/CreateCertificateRequest.h
+	include/alibabacloud/kms/model/CreateCertificateResult.h
 	include/alibabacloud/kms/model/CreateKeyRequest.h
 	include/alibabacloud/kms/model/CreateKeyResult.h
 	include/alibabacloud/kms/model/CreateKeyVersionRequest.h
@@ -43,12 +53,16 @@ set(kms_public_header_model
 	include/alibabacloud/kms/model/DecryptResult.h
 	include/alibabacloud/kms/model/DeleteAliasRequest.h
 	include/alibabacloud/kms/model/DeleteAliasResult.h
+	include/alibabacloud/kms/model/DeleteCertificateRequest.h
+	include/alibabacloud/kms/model/DeleteCertificateResult.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/DescribeAccountKmsStatusRequest.h
 	include/alibabacloud/kms/model/DescribeAccountKmsStatusResult.h
+	include/alibabacloud/kms/model/DescribeCertificateRequest.h
+	include/alibabacloud/kms/model/DescribeCertificateResult.h
 	include/alibabacloud/kms/model/DescribeKeyRequest.h
 	include/alibabacloud/kms/model/DescribeKeyResult.h
 	include/alibabacloud/kms/model/DescribeKeyVersionRequest.h
@@ -65,6 +79,8 @@ set(kms_public_header_model
 	include/alibabacloud/kms/model/EnableKeyResult.h
 	include/alibabacloud/kms/model/EncryptRequest.h
 	include/alibabacloud/kms/model/EncryptResult.h
+	include/alibabacloud/kms/model/ExportCertificateRequest.h
+	include/alibabacloud/kms/model/ExportCertificateResult.h
 	include/alibabacloud/kms/model/ExportDataKeyRequest.h
 	include/alibabacloud/kms/model/ExportDataKeyResult.h
 	include/alibabacloud/kms/model/GenerateAndExportDataKeyRequest.h
@@ -73,6 +89,8 @@ set(kms_public_header_model
 	include/alibabacloud/kms/model/GenerateDataKeyResult.h
 	include/alibabacloud/kms/model/GenerateDataKeyWithoutPlaintextRequest.h
 	include/alibabacloud/kms/model/GenerateDataKeyWithoutPlaintextResult.h
+	include/alibabacloud/kms/model/GetCertificateRequest.h
+	include/alibabacloud/kms/model/GetCertificateResult.h
 	include/alibabacloud/kms/model/GetParametersForImportRequest.h
 	include/alibabacloud/kms/model/GetParametersForImportResult.h
 	include/alibabacloud/kms/model/GetPublicKeyRequest.h
@@ -81,12 +99,18 @@ set(kms_public_header_model
 	include/alibabacloud/kms/model/GetRandomPasswordResult.h
 	include/alibabacloud/kms/model/GetSecretValueRequest.h
 	include/alibabacloud/kms/model/GetSecretValueResult.h
+	include/alibabacloud/kms/model/ImportCertificateRequest.h
+	include/alibabacloud/kms/model/ImportCertificateResult.h
+	include/alibabacloud/kms/model/ImportEncryptionCertificateRequest.h
+	include/alibabacloud/kms/model/ImportEncryptionCertificateResult.h
 	include/alibabacloud/kms/model/ImportKeyMaterialRequest.h
 	include/alibabacloud/kms/model/ImportKeyMaterialResult.h
 	include/alibabacloud/kms/model/ListAliasesRequest.h
 	include/alibabacloud/kms/model/ListAliasesResult.h
 	include/alibabacloud/kms/model/ListAliasesByKeyIdRequest.h
 	include/alibabacloud/kms/model/ListAliasesByKeyIdResult.h
+	include/alibabacloud/kms/model/ListCertificatesRequest.h
+	include/alibabacloud/kms/model/ListCertificatesResult.h
 	include/alibabacloud/kms/model/ListKeyVersionsRequest.h
 	include/alibabacloud/kms/model/ListKeyVersionsResult.h
 	include/alibabacloud/kms/model/ListKeysRequest.h
@@ -113,6 +137,8 @@ set(kms_public_header_model
 	include/alibabacloud/kms/model/UntagResourceResult.h
 	include/alibabacloud/kms/model/UpdateAliasRequest.h
 	include/alibabacloud/kms/model/UpdateAliasResult.h
+	include/alibabacloud/kms/model/UpdateCertificateStatusRequest.h
+	include/alibabacloud/kms/model/UpdateCertificateStatusResult.h
 	include/alibabacloud/kms/model/UpdateKeyDescriptionRequest.h
 	include/alibabacloud/kms/model/UpdateKeyDescriptionResult.h
 	include/alibabacloud/kms/model/UpdateRotationPolicyRequest.h
@@ -120,7 +146,9 @@ set(kms_public_header_model
 	include/alibabacloud/kms/model/UpdateSecretRequest.h
 	include/alibabacloud/kms/model/UpdateSecretResult.h
 	include/alibabacloud/kms/model/UpdateSecretVersionStageRequest.h
-	include/alibabacloud/kms/model/UpdateSecretVersionStageResult.h )
+	include/alibabacloud/kms/model/UpdateSecretVersionStageResult.h
+	include/alibabacloud/kms/model/UploadCertificateRequest.h
+	include/alibabacloud/kms/model/UploadCertificateResult.h )
 
 set(kms_src 
 	src/KmsClient.cc
@@ -134,8 +162,18 @@ set(kms_src
 	src/model/AsymmetricVerifyResult.cc
 	src/model/CancelKeyDeletionRequest.cc
 	src/model/CancelKeyDeletionResult.cc
+	src/model/CertificatePrivateKeyDecryptRequest.cc
+	src/model/CertificatePrivateKeyDecryptResult.cc
+	src/model/CertificatePrivateKeySignRequest.cc
+	src/model/CertificatePrivateKeySignResult.cc
+	src/model/CertificatePublicKeyEncryptRequest.cc
+	src/model/CertificatePublicKeyEncryptResult.cc
+	src/model/CertificatePublicKeyVerifyRequest.cc
+	src/model/CertificatePublicKeyVerifyResult.cc
 	src/model/CreateAliasRequest.cc
 	src/model/CreateAliasResult.cc
+	src/model/CreateCertificateRequest.cc
+	src/model/CreateCertificateResult.cc
 	src/model/CreateKeyRequest.cc
 	src/model/CreateKeyResult.cc
 	src/model/CreateKeyVersionRequest.cc
@@ -146,12 +184,16 @@ set(kms_src
 	src/model/DecryptResult.cc
 	src/model/DeleteAliasRequest.cc
 	src/model/DeleteAliasResult.cc
+	src/model/DeleteCertificateRequest.cc
+	src/model/DeleteCertificateResult.cc
 	src/model/DeleteKeyMaterialRequest.cc
 	src/model/DeleteKeyMaterialResult.cc
 	src/model/DeleteSecretRequest.cc
 	src/model/DeleteSecretResult.cc
 	src/model/DescribeAccountKmsStatusRequest.cc
 	src/model/DescribeAccountKmsStatusResult.cc
+	src/model/DescribeCertificateRequest.cc
+	src/model/DescribeCertificateResult.cc
 	src/model/DescribeKeyRequest.cc
 	src/model/DescribeKeyResult.cc
 	src/model/DescribeKeyVersionRequest.cc
@@ -168,6 +210,8 @@ set(kms_src
 	src/model/EnableKeyResult.cc
 	src/model/EncryptRequest.cc
 	src/model/EncryptResult.cc
+	src/model/ExportCertificateRequest.cc
+	src/model/ExportCertificateResult.cc
 	src/model/ExportDataKeyRequest.cc
 	src/model/ExportDataKeyResult.cc
 	src/model/GenerateAndExportDataKeyRequest.cc
@@ -176,6 +220,8 @@ set(kms_src
 	src/model/GenerateDataKeyResult.cc
 	src/model/GenerateDataKeyWithoutPlaintextRequest.cc
 	src/model/GenerateDataKeyWithoutPlaintextResult.cc
+	src/model/GetCertificateRequest.cc
+	src/model/GetCertificateResult.cc
 	src/model/GetParametersForImportRequest.cc
 	src/model/GetParametersForImportResult.cc
 	src/model/GetPublicKeyRequest.cc
@@ -184,12 +230,18 @@ set(kms_src
 	src/model/GetRandomPasswordResult.cc
 	src/model/GetSecretValueRequest.cc
 	src/model/GetSecretValueResult.cc
+	src/model/ImportCertificateRequest.cc
+	src/model/ImportCertificateResult.cc
+	src/model/ImportEncryptionCertificateRequest.cc
+	src/model/ImportEncryptionCertificateResult.cc
 	src/model/ImportKeyMaterialRequest.cc
 	src/model/ImportKeyMaterialResult.cc
 	src/model/ListAliasesRequest.cc
 	src/model/ListAliasesResult.cc
 	src/model/ListAliasesByKeyIdRequest.cc
 	src/model/ListAliasesByKeyIdResult.cc
+	src/model/ListCertificatesRequest.cc
+	src/model/ListCertificatesResult.cc
 	src/model/ListKeyVersionsRequest.cc
 	src/model/ListKeyVersionsResult.cc
 	src/model/ListKeysRequest.cc
@@ -216,6 +268,8 @@ set(kms_src
 	src/model/UntagResourceResult.cc
 	src/model/UpdateAliasRequest.cc
 	src/model/UpdateAliasResult.cc
+	src/model/UpdateCertificateStatusRequest.cc
+	src/model/UpdateCertificateStatusResult.cc
 	src/model/UpdateKeyDescriptionRequest.cc
 	src/model/UpdateKeyDescriptionResult.cc
 	src/model/UpdateRotationPolicyRequest.cc
@@ -223,7 +277,9 @@ set(kms_src
 	src/model/UpdateSecretRequest.cc
 	src/model/UpdateSecretResult.cc
 	src/model/UpdateSecretVersionStageRequest.cc
-	src/model/UpdateSecretVersionStageResult.cc )
+	src/model/UpdateSecretVersionStageResult.cc
+	src/model/UploadCertificateRequest.cc
+	src/model/UploadCertificateResult.cc )
 
 add_library(kms ${LIB_TYPE}
 	${kms_public_header}

kms/include/alibabacloud/kms/KmsClient.h

@@ -32,8 +32,18 @@
 #include "model/AsymmetricVerifyResult.h"
 #include "model/CancelKeyDeletionRequest.h"
 #include "model/CancelKeyDeletionResult.h"
+#include "model/CertificatePrivateKeyDecryptRequest.h"
+#include "model/CertificatePrivateKeyDecryptResult.h"
+#include "model/CertificatePrivateKeySignRequest.h"
+#include "model/CertificatePrivateKeySignResult.h"
+#include "model/CertificatePublicKeyEncryptRequest.h"
+#include "model/CertificatePublicKeyEncryptResult.h"
+#include "model/CertificatePublicKeyVerifyRequest.h"
+#include "model/CertificatePublicKeyVerifyResult.h"
 #include "model/CreateAliasRequest.h"
 #include "model/CreateAliasResult.h"
+#include "model/CreateCertificateRequest.h"
+#include "model/CreateCertificateResult.h"
 #include "model/CreateKeyRequest.h"
 #include "model/CreateKeyResult.h"
 #include "model/CreateKeyVersionRequest.h"
@@ -44,12 +54,16 @@
 #include "model/DecryptResult.h"
 #include "model/DeleteAliasRequest.h"
 #include "model/DeleteAliasResult.h"
+#include "model/DeleteCertificateRequest.h"
+#include "model/DeleteCertificateResult.h"
 #include "model/DeleteKeyMaterialRequest.h"
 #include "model/DeleteKeyMaterialResult.h"
 #include "model/DeleteSecretRequest.h"
 #include "model/DeleteSecretResult.h"
 #include "model/DescribeAccountKmsStatusRequest.h"
 #include "model/DescribeAccountKmsStatusResult.h"
+#include "model/DescribeCertificateRequest.h"
+#include "model/DescribeCertificateResult.h"
 #include "model/DescribeKeyRequest.h"
 #include "model/DescribeKeyResult.h"
 #include "model/DescribeKeyVersionRequest.h"
@@ -66,6 +80,8 @@
 #include "model/EnableKeyResult.h"
 #include "model/EncryptRequest.h"
 #include "model/EncryptResult.h"
+#include "model/ExportCertificateRequest.h"
+#include "model/ExportCertificateResult.h"
 #include "model/ExportDataKeyRequest.h"
 #include "model/ExportDataKeyResult.h"
 #include "model/GenerateAndExportDataKeyRequest.h"
@@ -74,6 +90,8 @@
 #include "model/GenerateDataKeyResult.h"
 #include "model/GenerateDataKeyWithoutPlaintextRequest.h"
 #include "model/GenerateDataKeyWithoutPlaintextResult.h"
+#include "model/GetCertificateRequest.h"
+#include "model/GetCertificateResult.h"
 #include "model/GetParametersForImportRequest.h"
 #include "model/GetParametersForImportResult.h"
 #include "model/GetPublicKeyRequest.h"
@@ -82,12 +100,18 @@
 #include "model/GetRandomPasswordResult.h"
 #include "model/GetSecretValueRequest.h"
 #include "model/GetSecretValueResult.h"
+#include "model/ImportCertificateRequest.h"
+#include "model/ImportCertificateResult.h"
+#include "model/ImportEncryptionCertificateRequest.h"
+#include "model/ImportEncryptionCertificateResult.h"
 #include "model/ImportKeyMaterialRequest.h"
 #include "model/ImportKeyMaterialResult.h"
 #include "model/ListAliasesRequest.h"
 #include "model/ListAliasesResult.h"
 #include "model/ListAliasesByKeyIdRequest.h"
 #include "model/ListAliasesByKeyIdResult.h"
+#include "model/ListCertificatesRequest.h"
+#include "model/ListCertificatesResult.h"
 #include "model/ListKeyVersionsRequest.h"
 #include "model/ListKeyVersionsResult.h"
 #include "model/ListKeysRequest.h"
@@ -114,6 +138,8 @@
 #include "model/UntagResourceResult.h"
 #include "model/UpdateAliasRequest.h"
 #include "model/UpdateAliasResult.h"
+#include "model/UpdateCertificateStatusRequest.h"
+#include "model/UpdateCertificateStatusResult.h"
 #include "model/UpdateKeyDescriptionRequest.h"
 #include "model/UpdateKeyDescriptionResult.h"
 #include "model/UpdateRotationPolicyRequest.h"
@@ -122,6 +148,8 @@
 #include "model/UpdateSecretResult.h"
 #include "model/UpdateSecretVersionStageRequest.h"
 #include "model/UpdateSecretVersionStageResult.h"
+#include "model/UploadCertificateRequest.h"
+#include "model/UploadCertificateResult.h"
 
 
 namespace AlibabaCloud
@@ -146,9 +174,24 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CancelKeyDeletionResult> CancelKeyDeletionOutcome;
 			typedef std::future<CancelKeyDeletionOutcome> CancelKeyDeletionOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::CancelKeyDeletionRequest&, const CancelKeyDeletionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CancelKeyDeletionAsyncHandler;
+			typedef Outcome<Error, Model::CertificatePrivateKeyDecryptResult> CertificatePrivateKeyDecryptOutcome;
+			typedef std::future<CertificatePrivateKeyDecryptOutcome> CertificatePrivateKeyDecryptOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::CertificatePrivateKeyDecryptRequest&, const CertificatePrivateKeyDecryptOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CertificatePrivateKeyDecryptAsyncHandler;
+			typedef Outcome<Error, Model::CertificatePrivateKeySignResult> CertificatePrivateKeySignOutcome;
+			typedef std::future<CertificatePrivateKeySignOutcome> CertificatePrivateKeySignOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::CertificatePrivateKeySignRequest&, const CertificatePrivateKeySignOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CertificatePrivateKeySignAsyncHandler;
+			typedef Outcome<Error, Model::CertificatePublicKeyEncryptResult> CertificatePublicKeyEncryptOutcome;
+			typedef std::future<CertificatePublicKeyEncryptOutcome> CertificatePublicKeyEncryptOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::CertificatePublicKeyEncryptRequest&, const CertificatePublicKeyEncryptOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CertificatePublicKeyEncryptAsyncHandler;
+			typedef Outcome<Error, Model::CertificatePublicKeyVerifyResult> CertificatePublicKeyVerifyOutcome;
+			typedef std::future<CertificatePublicKeyVerifyOutcome> CertificatePublicKeyVerifyOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::CertificatePublicKeyVerifyRequest&, const CertificatePublicKeyVerifyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CertificatePublicKeyVerifyAsyncHandler;
 			typedef Outcome<Error, Model::CreateAliasResult> CreateAliasOutcome;
 			typedef std::future<CreateAliasOutcome> CreateAliasOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::CreateAliasRequest&, const CreateAliasOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAliasAsyncHandler;
+			typedef Outcome<Error, Model::CreateCertificateResult> CreateCertificateOutcome;
+			typedef std::future<CreateCertificateOutcome> CreateCertificateOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::CreateCertificateRequest&, const CreateCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCertificateAsyncHandler;
 			typedef Outcome<Error, Model::CreateKeyResult> CreateKeyOutcome;
 			typedef std::future<CreateKeyOutcome> CreateKeyOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::CreateKeyRequest&, const CreateKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateKeyAsyncHandler;
@@ -164,6 +207,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteAliasResult> DeleteAliasOutcome;
 			typedef std::future<DeleteAliasOutcome> DeleteAliasOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::DeleteAliasRequest&, const DeleteAliasOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAliasAsyncHandler;
+			typedef Outcome<Error, Model::DeleteCertificateResult> DeleteCertificateOutcome;
+			typedef std::future<DeleteCertificateOutcome> DeleteCertificateOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::DeleteCertificateRequest&, const DeleteCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCertificateAsyncHandler;
 			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;
@@ -173,6 +219,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeAccountKmsStatusResult> DescribeAccountKmsStatusOutcome;
 			typedef std::future<DescribeAccountKmsStatusOutcome> DescribeAccountKmsStatusOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::DescribeAccountKmsStatusRequest&, const DescribeAccountKmsStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccountKmsStatusAsyncHandler;
+			typedef Outcome<Error, Model::DescribeCertificateResult> DescribeCertificateOutcome;
+			typedef std::future<DescribeCertificateOutcome> DescribeCertificateOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::DescribeCertificateRequest&, const DescribeCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCertificateAsyncHandler;
 			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;
@@ -197,6 +246,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::EncryptResult> EncryptOutcome;
 			typedef std::future<EncryptOutcome> EncryptOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::EncryptRequest&, const EncryptOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EncryptAsyncHandler;
+			typedef Outcome<Error, Model::ExportCertificateResult> ExportCertificateOutcome;
+			typedef std::future<ExportCertificateOutcome> ExportCertificateOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::ExportCertificateRequest&, const ExportCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExportCertificateAsyncHandler;
 			typedef Outcome<Error, Model::ExportDataKeyResult> ExportDataKeyOutcome;
 			typedef std::future<ExportDataKeyOutcome> ExportDataKeyOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::ExportDataKeyRequest&, const ExportDataKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExportDataKeyAsyncHandler;
@@ -209,6 +261,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GenerateDataKeyWithoutPlaintextResult> GenerateDataKeyWithoutPlaintextOutcome;
 			typedef std::future<GenerateDataKeyWithoutPlaintextOutcome> GenerateDataKeyWithoutPlaintextOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::GenerateDataKeyWithoutPlaintextRequest&, const GenerateDataKeyWithoutPlaintextOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateDataKeyWithoutPlaintextAsyncHandler;
+			typedef Outcome<Error, Model::GetCertificateResult> GetCertificateOutcome;
+			typedef std::future<GetCertificateOutcome> GetCertificateOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::GetCertificateRequest&, const GetCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetCertificateAsyncHandler;
 			typedef Outcome<Error, Model::GetParametersForImportResult> GetParametersForImportOutcome;
 			typedef std::future<GetParametersForImportOutcome> GetParametersForImportOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::GetParametersForImportRequest&, const GetParametersForImportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetParametersForImportAsyncHandler;
@@ -221,6 +276,12 @@ namespace AlibabaCloud
 			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::ImportCertificateResult> ImportCertificateOutcome;
+			typedef std::future<ImportCertificateOutcome> ImportCertificateOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::ImportCertificateRequest&, const ImportCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImportCertificateAsyncHandler;
+			typedef Outcome<Error, Model::ImportEncryptionCertificateResult> ImportEncryptionCertificateOutcome;
+			typedef std::future<ImportEncryptionCertificateOutcome> ImportEncryptionCertificateOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::ImportEncryptionCertificateRequest&, const ImportEncryptionCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImportEncryptionCertificateAsyncHandler;
 			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;
@@ -230,6 +291,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListAliasesByKeyIdResult> ListAliasesByKeyIdOutcome;
 			typedef std::future<ListAliasesByKeyIdOutcome> ListAliasesByKeyIdOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::ListAliasesByKeyIdRequest&, const ListAliasesByKeyIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAliasesByKeyIdAsyncHandler;
+			typedef Outcome<Error, Model::ListCertificatesResult> ListCertificatesOutcome;
+			typedef std::future<ListCertificatesOutcome> ListCertificatesOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::ListCertificatesRequest&, const ListCertificatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCertificatesAsyncHandler;
 			typedef Outcome<Error, Model::ListKeyVersionsResult> ListKeyVersionsOutcome;
 			typedef std::future<ListKeyVersionsOutcome> ListKeyVersionsOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::ListKeyVersionsRequest&, const ListKeyVersionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListKeyVersionsAsyncHandler;
@@ -269,6 +333,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateAliasResult> UpdateAliasOutcome;
 			typedef std::future<UpdateAliasOutcome> UpdateAliasOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::UpdateAliasRequest&, const UpdateAliasOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAliasAsyncHandler;
+			typedef Outcome<Error, Model::UpdateCertificateStatusResult> UpdateCertificateStatusOutcome;
+			typedef std::future<UpdateCertificateStatusOutcome> UpdateCertificateStatusOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::UpdateCertificateStatusRequest&, const UpdateCertificateStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateCertificateStatusAsyncHandler;
 			typedef Outcome<Error, Model::UpdateKeyDescriptionResult> UpdateKeyDescriptionOutcome;
 			typedef std::future<UpdateKeyDescriptionOutcome> UpdateKeyDescriptionOutcomeCallable;
 			typedef std::function<void(const KmsClient*, const Model::UpdateKeyDescriptionRequest&, const UpdateKeyDescriptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateKeyDescriptionAsyncHandler;
@@ -281,6 +348,9 @@ namespace AlibabaCloud
 			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;
+			typedef Outcome<Error, Model::UploadCertificateResult> UploadCertificateOutcome;
+			typedef std::future<UploadCertificateOutcome> UploadCertificateOutcomeCallable;
+			typedef std::function<void(const KmsClient*, const Model::UploadCertificateRequest&, const UploadCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UploadCertificateAsyncHandler;
 
 			KmsClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			KmsClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
@@ -301,9 +371,24 @@ namespace AlibabaCloud
 			CancelKeyDeletionOutcome cancelKeyDeletion(const Model::CancelKeyDeletionRequest &request)const;
 			void cancelKeyDeletionAsync(const Model::CancelKeyDeletionRequest& request, const CancelKeyDeletionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CancelKeyDeletionOutcomeCallable cancelKeyDeletionCallable(const Model::CancelKeyDeletionRequest& request) const;
+			CertificatePrivateKeyDecryptOutcome certificatePrivateKeyDecrypt(const Model::CertificatePrivateKeyDecryptRequest &request)const;
+			void certificatePrivateKeyDecryptAsync(const Model::CertificatePrivateKeyDecryptRequest& request, const CertificatePrivateKeyDecryptAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CertificatePrivateKeyDecryptOutcomeCallable certificatePrivateKeyDecryptCallable(const Model::CertificatePrivateKeyDecryptRequest& request) const;
+			CertificatePrivateKeySignOutcome certificatePrivateKeySign(const Model::CertificatePrivateKeySignRequest &request)const;
+			void certificatePrivateKeySignAsync(const Model::CertificatePrivateKeySignRequest& request, const CertificatePrivateKeySignAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CertificatePrivateKeySignOutcomeCallable certificatePrivateKeySignCallable(const Model::CertificatePrivateKeySignRequest& request) const;
+			CertificatePublicKeyEncryptOutcome certificatePublicKeyEncrypt(const Model::CertificatePublicKeyEncryptRequest &request)const;
+			void certificatePublicKeyEncryptAsync(const Model::CertificatePublicKeyEncryptRequest& request, const CertificatePublicKeyEncryptAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CertificatePublicKeyEncryptOutcomeCallable certificatePublicKeyEncryptCallable(const Model::CertificatePublicKeyEncryptRequest& request) const;
+			CertificatePublicKeyVerifyOutcome certificatePublicKeyVerify(const Model::CertificatePublicKeyVerifyRequest &request)const;
+			void certificatePublicKeyVerifyAsync(const Model::CertificatePublicKeyVerifyRequest& request, const CertificatePublicKeyVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CertificatePublicKeyVerifyOutcomeCallable certificatePublicKeyVerifyCallable(const Model::CertificatePublicKeyVerifyRequest& request) const;
 			CreateAliasOutcome createAlias(const Model::CreateAliasRequest &request)const;
 			void createAliasAsync(const Model::CreateAliasRequest& request, const CreateAliasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateAliasOutcomeCallable createAliasCallable(const Model::CreateAliasRequest& request) const;
+			CreateCertificateOutcome createCertificate(const Model::CreateCertificateRequest &request)const;
+			void createCertificateAsync(const Model::CreateCertificateRequest& request, const CreateCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateCertificateOutcomeCallable createCertificateCallable(const Model::CreateCertificateRequest& request) const;
 			CreateKeyOutcome createKey(const Model::CreateKeyRequest &request)const;
 			void createKeyAsync(const Model::CreateKeyRequest& request, const CreateKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateKeyOutcomeCallable createKeyCallable(const Model::CreateKeyRequest& request) const;
@@ -319,6 +404,9 @@ namespace AlibabaCloud
 			DeleteAliasOutcome deleteAlias(const Model::DeleteAliasRequest &request)const;
 			void deleteAliasAsync(const Model::DeleteAliasRequest& request, const DeleteAliasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteAliasOutcomeCallable deleteAliasCallable(const Model::DeleteAliasRequest& request) const;
+			DeleteCertificateOutcome deleteCertificate(const Model::DeleteCertificateRequest &request)const;
+			void deleteCertificateAsync(const Model::DeleteCertificateRequest& request, const DeleteCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteCertificateOutcomeCallable deleteCertificateCallable(const Model::DeleteCertificateRequest& request) const;
 			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;
@@ -328,6 +416,9 @@ namespace AlibabaCloud
 			DescribeAccountKmsStatusOutcome describeAccountKmsStatus(const Model::DescribeAccountKmsStatusRequest &request)const;
 			void describeAccountKmsStatusAsync(const Model::DescribeAccountKmsStatusRequest& request, const DescribeAccountKmsStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeAccountKmsStatusOutcomeCallable describeAccountKmsStatusCallable(const Model::DescribeAccountKmsStatusRequest& request) const;
+			DescribeCertificateOutcome describeCertificate(const Model::DescribeCertificateRequest &request)const;
+			void describeCertificateAsync(const Model::DescribeCertificateRequest& request, const DescribeCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeCertificateOutcomeCallable describeCertificateCallable(const Model::DescribeCertificateRequest& 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;
@@ -352,6 +443,9 @@ namespace AlibabaCloud
 			EncryptOutcome encrypt(const Model::EncryptRequest &request)const;
 			void encryptAsync(const Model::EncryptRequest& request, const EncryptAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			EncryptOutcomeCallable encryptCallable(const Model::EncryptRequest& request) const;
+			ExportCertificateOutcome exportCertificate(const Model::ExportCertificateRequest &request)const;
+			void exportCertificateAsync(const Model::ExportCertificateRequest& request, const ExportCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ExportCertificateOutcomeCallable exportCertificateCallable(const Model::ExportCertificateRequest& request) const;
 			ExportDataKeyOutcome exportDataKey(const Model::ExportDataKeyRequest &request)const;
 			void exportDataKeyAsync(const Model::ExportDataKeyRequest& request, const ExportDataKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ExportDataKeyOutcomeCallable exportDataKeyCallable(const Model::ExportDataKeyRequest& request) const;
@@ -364,6 +458,9 @@ namespace AlibabaCloud
 			GenerateDataKeyWithoutPlaintextOutcome generateDataKeyWithoutPlaintext(const Model::GenerateDataKeyWithoutPlaintextRequest &request)const;
 			void generateDataKeyWithoutPlaintextAsync(const Model::GenerateDataKeyWithoutPlaintextRequest& request, const GenerateDataKeyWithoutPlaintextAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GenerateDataKeyWithoutPlaintextOutcomeCallable generateDataKeyWithoutPlaintextCallable(const Model::GenerateDataKeyWithoutPlaintextRequest& request) const;
+			GetCertificateOutcome getCertificate(const Model::GetCertificateRequest &request)const;
+			void getCertificateAsync(const Model::GetCertificateRequest& request, const GetCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetCertificateOutcomeCallable getCertificateCallable(const Model::GetCertificateRequest& request) const;
 			GetParametersForImportOutcome getParametersForImport(const Model::GetParametersForImportRequest &request)const;
 			void getParametersForImportAsync(const Model::GetParametersForImportRequest& request, const GetParametersForImportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetParametersForImportOutcomeCallable getParametersForImportCallable(const Model::GetParametersForImportRequest& request) const;
@@ -376,6 +473,12 @@ namespace AlibabaCloud
 			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;
+			ImportCertificateOutcome importCertificate(const Model::ImportCertificateRequest &request)const;
+			void importCertificateAsync(const Model::ImportCertificateRequest& request, const ImportCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ImportCertificateOutcomeCallable importCertificateCallable(const Model::ImportCertificateRequest& request) const;
+			ImportEncryptionCertificateOutcome importEncryptionCertificate(const Model::ImportEncryptionCertificateRequest &request)const;
+			void importEncryptionCertificateAsync(const Model::ImportEncryptionCertificateRequest& request, const ImportEncryptionCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ImportEncryptionCertificateOutcomeCallable importEncryptionCertificateCallable(const Model::ImportEncryptionCertificateRequest& 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;
@@ -385,6 +488,9 @@ namespace AlibabaCloud
 			ListAliasesByKeyIdOutcome listAliasesByKeyId(const Model::ListAliasesByKeyIdRequest &request)const;
 			void listAliasesByKeyIdAsync(const Model::ListAliasesByKeyIdRequest& request, const ListAliasesByKeyIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListAliasesByKeyIdOutcomeCallable listAliasesByKeyIdCallable(const Model::ListAliasesByKeyIdRequest& request) const;
+			ListCertificatesOutcome listCertificates(const Model::ListCertificatesRequest &request)const;
+			void listCertificatesAsync(const Model::ListCertificatesRequest& request, const ListCertificatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListCertificatesOutcomeCallable listCertificatesCallable(const Model::ListCertificatesRequest& request) const;
 			ListKeyVersionsOutcome listKeyVersions(const Model::ListKeyVersionsRequest &request)const;
 			void listKeyVersionsAsync(const Model::ListKeyVersionsRequest& request, const ListKeyVersionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListKeyVersionsOutcomeCallable listKeyVersionsCallable(const Model::ListKeyVersionsRequest& request) const;
@@ -424,6 +530,9 @@ namespace AlibabaCloud
 			UpdateAliasOutcome updateAlias(const Model::UpdateAliasRequest &request)const;
 			void updateAliasAsync(const Model::UpdateAliasRequest& request, const UpdateAliasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateAliasOutcomeCallable updateAliasCallable(const Model::UpdateAliasRequest& request) const;
+			UpdateCertificateStatusOutcome updateCertificateStatus(const Model::UpdateCertificateStatusRequest &request)const;
+			void updateCertificateStatusAsync(const Model::UpdateCertificateStatusRequest& request, const UpdateCertificateStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateCertificateStatusOutcomeCallable updateCertificateStatusCallable(const Model::UpdateCertificateStatusRequest& request) const;
 			UpdateKeyDescriptionOutcome updateKeyDescription(const Model::UpdateKeyDescriptionRequest &request)const;
 			void updateKeyDescriptionAsync(const Model::UpdateKeyDescriptionRequest& request, const UpdateKeyDescriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateKeyDescriptionOutcomeCallable updateKeyDescriptionCallable(const Model::UpdateKeyDescriptionRequest& request) const;
@@ -436,6 +545,9 @@ namespace AlibabaCloud
 			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;
+			UploadCertificateOutcome uploadCertificate(const Model::UploadCertificateRequest &request)const;
+			void uploadCertificateAsync(const Model::UploadCertificateRequest& request, const UploadCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UploadCertificateOutcomeCallable uploadCertificateCallable(const Model::UploadCertificateRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

kms/include/alibabacloud/kms/model/CertificatePrivateKeyDecryptRequest.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_CERTIFICATEPRIVATEKEYDECRYPTREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_CERTIFICATEPRIVATEKEYDECRYPTREQUEST_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 CertificatePrivateKeyDecryptRequest : public RpcServiceRequest
+			{
+
+			public:
+				CertificatePrivateKeyDecryptRequest();
+				~CertificatePrivateKeyDecryptRequest();
+
+				std::string getCertificateId()const;
+				void setCertificateId(const std::string& certificateId);
+				std::string getAlgorithm()const;
+				void setAlgorithm(const std::string& algorithm);
+				std::string getCiphertextBlob()const;
+				void setCiphertextBlob(const std::string& ciphertextBlob);
+
+            private:
+				std::string certificateId_;
+				std::string algorithm_;
+				std::string ciphertextBlob_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_CERTIFICATEPRIVATEKEYDECRYPTREQUEST_H_

kms/include/alibabacloud/kms/model/CertificatePrivateKeyDecryptResult.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_CERTIFICATEPRIVATEKEYDECRYPTRESULT_H_
+#define ALIBABACLOUD_KMS_MODEL_CERTIFICATEPRIVATEKEYDECRYPTRESULT_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 CertificatePrivateKeyDecryptResult : public ServiceResult
+			{
+			public:
+
+
+				CertificatePrivateKeyDecryptResult();
+				explicit CertificatePrivateKeyDecryptResult(const std::string &payload);
+				~CertificatePrivateKeyDecryptResult();
+				std::string getCertificateId()const;
+				std::string getPlaintext()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string certificateId_;
+				std::string plaintext_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_CERTIFICATEPRIVATEKEYDECRYPTRESULT_H_

kms/include/alibabacloud/kms/model/CertificatePrivateKeySignRequest.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_CERTIFICATEPRIVATEKEYSIGNREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_CERTIFICATEPRIVATEKEYSIGNREQUEST_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 CertificatePrivateKeySignRequest : public RpcServiceRequest
+			{
+
+			public:
+				CertificatePrivateKeySignRequest();
+				~CertificatePrivateKeySignRequest();
+
+				std::string getMessageType()const;
+				void setMessageType(const std::string& messageType);
+				std::string getCertificateId()const;
+				void setCertificateId(const std::string& certificateId);
+				std::string getMessage()const;
+				void setMessage(const std::string& message);
+				std::string getAlgorithm()const;
+				void setAlgorithm(const std::string& algorithm);
+
+            private:
+				std::string messageType_;
+				std::string certificateId_;
+				std::string message_;
+				std::string algorithm_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_CERTIFICATEPRIVATEKEYSIGNREQUEST_H_

kms/include/alibabacloud/kms/model/CertificatePrivateKeySignResult.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_CERTIFICATEPRIVATEKEYSIGNRESULT_H_
+#define ALIBABACLOUD_KMS_MODEL_CERTIFICATEPRIVATEKEYSIGNRESULT_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 CertificatePrivateKeySignResult : public ServiceResult
+			{
+			public:
+
+
+				CertificatePrivateKeySignResult();
+				explicit CertificatePrivateKeySignResult(const std::string &payload);
+				~CertificatePrivateKeySignResult();
+				std::string getSignatureValue()const;
+				std::string getCertificateId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string signatureValue_;
+				std::string certificateId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_CERTIFICATEPRIVATEKEYSIGNRESULT_H_

kms/include/alibabacloud/kms/model/CertificatePublicKeyEncryptRequest.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_CERTIFICATEPUBLICKEYENCRYPTREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_CERTIFICATEPUBLICKEYENCRYPTREQUEST_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 CertificatePublicKeyEncryptRequest : public RpcServiceRequest
+			{
+
+			public:
+				CertificatePublicKeyEncryptRequest();
+				~CertificatePublicKeyEncryptRequest();
+
+				std::string getCertificateId()const;
+				void setCertificateId(const std::string& certificateId);
+				std::string getPlaintext()const;
+				void setPlaintext(const std::string& plaintext);
+				std::string getAlgorithm()const;
+				void setAlgorithm(const std::string& algorithm);
+
+            private:
+				std::string certificateId_;
+				std::string plaintext_;
+				std::string algorithm_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_CERTIFICATEPUBLICKEYENCRYPTREQUEST_H_

kms/include/alibabacloud/kms/model/CertificatePublicKeyEncryptResult.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_CERTIFICATEPUBLICKEYENCRYPTRESULT_H_
+#define ALIBABACLOUD_KMS_MODEL_CERTIFICATEPUBLICKEYENCRYPTRESULT_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 CertificatePublicKeyEncryptResult : public ServiceResult
+			{
+			public:
+
+
+				CertificatePublicKeyEncryptResult();
+				explicit CertificatePublicKeyEncryptResult(const std::string &payload);
+				~CertificatePublicKeyEncryptResult();
+				std::string getCertificateId()const;
+				std::string getCiphertextBlob()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string certificateId_;
+				std::string ciphertextBlob_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_CERTIFICATEPUBLICKEYENCRYPTRESULT_H_

kms/include/alibabacloud/kms/model/CertificatePublicKeyVerifyRequest.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_CERTIFICATEPUBLICKEYVERIFYREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_CERTIFICATEPUBLICKEYVERIFYREQUEST_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 CertificatePublicKeyVerifyRequest : public RpcServiceRequest
+			{
+
+			public:
+				CertificatePublicKeyVerifyRequest();
+				~CertificatePublicKeyVerifyRequest();
+
+				std::string getSignatureValue()const;
+				void setSignatureValue(const std::string& signatureValue);
+				std::string getMessageType()const;
+				void setMessageType(const std::string& messageType);
+				std::string getCertificateId()const;
+				void setCertificateId(const std::string& certificateId);
+				std::string getMessage()const;
+				void setMessage(const std::string& message);
+				std::string getAlgorithm()const;
+				void setAlgorithm(const std::string& algorithm);
+
+            private:
+				std::string signatureValue_;
+				std::string messageType_;
+				std::string certificateId_;
+				std::string message_;
+				std::string algorithm_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_CERTIFICATEPUBLICKEYVERIFYREQUEST_H_

kms/include/alibabacloud/kms/model/CertificatePublicKeyVerifyResult.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_CERTIFICATEPUBLICKEYVERIFYRESULT_H_
+#define ALIBABACLOUD_KMS_MODEL_CERTIFICATEPUBLICKEYVERIFYRESULT_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 CertificatePublicKeyVerifyResult : public ServiceResult
+			{
+			public:
+
+
+				CertificatePublicKeyVerifyResult();
+				explicit CertificatePublicKeyVerifyResult(const std::string &payload);
+				~CertificatePublicKeyVerifyResult();
+				std::string getCertificateId()const;
+				bool getSignatureValid()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string certificateId_;
+				bool signatureValid_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_CERTIFICATEPUBLICKEYVERIFYRESULT_H_

kms/include/alibabacloud/kms/model/CreateCertificateRequest.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_CREATECERTIFICATEREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_CREATECERTIFICATEREQUEST_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 CreateCertificateRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateCertificateRequest();
+				~CreateCertificateRequest();
+
+				std::string getProtectionLevel()const;
+				void setProtectionLevel(const std::string& protectionLevel);
+				std::string getSubject()const;
+				void setSubject(const std::string& subject);
+				std::map<std::string, std::string> getSubjectAlternativeNames()const;
+				void setSubjectAlternativeNames(const std::map<std::string, std::string>& subjectAlternativeNames);
+				std::string getKeySpec()const;
+				void setKeySpec(const std::string& keySpec);
+
+            private:
+				std::string protectionLevel_;
+				std::string subject_;
+				std::map<std::string, std::string> subjectAlternativeNames_;
+				std::string keySpec_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_CREATECERTIFICATEREQUEST_H_

kms/include/alibabacloud/kms/model/CreateCertificateResult.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_CREATECERTIFICATERESULT_H_
+#define ALIBABACLOUD_KMS_MODEL_CREATECERTIFICATERESULT_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 CreateCertificateResult : public ServiceResult
+			{
+			public:
+
+
+				CreateCertificateResult();
+				explicit CreateCertificateResult(const std::string &payload);
+				~CreateCertificateResult();
+				std::string getCsr()const;
+				std::string getCertificateId()const;
+				std::string getArn()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string csr_;
+				std::string certificateId_;
+				std::string arn_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_CREATECERTIFICATERESULT_H_

kms/include/alibabacloud/kms/model/DeleteCertificateRequest.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_DELETECERTIFICATEREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_DELETECERTIFICATEREQUEST_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 DeleteCertificateRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteCertificateRequest();
+				~DeleteCertificateRequest();
+
+				std::string getCertificateId()const;
+				void setCertificateId(const std::string& certificateId);
+
+            private:
+				std::string certificateId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_DELETECERTIFICATEREQUEST_H_

kms/include/alibabacloud/kms/model/DeleteCertificateResult.h

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

kms/include/alibabacloud/kms/model/DescribeCertificateRequest.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_DESCRIBECERTIFICATEREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_DESCRIBECERTIFICATEREQUEST_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 DescribeCertificateRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeCertificateRequest();
+				~DescribeCertificateRequest();
+
+				std::string getCertificateId()const;
+				void setCertificateId(const std::string& certificateId);
+
+            private:
+				std::string certificateId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_DESCRIBECERTIFICATEREQUEST_H_

kms/include/alibabacloud/kms/model/DescribeCertificateResult.h

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_KMS_MODEL_DESCRIBECERTIFICATERESULT_H_
+#define ALIBABACLOUD_KMS_MODEL_DESCRIBECERTIFICATERESULT_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 DescribeCertificateResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeCertificateResult();
+				explicit DescribeCertificateResult(const std::string &payload);
+				~DescribeCertificateResult();
+				std::string getStatus()const;
+				std::string getProtectionLevel()const;
+				std::string getIssuer()const;
+				std::string getCertificateId()const;
+				std::string getKeySpec()const;
+				std::string getCreatedAt()const;
+				std::vector<std::string> getSubjectAlternativeNames()const;
+				std::string getSignatureAlgorithm()const;
+				std::string getSubjectKeyIdentifier()const;
+				std::string getNotAfter()const;
+				std::string getUpdatedAt()const;
+				std::string getSubject()const;
+				std::string getSerial()const;
+				std::string getSubjectPublicKey()const;
+				std::string getArn()const;
+				std::string getNotBefore()const;
+				std::string getTags()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string status_;
+				std::string protectionLevel_;
+				std::string issuer_;
+				std::string certificateId_;
+				std::string keySpec_;
+				std::string createdAt_;
+				std::vector<std::string> subjectAlternativeNames_;
+				std::string signatureAlgorithm_;
+				std::string subjectKeyIdentifier_;
+				std::string notAfter_;
+				std::string updatedAt_;
+				std::string subject_;
+				std::string serial_;
+				std::string subjectPublicKey_;
+				std::string arn_;
+				std::string notBefore_;
+				std::string tags_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_DESCRIBECERTIFICATERESULT_H_

kms/include/alibabacloud/kms/model/ExportCertificateRequest.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_EXPORTCERTIFICATEREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_EXPORTCERTIFICATEREQUEST_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 ExportCertificateRequest : public RpcServiceRequest
+			{
+
+			public:
+				ExportCertificateRequest();
+				~ExportCertificateRequest();
+
+				std::string getCertificateId()const;
+				void setCertificateId(const std::string& certificateId);
+				std::string getPassphrase()const;
+				void setPassphrase(const std::string& passphrase);
+				std::string getExportFormat()const;
+				void setExportFormat(const std::string& exportFormat);
+
+            private:
+				std::string certificateId_;
+				std::string passphrase_;
+				std::string exportFormat_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_EXPORTCERTIFICATEREQUEST_H_

kms/include/alibabacloud/kms/model/ExportCertificateResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_KMS_MODEL_EXPORTCERTIFICATERESULT_H_
+#define ALIBABACLOUD_KMS_MODEL_EXPORTCERTIFICATERESULT_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 ExportCertificateResult : public ServiceResult
+			{
+			public:
+
+
+				ExportCertificateResult();
+				explicit ExportCertificateResult(const std::string &payload);
+				~ExportCertificateResult();
+				std::string getPrivateKey()const;
+				std::string getCertificateId()const;
+				std::string getCertificateChain()const;
+				std::string getPKCS12Blob()const;
+				std::string getCertificate()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string privateKey_;
+				std::string certificateId_;
+				std::string certificateChain_;
+				std::string pKCS12Blob_;
+				std::string certificate_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_EXPORTCERTIFICATERESULT_H_

kms/include/alibabacloud/kms/model/GetCertificateRequest.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_GETCERTIFICATEREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_GETCERTIFICATEREQUEST_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 GetCertificateRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetCertificateRequest();
+				~GetCertificateRequest();
+
+				std::string getCertificateId()const;
+				void setCertificateId(const std::string& certificateId);
+
+            private:
+				std::string certificateId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_GETCERTIFICATEREQUEST_H_

kms/include/alibabacloud/kms/model/GetCertificateResult.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_GETCERTIFICATERESULT_H_
+#define ALIBABACLOUD_KMS_MODEL_GETCERTIFICATERESULT_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 GetCertificateResult : public ServiceResult
+			{
+			public:
+
+
+				GetCertificateResult();
+				explicit GetCertificateResult(const std::string &payload);
+				~GetCertificateResult();
+				std::string getCsr()const;
+				std::string getCertificateId()const;
+				std::string getCertificateChain()const;
+				std::string getCertificate()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string csr_;
+				std::string certificateId_;
+				std::string certificateChain_;
+				std::string certificate_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_GETCERTIFICATERESULT_H_

kms/include/alibabacloud/kms/model/ImportCertificateRequest.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_IMPORTCERTIFICATEREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_IMPORTCERTIFICATEREQUEST_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 ImportCertificateRequest : public RpcServiceRequest
+			{
+
+			public:
+				ImportCertificateRequest();
+				~ImportCertificateRequest();
+
+				std::string getPKCS12Blob()const;
+				void setPKCS12Blob(const std::string& pKCS12Blob);
+				std::string getPassphrase()const;
+				void setPassphrase(const std::string& passphrase);
+
+            private:
+				std::string pKCS12Blob_;
+				std::string passphrase_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_IMPORTCERTIFICATEREQUEST_H_

kms/include/alibabacloud/kms/model/ImportCertificateResult.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_IMPORTCERTIFICATERESULT_H_
+#define ALIBABACLOUD_KMS_MODEL_IMPORTCERTIFICATERESULT_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 ImportCertificateResult : public ServiceResult
+			{
+			public:
+
+
+				ImportCertificateResult();
+				explicit ImportCertificateResult(const std::string &payload);
+				~ImportCertificateResult();
+				std::string getCertificateId()const;
+				std::string getArn()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string certificateId_;
+				std::string arn_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_IMPORTCERTIFICATERESULT_H_

kms/include/alibabacloud/kms/model/ImportEncryptionCertificateRequest.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_IMPORTENCRYPTIONCERTIFICATEREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_IMPORTENCRYPTIONCERTIFICATEREQUEST_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 ImportEncryptionCertificateRequest : public RpcServiceRequest
+			{
+
+			public:
+				ImportEncryptionCertificateRequest();
+				~ImportEncryptionCertificateRequest();
+
+				std::string getAsymmetricAlgorithm()const;
+				void setAsymmetricAlgorithm(const std::string& asymmetricAlgorithm);
+				std::string getSymmetricAlgorithm()const;
+				void setSymmetricAlgorithm(const std::string& symmetricAlgorithm);
+				std::string getEncryptedPrivateKey()const;
+				void setEncryptedPrivateKey(const std::string& encryptedPrivateKey);
+				std::string getEncryptedSymmetricKey()const;
+				void setEncryptedSymmetricKey(const std::string& encryptedSymmetricKey);
+				std::string getCertificateId()const;
+				void setCertificateId(const std::string& certificateId);
+				std::string getCertificate()const;
+				void setCertificate(const std::string& certificate);
+				std::string getCertificateChain()const;
+				void setCertificateChain(const std::string& certificateChain);
+
+            private:
+				std::string asymmetricAlgorithm_;
+				std::string symmetricAlgorithm_;
+				std::string encryptedPrivateKey_;
+				std::string encryptedSymmetricKey_;
+				std::string certificateId_;
+				std::string certificate_;
+				std::string certificateChain_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_IMPORTENCRYPTIONCERTIFICATEREQUEST_H_

kms/include/alibabacloud/kms/model/ImportEncryptionCertificateResult.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_IMPORTENCRYPTIONCERTIFICATERESULT_H_
+#define ALIBABACLOUD_KMS_MODEL_IMPORTENCRYPTIONCERTIFICATERESULT_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 ImportEncryptionCertificateResult : public ServiceResult
+			{
+			public:
+
+
+				ImportEncryptionCertificateResult();
+				explicit ImportEncryptionCertificateResult(const std::string &payload);
+				~ImportEncryptionCertificateResult();
+				std::string getCertificateId()const;
+				std::string getArn()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string certificateId_;
+				std::string arn_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_IMPORTENCRYPTIONCERTIFICATERESULT_H_

kms/include/alibabacloud/kms/model/ListCertificatesRequest.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_LISTCERTIFICATESREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_LISTCERTIFICATESREQUEST_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 ListCertificatesRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListCertificatesRequest();
+				~ListCertificatesRequest();
+
+				std::string getSubject()const;
+				void setSubject(const std::string& subject);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getIssuer()const;
+				void setIssuer(const std::string& issuer);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getStatus()const;
+				void setStatus(const std::string& status);
+
+            private:
+				std::string subject_;
+				int pageSize_;
+				std::string issuer_;
+				int pageNumber_;
+				std::string status_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_LISTCERTIFICATESREQUEST_H_

kms/include/alibabacloud/kms/model/ListCertificatesResult.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_KMS_MODEL_LISTCERTIFICATESRESULT_H_
+#define ALIBABACLOUD_KMS_MODEL_LISTCERTIFICATESRESULT_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 ListCertificatesResult : public ServiceResult
+			{
+			public:
+				struct CertificateSummary
+				{
+					std::string status;
+					std::string protectionLevel;
+					std::string issuer;
+					std::string certificateId;
+					std::string keySpec;
+					std::string notBefore;
+					std::string notAfter;
+					std::string subject;
+				};
+
+
+				ListCertificatesResult();
+				explicit ListCertificatesResult(const std::string &payload);
+				~ListCertificatesResult();
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<CertificateSummary> getCertificateSummaryList()const;
+				int getTotalSize()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int pageSize_;
+				int pageNumber_;
+				std::vector<CertificateSummary> certificateSummaryList_;
+				int totalSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_LISTCERTIFICATESRESULT_H_

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

@@ -35,6 +35,8 @@ namespace AlibabaCloud
 				TagResourceRequest();
 				~TagResourceRequest();
 
+				std::string getCertificateId()const;
+				void setCertificateId(const std::string& certificateId);
 				std::string getKeyId()const;
 				void setKeyId(const std::string& keyId);
 				std::string getSecretName()const;
@@ -43,6 +45,7 @@ namespace AlibabaCloud
 				void setTags(const std::string& tags);
 
             private:
+				std::string certificateId_;
 				std::string keyId_;
 				std::string secretName_;
 				std::string tags_;

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

@@ -35,6 +35,8 @@ namespace AlibabaCloud
 				UntagResourceRequest();
 				~UntagResourceRequest();
 
+				std::string getCertificateId()const;
+				void setCertificateId(const std::string& certificateId);
 				std::string getTagKeys()const;
 				void setTagKeys(const std::string& tagKeys);
 				std::string getKeyId()const;
@@ -43,6 +45,7 @@ namespace AlibabaCloud
 				void setSecretName(const std::string& secretName);
 
             private:
+				std::string certificateId_;
 				std::string tagKeys_;
 				std::string keyId_;
 				std::string secretName_;

kms/include/alibabacloud/kms/model/UpdateCertificateStatusRequest.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_UPDATECERTIFICATESTATUSREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_UPDATECERTIFICATESTATUSREQUEST_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 UpdateCertificateStatusRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateCertificateStatusRequest();
+				~UpdateCertificateStatusRequest();
+
+				std::string getCertificateId()const;
+				void setCertificateId(const std::string& certificateId);
+				std::string getStatus()const;
+				void setStatus(const std::string& status);
+
+            private:
+				std::string certificateId_;
+				std::string status_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_UPDATECERTIFICATESTATUSREQUEST_H_

kms/include/alibabacloud/kms/model/UpdateCertificateStatusResult.h

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

kms/include/alibabacloud/kms/model/UploadCertificateRequest.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_UPLOADCERTIFICATEREQUEST_H_
+#define ALIBABACLOUD_KMS_MODEL_UPLOADCERTIFICATEREQUEST_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 UploadCertificateRequest : public RpcServiceRequest
+			{
+
+			public:
+				UploadCertificateRequest();
+				~UploadCertificateRequest();
+
+				std::string getCertificateId()const;
+				void setCertificateId(const std::string& certificateId);
+				std::string getCertificate()const;
+				void setCertificate(const std::string& certificate);
+				std::string getCertificateChain()const;
+				void setCertificateChain(const std::string& certificateChain);
+
+            private:
+				std::string certificateId_;
+				std::string certificate_;
+				std::string certificateChain_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_KMS_MODEL_UPLOADCERTIFICATEREQUEST_H_

kms/include/alibabacloud/kms/model/UploadCertificateResult.h

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

kms/src/KmsClient.cc

@@ -31,21 +31,21 @@ KmsClient::KmsClient(const Credentials &credentials, const ClientConfiguration &
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "kms");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "kms-service");
 }
 
 KmsClient::KmsClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "kms");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "kms-service");
 }
 
 KmsClient::KmsClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "kms");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "kms-service");
 }
 
 KmsClient::~KmsClient()
@@ -231,6 +231,150 @@ KmsClient::CancelKeyDeletionOutcomeCallable KmsClient::cancelKeyDeletionCallable
 	return task->get_future();
 }
 
+KmsClient::CertificatePrivateKeyDecryptOutcome KmsClient::certificatePrivateKeyDecrypt(const CertificatePrivateKeyDecryptRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CertificatePrivateKeyDecryptOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CertificatePrivateKeyDecryptOutcome(CertificatePrivateKeyDecryptResult(outcome.result()));
+	else
+		return CertificatePrivateKeyDecryptOutcome(outcome.error());
+}
+
+void KmsClient::certificatePrivateKeyDecryptAsync(const CertificatePrivateKeyDecryptRequest& request, const CertificatePrivateKeyDecryptAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, certificatePrivateKeyDecrypt(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::CertificatePrivateKeyDecryptOutcomeCallable KmsClient::certificatePrivateKeyDecryptCallable(const CertificatePrivateKeyDecryptRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CertificatePrivateKeyDecryptOutcome()>>(
+			[this, request]()
+			{
+			return this->certificatePrivateKeyDecrypt(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+KmsClient::CertificatePrivateKeySignOutcome KmsClient::certificatePrivateKeySign(const CertificatePrivateKeySignRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CertificatePrivateKeySignOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CertificatePrivateKeySignOutcome(CertificatePrivateKeySignResult(outcome.result()));
+	else
+		return CertificatePrivateKeySignOutcome(outcome.error());
+}
+
+void KmsClient::certificatePrivateKeySignAsync(const CertificatePrivateKeySignRequest& request, const CertificatePrivateKeySignAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, certificatePrivateKeySign(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::CertificatePrivateKeySignOutcomeCallable KmsClient::certificatePrivateKeySignCallable(const CertificatePrivateKeySignRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CertificatePrivateKeySignOutcome()>>(
+			[this, request]()
+			{
+			return this->certificatePrivateKeySign(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+KmsClient::CertificatePublicKeyEncryptOutcome KmsClient::certificatePublicKeyEncrypt(const CertificatePublicKeyEncryptRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CertificatePublicKeyEncryptOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CertificatePublicKeyEncryptOutcome(CertificatePublicKeyEncryptResult(outcome.result()));
+	else
+		return CertificatePublicKeyEncryptOutcome(outcome.error());
+}
+
+void KmsClient::certificatePublicKeyEncryptAsync(const CertificatePublicKeyEncryptRequest& request, const CertificatePublicKeyEncryptAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, certificatePublicKeyEncrypt(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::CertificatePublicKeyEncryptOutcomeCallable KmsClient::certificatePublicKeyEncryptCallable(const CertificatePublicKeyEncryptRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CertificatePublicKeyEncryptOutcome()>>(
+			[this, request]()
+			{
+			return this->certificatePublicKeyEncrypt(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+KmsClient::CertificatePublicKeyVerifyOutcome KmsClient::certificatePublicKeyVerify(const CertificatePublicKeyVerifyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CertificatePublicKeyVerifyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CertificatePublicKeyVerifyOutcome(CertificatePublicKeyVerifyResult(outcome.result()));
+	else
+		return CertificatePublicKeyVerifyOutcome(outcome.error());
+}
+
+void KmsClient::certificatePublicKeyVerifyAsync(const CertificatePublicKeyVerifyRequest& request, const CertificatePublicKeyVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, certificatePublicKeyVerify(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::CertificatePublicKeyVerifyOutcomeCallable KmsClient::certificatePublicKeyVerifyCallable(const CertificatePublicKeyVerifyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CertificatePublicKeyVerifyOutcome()>>(
+			[this, request]()
+			{
+			return this->certificatePublicKeyVerify(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 KmsClient::CreateAliasOutcome KmsClient::createAlias(const CreateAliasRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -267,6 +411,42 @@ KmsClient::CreateAliasOutcomeCallable KmsClient::createAliasCallable(const Creat
 	return task->get_future();
 }
 
+KmsClient::CreateCertificateOutcome KmsClient::createCertificate(const CreateCertificateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateCertificateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateCertificateOutcome(CreateCertificateResult(outcome.result()));
+	else
+		return CreateCertificateOutcome(outcome.error());
+}
+
+void KmsClient::createCertificateAsync(const CreateCertificateRequest& request, const CreateCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createCertificate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::CreateCertificateOutcomeCallable KmsClient::createCertificateCallable(const CreateCertificateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateCertificateOutcome()>>(
+			[this, request]()
+			{
+			return this->createCertificate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 KmsClient::CreateKeyOutcome KmsClient::createKey(const CreateKeyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -447,6 +627,42 @@ KmsClient::DeleteAliasOutcomeCallable KmsClient::deleteAliasCallable(const Delet
 	return task->get_future();
 }
 
+KmsClient::DeleteCertificateOutcome KmsClient::deleteCertificate(const DeleteCertificateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteCertificateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteCertificateOutcome(DeleteCertificateResult(outcome.result()));
+	else
+		return DeleteCertificateOutcome(outcome.error());
+}
+
+void KmsClient::deleteCertificateAsync(const DeleteCertificateRequest& request, const DeleteCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteCertificate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::DeleteCertificateOutcomeCallable KmsClient::deleteCertificateCallable(const DeleteCertificateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteCertificateOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteCertificate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 KmsClient::DeleteKeyMaterialOutcome KmsClient::deleteKeyMaterial(const DeleteKeyMaterialRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -555,6 +771,42 @@ KmsClient::DescribeAccountKmsStatusOutcomeCallable KmsClient::describeAccountKms
 	return task->get_future();
 }
 
+KmsClient::DescribeCertificateOutcome KmsClient::describeCertificate(const DescribeCertificateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeCertificateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeCertificateOutcome(DescribeCertificateResult(outcome.result()));
+	else
+		return DescribeCertificateOutcome(outcome.error());
+}
+
+void KmsClient::describeCertificateAsync(const DescribeCertificateRequest& request, const DescribeCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeCertificate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::DescribeCertificateOutcomeCallable KmsClient::describeCertificateCallable(const DescribeCertificateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeCertificateOutcome()>>(
+			[this, request]()
+			{
+			return this->describeCertificate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 KmsClient::DescribeKeyOutcome KmsClient::describeKey(const DescribeKeyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -843,6 +1095,42 @@ KmsClient::EncryptOutcomeCallable KmsClient::encryptCallable(const EncryptReques
 	return task->get_future();
 }
 
+KmsClient::ExportCertificateOutcome KmsClient::exportCertificate(const ExportCertificateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ExportCertificateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ExportCertificateOutcome(ExportCertificateResult(outcome.result()));
+	else
+		return ExportCertificateOutcome(outcome.error());
+}
+
+void KmsClient::exportCertificateAsync(const ExportCertificateRequest& request, const ExportCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, exportCertificate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::ExportCertificateOutcomeCallable KmsClient::exportCertificateCallable(const ExportCertificateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ExportCertificateOutcome()>>(
+			[this, request]()
+			{
+			return this->exportCertificate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 KmsClient::ExportDataKeyOutcome KmsClient::exportDataKey(const ExportDataKeyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -987,6 +1275,42 @@ KmsClient::GenerateDataKeyWithoutPlaintextOutcomeCallable KmsClient::generateDat
 	return task->get_future();
 }
 
+KmsClient::GetCertificateOutcome KmsClient::getCertificate(const GetCertificateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetCertificateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetCertificateOutcome(GetCertificateResult(outcome.result()));
+	else
+		return GetCertificateOutcome(outcome.error());
+}
+
+void KmsClient::getCertificateAsync(const GetCertificateRequest& request, const GetCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getCertificate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::GetCertificateOutcomeCallable KmsClient::getCertificateCallable(const GetCertificateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetCertificateOutcome()>>(
+			[this, request]()
+			{
+			return this->getCertificate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 KmsClient::GetParametersForImportOutcome KmsClient::getParametersForImport(const GetParametersForImportRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1131,6 +1455,78 @@ KmsClient::GetSecretValueOutcomeCallable KmsClient::getSecretValueCallable(const
 	return task->get_future();
 }
 
+KmsClient::ImportCertificateOutcome KmsClient::importCertificate(const ImportCertificateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ImportCertificateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ImportCertificateOutcome(ImportCertificateResult(outcome.result()));
+	else
+		return ImportCertificateOutcome(outcome.error());
+}
+
+void KmsClient::importCertificateAsync(const ImportCertificateRequest& request, const ImportCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, importCertificate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::ImportCertificateOutcomeCallable KmsClient::importCertificateCallable(const ImportCertificateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ImportCertificateOutcome()>>(
+			[this, request]()
+			{
+			return this->importCertificate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+KmsClient::ImportEncryptionCertificateOutcome KmsClient::importEncryptionCertificate(const ImportEncryptionCertificateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ImportEncryptionCertificateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ImportEncryptionCertificateOutcome(ImportEncryptionCertificateResult(outcome.result()));
+	else
+		return ImportEncryptionCertificateOutcome(outcome.error());
+}
+
+void KmsClient::importEncryptionCertificateAsync(const ImportEncryptionCertificateRequest& request, const ImportEncryptionCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, importEncryptionCertificate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::ImportEncryptionCertificateOutcomeCallable KmsClient::importEncryptionCertificateCallable(const ImportEncryptionCertificateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ImportEncryptionCertificateOutcome()>>(
+			[this, request]()
+			{
+			return this->importEncryptionCertificate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 KmsClient::ImportKeyMaterialOutcome KmsClient::importKeyMaterial(const ImportKeyMaterialRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1239,6 +1635,42 @@ KmsClient::ListAliasesByKeyIdOutcomeCallable KmsClient::listAliasesByKeyIdCallab
 	return task->get_future();
 }
 
+KmsClient::ListCertificatesOutcome KmsClient::listCertificates(const ListCertificatesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListCertificatesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListCertificatesOutcome(ListCertificatesResult(outcome.result()));
+	else
+		return ListCertificatesOutcome(outcome.error());
+}
+
+void KmsClient::listCertificatesAsync(const ListCertificatesRequest& request, const ListCertificatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listCertificates(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::ListCertificatesOutcomeCallable KmsClient::listCertificatesCallable(const ListCertificatesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListCertificatesOutcome()>>(
+			[this, request]()
+			{
+			return this->listCertificates(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 KmsClient::ListKeyVersionsOutcome KmsClient::listKeyVersions(const ListKeyVersionsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1707,6 +2139,42 @@ KmsClient::UpdateAliasOutcomeCallable KmsClient::updateAliasCallable(const Updat
 	return task->get_future();
 }
 
+KmsClient::UpdateCertificateStatusOutcome KmsClient::updateCertificateStatus(const UpdateCertificateStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateCertificateStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateCertificateStatusOutcome(UpdateCertificateStatusResult(outcome.result()));
+	else
+		return UpdateCertificateStatusOutcome(outcome.error());
+}
+
+void KmsClient::updateCertificateStatusAsync(const UpdateCertificateStatusRequest& request, const UpdateCertificateStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateCertificateStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::UpdateCertificateStatusOutcomeCallable KmsClient::updateCertificateStatusCallable(const UpdateCertificateStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateCertificateStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->updateCertificateStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 KmsClient::UpdateKeyDescriptionOutcome KmsClient::updateKeyDescription(const UpdateKeyDescriptionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1851,3 +2319,39 @@ KmsClient::UpdateSecretVersionStageOutcomeCallable KmsClient::updateSecretVersio
 	return task->get_future();
 }
 
+KmsClient::UploadCertificateOutcome KmsClient::uploadCertificate(const UploadCertificateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UploadCertificateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UploadCertificateOutcome(UploadCertificateResult(outcome.result()));
+	else
+		return UploadCertificateOutcome(outcome.error());
+}
+
+void KmsClient::uploadCertificateAsync(const UploadCertificateRequest& request, const UploadCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, uploadCertificate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+KmsClient::UploadCertificateOutcomeCallable KmsClient::uploadCertificateCallable(const UploadCertificateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UploadCertificateOutcome()>>(
+			[this, request]()
+			{
+			return this->uploadCertificate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

kms/src/model/CertificatePrivateKeyDecryptRequest.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/CertificatePrivateKeyDecryptRequest.h>
+
+using AlibabaCloud::Kms::Model::CertificatePrivateKeyDecryptRequest;
+
+CertificatePrivateKeyDecryptRequest::CertificatePrivateKeyDecryptRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "CertificatePrivateKeyDecrypt")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CertificatePrivateKeyDecryptRequest::~CertificatePrivateKeyDecryptRequest()
+{}
+
+std::string CertificatePrivateKeyDecryptRequest::getCertificateId()const
+{
+	return certificateId_;
+}
+
+void CertificatePrivateKeyDecryptRequest::setCertificateId(const std::string& certificateId)
+{
+	certificateId_ = certificateId;
+	setParameter("CertificateId", certificateId);
+}
+
+std::string CertificatePrivateKeyDecryptRequest::getAlgorithm()const
+{
+	return algorithm_;
+}
+
+void CertificatePrivateKeyDecryptRequest::setAlgorithm(const std::string& algorithm)
+{
+	algorithm_ = algorithm;
+	setParameter("Algorithm", algorithm);
+}
+
+std::string CertificatePrivateKeyDecryptRequest::getCiphertextBlob()const
+{
+	return ciphertextBlob_;
+}
+
+void CertificatePrivateKeyDecryptRequest::setCiphertextBlob(const std::string& ciphertextBlob)
+{
+	ciphertextBlob_ = ciphertextBlob;
+	setParameter("CiphertextBlob", ciphertextBlob);
+}
+

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

kms/src/model/CertificatePrivateKeySignRequest.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/CertificatePrivateKeySignRequest.h>
+
+using AlibabaCloud::Kms::Model::CertificatePrivateKeySignRequest;
+
+CertificatePrivateKeySignRequest::CertificatePrivateKeySignRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "CertificatePrivateKeySign")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CertificatePrivateKeySignRequest::~CertificatePrivateKeySignRequest()
+{}
+
+std::string CertificatePrivateKeySignRequest::getMessageType()const
+{
+	return messageType_;
+}
+
+void CertificatePrivateKeySignRequest::setMessageType(const std::string& messageType)
+{
+	messageType_ = messageType;
+	setParameter("MessageType", messageType);
+}
+
+std::string CertificatePrivateKeySignRequest::getCertificateId()const
+{
+	return certificateId_;
+}
+
+void CertificatePrivateKeySignRequest::setCertificateId(const std::string& certificateId)
+{
+	certificateId_ = certificateId;
+	setParameter("CertificateId", certificateId);
+}
+
+std::string CertificatePrivateKeySignRequest::getMessage()const
+{
+	return message_;
+}
+
+void CertificatePrivateKeySignRequest::setMessage(const std::string& message)
+{
+	message_ = message;
+	setParameter("Message", message);
+}
+
+std::string CertificatePrivateKeySignRequest::getAlgorithm()const
+{
+	return algorithm_;
+}
+
+void CertificatePrivateKeySignRequest::setAlgorithm(const std::string& algorithm)
+{
+	algorithm_ = algorithm;
+	setParameter("Algorithm", algorithm);
+}
+

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

kms/src/model/CertificatePublicKeyEncryptRequest.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/CertificatePublicKeyEncryptRequest.h>
+
+using AlibabaCloud::Kms::Model::CertificatePublicKeyEncryptRequest;
+
+CertificatePublicKeyEncryptRequest::CertificatePublicKeyEncryptRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "CertificatePublicKeyEncrypt")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CertificatePublicKeyEncryptRequest::~CertificatePublicKeyEncryptRequest()
+{}
+
+std::string CertificatePublicKeyEncryptRequest::getCertificateId()const
+{
+	return certificateId_;
+}
+
+void CertificatePublicKeyEncryptRequest::setCertificateId(const std::string& certificateId)
+{
+	certificateId_ = certificateId;
+	setParameter("CertificateId", certificateId);
+}
+
+std::string CertificatePublicKeyEncryptRequest::getPlaintext()const
+{
+	return plaintext_;
+}
+
+void CertificatePublicKeyEncryptRequest::setPlaintext(const std::string& plaintext)
+{
+	plaintext_ = plaintext;
+	setParameter("Plaintext", plaintext);
+}
+
+std::string CertificatePublicKeyEncryptRequest::getAlgorithm()const
+{
+	return algorithm_;
+}
+
+void CertificatePublicKeyEncryptRequest::setAlgorithm(const std::string& algorithm)
+{
+	algorithm_ = algorithm;
+	setParameter("Algorithm", algorithm);
+}
+

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

kms/src/model/CertificatePublicKeyVerifyRequest.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/CertificatePublicKeyVerifyRequest.h>
+
+using AlibabaCloud::Kms::Model::CertificatePublicKeyVerifyRequest;
+
+CertificatePublicKeyVerifyRequest::CertificatePublicKeyVerifyRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "CertificatePublicKeyVerify")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CertificatePublicKeyVerifyRequest::~CertificatePublicKeyVerifyRequest()
+{}
+
+std::string CertificatePublicKeyVerifyRequest::getSignatureValue()const
+{
+	return signatureValue_;
+}
+
+void CertificatePublicKeyVerifyRequest::setSignatureValue(const std::string& signatureValue)
+{
+	signatureValue_ = signatureValue;
+	setParameter("SignatureValue", signatureValue);
+}
+
+std::string CertificatePublicKeyVerifyRequest::getMessageType()const
+{
+	return messageType_;
+}
+
+void CertificatePublicKeyVerifyRequest::setMessageType(const std::string& messageType)
+{
+	messageType_ = messageType;
+	setParameter("MessageType", messageType);
+}
+
+std::string CertificatePublicKeyVerifyRequest::getCertificateId()const
+{
+	return certificateId_;
+}
+
+void CertificatePublicKeyVerifyRequest::setCertificateId(const std::string& certificateId)
+{
+	certificateId_ = certificateId;
+	setParameter("CertificateId", certificateId);
+}
+
+std::string CertificatePublicKeyVerifyRequest::getMessage()const
+{
+	return message_;
+}
+
+void CertificatePublicKeyVerifyRequest::setMessage(const std::string& message)
+{
+	message_ = message;
+	setParameter("Message", message);
+}
+
+std::string CertificatePublicKeyVerifyRequest::getAlgorithm()const
+{
+	return algorithm_;
+}
+
+void CertificatePublicKeyVerifyRequest::setAlgorithm(const std::string& algorithm)
+{
+	algorithm_ = algorithm;
+	setParameter("Algorithm", algorithm);
+}
+

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

kms/src/model/CreateCertificateRequest.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/CreateCertificateRequest.h>
+
+using AlibabaCloud::Kms::Model::CreateCertificateRequest;
+
+CreateCertificateRequest::CreateCertificateRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "CreateCertificate")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateCertificateRequest::~CreateCertificateRequest()
+{}
+
+std::string CreateCertificateRequest::getProtectionLevel()const
+{
+	return protectionLevel_;
+}
+
+void CreateCertificateRequest::setProtectionLevel(const std::string& protectionLevel)
+{
+	protectionLevel_ = protectionLevel;
+	setParameter("ProtectionLevel", protectionLevel);
+}
+
+std::string CreateCertificateRequest::getSubject()const
+{
+	return subject_;
+}
+
+void CreateCertificateRequest::setSubject(const std::string& subject)
+{
+	subject_ = subject;
+	setParameter("Subject", subject);
+}
+
+std::map<std::string, std::string> CreateCertificateRequest::getSubjectAlternativeNames()const
+{
+	return subjectAlternativeNames_;
+}
+
+void CreateCertificateRequest::setSubjectAlternativeNames(const std::map<std::string, std::string>& subjectAlternativeNames)
+{
+	subjectAlternativeNames_ = subjectAlternativeNames;
+	setJsonParameters("SubjectAlternativeNames", subjectAlternativeNames);
+}
+
+std::string CreateCertificateRequest::getKeySpec()const
+{
+	return keySpec_;
+}
+
+void CreateCertificateRequest::setKeySpec(const std::string& keySpec)
+{
+	keySpec_ = keySpec;
+	setParameter("KeySpec", keySpec);
+}
+

kms/src/model/CreateCertificateResult.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/CreateCertificateResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Kms;
+using namespace AlibabaCloud::Kms::Model;
+
+CreateCertificateResult::CreateCertificateResult() :
+	ServiceResult()
+{}
+
+CreateCertificateResult::CreateCertificateResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateCertificateResult::~CreateCertificateResult()
+{}
+
+void CreateCertificateResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["CertificateId"].isNull())
+		certificateId_ = value["CertificateId"].asString();
+	if(!value["Arn"].isNull())
+		arn_ = value["Arn"].asString();
+	if(!value["Csr"].isNull())
+		csr_ = value["Csr"].asString();
+
+}
+
+std::string CreateCertificateResult::getCsr()const
+{
+	return csr_;
+}
+
+std::string CreateCertificateResult::getCertificateId()const
+{
+	return certificateId_;
+}
+
+std::string CreateCertificateResult::getArn()const
+{
+	return arn_;
+}
+

kms/src/model/DeleteCertificateRequest.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/DeleteCertificateRequest.h>
+
+using AlibabaCloud::Kms::Model::DeleteCertificateRequest;
+
+DeleteCertificateRequest::DeleteCertificateRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "DeleteCertificate")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteCertificateRequest::~DeleteCertificateRequest()
+{}
+
+std::string DeleteCertificateRequest::getCertificateId()const
+{
+	return certificateId_;
+}
+
+void DeleteCertificateRequest::setCertificateId(const std::string& certificateId)
+{
+	certificateId_ = certificateId;
+	setParameter("CertificateId", certificateId);
+}
+

kms/src/model/DeleteCertificateResult.cc

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

kms/src/model/DescribeCertificateRequest.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/DescribeCertificateRequest.h>
+
+using AlibabaCloud::Kms::Model::DescribeCertificateRequest;
+
+DescribeCertificateRequest::DescribeCertificateRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "DescribeCertificate")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeCertificateRequest::~DescribeCertificateRequest()
+{}
+
+std::string DescribeCertificateRequest::getCertificateId()const
+{
+	return certificateId_;
+}
+
+void DescribeCertificateRequest::setCertificateId(const std::string& certificateId)
+{
+	certificateId_ = certificateId;
+	setParameter("CertificateId", certificateId);
+}
+

kms/src/model/DescribeCertificateResult.cc

@@ -0,0 +1,164 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DescribeCertificateResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Kms;
+using namespace AlibabaCloud::Kms::Model;
+
+DescribeCertificateResult::DescribeCertificateResult() :
+	ServiceResult()
+{}
+
+DescribeCertificateResult::DescribeCertificateResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeCertificateResult::~DescribeCertificateResult()
+{}
+
+void DescribeCertificateResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allSubjectAlternativeNames = value["SubjectAlternativeNames"]["SubjectAlternativeName"];
+	for (const auto &item : allSubjectAlternativeNames)
+		subjectAlternativeNames_.push_back(item.asString());
+	if(!value["CertificateId"].isNull())
+		certificateId_ = value["CertificateId"].asString();
+	if(!value["Arn"].isNull())
+		arn_ = value["Arn"].asString();
+	if(!value["KeySpec"].isNull())
+		keySpec_ = value["KeySpec"].asString();
+	if(!value["ProtectionLevel"].isNull())
+		protectionLevel_ = value["ProtectionLevel"].asString();
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["CreatedAt"].isNull())
+		createdAt_ = value["CreatedAt"].asString();
+	if(!value["UpdatedAt"].isNull())
+		updatedAt_ = value["UpdatedAt"].asString();
+	if(!value["Serial"].isNull())
+		serial_ = value["Serial"].asString();
+	if(!value["Subject"].isNull())
+		subject_ = value["Subject"].asString();
+	if(!value["Issuer"].isNull())
+		issuer_ = value["Issuer"].asString();
+	if(!value["NotBefore"].isNull())
+		notBefore_ = value["NotBefore"].asString();
+	if(!value["NotAfter"].isNull())
+		notAfter_ = value["NotAfter"].asString();
+	if(!value["SignatureAlgorithm"].isNull())
+		signatureAlgorithm_ = value["SignatureAlgorithm"].asString();
+	if(!value["SubjectPublicKey"].isNull())
+		subjectPublicKey_ = value["SubjectPublicKey"].asString();
+	if(!value["SubjectKeyIdentifier"].isNull())
+		subjectKeyIdentifier_ = value["SubjectKeyIdentifier"].asString();
+	if(!value["Tags"].isNull())
+		tags_ = value["Tags"].asString();
+
+}
+
+std::string DescribeCertificateResult::getStatus()const
+{
+	return status_;
+}
+
+std::string DescribeCertificateResult::getProtectionLevel()const
+{
+	return protectionLevel_;
+}
+
+std::string DescribeCertificateResult::getIssuer()const
+{
+	return issuer_;
+}
+
+std::string DescribeCertificateResult::getCertificateId()const
+{
+	return certificateId_;
+}
+
+std::string DescribeCertificateResult::getKeySpec()const
+{
+	return keySpec_;
+}
+
+std::string DescribeCertificateResult::getCreatedAt()const
+{
+	return createdAt_;
+}
+
+std::vector<std::string> DescribeCertificateResult::getSubjectAlternativeNames()const
+{
+	return subjectAlternativeNames_;
+}
+
+std::string DescribeCertificateResult::getSignatureAlgorithm()const
+{
+	return signatureAlgorithm_;
+}
+
+std::string DescribeCertificateResult::getSubjectKeyIdentifier()const
+{
+	return subjectKeyIdentifier_;
+}
+
+std::string DescribeCertificateResult::getNotAfter()const
+{
+	return notAfter_;
+}
+
+std::string DescribeCertificateResult::getUpdatedAt()const
+{
+	return updatedAt_;
+}
+
+std::string DescribeCertificateResult::getSubject()const
+{
+	return subject_;
+}
+
+std::string DescribeCertificateResult::getSerial()const
+{
+	return serial_;
+}
+
+std::string DescribeCertificateResult::getSubjectPublicKey()const
+{
+	return subjectPublicKey_;
+}
+
+std::string DescribeCertificateResult::getArn()const
+{
+	return arn_;
+}
+
+std::string DescribeCertificateResult::getNotBefore()const
+{
+	return notBefore_;
+}
+
+std::string DescribeCertificateResult::getTags()const
+{
+	return tags_;
+}
+

kms/src/model/ExportCertificateRequest.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/ExportCertificateRequest.h>
+
+using AlibabaCloud::Kms::Model::ExportCertificateRequest;
+
+ExportCertificateRequest::ExportCertificateRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "ExportCertificate")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ExportCertificateRequest::~ExportCertificateRequest()
+{}
+
+std::string ExportCertificateRequest::getCertificateId()const
+{
+	return certificateId_;
+}
+
+void ExportCertificateRequest::setCertificateId(const std::string& certificateId)
+{
+	certificateId_ = certificateId;
+	setParameter("CertificateId", certificateId);
+}
+
+std::string ExportCertificateRequest::getPassphrase()const
+{
+	return passphrase_;
+}
+
+void ExportCertificateRequest::setPassphrase(const std::string& passphrase)
+{
+	passphrase_ = passphrase;
+	setParameter("Passphrase", passphrase);
+}
+
+std::string ExportCertificateRequest::getExportFormat()const
+{
+	return exportFormat_;
+}
+
+void ExportCertificateRequest::setExportFormat(const std::string& exportFormat)
+{
+	exportFormat_ = exportFormat;
+	setParameter("ExportFormat", exportFormat);
+}
+

kms/src/model/ExportCertificateResult.cc

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ExportCertificateResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Kms;
+using namespace AlibabaCloud::Kms::Model;
+
+ExportCertificateResult::ExportCertificateResult() :
+	ServiceResult()
+{}
+
+ExportCertificateResult::ExportCertificateResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ExportCertificateResult::~ExportCertificateResult()
+{}
+
+void ExportCertificateResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["CertificateId"].isNull())
+		certificateId_ = value["CertificateId"].asString();
+	if(!value["Certificate"].isNull())
+		certificate_ = value["Certificate"].asString();
+	if(!value["CertificateChain"].isNull())
+		certificateChain_ = value["CertificateChain"].asString();
+	if(!value["PrivateKey"].isNull())
+		privateKey_ = value["PrivateKey"].asString();
+	if(!value["PKCS12Blob"].isNull())
+		pKCS12Blob_ = value["PKCS12Blob"].asString();
+
+}
+
+std::string ExportCertificateResult::getPrivateKey()const
+{
+	return privateKey_;
+}
+
+std::string ExportCertificateResult::getCertificateId()const
+{
+	return certificateId_;
+}
+
+std::string ExportCertificateResult::getCertificateChain()const
+{
+	return certificateChain_;
+}
+
+std::string ExportCertificateResult::getPKCS12Blob()const
+{
+	return pKCS12Blob_;
+}
+
+std::string ExportCertificateResult::getCertificate()const
+{
+	return certificate_;
+}
+

kms/src/model/GetCertificateRequest.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/GetCertificateRequest.h>
+
+using AlibabaCloud::Kms::Model::GetCertificateRequest;
+
+GetCertificateRequest::GetCertificateRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "GetCertificate")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetCertificateRequest::~GetCertificateRequest()
+{}
+
+std::string GetCertificateRequest::getCertificateId()const
+{
+	return certificateId_;
+}
+
+void GetCertificateRequest::setCertificateId(const std::string& certificateId)
+{
+	certificateId_ = certificateId;
+	setParameter("CertificateId", certificateId);
+}
+

kms/src/model/GetCertificateResult.cc

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

kms/src/model/ImportCertificateRequest.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/ImportCertificateRequest.h>
+
+using AlibabaCloud::Kms::Model::ImportCertificateRequest;
+
+ImportCertificateRequest::ImportCertificateRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "ImportCertificate")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ImportCertificateRequest::~ImportCertificateRequest()
+{}
+
+std::string ImportCertificateRequest::getPKCS12Blob()const
+{
+	return pKCS12Blob_;
+}
+
+void ImportCertificateRequest::setPKCS12Blob(const std::string& pKCS12Blob)
+{
+	pKCS12Blob_ = pKCS12Blob;
+	setParameter("PKCS12Blob", pKCS12Blob);
+}
+
+std::string ImportCertificateRequest::getPassphrase()const
+{
+	return passphrase_;
+}
+
+void ImportCertificateRequest::setPassphrase(const std::string& passphrase)
+{
+	passphrase_ = passphrase;
+	setParameter("Passphrase", passphrase);
+}
+

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

kms/src/model/ImportEncryptionCertificateRequest.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/ImportEncryptionCertificateRequest.h>
+
+using AlibabaCloud::Kms::Model::ImportEncryptionCertificateRequest;
+
+ImportEncryptionCertificateRequest::ImportEncryptionCertificateRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "ImportEncryptionCertificate")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ImportEncryptionCertificateRequest::~ImportEncryptionCertificateRequest()
+{}
+
+std::string ImportEncryptionCertificateRequest::getAsymmetricAlgorithm()const
+{
+	return asymmetricAlgorithm_;
+}
+
+void ImportEncryptionCertificateRequest::setAsymmetricAlgorithm(const std::string& asymmetricAlgorithm)
+{
+	asymmetricAlgorithm_ = asymmetricAlgorithm;
+	setParameter("AsymmetricAlgorithm", asymmetricAlgorithm);
+}
+
+std::string ImportEncryptionCertificateRequest::getSymmetricAlgorithm()const
+{
+	return symmetricAlgorithm_;
+}
+
+void ImportEncryptionCertificateRequest::setSymmetricAlgorithm(const std::string& symmetricAlgorithm)
+{
+	symmetricAlgorithm_ = symmetricAlgorithm;
+	setParameter("SymmetricAlgorithm", symmetricAlgorithm);
+}
+
+std::string ImportEncryptionCertificateRequest::getEncryptedPrivateKey()const
+{
+	return encryptedPrivateKey_;
+}
+
+void ImportEncryptionCertificateRequest::setEncryptedPrivateKey(const std::string& encryptedPrivateKey)
+{
+	encryptedPrivateKey_ = encryptedPrivateKey;
+	setParameter("EncryptedPrivateKey", encryptedPrivateKey);
+}
+
+std::string ImportEncryptionCertificateRequest::getEncryptedSymmetricKey()const
+{
+	return encryptedSymmetricKey_;
+}
+
+void ImportEncryptionCertificateRequest::setEncryptedSymmetricKey(const std::string& encryptedSymmetricKey)
+{
+	encryptedSymmetricKey_ = encryptedSymmetricKey;
+	setParameter("EncryptedSymmetricKey", encryptedSymmetricKey);
+}
+
+std::string ImportEncryptionCertificateRequest::getCertificateId()const
+{
+	return certificateId_;
+}
+
+void ImportEncryptionCertificateRequest::setCertificateId(const std::string& certificateId)
+{
+	certificateId_ = certificateId;
+	setParameter("CertificateId", certificateId);
+}
+
+std::string ImportEncryptionCertificateRequest::getCertificate()const
+{
+	return certificate_;
+}
+
+void ImportEncryptionCertificateRequest::setCertificate(const std::string& certificate)
+{
+	certificate_ = certificate;
+	setParameter("Certificate", certificate);
+}
+
+std::string ImportEncryptionCertificateRequest::getCertificateChain()const
+{
+	return certificateChain_;
+}
+
+void ImportEncryptionCertificateRequest::setCertificateChain(const std::string& certificateChain)
+{
+	certificateChain_ = certificateChain;
+	setParameter("CertificateChain", certificateChain);
+}
+

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

kms/src/model/ListCertificatesRequest.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/ListCertificatesRequest.h>
+
+using AlibabaCloud::Kms::Model::ListCertificatesRequest;
+
+ListCertificatesRequest::ListCertificatesRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "ListCertificates")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListCertificatesRequest::~ListCertificatesRequest()
+{}
+
+std::string ListCertificatesRequest::getSubject()const
+{
+	return subject_;
+}
+
+void ListCertificatesRequest::setSubject(const std::string& subject)
+{
+	subject_ = subject;
+	setParameter("Subject", subject);
+}
+
+int ListCertificatesRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListCertificatesRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string ListCertificatesRequest::getIssuer()const
+{
+	return issuer_;
+}
+
+void ListCertificatesRequest::setIssuer(const std::string& issuer)
+{
+	issuer_ = issuer;
+	setParameter("Issuer", issuer);
+}
+
+int ListCertificatesRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListCertificatesRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string ListCertificatesRequest::getStatus()const
+{
+	return status_;
+}
+
+void ListCertificatesRequest::setStatus(const std::string& status)
+{
+	status_ = status;
+	setParameter("Status", status);
+}
+

kms/src/model/ListCertificatesResult.cc

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/kms/model/ListCertificatesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Kms;
+using namespace AlibabaCloud::Kms::Model;
+
+ListCertificatesResult::ListCertificatesResult() :
+	ServiceResult()
+{}
+
+ListCertificatesResult::ListCertificatesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListCertificatesResult::~ListCertificatesResult()
+{}
+
+void ListCertificatesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allCertificateSummaryListNode = value["CertificateSummaryList"]["CertificateSummary"];
+	for (auto valueCertificateSummaryListCertificateSummary : allCertificateSummaryListNode)
+	{
+		CertificateSummary certificateSummaryListObject;
+		if(!valueCertificateSummaryListCertificateSummary["CertificateId"].isNull())
+			certificateSummaryListObject.certificateId = valueCertificateSummaryListCertificateSummary["CertificateId"].asString();
+		if(!valueCertificateSummaryListCertificateSummary["Subject"].isNull())
+			certificateSummaryListObject.subject = valueCertificateSummaryListCertificateSummary["Subject"].asString();
+		if(!valueCertificateSummaryListCertificateSummary["Issuer"].isNull())
+			certificateSummaryListObject.issuer = valueCertificateSummaryListCertificateSummary["Issuer"].asString();
+		if(!valueCertificateSummaryListCertificateSummary["KeySpec"].isNull())
+			certificateSummaryListObject.keySpec = valueCertificateSummaryListCertificateSummary["KeySpec"].asString();
+		if(!valueCertificateSummaryListCertificateSummary["ProtectionLevel"].isNull())
+			certificateSummaryListObject.protectionLevel = valueCertificateSummaryListCertificateSummary["ProtectionLevel"].asString();
+		if(!valueCertificateSummaryListCertificateSummary["NotBefore"].isNull())
+			certificateSummaryListObject.notBefore = valueCertificateSummaryListCertificateSummary["NotBefore"].asString();
+		if(!valueCertificateSummaryListCertificateSummary["NotAfter"].isNull())
+			certificateSummaryListObject.notAfter = valueCertificateSummaryListCertificateSummary["NotAfter"].asString();
+		if(!valueCertificateSummaryListCertificateSummary["Status"].isNull())
+			certificateSummaryListObject.status = valueCertificateSummaryListCertificateSummary["Status"].asString();
+		certificateSummaryList_.push_back(certificateSummaryListObject);
+	}
+	if(!value["TotalSize"].isNull())
+		totalSize_ = std::stoi(value["TotalSize"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+
+}
+
+int ListCertificatesResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int ListCertificatesResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<ListCertificatesResult::CertificateSummary> ListCertificatesResult::getCertificateSummaryList()const
+{
+	return certificateSummaryList_;
+}
+
+int ListCertificatesResult::getTotalSize()const
+{
+	return totalSize_;
+}
+

kms/src/model/ListSecretsResult.cc

@@ -51,14 +51,14 @@ void ListSecretsResult::parse(const std::string &payload)
 			secretListObject.secretName = valueSecretListSecret["SecretName"].asString();
 		if(!valueSecretListSecret["UpdateTime"].isNull())
 			secretListObject.updateTime = valueSecretListSecret["UpdateTime"].asString();
-		auto allTagsNode = allSecretListNode["Tags"]["Tag"];
-		for (auto allSecretListNodeTagsTag : allTagsNode)
+		auto allTagsNode = valueSecretListSecret["Tags"]["Tag"];
+		for (auto valueSecretListSecretTagsTag : allTagsNode)
 		{
 			Secret::Tag tagsObject;
-			if(!allSecretListNodeTagsTag["TagKey"].isNull())
-				tagsObject.tagKey = allSecretListNodeTagsTag["TagKey"].asString();
-			if(!allSecretListNodeTagsTag["TagValue"].isNull())
-				tagsObject.tagValue = allSecretListNodeTagsTag["TagValue"].asString();
+			if(!valueSecretListSecretTagsTag["TagKey"].isNull())
+				tagsObject.tagKey = valueSecretListSecretTagsTag["TagKey"].asString();
+			if(!valueSecretListSecretTagsTag["TagValue"].isNull())
+				tagsObject.tagValue = valueSecretListSecretTagsTag["TagValue"].asString();
 			secretListObject.tags.push_back(tagsObject);
 		}
 		secretList_.push_back(secretListObject);

kms/src/model/TagResourceRequest.cc

@@ -27,6 +27,17 @@ TagResourceRequest::TagResourceRequest() :
 TagResourceRequest::~TagResourceRequest()
 {}
 
+std::string TagResourceRequest::getCertificateId()const
+{
+	return certificateId_;
+}
+
+void TagResourceRequest::setCertificateId(const std::string& certificateId)
+{
+	certificateId_ = certificateId;
+	setParameter("CertificateId", certificateId);
+}
+
 std::string TagResourceRequest::getKeyId()const
 {
 	return keyId_;

kms/src/model/UntagResourceRequest.cc

@@ -27,6 +27,17 @@ UntagResourceRequest::UntagResourceRequest() :
 UntagResourceRequest::~UntagResourceRequest()
 {}
 
+std::string UntagResourceRequest::getCertificateId()const
+{
+	return certificateId_;
+}
+
+void UntagResourceRequest::setCertificateId(const std::string& certificateId)
+{
+	certificateId_ = certificateId;
+	setParameter("CertificateId", certificateId);
+}
+
 std::string UntagResourceRequest::getTagKeys()const
 {
 	return tagKeys_;

kms/src/model/UpdateCertificateStatusRequest.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/UpdateCertificateStatusRequest.h>
+
+using AlibabaCloud::Kms::Model::UpdateCertificateStatusRequest;
+
+UpdateCertificateStatusRequest::UpdateCertificateStatusRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "UpdateCertificateStatus")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+UpdateCertificateStatusRequest::~UpdateCertificateStatusRequest()
+{}
+
+std::string UpdateCertificateStatusRequest::getCertificateId()const
+{
+	return certificateId_;
+}
+
+void UpdateCertificateStatusRequest::setCertificateId(const std::string& certificateId)
+{
+	certificateId_ = certificateId;
+	setParameter("CertificateId", certificateId);
+}
+
+std::string UpdateCertificateStatusRequest::getStatus()const
+{
+	return status_;
+}
+
+void UpdateCertificateStatusRequest::setStatus(const std::string& status)
+{
+	status_ = status;
+	setParameter("Status", status);
+}
+

kms/src/model/UpdateCertificateStatusResult.cc

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

kms/src/model/UploadCertificateRequest.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/UploadCertificateRequest.h>
+
+using AlibabaCloud::Kms::Model::UploadCertificateRequest;
+
+UploadCertificateRequest::UploadCertificateRequest() :
+	RpcServiceRequest("kms", "2016-01-20", "UploadCertificate")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+UploadCertificateRequest::~UploadCertificateRequest()
+{}
+
+std::string UploadCertificateRequest::getCertificateId()const
+{
+	return certificateId_;
+}
+
+void UploadCertificateRequest::setCertificateId(const std::string& certificateId)
+{
+	certificateId_ = certificateId;
+	setParameter("CertificateId", certificateId);
+}
+
+std::string UploadCertificateRequest::getCertificate()const
+{
+	return certificate_;
+}
+
+void UploadCertificateRequest::setCertificate(const std::string& certificate)
+{
+	certificate_ = certificate;
+	setParameter("Certificate", certificate);
+}
+
+std::string UploadCertificateRequest::getCertificateChain()const
+{
+	return certificateChain_;
+}
+
+void UploadCertificateRequest::setCertificateChain(const std::string& certificateChain)
+{
+	certificateChain_ = certificateChain;
+	setParameter("CertificateChain", certificateChain);
+}
+

kms/src/model/UploadCertificateResult.cc

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