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

KMS SDK Auto Released By shenshi,Version：1.34.57

Browse Source 
Signed-off-by: haowei.yao <haowei.yao@alibaba-inc.com>
This commit is contained in:
haowei.yao
2019-03-21 17:12:57 +08:00
parent 50463a22aa
commit c98efebbad
95 changed files with 6224 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

222
kms/include/alibabacloud/kms/KmsClient.h Normal file
View File

@@ -0,0 +1,222 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_KMSCLIENT_H_
#define ALIBABACLOUD_KMS_KMSCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "KmsExport.h"
#include "model/ListAliasesRequest.h"
#include "model/ListAliasesResult.h"
#include "model/GenerateDataKeyRequest.h"
#include "model/GenerateDataKeyResult.h"
#include "model/CancelKeyDeletionRequest.h"
#include "model/CancelKeyDeletionResult.h"
#include "model/DisableKeyRequest.h"
#include "model/DisableKeyResult.h"
#include "model/DeleteAliasRequest.h"
#include "model/DeleteAliasResult.h"
#include "model/DecryptRequest.h"
#include "model/DecryptResult.h"
#include "model/TagResourceRequest.h"
#include "model/TagResourceResult.h"
#include "model/DescribeKeyRequest.h"
#include "model/DescribeKeyResult.h"
#include "model/CreateAliasRequest.h"
#include "model/CreateAliasResult.h"
#include "model/DeleteKeyMaterialRequest.h"
#include "model/DeleteKeyMaterialResult.h"
#include "model/ListResourceTagsRequest.h"
#include "model/ListResourceTagsResult.h"
#include "model/ImportKeyMaterialRequest.h"
#include "model/ImportKeyMaterialResult.h"
#include "model/EncryptRequest.h"
#include "model/EncryptResult.h"
#include "model/UntagResourceRequest.h"
#include "model/UntagResourceResult.h"
#include "model/UpdateAliasRequest.h"
#include "model/UpdateAliasResult.h"
#include "model/ListAliasesByKeyIdRequest.h"
#include "model/ListAliasesByKeyIdResult.h"
#include "model/EnableKeyRequest.h"
#include "model/EnableKeyResult.h"
#include "model/ScheduleKeyDeletionRequest.h"
#include "model/ScheduleKeyDeletionResult.h"
#include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h"
#include "model/ListKeysRequest.h"
#include "model/ListKeysResult.h"
#include "model/GetParametersForImportRequest.h"
#include "model/GetParametersForImportResult.h"
#include "model/CreateKeyRequest.h"
#include "model/CreateKeyResult.h"
namespace AlibabaCloud
{
namespace Kms
{
class ALIBABACLOUD_KMS_EXPORT KmsClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::ListAliasesResult> ListAliasesOutcome;
typedef std::future<ListAliasesOutcome> ListAliasesOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::ListAliasesRequest&, const ListAliasesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAliasesAsyncHandler;
typedef Outcome<Error, Model::GenerateDataKeyResult> GenerateDataKeyOutcome;
typedef std::future<GenerateDataKeyOutcome> GenerateDataKeyOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::GenerateDataKeyRequest&, const GenerateDataKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateDataKeyAsyncHandler;
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::DisableKeyResult> DisableKeyOutcome;
typedef std::future<DisableKeyOutcome> DisableKeyOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::DisableKeyRequest&, const DisableKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableKeyAsyncHandler;
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::DecryptResult> DecryptOutcome;
typedef std::future<DecryptOutcome> DecryptOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::DecryptRequest&, const DecryptOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DecryptAsyncHandler;
typedef Outcome<Error, Model::TagResourceResult> TagResourceOutcome;
typedef std::future<TagResourceOutcome> TagResourceOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::TagResourceRequest&, const TagResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TagResourceAsyncHandler;
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;
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::DeleteKeyMaterialResult> DeleteKeyMaterialOutcome;
typedef std::future<DeleteKeyMaterialOutcome> DeleteKeyMaterialOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::DeleteKeyMaterialRequest&, const DeleteKeyMaterialOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteKeyMaterialAsyncHandler;
typedef Outcome<Error, Model::ListResourceTagsResult> ListResourceTagsOutcome;
typedef std::future<ListResourceTagsOutcome> ListResourceTagsOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::ListResourceTagsRequest&, const ListResourceTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListResourceTagsAsyncHandler;
typedef Outcome<Error, Model::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;
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::UntagResourceResult> UntagResourceOutcome;
typedef std::future<UntagResourceOutcome> UntagResourceOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::UntagResourceRequest&, const UntagResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UntagResourceAsyncHandler;
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::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::EnableKeyResult> EnableKeyOutcome;
typedef std::future<EnableKeyOutcome> EnableKeyOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::EnableKeyRequest&, const EnableKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableKeyAsyncHandler;
typedef Outcome<Error, Model::ScheduleKeyDeletionResult> ScheduleKeyDeletionOutcome;
typedef std::future<ScheduleKeyDeletionOutcome> ScheduleKeyDeletionOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::ScheduleKeyDeletionRequest&, const ScheduleKeyDeletionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ScheduleKeyDeletionAsyncHandler;
typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
typedef Outcome<Error, Model::ListKeysResult> ListKeysOutcome;
typedef std::future<ListKeysOutcome> ListKeysOutcomeCallable;
typedef std::function<void(const KmsClient*, const Model::ListKeysRequest&, const ListKeysOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListKeysAsyncHandler;
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;
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;
KmsClient(const Credentials &credentials, const ClientConfiguration &configuration);
KmsClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
KmsClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~KmsClient();
ListAliasesOutcome listAliases(const Model::ListAliasesRequest &request)const;
void listAliasesAsync(const Model::ListAliasesRequest& request, const ListAliasesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListAliasesOutcomeCallable listAliasesCallable(const Model::ListAliasesRequest& request) const;
GenerateDataKeyOutcome generateDataKey(const Model::GenerateDataKeyRequest &request)const;
void generateDataKeyAsync(const Model::GenerateDataKeyRequest& request, const GenerateDataKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GenerateDataKeyOutcomeCallable generateDataKeyCallable(const Model::GenerateDataKeyRequest& request) const;
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;
DisableKeyOutcome disableKey(const Model::DisableKeyRequest &request)const;
void disableKeyAsync(const Model::DisableKeyRequest& request, const DisableKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DisableKeyOutcomeCallable disableKeyCallable(const Model::DisableKeyRequest& request) const;
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;
DecryptOutcome decrypt(const Model::DecryptRequest &request)const;
void decryptAsync(const Model::DecryptRequest& request, const DecryptAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DecryptOutcomeCallable decryptCallable(const Model::DecryptRequest& request) const;
TagResourceOutcome tagResource(const Model::TagResourceRequest &request)const;
void tagResourceAsync(const Model::TagResourceRequest& request, const TagResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TagResourceOutcomeCallable tagResourceCallable(const Model::TagResourceRequest& 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;
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;
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;
ListResourceTagsOutcome listResourceTags(const Model::ListResourceTagsRequest &request)const;
void listResourceTagsAsync(const Model::ListResourceTagsRequest& request, const ListResourceTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListResourceTagsOutcomeCallable listResourceTagsCallable(const Model::ListResourceTagsRequest& request) const;
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;
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;
UntagResourceOutcome untagResource(const Model::UntagResourceRequest &request)const;
void untagResourceAsync(const Model::UntagResourceRequest& request, const UntagResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UntagResourceOutcomeCallable untagResourceCallable(const Model::UntagResourceRequest& request) const;
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;
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;
EnableKeyOutcome enableKey(const Model::EnableKeyRequest &request)const;
void enableKeyAsync(const Model::EnableKeyRequest& request, const EnableKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EnableKeyOutcomeCallable enableKeyCallable(const Model::EnableKeyRequest& request) const;
ScheduleKeyDeletionOutcome scheduleKeyDeletion(const Model::ScheduleKeyDeletionRequest &request)const;
void scheduleKeyDeletionAsync(const Model::ScheduleKeyDeletionRequest& request, const ScheduleKeyDeletionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ScheduleKeyDeletionOutcomeCallable scheduleKeyDeletionCallable(const Model::ScheduleKeyDeletionRequest& request) const;
DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
ListKeysOutcome listKeys(const Model::ListKeysRequest &request)const;
void listKeysAsync(const Model::ListKeysRequest& request, const ListKeysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListKeysOutcomeCallable listKeysCallable(const Model::ListKeysRequest& 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;
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;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_KMS_KMSCLIENT_H_

32
kms/include/alibabacloud/kms/KmsExport.h Normal file
View File

@@ -0,0 +1,32 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_KMSEXPORT_H_
#define ALIBABACLOUD_KMS_KMSEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_KMS_LIBRARY)
# define ALIBABACLOUD_KMS_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_KMS_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_KMS_EXPORT
#endif
#endif // !ALIBABACLOUD_KMS_KMSEXPORT_H_

51
kms/include/alibabacloud/kms/model/CancelKeyDeletionRequest.h Normal file
View File

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

49
kms/include/alibabacloud/kms/model/CancelKeyDeletionResult.h Normal file
View File

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

54
kms/include/alibabacloud/kms/model/CreateAliasRequest.h Normal file
View File

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

49
kms/include/alibabacloud/kms/model/CreateAliasResult.h Normal file
View File

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

57
kms/include/alibabacloud/kms/model/CreateKeyRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_CREATEKEYREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_CREATEKEYREQUEST_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 CreateKeyRequest : public RpcServiceRequest
{
public:
CreateKeyRequest();
~CreateKeyRequest();
std::string getKeyUsage()const;
void setKeyUsage(const std::string& keyUsage);
std::string getOrigin()const;
void setOrigin(const std::string& origin);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getSTSToken()const;
void setSTSToken(const std::string& sTSToken);
private:
std::string keyUsage_;
std::string origin_;
std::string description_;
std::string sTSToken_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_CREATEKEYREQUEST_H_

64
kms/include/alibabacloud/kms/model/CreateKeyResult.h Normal file
View File

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

54
kms/include/alibabacloud/kms/model/DecryptRequest.h Normal file
View File

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

53
kms/include/alibabacloud/kms/model/DecryptResult.h Normal file
View File

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

51
kms/include/alibabacloud/kms/model/DeleteAliasRequest.h Normal file
View File

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

49
kms/include/alibabacloud/kms/model/DeleteAliasResult.h Normal file
View File

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

51
kms/include/alibabacloud/kms/model/DeleteKeyMaterialRequest.h Normal file
View File

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

49
kms/include/alibabacloud/kms/model/DeleteKeyMaterialResult.h Normal file
View File

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

51
kms/include/alibabacloud/kms/model/DescribeKeyRequest.h Normal file
View File

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

64
kms/include/alibabacloud/kms/model/DescribeKeyResult.h Normal file
View File

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

48
kms/include/alibabacloud/kms/model/DescribeRegionsRequest.h Normal file
View File

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

55
kms/include/alibabacloud/kms/model/DescribeRegionsResult.h Normal file
View File

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

51
kms/include/alibabacloud/kms/model/DisableKeyRequest.h Normal file
View File

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

49
kms/include/alibabacloud/kms/model/DisableKeyResult.h Normal file
View File

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

51
kms/include/alibabacloud/kms/model/EnableKeyRequest.h Normal file
View File

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

49
kms/include/alibabacloud/kms/model/EnableKeyResult.h Normal file
View File

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

57
kms/include/alibabacloud/kms/model/EncryptRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_ENCRYPTREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_ENCRYPTREQUEST_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 EncryptRequest : public RpcServiceRequest
{
public:
EncryptRequest();
~EncryptRequest();
std::string getEncryptionContext()const;
void setEncryptionContext(const std::string& encryptionContext);
std::string getKeyId()const;
void setKeyId(const std::string& keyId);
std::string getSTSToken()const;
void setSTSToken(const std::string& sTSToken);
std::string getPlaintext()const;
void setPlaintext(const std::string& plaintext);
private:
std::string encryptionContext_;
std::string keyId_;
std::string sTSToken_;
std::string plaintext_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_ENCRYPTREQUEST_H_

53
kms/include/alibabacloud/kms/model/EncryptResult.h Normal file
View File

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

60
kms/include/alibabacloud/kms/model/GenerateDataKeyRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_GENERATEDATAKEYREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_GENERATEDATAKEYREQUEST_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 GenerateDataKeyRequest : public RpcServiceRequest
{
public:
GenerateDataKeyRequest();
~GenerateDataKeyRequest();
std::string getEncryptionContext()const;
void setEncryptionContext(const std::string& encryptionContext);
std::string getKeyId()const;
void setKeyId(const std::string& keyId);
std::string getKeySpec()const;
void setKeySpec(const std::string& keySpec);
std::string getSTSToken()const;
void setSTSToken(const std::string& sTSToken);
int getNumberOfBytes()const;
void setNumberOfBytes(int numberOfBytes);
private:
std::string encryptionContext_;
std::string keyId_;
std::string keySpec_;
std::string sTSToken_;
int numberOfBytes_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_GENERATEDATAKEYREQUEST_H_

55
kms/include/alibabacloud/kms/model/GenerateDataKeyResult.h Normal file
View File

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

57
kms/include/alibabacloud/kms/model/GetParametersForImportRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_GETPARAMETERSFORIMPORTREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_GETPARAMETERSFORIMPORTREQUEST_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 GetParametersForImportRequest : public RpcServiceRequest
{
public:
GetParametersForImportRequest();
~GetParametersForImportRequest();
std::string getKeyId()const;
void setKeyId(const std::string& keyId);
std::string getSTSToken()const;
void setSTSToken(const std::string& sTSToken);
std::string getWrappingAlgorithm()const;
void setWrappingAlgorithm(const std::string& wrappingAlgorithm);
std::string getWrappingKeySpec()const;
void setWrappingKeySpec(const std::string& wrappingKeySpec);
private:
std::string keyId_;
std::string sTSToken_;
std::string wrappingAlgorithm_;
std::string wrappingKeySpec_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_GETPARAMETERSFORIMPORTREQUEST_H_

57
kms/include/alibabacloud/kms/model/GetParametersForImportResult.h Normal file
View File

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

60
kms/include/alibabacloud/kms/model/ImportKeyMaterialRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_IMPORTKEYMATERIALREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_IMPORTKEYMATERIALREQUEST_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 ImportKeyMaterialRequest : public RpcServiceRequest
{
public:
ImportKeyMaterialRequest();
~ImportKeyMaterialRequest();
std::string getImportToken()const;
void setImportToken(const std::string& importToken);
std::string getEncryptedKeyMaterial()const;
void setEncryptedKeyMaterial(const std::string& encryptedKeyMaterial);
long getKeyMaterialExpireUnix()const;
void setKeyMaterialExpireUnix(long keyMaterialExpireUnix);
std::string getKeyId()const;
void setKeyId(const std::string& keyId);
std::string getSTSToken()const;
void setSTSToken(const std::string& sTSToken);
private:
std::string importToken_;
std::string encryptedKeyMaterial_;
long keyMaterialExpireUnix_;
std::string keyId_;
std::string sTSToken_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_IMPORTKEYMATERIALREQUEST_H_

49
kms/include/alibabacloud/kms/model/ImportKeyMaterialResult.h Normal file
View File

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

57
kms/include/alibabacloud/kms/model/ListAliasesByKeyIdRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_KMS_MODEL_LISTALIASESBYKEYIDREQUEST_H_
#define ALIBABACLOUD_KMS_MODEL_LISTALIASESBYKEYIDREQUEST_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 ListAliasesByKeyIdRequest : public RpcServiceRequest
{
public:
ListAliasesByKeyIdRequest();
~ListAliasesByKeyIdRequest();
int getPageSize()const;
void setPageSize(int pageSize);
std::string getKeyId()const;
void setKeyId(const std::string& keyId);
std::string getSTSToken()const;
void setSTSToken(const std::string& sTSToken);
int getPageNumber()const;
void setPageNumber(int pageNumber);
private:
int pageSize_;
std::string keyId_;
std::string sTSToken_;
int pageNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_KMS_MODEL_LISTALIASESBYKEYIDREQUEST_H_

63
kms/include/alibabacloud/kms/model/ListAliasesByKeyIdResult.h Normal file
View File

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

54
kms/include/alibabacloud/kms/model/ListAliasesRequest.h Normal file
View File

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

63
kms/include/alibabacloud/kms/model/ListAliasesResult.h Normal file
View File

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

54
kms/include/alibabacloud/kms/model/ListKeysRequest.h Normal file
View File

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

62
kms/include/alibabacloud/kms/model/ListKeysResult.h Normal file
View File

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

51
kms/include/alibabacloud/kms/model/ListResourceTagsRequest.h Normal file
View File

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

57
kms/include/alibabacloud/kms/model/ListResourceTagsResult.h Normal file
View File

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

54
kms/include/alibabacloud/kms/model/ScheduleKeyDeletionRequest.h Normal file
View File

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

49
kms/include/alibabacloud/kms/model/ScheduleKeyDeletionResult.h Normal file
View File

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

54
kms/include/alibabacloud/kms/model/TagResourceRequest.h Normal file
View File

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

49
kms/include/alibabacloud/kms/model/TagResourceResult.h Normal file
View File

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

54
kms/include/alibabacloud/kms/model/UntagResourceRequest.h Normal file
View File

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

51
kms/include/alibabacloud/kms/model/UntagResourceResult.h Normal file
View File

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

54
kms/include/alibabacloud/kms/model/UpdateAliasRequest.h Normal file
View File

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

49
kms/include/alibabacloud/kms/model/UpdateAliasResult.h Normal file
View File

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