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

Publish apis for ledger instances.

Browse Source
This commit is contained in:
sdk-team
2020-04-24 16:01:11 +08:00
parent 7e80260525
commit d005611f56
86 changed files with 5848 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

206
ledgerdb/include/alibabacloud/ledgerdb/LedgerdbClient.h Normal file
View File

@@ -0,0 +1,206 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_LEDGERDB_LEDGERDBCLIENT_H_
#define ALIBABACLOUD_LEDGERDB_LEDGERDBCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "LedgerdbExport.h"
#include "model/AcceptMemberRequest.h"
#include "model/AcceptMemberResult.h"
#include "model/CreateVpcEndpointRequest.h"
#include "model/CreateVpcEndpointResult.h"
#include "model/DeleteLedgerRequest.h"
#include "model/DeleteLedgerResult.h"
#include "model/DeleteMemberRequest.h"
#include "model/DeleteMemberResult.h"
#include "model/DeleteVpcEndpointRequest.h"
#include "model/DeleteVpcEndpointResult.h"
#include "model/DescribeLedgerRequest.h"
#include "model/DescribeLedgerResult.h"
#include "model/DescribeLedgersRequest.h"
#include "model/DescribeLedgersResult.h"
#include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h"
#include "model/DisableMemberRequest.h"
#include "model/DisableMemberResult.h"
#include "model/EnableMemberRequest.h"
#include "model/EnableMemberResult.h"
#include "model/GetJournalRequest.h"
#include "model/GetJournalResult.h"
#include "model/GetMemberRequest.h"
#include "model/GetMemberResult.h"
#include "model/InviteMembersRequest.h"
#include "model/InviteMembersResult.h"
#include "model/ListJournalsRequest.h"
#include "model/ListJournalsResult.h"
#include "model/ListMembersRequest.h"
#include "model/ListMembersResult.h"
#include "model/ListTimeAnchorsRequest.h"
#include "model/ListTimeAnchorsResult.h"
#include "model/ListVpcEndpointsRequest.h"
#include "model/ListVpcEndpointsResult.h"
#include "model/ModifyLedgerAttributeRequest.h"
#include "model/ModifyLedgerAttributeResult.h"
#include "model/ModifyMemberACLsRequest.h"
#include "model/ModifyMemberACLsResult.h"
#include "model/ModifyMemberKeyRequest.h"
#include "model/ModifyMemberKeyResult.h"
namespace AlibabaCloud
{
namespace Ledgerdb
{
class ALIBABACLOUD_LEDGERDB_EXPORT LedgerdbClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::AcceptMemberResult> AcceptMemberOutcome;
typedef std::future<AcceptMemberOutcome> AcceptMemberOutcomeCallable;
typedef std::function<void(const LedgerdbClient*, const Model::AcceptMemberRequest&, const AcceptMemberOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AcceptMemberAsyncHandler;
typedef Outcome<Error, Model::CreateVpcEndpointResult> CreateVpcEndpointOutcome;
typedef std::future<CreateVpcEndpointOutcome> CreateVpcEndpointOutcomeCallable;
typedef std::function<void(const LedgerdbClient*, const Model::CreateVpcEndpointRequest&, const CreateVpcEndpointOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVpcEndpointAsyncHandler;
typedef Outcome<Error, Model::DeleteLedgerResult> DeleteLedgerOutcome;
typedef std::future<DeleteLedgerOutcome> DeleteLedgerOutcomeCallable;
typedef std::function<void(const LedgerdbClient*, const Model::DeleteLedgerRequest&, const DeleteLedgerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLedgerAsyncHandler;
typedef Outcome<Error, Model::DeleteMemberResult> DeleteMemberOutcome;
typedef std::future<DeleteMemberOutcome> DeleteMemberOutcomeCallable;
typedef std::function<void(const LedgerdbClient*, const Model::DeleteMemberRequest&, const DeleteMemberOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteMemberAsyncHandler;
typedef Outcome<Error, Model::DeleteVpcEndpointResult> DeleteVpcEndpointOutcome;
typedef std::future<DeleteVpcEndpointOutcome> DeleteVpcEndpointOutcomeCallable;
typedef std::function<void(const LedgerdbClient*, const Model::DeleteVpcEndpointRequest&, const DeleteVpcEndpointOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVpcEndpointAsyncHandler;
typedef Outcome<Error, Model::DescribeLedgerResult> DescribeLedgerOutcome;
typedef std::future<DescribeLedgerOutcome> DescribeLedgerOutcomeCallable;
typedef std::function<void(const LedgerdbClient*, const Model::DescribeLedgerRequest&, const DescribeLedgerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLedgerAsyncHandler;
typedef Outcome<Error, Model::DescribeLedgersResult> DescribeLedgersOutcome;
typedef std::future<DescribeLedgersOutcome> DescribeLedgersOutcomeCallable;
typedef std::function<void(const LedgerdbClient*, const Model::DescribeLedgersRequest&, const DescribeLedgersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLedgersAsyncHandler;
typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
typedef std::function<void(const LedgerdbClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
typedef Outcome<Error, Model::DisableMemberResult> DisableMemberOutcome;
typedef std::future<DisableMemberOutcome> DisableMemberOutcomeCallable;
typedef std::function<void(const LedgerdbClient*, const Model::DisableMemberRequest&, const DisableMemberOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableMemberAsyncHandler;
typedef Outcome<Error, Model::EnableMemberResult> EnableMemberOutcome;
typedef std::future<EnableMemberOutcome> EnableMemberOutcomeCallable;
typedef std::function<void(const LedgerdbClient*, const Model::EnableMemberRequest&, const EnableMemberOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableMemberAsyncHandler;
typedef Outcome<Error, Model::GetJournalResult> GetJournalOutcome;
typedef std::future<GetJournalOutcome> GetJournalOutcomeCallable;
typedef std::function<void(const LedgerdbClient*, const Model::GetJournalRequest&, const GetJournalOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetJournalAsyncHandler;
typedef Outcome<Error, Model::GetMemberResult> GetMemberOutcome;
typedef std::future<GetMemberOutcome> GetMemberOutcomeCallable;
typedef std::function<void(const LedgerdbClient*, const Model::GetMemberRequest&, const GetMemberOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMemberAsyncHandler;
typedef Outcome<Error, Model::InviteMembersResult> InviteMembersOutcome;
typedef std::future<InviteMembersOutcome> InviteMembersOutcomeCallable;
typedef std::function<void(const LedgerdbClient*, const Model::InviteMembersRequest&, const InviteMembersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> InviteMembersAsyncHandler;
typedef Outcome<Error, Model::ListJournalsResult> ListJournalsOutcome;
typedef std::future<ListJournalsOutcome> ListJournalsOutcomeCallable;
typedef std::function<void(const LedgerdbClient*, const Model::ListJournalsRequest&, const ListJournalsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListJournalsAsyncHandler;
typedef Outcome<Error, Model::ListMembersResult> ListMembersOutcome;
typedef std::future<ListMembersOutcome> ListMembersOutcomeCallable;
typedef std::function<void(const LedgerdbClient*, const Model::ListMembersRequest&, const ListMembersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListMembersAsyncHandler;
typedef Outcome<Error, Model::ListTimeAnchorsResult> ListTimeAnchorsOutcome;
typedef std::future<ListTimeAnchorsOutcome> ListTimeAnchorsOutcomeCallable;
typedef std::function<void(const LedgerdbClient*, const Model::ListTimeAnchorsRequest&, const ListTimeAnchorsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTimeAnchorsAsyncHandler;
typedef Outcome<Error, Model::ListVpcEndpointsResult> ListVpcEndpointsOutcome;
typedef std::future<ListVpcEndpointsOutcome> ListVpcEndpointsOutcomeCallable;
typedef std::function<void(const LedgerdbClient*, const Model::ListVpcEndpointsRequest&, const ListVpcEndpointsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpcEndpointsAsyncHandler;
typedef Outcome<Error, Model::ModifyLedgerAttributeResult> ModifyLedgerAttributeOutcome;
typedef std::future<ModifyLedgerAttributeOutcome> ModifyLedgerAttributeOutcomeCallable;
typedef std::function<void(const LedgerdbClient*, const Model::ModifyLedgerAttributeRequest&, const ModifyLedgerAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyLedgerAttributeAsyncHandler;
typedef Outcome<Error, Model::ModifyMemberACLsResult> ModifyMemberACLsOutcome;
typedef std::future<ModifyMemberACLsOutcome> ModifyMemberACLsOutcomeCallable;
typedef std::function<void(const LedgerdbClient*, const Model::ModifyMemberACLsRequest&, const ModifyMemberACLsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyMemberACLsAsyncHandler;
typedef Outcome<Error, Model::ModifyMemberKeyResult> ModifyMemberKeyOutcome;
typedef std::future<ModifyMemberKeyOutcome> ModifyMemberKeyOutcomeCallable;
typedef std::function<void(const LedgerdbClient*, const Model::ModifyMemberKeyRequest&, const ModifyMemberKeyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyMemberKeyAsyncHandler;
LedgerdbClient(const Credentials &credentials, const ClientConfiguration &configuration);
LedgerdbClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
LedgerdbClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~LedgerdbClient();
AcceptMemberOutcome acceptMember(const Model::AcceptMemberRequest &request)const;
void acceptMemberAsync(const Model::AcceptMemberRequest& request, const AcceptMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AcceptMemberOutcomeCallable acceptMemberCallable(const Model::AcceptMemberRequest& request) const;
CreateVpcEndpointOutcome createVpcEndpoint(const Model::CreateVpcEndpointRequest &request)const;
void createVpcEndpointAsync(const Model::CreateVpcEndpointRequest& request, const CreateVpcEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateVpcEndpointOutcomeCallable createVpcEndpointCallable(const Model::CreateVpcEndpointRequest& request) const;
DeleteLedgerOutcome deleteLedger(const Model::DeleteLedgerRequest &request)const;
void deleteLedgerAsync(const Model::DeleteLedgerRequest& request, const DeleteLedgerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLedgerOutcomeCallable deleteLedgerCallable(const Model::DeleteLedgerRequest& request) const;
DeleteMemberOutcome deleteMember(const Model::DeleteMemberRequest &request)const;
void deleteMemberAsync(const Model::DeleteMemberRequest& request, const DeleteMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteMemberOutcomeCallable deleteMemberCallable(const Model::DeleteMemberRequest& request) const;
DeleteVpcEndpointOutcome deleteVpcEndpoint(const Model::DeleteVpcEndpointRequest &request)const;
void deleteVpcEndpointAsync(const Model::DeleteVpcEndpointRequest& request, const DeleteVpcEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteVpcEndpointOutcomeCallable deleteVpcEndpointCallable(const Model::DeleteVpcEndpointRequest& request) const;
DescribeLedgerOutcome describeLedger(const Model::DescribeLedgerRequest &request)const;
void describeLedgerAsync(const Model::DescribeLedgerRequest& request, const DescribeLedgerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLedgerOutcomeCallable describeLedgerCallable(const Model::DescribeLedgerRequest& request) const;
DescribeLedgersOutcome describeLedgers(const Model::DescribeLedgersRequest &request)const;
void describeLedgersAsync(const Model::DescribeLedgersRequest& request, const DescribeLedgersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLedgersOutcomeCallable describeLedgersCallable(const Model::DescribeLedgersRequest& 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;
DisableMemberOutcome disableMember(const Model::DisableMemberRequest &request)const;
void disableMemberAsync(const Model::DisableMemberRequest& request, const DisableMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DisableMemberOutcomeCallable disableMemberCallable(const Model::DisableMemberRequest& request) const;
EnableMemberOutcome enableMember(const Model::EnableMemberRequest &request)const;
void enableMemberAsync(const Model::EnableMemberRequest& request, const EnableMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EnableMemberOutcomeCallable enableMemberCallable(const Model::EnableMemberRequest& request) const;
GetJournalOutcome getJournal(const Model::GetJournalRequest &request)const;
void getJournalAsync(const Model::GetJournalRequest& request, const GetJournalAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetJournalOutcomeCallable getJournalCallable(const Model::GetJournalRequest& request) const;
GetMemberOutcome getMember(const Model::GetMemberRequest &request)const;
void getMemberAsync(const Model::GetMemberRequest& request, const GetMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetMemberOutcomeCallable getMemberCallable(const Model::GetMemberRequest& request) const;
InviteMembersOutcome inviteMembers(const Model::InviteMembersRequest &request)const;
void inviteMembersAsync(const Model::InviteMembersRequest& request, const InviteMembersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
InviteMembersOutcomeCallable inviteMembersCallable(const Model::InviteMembersRequest& request) const;
ListJournalsOutcome listJournals(const Model::ListJournalsRequest &request)const;
void listJournalsAsync(const Model::ListJournalsRequest& request, const ListJournalsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListJournalsOutcomeCallable listJournalsCallable(const Model::ListJournalsRequest& request) const;
ListMembersOutcome listMembers(const Model::ListMembersRequest &request)const;
void listMembersAsync(const Model::ListMembersRequest& request, const ListMembersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListMembersOutcomeCallable listMembersCallable(const Model::ListMembersRequest& request) const;
ListTimeAnchorsOutcome listTimeAnchors(const Model::ListTimeAnchorsRequest &request)const;
void listTimeAnchorsAsync(const Model::ListTimeAnchorsRequest& request, const ListTimeAnchorsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTimeAnchorsOutcomeCallable listTimeAnchorsCallable(const Model::ListTimeAnchorsRequest& request) const;
ListVpcEndpointsOutcome listVpcEndpoints(const Model::ListVpcEndpointsRequest &request)const;
void listVpcEndpointsAsync(const Model::ListVpcEndpointsRequest& request, const ListVpcEndpointsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListVpcEndpointsOutcomeCallable listVpcEndpointsCallable(const Model::ListVpcEndpointsRequest& request) const;
ModifyLedgerAttributeOutcome modifyLedgerAttribute(const Model::ModifyLedgerAttributeRequest &request)const;
void modifyLedgerAttributeAsync(const Model::ModifyLedgerAttributeRequest& request, const ModifyLedgerAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyLedgerAttributeOutcomeCallable modifyLedgerAttributeCallable(const Model::ModifyLedgerAttributeRequest& request) const;
ModifyMemberACLsOutcome modifyMemberACLs(const Model::ModifyMemberACLsRequest &request)const;
void modifyMemberACLsAsync(const Model::ModifyMemberACLsRequest& request, const ModifyMemberACLsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyMemberACLsOutcomeCallable modifyMemberACLsCallable(const Model::ModifyMemberACLsRequest& request) const;
ModifyMemberKeyOutcome modifyMemberKey(const Model::ModifyMemberKeyRequest &request)const;
void modifyMemberKeyAsync(const Model::ModifyMemberKeyRequest& request, const ModifyMemberKeyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyMemberKeyOutcomeCallable modifyMemberKeyCallable(const Model::ModifyMemberKeyRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_LEDGERDB_LEDGERDBCLIENT_H_

32
ledgerdb/include/alibabacloud/ledgerdb/LedgerdbExport.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_LEDGERDB_LEDGERDBEXPORT_H_
#define ALIBABACLOUD_LEDGERDB_LEDGERDBEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_LEDGERDB_LIBRARY)
# define ALIBABACLOUD_LEDGERDB_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_LEDGERDB_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_LEDGERDB_EXPORT
#endif
#endif // !ALIBABACLOUD_LEDGERDB_LEDGERDBEXPORT_H_

54
ledgerdb/include/alibabacloud/ledgerdb/model/AcceptMemberRequest.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_LEDGERDB_MODEL_ACCEPTMEMBERREQUEST_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_ACCEPTMEMBERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT AcceptMemberRequest : public RpcServiceRequest
{
public:
AcceptMemberRequest();
~AcceptMemberRequest();
std::string getPublicKey()const;
void setPublicKey(const std::string& publicKey);
std::string getKeyType()const;
void setKeyType(const std::string& keyType);
std::string getLedgerId()const;
void setLedgerId(const std::string& ledgerId);
private:
std::string publicKey_;
std::string keyType_;
std::string ledgerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_ACCEPTMEMBERREQUEST_H_

51
ledgerdb/include/alibabacloud/ledgerdb/model/AcceptMemberResult.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_LEDGERDB_MODEL_ACCEPTMEMBERRESULT_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_ACCEPTMEMBERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT AcceptMemberResult : public ServiceResult
{
public:
AcceptMemberResult();
explicit AcceptMemberResult(const std::string &payload);
~AcceptMemberResult();
std::string getMemberId()const;
protected:
void parse(const std::string &payload);
private:
std::string memberId_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_ACCEPTMEMBERRESULT_H_

57
ledgerdb/include/alibabacloud/ledgerdb/model/CreateVpcEndpointRequest.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_LEDGERDB_MODEL_CREATEVPCENDPOINTREQUEST_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_CREATEVPCENDPOINTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT CreateVpcEndpointRequest : public RpcServiceRequest
{
public:
CreateVpcEndpointRequest();
~CreateVpcEndpointRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getLedgerId()const;
void setLedgerId(const std::string& ledgerId);
std::string getVSwitchId()const;
void setVSwitchId(const std::string& vSwitchId);
std::string getVpcId()const;
void setVpcId(const std::string& vpcId);
private:
std::string clientToken_;
std::string ledgerId_;
std::string vSwitchId_;
std::string vpcId_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_CREATEVPCENDPOINTREQUEST_H_

51
ledgerdb/include/alibabacloud/ledgerdb/model/CreateVpcEndpointResult.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_LEDGERDB_MODEL_CREATEVPCENDPOINTRESULT_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_CREATEVPCENDPOINTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT CreateVpcEndpointResult : public ServiceResult
{
public:
CreateVpcEndpointResult();
explicit CreateVpcEndpointResult(const std::string &payload);
~CreateVpcEndpointResult();
std::string getVpcEndpointId()const;
protected:
void parse(const std::string &payload);
private:
std::string vpcEndpointId_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_CREATEVPCENDPOINTRESULT_H_

48
ledgerdb/include/alibabacloud/ledgerdb/model/DeleteLedgerRequest.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_LEDGERDB_MODEL_DELETELEDGERREQUEST_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_DELETELEDGERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT DeleteLedgerRequest : public RpcServiceRequest
{
public:
DeleteLedgerRequest();
~DeleteLedgerRequest();
std::string getLedgerId()const;
void setLedgerId(const std::string& ledgerId);
private:
std::string ledgerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_DELETELEDGERREQUEST_H_

49
ledgerdb/include/alibabacloud/ledgerdb/model/DeleteLedgerResult.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_LEDGERDB_MODEL_DELETELEDGERRESULT_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_DELETELEDGERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT DeleteLedgerResult : public ServiceResult
{
public:
DeleteLedgerResult();
explicit DeleteLedgerResult(const std::string &payload);
~DeleteLedgerResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_DELETELEDGERRESULT_H_

51
ledgerdb/include/alibabacloud/ledgerdb/model/DeleteMemberRequest.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_LEDGERDB_MODEL_DELETEMEMBERREQUEST_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_DELETEMEMBERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT DeleteMemberRequest : public RpcServiceRequest
{
public:
DeleteMemberRequest();
~DeleteMemberRequest();
std::string getLedgerId()const;
void setLedgerId(const std::string& ledgerId);
std::string getMemberId()const;
void setMemberId(const std::string& memberId);
private:
std::string ledgerId_;
std::string memberId_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_DELETEMEMBERREQUEST_H_

49
ledgerdb/include/alibabacloud/ledgerdb/model/DeleteMemberResult.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_LEDGERDB_MODEL_DELETEMEMBERRESULT_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_DELETEMEMBERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT DeleteMemberResult : public ServiceResult
{
public:
DeleteMemberResult();
explicit DeleteMemberResult(const std::string &payload);
~DeleteMemberResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_DELETEMEMBERRESULT_H_

57
ledgerdb/include/alibabacloud/ledgerdb/model/DeleteVpcEndpointRequest.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_LEDGERDB_MODEL_DELETEVPCENDPOINTREQUEST_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_DELETEVPCENDPOINTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT DeleteVpcEndpointRequest : public RpcServiceRequest
{
public:
DeleteVpcEndpointRequest();
~DeleteVpcEndpointRequest();
std::string getLedgerId()const;
void setLedgerId(const std::string& ledgerId);
std::string getVSwitchId()const;
void setVSwitchId(const std::string& vSwitchId);
std::string getVpcId()const;
void setVpcId(const std::string& vpcId);
std::string getVpcEndpointId()const;
void setVpcEndpointId(const std::string& vpcEndpointId);
private:
std::string ledgerId_;
std::string vSwitchId_;
std::string vpcId_;
std::string vpcEndpointId_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_DELETEVPCENDPOINTREQUEST_H_

49
ledgerdb/include/alibabacloud/ledgerdb/model/DeleteVpcEndpointResult.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_LEDGERDB_MODEL_DELETEVPCENDPOINTRESULT_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_DELETEVPCENDPOINTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT DeleteVpcEndpointResult : public ServiceResult
{
public:
DeleteVpcEndpointResult();
explicit DeleteVpcEndpointResult(const std::string &payload);
~DeleteVpcEndpointResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_DELETEVPCENDPOINTRESULT_H_

48
ledgerdb/include/alibabacloud/ledgerdb/model/DescribeLedgerRequest.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_LEDGERDB_MODEL_DESCRIBELEDGERREQUEST_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_DESCRIBELEDGERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT DescribeLedgerRequest : public RpcServiceRequest
{
public:
DescribeLedgerRequest();
~DescribeLedgerRequest();
std::string getLedgerId()const;
void setLedgerId(const std::string& ledgerId);
private:
std::string ledgerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_DESCRIBELEDGERREQUEST_H_

77
ledgerdb/include/alibabacloud/ledgerdb/model/DescribeLedgerResult.h Normal file
View File

@@ -0,0 +1,77 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LEDGERDB_MODEL_DESCRIBELEDGERRESULT_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_DESCRIBELEDGERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT DescribeLedgerResult : public ServiceResult
{
public:
struct Ledger
{
struct LastTimeAnchor
{
std::string ledgerDigest;
std::string journalId;
std::string ledgerDigestType;
std::string proof;
std::string ledgerVersion;
std::string timeStamp;
};
long journalCount;
std::string zoneId;
long timeAnchorCount;
std::string createTime;
long memberCount;
std::string ledgerId;
LastTimeAnchor lastTimeAnchor;
std::string ledgerDescription;
std::string ownerAliUid;
std::string ledgerType;
std::string updateTime;
std::string regionId;
std::string ledgerStatus;
std::string ledgerName;
};
DescribeLedgerResult();
explicit DescribeLedgerResult(const std::string &payload);
~DescribeLedgerResult();
Ledger getLedger()const;
protected:
void parse(const std::string &payload);
private:
Ledger ledger_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_DESCRIBELEDGERRESULT_H_

51
ledgerdb/include/alibabacloud/ledgerdb/model/DescribeLedgersRequest.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_LEDGERDB_MODEL_DESCRIBELEDGERSREQUEST_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_DESCRIBELEDGERSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT DescribeLedgersRequest : public RpcServiceRequest
{
public:
DescribeLedgersRequest();
~DescribeLedgersRequest();
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
int getMaxResults()const;
void setMaxResults(int maxResults);
private:
std::string nextToken_;
int maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_DESCRIBELEDGERSREQUEST_H_

81
ledgerdb/include/alibabacloud/ledgerdb/model/DescribeLedgersResult.h Normal file
View File

@@ -0,0 +1,81 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LEDGERDB_MODEL_DESCRIBELEDGERSRESULT_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_DESCRIBELEDGERSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT DescribeLedgersResult : public ServiceResult
{
public:
struct Ledger
{
struct LastTimeAnchor
{
std::string ledgerDigest;
std::string journalId;
std::string ledgerDigestType;
std::string proof;
std::string ledgerVersion;
std::string timeStamp;
};
long journalCount;
std::string zoneId;
long timeAnchorCount;
std::string createTime;
long memberCount;
std::string ledgerId;
LastTimeAnchor lastTimeAnchor;
std::string ledgerDescription;
std::string ownerAliUid;
std::string ledgerType;
std::string updateTime;
std::string regionId;
std::string ledgerStatus;
std::string ledgerName;
};
DescribeLedgersResult();
explicit DescribeLedgersResult(const std::string &payload);
~DescribeLedgersResult();
std::string getNextToken()const;
int getMaxResults()const;
std::vector<Ledger> getLedgers()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
int maxResults_;
std::vector<Ledger> ledgers_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_DESCRIBELEDGERSRESULT_H_

48
ledgerdb/include/alibabacloud/ledgerdb/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_LEDGERDB_MODEL_DESCRIBEREGIONSREQUEST_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_DESCRIBEREGIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT DescribeRegionsRequest : public RpcServiceRequest
{
public:
DescribeRegionsRequest();
~DescribeRegionsRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_DESCRIBEREGIONSREQUEST_H_

61
ledgerdb/include/alibabacloud/ledgerdb/model/DescribeRegionsResult.h Normal file
View File

@@ -0,0 +1,61 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LEDGERDB_MODEL_DESCRIBEREGIONSRESULT_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_DESCRIBEREGIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT DescribeRegionsResult : public ServiceResult
{
public:
struct Result
{
std::string regionId;
std::string regionEndpoint;
std::string localName;
};
DescribeRegionsResult();
explicit DescribeRegionsResult(const std::string &payload);
~DescribeRegionsResult();
std::vector<Result> getRegions()const;
int getErrorCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Result> regions_;
int errorCode_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_DESCRIBEREGIONSRESULT_H_

51
ledgerdb/include/alibabacloud/ledgerdb/model/DisableMemberRequest.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_LEDGERDB_MODEL_DISABLEMEMBERREQUEST_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_DISABLEMEMBERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT DisableMemberRequest : public RpcServiceRequest
{
public:
DisableMemberRequest();
~DisableMemberRequest();
std::string getLedgerId()const;
void setLedgerId(const std::string& ledgerId);
std::string getMemberId()const;
void setMemberId(const std::string& memberId);
private:
std::string ledgerId_;
std::string memberId_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_DISABLEMEMBERREQUEST_H_

49
ledgerdb/include/alibabacloud/ledgerdb/model/DisableMemberResult.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_LEDGERDB_MODEL_DISABLEMEMBERRESULT_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_DISABLEMEMBERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT DisableMemberResult : public ServiceResult
{
public:
DisableMemberResult();
explicit DisableMemberResult(const std::string &payload);
~DisableMemberResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_DISABLEMEMBERRESULT_H_

51
ledgerdb/include/alibabacloud/ledgerdb/model/EnableMemberRequest.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_LEDGERDB_MODEL_ENABLEMEMBERREQUEST_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_ENABLEMEMBERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT EnableMemberRequest : public RpcServiceRequest
{
public:
EnableMemberRequest();
~EnableMemberRequest();
std::string getLedgerId()const;
void setLedgerId(const std::string& ledgerId);
std::string getMemberId()const;
void setMemberId(const std::string& memberId);
private:
std::string ledgerId_;
std::string memberId_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_ENABLEMEMBERREQUEST_H_

49
ledgerdb/include/alibabacloud/ledgerdb/model/EnableMemberResult.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_LEDGERDB_MODEL_ENABLEMEMBERRESULT_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_ENABLEMEMBERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT EnableMemberResult : public ServiceResult
{
public:
EnableMemberResult();
explicit EnableMemberResult(const std::string &payload);
~EnableMemberResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_ENABLEMEMBERRESULT_H_

51
ledgerdb/include/alibabacloud/ledgerdb/model/GetJournalRequest.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_LEDGERDB_MODEL_GETJOURNALREQUEST_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_GETJOURNALREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT GetJournalRequest : public RpcServiceRequest
{
public:
GetJournalRequest();
~GetJournalRequest();
long getJournalId()const;
void setJournalId(long journalId);
std::string getLedgerId()const;
void setLedgerId(const std::string& ledgerId);
private:
long journalId_;
std::string ledgerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_GETJOURNALREQUEST_H_

63
ledgerdb/include/alibabacloud/ledgerdb/model/GetJournalResult.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_LEDGERDB_MODEL_GETJOURNALRESULT_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_GETJOURNALRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT GetJournalResult : public ServiceResult
{
public:
struct Journal
{
std::string memberId;
std::string journalId;
std::string clientId;
std::vector<std::string> clues;
std::string ledgerId;
std::string journalHash;
long timestamp;
std::string payloadType;
std::string payloadJsonString;
};
GetJournalResult();
explicit GetJournalResult(const std::string &payload);
~GetJournalResult();
Journal getJournal()const;
protected:
void parse(const std::string &payload);
private:
Journal journal_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_GETJOURNALRESULT_H_

51
ledgerdb/include/alibabacloud/ledgerdb/model/GetMemberRequest.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_LEDGERDB_MODEL_GETMEMBERREQUEST_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_GETMEMBERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT GetMemberRequest : public RpcServiceRequest
{
public:
GetMemberRequest();
~GetMemberRequest();
std::string getLedgerId()const;
void setLedgerId(const std::string& ledgerId);
std::string getMemberId()const;
void setMemberId(const std::string& memberId);
private:
std::string ledgerId_;
std::string memberId_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_GETMEMBERREQUEST_H_

67
ledgerdb/include/alibabacloud/ledgerdb/model/GetMemberResult.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LEDGERDB_MODEL_GETMEMBERRESULT_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_GETMEMBERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT GetMemberResult : public ServiceResult
{
public:
GetMemberResult();
explicit GetMemberResult(const std::string &payload);
~GetMemberResult();
std::string getRole()const;
std::string getMemberId()const;
std::string getKeyType()const;
std::string getPublicKey()const;
std::string getState()const;
long getCreateTime()const;
long getUpdateTime()const;
std::string getLedgerId()const;
std::string getAliUid()const;
protected:
void parse(const std::string &payload);
private:
std::string role_;
std::string memberId_;
std::string keyType_;
std::string publicKey_;
std::string state_;
long createTime_;
long updateTime_;
std::string ledgerId_;
std::string aliUid_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_GETMEMBERRESULT_H_

51
ledgerdb/include/alibabacloud/ledgerdb/model/InviteMembersRequest.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_LEDGERDB_MODEL_INVITEMEMBERSREQUEST_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_INVITEMEMBERSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT InviteMembersRequest : public RpcServiceRequest
{
public:
InviteMembersRequest();
~InviteMembersRequest();
std::string getAliUids()const;
void setAliUids(const std::string& aliUids);
std::string getLedgerId()const;
void setLedgerId(const std::string& ledgerId);
private:
std::string aliUids_;
std::string ledgerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_INVITEMEMBERSREQUEST_H_

49
ledgerdb/include/alibabacloud/ledgerdb/model/InviteMembersResult.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_LEDGERDB_MODEL_INVITEMEMBERSRESULT_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_INVITEMEMBERSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT InviteMembersResult : public ServiceResult
{
public:
InviteMembersResult();
explicit InviteMembersResult(const std::string &payload);
~InviteMembersResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_INVITEMEMBERSRESULT_H_

60
ledgerdb/include/alibabacloud/ledgerdb/model/ListJournalsRequest.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_LEDGERDB_MODEL_LISTJOURNALSREQUEST_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_LISTJOURNALSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT ListJournalsRequest : public RpcServiceRequest
{
public:
ListJournalsRequest();
~ListJournalsRequest();
std::string getLedgerId()const;
void setLedgerId(const std::string& ledgerId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
std::string getClue()const;
void setClue(const std::string& clue);
int getMaxResults()const;
void setMaxResults(int maxResults);
std::string getMemberId()const;
void setMemberId(const std::string& memberId);
private:
std::string ledgerId_;
std::string nextToken_;
std::string clue_;
int maxResults_;
std::string memberId_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_LISTJOURNALSREQUEST_H_

67
ledgerdb/include/alibabacloud/ledgerdb/model/ListJournalsResult.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LEDGERDB_MODEL_LISTJOURNALSRESULT_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_LISTJOURNALSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT ListJournalsResult : public ServiceResult
{
public:
struct Journal
{
std::string memberId;
std::string journalId;
std::string clientId;
std::vector<std::string> clues;
std::string ledgerId;
std::string journalHash;
long timestamp;
std::string payloadType;
std::string payloadJsonString;
};
ListJournalsResult();
explicit ListJournalsResult(const std::string &payload);
~ListJournalsResult();
std::string getNextToken()const;
std::vector<Journal> getJournals()const;
int getMaxResults()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
std::vector<Journal> journals_;
int maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_LISTJOURNALSRESULT_H_

54
ledgerdb/include/alibabacloud/ledgerdb/model/ListMembersRequest.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_LEDGERDB_MODEL_LISTMEMBERSREQUEST_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_LISTMEMBERSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT ListMembersRequest : public RpcServiceRequest
{
public:
ListMembersRequest();
~ListMembersRequest();
std::string getLedgerId()const;
void setLedgerId(const std::string& ledgerId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
int getMaxResults()const;
void setMaxResults(int maxResults);
private:
std::string ledgerId_;
std::string nextToken_;
int maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_LISTMEMBERSREQUEST_H_

67
ledgerdb/include/alibabacloud/ledgerdb/model/ListMembersResult.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LEDGERDB_MODEL_LISTMEMBERSRESULT_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_LISTMEMBERSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT ListMembersResult : public ServiceResult
{
public:
struct Member
{
std::string role;
std::string memberId;
std::string keyType;
std::string publicKey;
std::string state;
long createTime;
long updateTime;
std::string ledgerId;
std::string aliUid;
};
ListMembersResult();
explicit ListMembersResult(const std::string &payload);
~ListMembersResult();
std::string getNextToken()const;
int getMaxResults()const;
std::vector<Member> getMembers()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
int maxResults_;
std::vector<Member> members_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_LISTMEMBERSRESULT_H_

57
ledgerdb/include/alibabacloud/ledgerdb/model/ListTimeAnchorsRequest.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_LEDGERDB_MODEL_LISTTIMEANCHORSREQUEST_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_LISTTIMEANCHORSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT ListTimeAnchorsRequest : public RpcServiceRequest
{
public:
ListTimeAnchorsRequest();
~ListTimeAnchorsRequest();
bool getReverse()const;
void setReverse(bool reverse);
std::string getLedgerId()const;
void setLedgerId(const std::string& ledgerId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
int getMaxResults()const;
void setMaxResults(int maxResults);
private:
bool reverse_;
std::string ledgerId_;
std::string nextToken_;
int maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_LISTTIMEANCHORSREQUEST_H_

64
ledgerdb/include/alibabacloud/ledgerdb/model/ListTimeAnchorsResult.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_LEDGERDB_MODEL_LISTTIMEANCHORSRESULT_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_LISTTIMEANCHORSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT ListTimeAnchorsResult : public ServiceResult
{
public:
struct TimeAnchor
{
std::string ledgerDigest;
long journalId;
std::string ledgerDigestType;
std::string proof;
long ledgerVersion;
long timeStamp;
};
ListTimeAnchorsResult();
explicit ListTimeAnchorsResult(const std::string &payload);
~ListTimeAnchorsResult();
std::vector<TimeAnchor> getTimeAnchors()const;
std::string getNextToken()const;
int getMaxResults()const;
protected:
void parse(const std::string &payload);
private:
std::vector<TimeAnchor> timeAnchors_;
std::string nextToken_;
int maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_LISTTIMEANCHORSRESULT_H_

54
ledgerdb/include/alibabacloud/ledgerdb/model/ListVpcEndpointsRequest.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_LEDGERDB_MODEL_LISTVPCENDPOINTSREQUEST_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_LISTVPCENDPOINTSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT ListVpcEndpointsRequest : public RpcServiceRequest
{
public:
ListVpcEndpointsRequest();
~ListVpcEndpointsRequest();
std::string getLedgerId()const;
void setLedgerId(const std::string& ledgerId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
int getMaxResults()const;
void setMaxResults(int maxResults);
private:
std::string ledgerId_;
std::string nextToken_;
int maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_LISTVPCENDPOINTSREQUEST_H_

67
ledgerdb/include/alibabacloud/ledgerdb/model/ListVpcEndpointsResult.h Normal file
View File

@@ -0,0 +1,67 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LEDGERDB_MODEL_LISTVPCENDPOINTSRESULT_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_LISTVPCENDPOINTSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT ListVpcEndpointsResult : public ServiceResult
{
public:
struct VpcEndpoint
{
std::string status;
std::string memberId;
std::string vpcId;
std::string address;
std::string vSwitchId;
long createTime;
std::string ledgerId;
std::string regionId;
std::string vpcEndpointId;
};
ListVpcEndpointsResult();
explicit ListVpcEndpointsResult(const std::string &payload);
~ListVpcEndpointsResult();
std::vector<VpcEndpoint> getVpcEndpoints()const;
std::string getNextToken()const;
int getMaxResults()const;
protected:
void parse(const std::string &payload);
private:
std::vector<VpcEndpoint> vpcEndpoints_;
std::string nextToken_;
int maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_LISTVPCENDPOINTSRESULT_H_

54
ledgerdb/include/alibabacloud/ledgerdb/model/ModifyLedgerAttributeRequest.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_LEDGERDB_MODEL_MODIFYLEDGERATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_MODIFYLEDGERATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT ModifyLedgerAttributeRequest : public RpcServiceRequest
{
public:
ModifyLedgerAttributeRequest();
~ModifyLedgerAttributeRequest();
std::string getLedgerId()const;
void setLedgerId(const std::string& ledgerId);
std::string getLedgerName()const;
void setLedgerName(const std::string& ledgerName);
std::string getLedgerDescription()const;
void setLedgerDescription(const std::string& ledgerDescription);
private:
std::string ledgerId_;
std::string ledgerName_;
std::string ledgerDescription_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_MODIFYLEDGERATTRIBUTEREQUEST_H_

49
ledgerdb/include/alibabacloud/ledgerdb/model/ModifyLedgerAttributeResult.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_LEDGERDB_MODEL_MODIFYLEDGERATTRIBUTERESULT_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_MODIFYLEDGERATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT ModifyLedgerAttributeResult : public ServiceResult
{
public:
ModifyLedgerAttributeResult();
explicit ModifyLedgerAttributeResult(const std::string &payload);
~ModifyLedgerAttributeResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_MODIFYLEDGERATTRIBUTERESULT_H_

54
ledgerdb/include/alibabacloud/ledgerdb/model/ModifyMemberACLsRequest.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_LEDGERDB_MODEL_MODIFYMEMBERACLSREQUEST_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_MODIFYMEMBERACLSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT ModifyMemberACLsRequest : public RpcServiceRequest
{
public:
ModifyMemberACLsRequest();
~ModifyMemberACLsRequest();
std::string getRole()const;
void setRole(const std::string& role);
std::string getLedgerId()const;
void setLedgerId(const std::string& ledgerId);
std::string getMemberId()const;
void setMemberId(const std::string& memberId);
private:
std::string role_;
std::string ledgerId_;
std::string memberId_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_MODIFYMEMBERACLSREQUEST_H_

49
ledgerdb/include/alibabacloud/ledgerdb/model/ModifyMemberACLsResult.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_LEDGERDB_MODEL_MODIFYMEMBERACLSRESULT_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_MODIFYMEMBERACLSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT ModifyMemberACLsResult : public ServiceResult
{
public:
ModifyMemberACLsResult();
explicit ModifyMemberACLsResult(const std::string &payload);
~ModifyMemberACLsResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_MODIFYMEMBERACLSRESULT_H_

57
ledgerdb/include/alibabacloud/ledgerdb/model/ModifyMemberKeyRequest.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_LEDGERDB_MODEL_MODIFYMEMBERKEYREQUEST_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_MODIFYMEMBERKEYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT ModifyMemberKeyRequest : public RpcServiceRequest
{
public:
ModifyMemberKeyRequest();
~ModifyMemberKeyRequest();
std::string getPublicKey()const;
void setPublicKey(const std::string& publicKey);
std::string getKeyType()const;
void setKeyType(const std::string& keyType);
std::string getLedgerId()const;
void setLedgerId(const std::string& ledgerId);
std::string getMemberId()const;
void setMemberId(const std::string& memberId);
private:
std::string publicKey_;
std::string keyType_;
std::string ledgerId_;
std::string memberId_;
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_MODIFYMEMBERKEYREQUEST_H_

49
ledgerdb/include/alibabacloud/ledgerdb/model/ModifyMemberKeyResult.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_LEDGERDB_MODEL_MODIFYMEMBERKEYRESULT_H_
#define ALIBABACLOUD_LEDGERDB_MODEL_MODIFYMEMBERKEYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ledgerdb/LedgerdbExport.h>
namespace AlibabaCloud
{
namespace Ledgerdb
{
namespace Model
{
class ALIBABACLOUD_LEDGERDB_EXPORT ModifyMemberKeyResult : public ServiceResult
{
public:
ModifyMemberKeyResult();
explicit ModifyMemberKeyResult(const std::string &payload);
~ModifyMemberKeyResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LEDGERDB_MODEL_MODIFYMEMBERKEYRESULT_H_