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

Modify some field types.

Browse Source
This commit is contained in:
sdk-team
2021-01-21 11:44:22 +00:00
parent baae93b317
commit 32dccef2ae
125 changed files with 9768 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

286
privatelink/include/alibabacloud/privatelink/PrivatelinkClient.h Normal file
View File

@@ -0,0 +1,286 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_PRIVATELINK_PRIVATELINKCLIENT_H_
#define ALIBABACLOUD_PRIVATELINK_PRIVATELINKCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "PrivatelinkExport.h"
#include "model/AddUserToVpcEndpointServiceRequest.h"
#include "model/AddUserToVpcEndpointServiceResult.h"
#include "model/AddZoneToVpcEndpointRequest.h"
#include "model/AddZoneToVpcEndpointResult.h"
#include "model/AttachResourceToVpcEndpointServiceRequest.h"
#include "model/AttachResourceToVpcEndpointServiceResult.h"
#include "model/AttachSecurityGroupToVpcEndpointRequest.h"
#include "model/AttachSecurityGroupToVpcEndpointResult.h"
#include "model/CreateVpcEndpointRequest.h"
#include "model/CreateVpcEndpointResult.h"
#include "model/CreateVpcEndpointServiceRequest.h"
#include "model/CreateVpcEndpointServiceResult.h"
#include "model/DeleteVpcEndpointRequest.h"
#include "model/DeleteVpcEndpointResult.h"
#include "model/DeleteVpcEndpointServiceRequest.h"
#include "model/DeleteVpcEndpointServiceResult.h"
#include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h"
#include "model/DescribeZonesRequest.h"
#include "model/DescribeZonesResult.h"
#include "model/DetachResourceFromVpcEndpointServiceRequest.h"
#include "model/DetachResourceFromVpcEndpointServiceResult.h"
#include "model/DetachSecurityGroupFromVpcEndpointRequest.h"
#include "model/DetachSecurityGroupFromVpcEndpointResult.h"
#include "model/DisableVpcEndpointConnectionRequest.h"
#include "model/DisableVpcEndpointConnectionResult.h"
#include "model/EnableVpcEndpointConnectionRequest.h"
#include "model/EnableVpcEndpointConnectionResult.h"
#include "model/GetVpcEndpointAttributeRequest.h"
#include "model/GetVpcEndpointAttributeResult.h"
#include "model/GetVpcEndpointServiceAttributeRequest.h"
#include "model/GetVpcEndpointServiceAttributeResult.h"
#include "model/ListVpcEndpointConnectionsRequest.h"
#include "model/ListVpcEndpointConnectionsResult.h"
#include "model/ListVpcEndpointSecurityGroupsRequest.h"
#include "model/ListVpcEndpointSecurityGroupsResult.h"
#include "model/ListVpcEndpointServiceResourcesRequest.h"
#include "model/ListVpcEndpointServiceResourcesResult.h"
#include "model/ListVpcEndpointServiceUsersRequest.h"
#include "model/ListVpcEndpointServiceUsersResult.h"
#include "model/ListVpcEndpointServicesRequest.h"
#include "model/ListVpcEndpointServicesResult.h"
#include "model/ListVpcEndpointServicesByEndUserRequest.h"
#include "model/ListVpcEndpointServicesByEndUserResult.h"
#include "model/ListVpcEndpointZonesRequest.h"
#include "model/ListVpcEndpointZonesResult.h"
#include "model/ListVpcEndpointsRequest.h"
#include "model/ListVpcEndpointsResult.h"
#include "model/OpenPrivateLinkServiceRequest.h"
#include "model/OpenPrivateLinkServiceResult.h"
#include "model/RemoveUserFromVpcEndpointServiceRequest.h"
#include "model/RemoveUserFromVpcEndpointServiceResult.h"
#include "model/RemoveZoneFromVpcEndpointRequest.h"
#include "model/RemoveZoneFromVpcEndpointResult.h"
#include "model/UpdateVpcEndpointAttributeRequest.h"
#include "model/UpdateVpcEndpointAttributeResult.h"
#include "model/UpdateVpcEndpointConnectionAttributeRequest.h"
#include "model/UpdateVpcEndpointConnectionAttributeResult.h"
#include "model/UpdateVpcEndpointServiceAttributeRequest.h"
#include "model/UpdateVpcEndpointServiceAttributeResult.h"
namespace AlibabaCloud
{
namespace Privatelink
{
class ALIBABACLOUD_PRIVATELINK_EXPORT PrivatelinkClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::AddUserToVpcEndpointServiceResult> AddUserToVpcEndpointServiceOutcome;
typedef std::future<AddUserToVpcEndpointServiceOutcome> AddUserToVpcEndpointServiceOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::AddUserToVpcEndpointServiceRequest&, const AddUserToVpcEndpointServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddUserToVpcEndpointServiceAsyncHandler;
typedef Outcome<Error, Model::AddZoneToVpcEndpointResult> AddZoneToVpcEndpointOutcome;
typedef std::future<AddZoneToVpcEndpointOutcome> AddZoneToVpcEndpointOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::AddZoneToVpcEndpointRequest&, const AddZoneToVpcEndpointOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddZoneToVpcEndpointAsyncHandler;
typedef Outcome<Error, Model::AttachResourceToVpcEndpointServiceResult> AttachResourceToVpcEndpointServiceOutcome;
typedef std::future<AttachResourceToVpcEndpointServiceOutcome> AttachResourceToVpcEndpointServiceOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::AttachResourceToVpcEndpointServiceRequest&, const AttachResourceToVpcEndpointServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachResourceToVpcEndpointServiceAsyncHandler;
typedef Outcome<Error, Model::AttachSecurityGroupToVpcEndpointResult> AttachSecurityGroupToVpcEndpointOutcome;
typedef std::future<AttachSecurityGroupToVpcEndpointOutcome> AttachSecurityGroupToVpcEndpointOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::AttachSecurityGroupToVpcEndpointRequest&, const AttachSecurityGroupToVpcEndpointOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachSecurityGroupToVpcEndpointAsyncHandler;
typedef Outcome<Error, Model::CreateVpcEndpointResult> CreateVpcEndpointOutcome;
typedef std::future<CreateVpcEndpointOutcome> CreateVpcEndpointOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::CreateVpcEndpointRequest&, const CreateVpcEndpointOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVpcEndpointAsyncHandler;
typedef Outcome<Error, Model::CreateVpcEndpointServiceResult> CreateVpcEndpointServiceOutcome;
typedef std::future<CreateVpcEndpointServiceOutcome> CreateVpcEndpointServiceOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::CreateVpcEndpointServiceRequest&, const CreateVpcEndpointServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVpcEndpointServiceAsyncHandler;
typedef Outcome<Error, Model::DeleteVpcEndpointResult> DeleteVpcEndpointOutcome;
typedef std::future<DeleteVpcEndpointOutcome> DeleteVpcEndpointOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::DeleteVpcEndpointRequest&, const DeleteVpcEndpointOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVpcEndpointAsyncHandler;
typedef Outcome<Error, Model::DeleteVpcEndpointServiceResult> DeleteVpcEndpointServiceOutcome;
typedef std::future<DeleteVpcEndpointServiceOutcome> DeleteVpcEndpointServiceOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::DeleteVpcEndpointServiceRequest&, const DeleteVpcEndpointServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVpcEndpointServiceAsyncHandler;
typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
typedef Outcome<Error, Model::DescribeZonesResult> DescribeZonesOutcome;
typedef std::future<DescribeZonesOutcome> DescribeZonesOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::DescribeZonesRequest&, const DescribeZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeZonesAsyncHandler;
typedef Outcome<Error, Model::DetachResourceFromVpcEndpointServiceResult> DetachResourceFromVpcEndpointServiceOutcome;
typedef std::future<DetachResourceFromVpcEndpointServiceOutcome> DetachResourceFromVpcEndpointServiceOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::DetachResourceFromVpcEndpointServiceRequest&, const DetachResourceFromVpcEndpointServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachResourceFromVpcEndpointServiceAsyncHandler;
typedef Outcome<Error, Model::DetachSecurityGroupFromVpcEndpointResult> DetachSecurityGroupFromVpcEndpointOutcome;
typedef std::future<DetachSecurityGroupFromVpcEndpointOutcome> DetachSecurityGroupFromVpcEndpointOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::DetachSecurityGroupFromVpcEndpointRequest&, const DetachSecurityGroupFromVpcEndpointOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachSecurityGroupFromVpcEndpointAsyncHandler;
typedef Outcome<Error, Model::DisableVpcEndpointConnectionResult> DisableVpcEndpointConnectionOutcome;
typedef std::future<DisableVpcEndpointConnectionOutcome> DisableVpcEndpointConnectionOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::DisableVpcEndpointConnectionRequest&, const DisableVpcEndpointConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableVpcEndpointConnectionAsyncHandler;
typedef Outcome<Error, Model::EnableVpcEndpointConnectionResult> EnableVpcEndpointConnectionOutcome;
typedef std::future<EnableVpcEndpointConnectionOutcome> EnableVpcEndpointConnectionOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::EnableVpcEndpointConnectionRequest&, const EnableVpcEndpointConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableVpcEndpointConnectionAsyncHandler;
typedef Outcome<Error, Model::GetVpcEndpointAttributeResult> GetVpcEndpointAttributeOutcome;
typedef std::future<GetVpcEndpointAttributeOutcome> GetVpcEndpointAttributeOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::GetVpcEndpointAttributeRequest&, const GetVpcEndpointAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVpcEndpointAttributeAsyncHandler;
typedef Outcome<Error, Model::GetVpcEndpointServiceAttributeResult> GetVpcEndpointServiceAttributeOutcome;
typedef std::future<GetVpcEndpointServiceAttributeOutcome> GetVpcEndpointServiceAttributeOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::GetVpcEndpointServiceAttributeRequest&, const GetVpcEndpointServiceAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVpcEndpointServiceAttributeAsyncHandler;
typedef Outcome<Error, Model::ListVpcEndpointConnectionsResult> ListVpcEndpointConnectionsOutcome;
typedef std::future<ListVpcEndpointConnectionsOutcome> ListVpcEndpointConnectionsOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::ListVpcEndpointConnectionsRequest&, const ListVpcEndpointConnectionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpcEndpointConnectionsAsyncHandler;
typedef Outcome<Error, Model::ListVpcEndpointSecurityGroupsResult> ListVpcEndpointSecurityGroupsOutcome;
typedef std::future<ListVpcEndpointSecurityGroupsOutcome> ListVpcEndpointSecurityGroupsOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::ListVpcEndpointSecurityGroupsRequest&, const ListVpcEndpointSecurityGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpcEndpointSecurityGroupsAsyncHandler;
typedef Outcome<Error, Model::ListVpcEndpointServiceResourcesResult> ListVpcEndpointServiceResourcesOutcome;
typedef std::future<ListVpcEndpointServiceResourcesOutcome> ListVpcEndpointServiceResourcesOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::ListVpcEndpointServiceResourcesRequest&, const ListVpcEndpointServiceResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpcEndpointServiceResourcesAsyncHandler;
typedef Outcome<Error, Model::ListVpcEndpointServiceUsersResult> ListVpcEndpointServiceUsersOutcome;
typedef std::future<ListVpcEndpointServiceUsersOutcome> ListVpcEndpointServiceUsersOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::ListVpcEndpointServiceUsersRequest&, const ListVpcEndpointServiceUsersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpcEndpointServiceUsersAsyncHandler;
typedef Outcome<Error, Model::ListVpcEndpointServicesResult> ListVpcEndpointServicesOutcome;
typedef std::future<ListVpcEndpointServicesOutcome> ListVpcEndpointServicesOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::ListVpcEndpointServicesRequest&, const ListVpcEndpointServicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpcEndpointServicesAsyncHandler;
typedef Outcome<Error, Model::ListVpcEndpointServicesByEndUserResult> ListVpcEndpointServicesByEndUserOutcome;
typedef std::future<ListVpcEndpointServicesByEndUserOutcome> ListVpcEndpointServicesByEndUserOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::ListVpcEndpointServicesByEndUserRequest&, const ListVpcEndpointServicesByEndUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpcEndpointServicesByEndUserAsyncHandler;
typedef Outcome<Error, Model::ListVpcEndpointZonesResult> ListVpcEndpointZonesOutcome;
typedef std::future<ListVpcEndpointZonesOutcome> ListVpcEndpointZonesOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::ListVpcEndpointZonesRequest&, const ListVpcEndpointZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpcEndpointZonesAsyncHandler;
typedef Outcome<Error, Model::ListVpcEndpointsResult> ListVpcEndpointsOutcome;
typedef std::future<ListVpcEndpointsOutcome> ListVpcEndpointsOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::ListVpcEndpointsRequest&, const ListVpcEndpointsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVpcEndpointsAsyncHandler;
typedef Outcome<Error, Model::OpenPrivateLinkServiceResult> OpenPrivateLinkServiceOutcome;
typedef std::future<OpenPrivateLinkServiceOutcome> OpenPrivateLinkServiceOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::OpenPrivateLinkServiceRequest&, const OpenPrivateLinkServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> OpenPrivateLinkServiceAsyncHandler;
typedef Outcome<Error, Model::RemoveUserFromVpcEndpointServiceResult> RemoveUserFromVpcEndpointServiceOutcome;
typedef std::future<RemoveUserFromVpcEndpointServiceOutcome> RemoveUserFromVpcEndpointServiceOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::RemoveUserFromVpcEndpointServiceRequest&, const RemoveUserFromVpcEndpointServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveUserFromVpcEndpointServiceAsyncHandler;
typedef Outcome<Error, Model::RemoveZoneFromVpcEndpointResult> RemoveZoneFromVpcEndpointOutcome;
typedef std::future<RemoveZoneFromVpcEndpointOutcome> RemoveZoneFromVpcEndpointOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::RemoveZoneFromVpcEndpointRequest&, const RemoveZoneFromVpcEndpointOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveZoneFromVpcEndpointAsyncHandler;
typedef Outcome<Error, Model::UpdateVpcEndpointAttributeResult> UpdateVpcEndpointAttributeOutcome;
typedef std::future<UpdateVpcEndpointAttributeOutcome> UpdateVpcEndpointAttributeOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::UpdateVpcEndpointAttributeRequest&, const UpdateVpcEndpointAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateVpcEndpointAttributeAsyncHandler;
typedef Outcome<Error, Model::UpdateVpcEndpointConnectionAttributeResult> UpdateVpcEndpointConnectionAttributeOutcome;
typedef std::future<UpdateVpcEndpointConnectionAttributeOutcome> UpdateVpcEndpointConnectionAttributeOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::UpdateVpcEndpointConnectionAttributeRequest&, const UpdateVpcEndpointConnectionAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateVpcEndpointConnectionAttributeAsyncHandler;
typedef Outcome<Error, Model::UpdateVpcEndpointServiceAttributeResult> UpdateVpcEndpointServiceAttributeOutcome;
typedef std::future<UpdateVpcEndpointServiceAttributeOutcome> UpdateVpcEndpointServiceAttributeOutcomeCallable;
typedef std::function<void(const PrivatelinkClient*, const Model::UpdateVpcEndpointServiceAttributeRequest&, const UpdateVpcEndpointServiceAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateVpcEndpointServiceAttributeAsyncHandler;
PrivatelinkClient(const Credentials &credentials, const ClientConfiguration &configuration);
PrivatelinkClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
PrivatelinkClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~PrivatelinkClient();
AddUserToVpcEndpointServiceOutcome addUserToVpcEndpointService(const Model::AddUserToVpcEndpointServiceRequest &request)const;
void addUserToVpcEndpointServiceAsync(const Model::AddUserToVpcEndpointServiceRequest& request, const AddUserToVpcEndpointServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddUserToVpcEndpointServiceOutcomeCallable addUserToVpcEndpointServiceCallable(const Model::AddUserToVpcEndpointServiceRequest& request) const;
AddZoneToVpcEndpointOutcome addZoneToVpcEndpoint(const Model::AddZoneToVpcEndpointRequest &request)const;
void addZoneToVpcEndpointAsync(const Model::AddZoneToVpcEndpointRequest& request, const AddZoneToVpcEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddZoneToVpcEndpointOutcomeCallable addZoneToVpcEndpointCallable(const Model::AddZoneToVpcEndpointRequest& request) const;
AttachResourceToVpcEndpointServiceOutcome attachResourceToVpcEndpointService(const Model::AttachResourceToVpcEndpointServiceRequest &request)const;
void attachResourceToVpcEndpointServiceAsync(const Model::AttachResourceToVpcEndpointServiceRequest& request, const AttachResourceToVpcEndpointServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AttachResourceToVpcEndpointServiceOutcomeCallable attachResourceToVpcEndpointServiceCallable(const Model::AttachResourceToVpcEndpointServiceRequest& request) const;
AttachSecurityGroupToVpcEndpointOutcome attachSecurityGroupToVpcEndpoint(const Model::AttachSecurityGroupToVpcEndpointRequest &request)const;
void attachSecurityGroupToVpcEndpointAsync(const Model::AttachSecurityGroupToVpcEndpointRequest& request, const AttachSecurityGroupToVpcEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AttachSecurityGroupToVpcEndpointOutcomeCallable attachSecurityGroupToVpcEndpointCallable(const Model::AttachSecurityGroupToVpcEndpointRequest& 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;
CreateVpcEndpointServiceOutcome createVpcEndpointService(const Model::CreateVpcEndpointServiceRequest &request)const;
void createVpcEndpointServiceAsync(const Model::CreateVpcEndpointServiceRequest& request, const CreateVpcEndpointServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateVpcEndpointServiceOutcomeCallable createVpcEndpointServiceCallable(const Model::CreateVpcEndpointServiceRequest& 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;
DeleteVpcEndpointServiceOutcome deleteVpcEndpointService(const Model::DeleteVpcEndpointServiceRequest &request)const;
void deleteVpcEndpointServiceAsync(const Model::DeleteVpcEndpointServiceRequest& request, const DeleteVpcEndpointServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteVpcEndpointServiceOutcomeCallable deleteVpcEndpointServiceCallable(const Model::DeleteVpcEndpointServiceRequest& 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;
DescribeZonesOutcome describeZones(const Model::DescribeZonesRequest &request)const;
void describeZonesAsync(const Model::DescribeZonesRequest& request, const DescribeZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeZonesOutcomeCallable describeZonesCallable(const Model::DescribeZonesRequest& request) const;
DetachResourceFromVpcEndpointServiceOutcome detachResourceFromVpcEndpointService(const Model::DetachResourceFromVpcEndpointServiceRequest &request)const;
void detachResourceFromVpcEndpointServiceAsync(const Model::DetachResourceFromVpcEndpointServiceRequest& request, const DetachResourceFromVpcEndpointServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetachResourceFromVpcEndpointServiceOutcomeCallable detachResourceFromVpcEndpointServiceCallable(const Model::DetachResourceFromVpcEndpointServiceRequest& request) const;
DetachSecurityGroupFromVpcEndpointOutcome detachSecurityGroupFromVpcEndpoint(const Model::DetachSecurityGroupFromVpcEndpointRequest &request)const;
void detachSecurityGroupFromVpcEndpointAsync(const Model::DetachSecurityGroupFromVpcEndpointRequest& request, const DetachSecurityGroupFromVpcEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DetachSecurityGroupFromVpcEndpointOutcomeCallable detachSecurityGroupFromVpcEndpointCallable(const Model::DetachSecurityGroupFromVpcEndpointRequest& request) const;
DisableVpcEndpointConnectionOutcome disableVpcEndpointConnection(const Model::DisableVpcEndpointConnectionRequest &request)const;
void disableVpcEndpointConnectionAsync(const Model::DisableVpcEndpointConnectionRequest& request, const DisableVpcEndpointConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DisableVpcEndpointConnectionOutcomeCallable disableVpcEndpointConnectionCallable(const Model::DisableVpcEndpointConnectionRequest& request) const;
EnableVpcEndpointConnectionOutcome enableVpcEndpointConnection(const Model::EnableVpcEndpointConnectionRequest &request)const;
void enableVpcEndpointConnectionAsync(const Model::EnableVpcEndpointConnectionRequest& request, const EnableVpcEndpointConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EnableVpcEndpointConnectionOutcomeCallable enableVpcEndpointConnectionCallable(const Model::EnableVpcEndpointConnectionRequest& request) const;
GetVpcEndpointAttributeOutcome getVpcEndpointAttribute(const Model::GetVpcEndpointAttributeRequest &request)const;
void getVpcEndpointAttributeAsync(const Model::GetVpcEndpointAttributeRequest& request, const GetVpcEndpointAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetVpcEndpointAttributeOutcomeCallable getVpcEndpointAttributeCallable(const Model::GetVpcEndpointAttributeRequest& request) const;
GetVpcEndpointServiceAttributeOutcome getVpcEndpointServiceAttribute(const Model::GetVpcEndpointServiceAttributeRequest &request)const;
void getVpcEndpointServiceAttributeAsync(const Model::GetVpcEndpointServiceAttributeRequest& request, const GetVpcEndpointServiceAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetVpcEndpointServiceAttributeOutcomeCallable getVpcEndpointServiceAttributeCallable(const Model::GetVpcEndpointServiceAttributeRequest& request) const;
ListVpcEndpointConnectionsOutcome listVpcEndpointConnections(const Model::ListVpcEndpointConnectionsRequest &request)const;
void listVpcEndpointConnectionsAsync(const Model::ListVpcEndpointConnectionsRequest& request, const ListVpcEndpointConnectionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListVpcEndpointConnectionsOutcomeCallable listVpcEndpointConnectionsCallable(const Model::ListVpcEndpointConnectionsRequest& request) const;
ListVpcEndpointSecurityGroupsOutcome listVpcEndpointSecurityGroups(const Model::ListVpcEndpointSecurityGroupsRequest &request)const;
void listVpcEndpointSecurityGroupsAsync(const Model::ListVpcEndpointSecurityGroupsRequest& request, const ListVpcEndpointSecurityGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListVpcEndpointSecurityGroupsOutcomeCallable listVpcEndpointSecurityGroupsCallable(const Model::ListVpcEndpointSecurityGroupsRequest& request) const;
ListVpcEndpointServiceResourcesOutcome listVpcEndpointServiceResources(const Model::ListVpcEndpointServiceResourcesRequest &request)const;
void listVpcEndpointServiceResourcesAsync(const Model::ListVpcEndpointServiceResourcesRequest& request, const ListVpcEndpointServiceResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListVpcEndpointServiceResourcesOutcomeCallable listVpcEndpointServiceResourcesCallable(const Model::ListVpcEndpointServiceResourcesRequest& request) const;
ListVpcEndpointServiceUsersOutcome listVpcEndpointServiceUsers(const Model::ListVpcEndpointServiceUsersRequest &request)const;
void listVpcEndpointServiceUsersAsync(const Model::ListVpcEndpointServiceUsersRequest& request, const ListVpcEndpointServiceUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListVpcEndpointServiceUsersOutcomeCallable listVpcEndpointServiceUsersCallable(const Model::ListVpcEndpointServiceUsersRequest& request) const;
ListVpcEndpointServicesOutcome listVpcEndpointServices(const Model::ListVpcEndpointServicesRequest &request)const;
void listVpcEndpointServicesAsync(const Model::ListVpcEndpointServicesRequest& request, const ListVpcEndpointServicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListVpcEndpointServicesOutcomeCallable listVpcEndpointServicesCallable(const Model::ListVpcEndpointServicesRequest& request) const;
ListVpcEndpointServicesByEndUserOutcome listVpcEndpointServicesByEndUser(const Model::ListVpcEndpointServicesByEndUserRequest &request)const;
void listVpcEndpointServicesByEndUserAsync(const Model::ListVpcEndpointServicesByEndUserRequest& request, const ListVpcEndpointServicesByEndUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListVpcEndpointServicesByEndUserOutcomeCallable listVpcEndpointServicesByEndUserCallable(const Model::ListVpcEndpointServicesByEndUserRequest& request) const;
ListVpcEndpointZonesOutcome listVpcEndpointZones(const Model::ListVpcEndpointZonesRequest &request)const;
void listVpcEndpointZonesAsync(const Model::ListVpcEndpointZonesRequest& request, const ListVpcEndpointZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListVpcEndpointZonesOutcomeCallable listVpcEndpointZonesCallable(const Model::ListVpcEndpointZonesRequest& 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;
OpenPrivateLinkServiceOutcome openPrivateLinkService(const Model::OpenPrivateLinkServiceRequest &request)const;
void openPrivateLinkServiceAsync(const Model::OpenPrivateLinkServiceRequest& request, const OpenPrivateLinkServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
OpenPrivateLinkServiceOutcomeCallable openPrivateLinkServiceCallable(const Model::OpenPrivateLinkServiceRequest& request) const;
RemoveUserFromVpcEndpointServiceOutcome removeUserFromVpcEndpointService(const Model::RemoveUserFromVpcEndpointServiceRequest &request)const;
void removeUserFromVpcEndpointServiceAsync(const Model::RemoveUserFromVpcEndpointServiceRequest& request, const RemoveUserFromVpcEndpointServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RemoveUserFromVpcEndpointServiceOutcomeCallable removeUserFromVpcEndpointServiceCallable(const Model::RemoveUserFromVpcEndpointServiceRequest& request) const;
RemoveZoneFromVpcEndpointOutcome removeZoneFromVpcEndpoint(const Model::RemoveZoneFromVpcEndpointRequest &request)const;
void removeZoneFromVpcEndpointAsync(const Model::RemoveZoneFromVpcEndpointRequest& request, const RemoveZoneFromVpcEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RemoveZoneFromVpcEndpointOutcomeCallable removeZoneFromVpcEndpointCallable(const Model::RemoveZoneFromVpcEndpointRequest& request) const;
UpdateVpcEndpointAttributeOutcome updateVpcEndpointAttribute(const Model::UpdateVpcEndpointAttributeRequest &request)const;
void updateVpcEndpointAttributeAsync(const Model::UpdateVpcEndpointAttributeRequest& request, const UpdateVpcEndpointAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateVpcEndpointAttributeOutcomeCallable updateVpcEndpointAttributeCallable(const Model::UpdateVpcEndpointAttributeRequest& request) const;
UpdateVpcEndpointConnectionAttributeOutcome updateVpcEndpointConnectionAttribute(const Model::UpdateVpcEndpointConnectionAttributeRequest &request)const;
void updateVpcEndpointConnectionAttributeAsync(const Model::UpdateVpcEndpointConnectionAttributeRequest& request, const UpdateVpcEndpointConnectionAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateVpcEndpointConnectionAttributeOutcomeCallable updateVpcEndpointConnectionAttributeCallable(const Model::UpdateVpcEndpointConnectionAttributeRequest& request) const;
UpdateVpcEndpointServiceAttributeOutcome updateVpcEndpointServiceAttribute(const Model::UpdateVpcEndpointServiceAttributeRequest &request)const;
void updateVpcEndpointServiceAttributeAsync(const Model::UpdateVpcEndpointServiceAttributeRequest& request, const UpdateVpcEndpointServiceAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateVpcEndpointServiceAttributeOutcomeCallable updateVpcEndpointServiceAttributeCallable(const Model::UpdateVpcEndpointServiceAttributeRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_PRIVATELINKCLIENT_H_

32
privatelink/include/alibabacloud/privatelink/PrivatelinkExport.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_PRIVATELINK_PRIVATELINKEXPORT_H_
#define ALIBABACLOUD_PRIVATELINK_PRIVATELINKEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_PRIVATELINK_LIBRARY)
# define ALIBABACLOUD_PRIVATELINK_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_PRIVATELINK_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_PRIVATELINK_EXPORT
#endif
#endif // !ALIBABACLOUD_PRIVATELINK_PRIVATELINKEXPORT_H_

60
privatelink/include/alibabacloud/privatelink/model/AddUserToVpcEndpointServiceRequest.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_PRIVATELINK_MODEL_ADDUSERTOVPCENDPOINTSERVICEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_ADDUSERTOVPCENDPOINTSERVICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT AddUserToVpcEndpointServiceRequest : public RpcServiceRequest
{
public:
AddUserToVpcEndpointServiceRequest();
~AddUserToVpcEndpointServiceRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getUserId()const;
void setUserId(const std::string& userId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getDryRun()const;
void setDryRun(bool dryRun);
std::string getServiceId()const;
void setServiceId(const std::string& serviceId);
private:
std::string clientToken_;
std::string userId_;
std::string regionId_;
bool dryRun_;
std::string serviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ADDUSERTOVPCENDPOINTSERVICEREQUEST_H_

49
privatelink/include/alibabacloud/privatelink/model/AddUserToVpcEndpointServiceResult.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_PRIVATELINK_MODEL_ADDUSERTOVPCENDPOINTSERVICERESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_ADDUSERTOVPCENDPOINTSERVICERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT AddUserToVpcEndpointServiceResult : public ServiceResult
{
public:
AddUserToVpcEndpointServiceResult();
explicit AddUserToVpcEndpointServiceResult(const std::string &payload);
~AddUserToVpcEndpointServiceResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ADDUSERTOVPCENDPOINTSERVICERESULT_H_

63
privatelink/include/alibabacloud/privatelink/model/AddZoneToVpcEndpointRequest.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_PRIVATELINK_MODEL_ADDZONETOVPCENDPOINTREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_ADDZONETOVPCENDPOINTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT AddZoneToVpcEndpointRequest : public RpcServiceRequest
{
public:
AddZoneToVpcEndpointRequest();
~AddZoneToVpcEndpointRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getEndpointId()const;
void setEndpointId(const std::string& endpointId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getDryRun()const;
void setDryRun(bool dryRun);
std::string getVSwitchId()const;
void setVSwitchId(const std::string& vSwitchId);
std::string getZoneId()const;
void setZoneId(const std::string& zoneId);
private:
std::string clientToken_;
std::string endpointId_;
std::string regionId_;
bool dryRun_;
std::string vSwitchId_;
std::string zoneId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ADDZONETOVPCENDPOINTREQUEST_H_

49
privatelink/include/alibabacloud/privatelink/model/AddZoneToVpcEndpointResult.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_PRIVATELINK_MODEL_ADDZONETOVPCENDPOINTRESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_ADDZONETOVPCENDPOINTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT AddZoneToVpcEndpointResult : public ServiceResult
{
public:
AddZoneToVpcEndpointResult();
explicit AddZoneToVpcEndpointResult(const std::string &payload);
~AddZoneToVpcEndpointResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ADDZONETOVPCENDPOINTRESULT_H_

63
privatelink/include/alibabacloud/privatelink/model/AttachResourceToVpcEndpointServiceRequest.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_PRIVATELINK_MODEL_ATTACHRESOURCETOVPCENDPOINTSERVICEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHRESOURCETOVPCENDPOINTSERVICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT AttachResourceToVpcEndpointServiceRequest : public RpcServiceRequest
{
public:
AttachResourceToVpcEndpointServiceRequest();
~AttachResourceToVpcEndpointServiceRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceId()const;
void setResourceId(const std::string& resourceId);
bool getDryRun()const;
void setDryRun(bool dryRun);
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
std::string getServiceId()const;
void setServiceId(const std::string& serviceId);
private:
std::string clientToken_;
std::string regionId_;
std::string resourceId_;
bool dryRun_;
std::string resourceType_;
std::string serviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHRESOURCETOVPCENDPOINTSERVICEREQUEST_H_

49
privatelink/include/alibabacloud/privatelink/model/AttachResourceToVpcEndpointServiceResult.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_PRIVATELINK_MODEL_ATTACHRESOURCETOVPCENDPOINTSERVICERESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHRESOURCETOVPCENDPOINTSERVICERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT AttachResourceToVpcEndpointServiceResult : public ServiceResult
{
public:
AttachResourceToVpcEndpointServiceResult();
explicit AttachResourceToVpcEndpointServiceResult(const std::string &payload);
~AttachResourceToVpcEndpointServiceResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHRESOURCETOVPCENDPOINTSERVICERESULT_H_

60
privatelink/include/alibabacloud/privatelink/model/AttachSecurityGroupToVpcEndpointRequest.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_PRIVATELINK_MODEL_ATTACHSECURITYGROUPTOVPCENDPOINTREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHSECURITYGROUPTOVPCENDPOINTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT AttachSecurityGroupToVpcEndpointRequest : public RpcServiceRequest
{
public:
AttachSecurityGroupToVpcEndpointRequest();
~AttachSecurityGroupToVpcEndpointRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getEndpointId()const;
void setEndpointId(const std::string& endpointId);
std::string getSecurityGroupId()const;
void setSecurityGroupId(const std::string& securityGroupId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getDryRun()const;
void setDryRun(bool dryRun);
private:
std::string clientToken_;
std::string endpointId_;
std::string securityGroupId_;
std::string regionId_;
bool dryRun_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHSECURITYGROUPTOVPCENDPOINTREQUEST_H_

49
privatelink/include/alibabacloud/privatelink/model/AttachSecurityGroupToVpcEndpointResult.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_PRIVATELINK_MODEL_ATTACHSECURITYGROUPTOVPCENDPOINTRESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHSECURITYGROUPTOVPCENDPOINTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT AttachSecurityGroupToVpcEndpointResult : public ServiceResult
{
public:
AttachSecurityGroupToVpcEndpointResult();
explicit AttachSecurityGroupToVpcEndpointResult(const std::string &payload);
~AttachSecurityGroupToVpcEndpointResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHSECURITYGROUPTOVPCENDPOINTRESULT_H_

81
privatelink/include/alibabacloud/privatelink/model/CreateVpcEndpointRequest.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_PRIVATELINK_MODEL_CREATEVPCENDPOINTREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT CreateVpcEndpointRequest : public RpcServiceRequest
{
public:
struct Zone
{
std::string vSwitchId;
std::string zoneId;
};
public:
CreateVpcEndpointRequest();
~CreateVpcEndpointRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::vector<std::string> getSecurityGroupId()const;
void setSecurityGroupId(const std::vector<std::string>& securityGroupId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::vector<Zone> getZone()const;
void setZone(const std::vector<Zone>& zone);
std::string getServiceName()const;
void setServiceName(const std::string& serviceName);
bool getDryRun()const;
void setDryRun(bool dryRun);
std::string getEndpointDescription()const;
void setEndpointDescription(const std::string& endpointDescription);
std::string getEndpointName()const;
void setEndpointName(const std::string& endpointName);
std::string getVpcId()const;
void setVpcId(const std::string& vpcId);
std::string getServiceId()const;
void setServiceId(const std::string& serviceId);
private:
std::string clientToken_;
std::vector<std::string> securityGroupId_;
std::string regionId_;
std::vector<Zone> zone_;
std::string serviceName_;
bool dryRun_;
std::string endpointDescription_;
std::string endpointName_;
std::string vpcId_;
std::string serviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTREQUEST_H_

73
privatelink/include/alibabacloud/privatelink/model/CreateVpcEndpointResult.h Normal file
View File

@@ -0,0 +1,73 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTRESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT CreateVpcEndpointResult : public ServiceResult
{
public:
CreateVpcEndpointResult();
explicit CreateVpcEndpointResult(const std::string &payload);
~CreateVpcEndpointResult();
std::string getEndpointStatus()const;
std::string getEndpointName()const;
std::string getVpcId()const;
std::string getEndpointDomain()const;
std::string getServiceName()const;
std::string getEndpointId()const;
std::string getCreateTime()const;
long getBandwidth()const;
std::string getEndpointBusinessStatus()const;
std::string getEndpointDescription()const;
std::string getConnectionStatus()const;
std::string getServiceId()const;
protected:
void parse(const std::string &payload);
private:
std::string endpointStatus_;
std::string endpointName_;
std::string vpcId_;
std::string endpointDomain_;
std::string serviceName_;
std::string endpointId_;
std::string createTime_;
long bandwidth_;
std::string endpointBusinessStatus_;
std::string endpointDescription_;
std::string connectionStatus_;
std::string serviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTRESULT_H_

72
privatelink/include/alibabacloud/privatelink/model/CreateVpcEndpointServiceRequest.h Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTSERVICEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTSERVICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT CreateVpcEndpointServiceRequest : public RpcServiceRequest
{
public:
struct Resource
{
std::string resourceId;
std::string resourceType;
};
public:
CreateVpcEndpointServiceRequest();
~CreateVpcEndpointServiceRequest();
bool getAutoAcceptEnabled()const;
void setAutoAcceptEnabled(bool autoAcceptEnabled);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getPayer()const;
void setPayer(const std::string& payer);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getDryRun()const;
void setDryRun(bool dryRun);
std::vector<Resource> getResource()const;
void setResource(const std::vector<Resource>& resource);
std::string getServiceDescription()const;
void setServiceDescription(const std::string& serviceDescription);
private:
bool autoAcceptEnabled_;
std::string clientToken_;
std::string payer_;
std::string regionId_;
bool dryRun_;
std::vector<Resource> resource_;
std::string serviceDescription_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTSERVICEREQUEST_H_

65
privatelink/include/alibabacloud/privatelink/model/CreateVpcEndpointServiceResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTSERVICERESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTSERVICERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT CreateVpcEndpointServiceResult : public ServiceResult
{
public:
CreateVpcEndpointServiceResult();
explicit CreateVpcEndpointServiceResult(const std::string &payload);
~CreateVpcEndpointServiceResult();
std::string getServiceBusinessStatus()const;
std::string getServiceName()const;
std::string getServiceDescription()const;
std::string getServiceStatus()const;
std::string getCreateTime()const;
std::string getServiceDomain()const;
bool getAutoAcceptEnabled()const;
std::string getServiceId()const;
protected:
void parse(const std::string &payload);
private:
std::string serviceBusinessStatus_;
std::string serviceName_;
std::string serviceDescription_;
std::string serviceStatus_;
std::string createTime_;
std::string serviceDomain_;
bool autoAcceptEnabled_;
std::string serviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTSERVICERESULT_H_

57
privatelink/include/alibabacloud/privatelink/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_PRIVATELINK_MODEL_DELETEVPCENDPOINTREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT DeleteVpcEndpointRequest : public RpcServiceRequest
{
public:
DeleteVpcEndpointRequest();
~DeleteVpcEndpointRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getEndpointId()const;
void setEndpointId(const std::string& endpointId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getDryRun()const;
void setDryRun(bool dryRun);
private:
std::string clientToken_;
std::string endpointId_;
std::string regionId_;
bool dryRun_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTREQUEST_H_

49
privatelink/include/alibabacloud/privatelink/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_PRIVATELINK_MODEL_DELETEVPCENDPOINTRESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT DeleteVpcEndpointResult : public ServiceResult
{
public:
DeleteVpcEndpointResult();
explicit DeleteVpcEndpointResult(const std::string &payload);
~DeleteVpcEndpointResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTRESULT_H_

57
privatelink/include/alibabacloud/privatelink/model/DeleteVpcEndpointServiceRequest.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_PRIVATELINK_MODEL_DELETEVPCENDPOINTSERVICEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTSERVICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT DeleteVpcEndpointServiceRequest : public RpcServiceRequest
{
public:
DeleteVpcEndpointServiceRequest();
~DeleteVpcEndpointServiceRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getDryRun()const;
void setDryRun(bool dryRun);
std::string getServiceId()const;
void setServiceId(const std::string& serviceId);
private:
std::string clientToken_;
std::string regionId_;
bool dryRun_;
std::string serviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTSERVICEREQUEST_H_

49
privatelink/include/alibabacloud/privatelink/model/DeleteVpcEndpointServiceResult.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_PRIVATELINK_MODEL_DELETEVPCENDPOINTSERVICERESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTSERVICERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT DeleteVpcEndpointServiceResult : public ServiceResult
{
public:
DeleteVpcEndpointServiceResult();
explicit DeleteVpcEndpointServiceResult(const std::string &payload);
~DeleteVpcEndpointServiceResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTSERVICERESULT_H_

48
privatelink/include/alibabacloud/privatelink/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_PRIVATELINK_MODEL_DESCRIBEREGIONSREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_DESCRIBEREGIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT DescribeRegionsRequest : public RpcServiceRequest
{
public:
DescribeRegionsRequest();
~DescribeRegionsRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DESCRIBEREGIONSREQUEST_H_

57
privatelink/include/alibabacloud/privatelink/model/DescribeRegionsResult.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_PRIVATELINK_MODEL_DESCRIBEREGIONSRESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_DESCRIBEREGIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT DescribeRegionsResult : public ServiceResult
{
public:
struct Region
{
std::string regionId;
std::string regionEndpoint;
std::string localName;
};
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_PRIVATELINK_MODEL_DESCRIBEREGIONSRESULT_H_

48
privatelink/include/alibabacloud/privatelink/model/DescribeZonesRequest.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_PRIVATELINK_MODEL_DESCRIBEZONESREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_DESCRIBEZONESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT DescribeZonesRequest : public RpcServiceRequest
{
public:
DescribeZonesRequest();
~DescribeZonesRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DESCRIBEZONESREQUEST_H_

56
privatelink/include/alibabacloud/privatelink/model/DescribeZonesResult.h Normal file
View File

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

63
privatelink/include/alibabacloud/privatelink/model/DetachResourceFromVpcEndpointServiceRequest.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_PRIVATELINK_MODEL_DETACHRESOURCEFROMVPCENDPOINTSERVICEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_DETACHRESOURCEFROMVPCENDPOINTSERVICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT DetachResourceFromVpcEndpointServiceRequest : public RpcServiceRequest
{
public:
DetachResourceFromVpcEndpointServiceRequest();
~DetachResourceFromVpcEndpointServiceRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceId()const;
void setResourceId(const std::string& resourceId);
bool getDryRun()const;
void setDryRun(bool dryRun);
std::string getResourceType()const;
void setResourceType(const std::string& resourceType);
std::string getServiceId()const;
void setServiceId(const std::string& serviceId);
private:
std::string clientToken_;
std::string regionId_;
std::string resourceId_;
bool dryRun_;
std::string resourceType_;
std::string serviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DETACHRESOURCEFROMVPCENDPOINTSERVICEREQUEST_H_

49
privatelink/include/alibabacloud/privatelink/model/DetachResourceFromVpcEndpointServiceResult.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_PRIVATELINK_MODEL_DETACHRESOURCEFROMVPCENDPOINTSERVICERESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_DETACHRESOURCEFROMVPCENDPOINTSERVICERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT DetachResourceFromVpcEndpointServiceResult : public ServiceResult
{
public:
DetachResourceFromVpcEndpointServiceResult();
explicit DetachResourceFromVpcEndpointServiceResult(const std::string &payload);
~DetachResourceFromVpcEndpointServiceResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DETACHRESOURCEFROMVPCENDPOINTSERVICERESULT_H_

60
privatelink/include/alibabacloud/privatelink/model/DetachSecurityGroupFromVpcEndpointRequest.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_PRIVATELINK_MODEL_DETACHSECURITYGROUPFROMVPCENDPOINTREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_DETACHSECURITYGROUPFROMVPCENDPOINTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT DetachSecurityGroupFromVpcEndpointRequest : public RpcServiceRequest
{
public:
DetachSecurityGroupFromVpcEndpointRequest();
~DetachSecurityGroupFromVpcEndpointRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getEndpointId()const;
void setEndpointId(const std::string& endpointId);
std::string getSecurityGroupId()const;
void setSecurityGroupId(const std::string& securityGroupId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getDryRun()const;
void setDryRun(bool dryRun);
private:
std::string clientToken_;
std::string endpointId_;
std::string securityGroupId_;
std::string regionId_;
bool dryRun_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DETACHSECURITYGROUPFROMVPCENDPOINTREQUEST_H_

49
privatelink/include/alibabacloud/privatelink/model/DetachSecurityGroupFromVpcEndpointResult.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_PRIVATELINK_MODEL_DETACHSECURITYGROUPFROMVPCENDPOINTRESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_DETACHSECURITYGROUPFROMVPCENDPOINTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT DetachSecurityGroupFromVpcEndpointResult : public ServiceResult
{
public:
DetachSecurityGroupFromVpcEndpointResult();
explicit DetachSecurityGroupFromVpcEndpointResult(const std::string &payload);
~DetachSecurityGroupFromVpcEndpointResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DETACHSECURITYGROUPFROMVPCENDPOINTRESULT_H_

60
privatelink/include/alibabacloud/privatelink/model/DisableVpcEndpointConnectionRequest.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_PRIVATELINK_MODEL_DISABLEVPCENDPOINTCONNECTIONREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_DISABLEVPCENDPOINTCONNECTIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT DisableVpcEndpointConnectionRequest : public RpcServiceRequest
{
public:
DisableVpcEndpointConnectionRequest();
~DisableVpcEndpointConnectionRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getEndpointId()const;
void setEndpointId(const std::string& endpointId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getDryRun()const;
void setDryRun(bool dryRun);
std::string getServiceId()const;
void setServiceId(const std::string& serviceId);
private:
std::string clientToken_;
std::string endpointId_;
std::string regionId_;
bool dryRun_;
std::string serviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DISABLEVPCENDPOINTCONNECTIONREQUEST_H_

49
privatelink/include/alibabacloud/privatelink/model/DisableVpcEndpointConnectionResult.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_PRIVATELINK_MODEL_DISABLEVPCENDPOINTCONNECTIONRESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_DISABLEVPCENDPOINTCONNECTIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT DisableVpcEndpointConnectionResult : public ServiceResult
{
public:
DisableVpcEndpointConnectionResult();
explicit DisableVpcEndpointConnectionResult(const std::string &payload);
~DisableVpcEndpointConnectionResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DISABLEVPCENDPOINTCONNECTIONRESULT_H_

63
privatelink/include/alibabacloud/privatelink/model/EnableVpcEndpointConnectionRequest.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_PRIVATELINK_MODEL_ENABLEVPCENDPOINTCONNECTIONREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_ENABLEVPCENDPOINTCONNECTIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT EnableVpcEndpointConnectionRequest : public RpcServiceRequest
{
public:
EnableVpcEndpointConnectionRequest();
~EnableVpcEndpointConnectionRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getEndpointId()const;
void setEndpointId(const std::string& endpointId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getDryRun()const;
void setDryRun(bool dryRun);
int getBandwidth()const;
void setBandwidth(int bandwidth);
std::string getServiceId()const;
void setServiceId(const std::string& serviceId);
private:
std::string clientToken_;
std::string endpointId_;
std::string regionId_;
bool dryRun_;
int bandwidth_;
std::string serviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ENABLEVPCENDPOINTCONNECTIONREQUEST_H_

49
privatelink/include/alibabacloud/privatelink/model/EnableVpcEndpointConnectionResult.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_PRIVATELINK_MODEL_ENABLEVPCENDPOINTCONNECTIONRESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_ENABLEVPCENDPOINTCONNECTIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT EnableVpcEndpointConnectionResult : public ServiceResult
{
public:
EnableVpcEndpointConnectionResult();
explicit EnableVpcEndpointConnectionResult(const std::string &payload);
~EnableVpcEndpointConnectionResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ENABLEVPCENDPOINTCONNECTIONRESULT_H_

51
privatelink/include/alibabacloud/privatelink/model/GetVpcEndpointAttributeRequest.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_PRIVATELINK_MODEL_GETVPCENDPOINTATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT GetVpcEndpointAttributeRequest : public RpcServiceRequest
{
public:
GetVpcEndpointAttributeRequest();
~GetVpcEndpointAttributeRequest();
std::string getEndpointId()const;
void setEndpointId(const std::string& endpointId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string endpointId_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTATTRIBUTEREQUEST_H_

79
privatelink/include/alibabacloud/privatelink/model/GetVpcEndpointAttributeResult.h Normal file
View File

@@ -0,0 +1,79 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTATTRIBUTERESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT GetVpcEndpointAttributeResult : public ServiceResult
{
public:
GetVpcEndpointAttributeResult();
explicit GetVpcEndpointAttributeResult(const std::string &payload);
~GetVpcEndpointAttributeResult();
std::string getPayer()const;
std::string getEndpointDomain()const;
std::string getCreateTime()const;
bool getResourceOwner()const;
std::string getEndpointBusinessStatus()const;
std::string getEndpointDescription()const;
std::string getServiceId()const;
std::string getEndpointStatus()const;
std::string getEndpointName()const;
std::string getVpcId()const;
std::string getServiceName()const;
int getBandwidth()const;
std::string getEndpointId()const;
std::string getRegionId()const;
std::string getConnectionStatus()const;
protected:
void parse(const std::string &payload);
private:
std::string payer_;
std::string endpointDomain_;
std::string createTime_;
bool resourceOwner_;
std::string endpointBusinessStatus_;
std::string endpointDescription_;
std::string serviceId_;
std::string endpointStatus_;
std::string endpointName_;
std::string vpcId_;
std::string serviceName_;
int bandwidth_;
std::string endpointId_;
std::string regionId_;
std::string connectionStatus_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTATTRIBUTERESULT_H_

51
privatelink/include/alibabacloud/privatelink/model/GetVpcEndpointServiceAttributeRequest.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_PRIVATELINK_MODEL_GETVPCENDPOINTSERVICEATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTSERVICEATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT GetVpcEndpointServiceAttributeRequest : public RpcServiceRequest
{
public:
GetVpcEndpointServiceAttributeRequest();
~GetVpcEndpointServiceAttributeRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getServiceId()const;
void setServiceId(const std::string& serviceId);
private:
std::string regionId_;
std::string serviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTSERVICEATTRIBUTEREQUEST_H_

77
privatelink/include/alibabacloud/privatelink/model/GetVpcEndpointServiceAttributeResult.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_PRIVATELINK_MODEL_GETVPCENDPOINTSERVICEATTRIBUTERESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTSERVICEATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT GetVpcEndpointServiceAttributeResult : public ServiceResult
{
public:
GetVpcEndpointServiceAttributeResult();
explicit GetVpcEndpointServiceAttributeResult(const std::string &payload);
~GetVpcEndpointServiceAttributeResult();
std::string getPayer()const;
std::string getServiceDescription()const;
std::string getCreateTime()const;
int getMaxBandwidth()const;
std::string getServiceDomain()const;
int getMinBandwidth()const;
std::vector<std::string> getZones()const;
std::string getServiceId()const;
bool getAutoAcceptEnabled()const;
std::string getServiceBusinessStatus()const;
std::string getServiceName()const;
std::string getServiceStatus()const;
int getConnectBandwidth()const;
std::string getRegionId()const;
protected:
void parse(const std::string &payload);
private:
std::string payer_;
std::string serviceDescription_;
std::string createTime_;
int maxBandwidth_;
std::string serviceDomain_;
int minBandwidth_;
std::vector<std::string> zones_;
std::string serviceId_;
bool autoAcceptEnabled_;
std::string serviceBusinessStatus_;
std::string serviceName_;
std::string serviceStatus_;
int connectBandwidth_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTSERVICEATTRIBUTERESULT_H_

66
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointConnectionsRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTCONNECTIONSREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTCONNECTIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointConnectionsRequest : public RpcServiceRequest
{
public:
ListVpcEndpointConnectionsRequest();
~ListVpcEndpointConnectionsRequest();
std::string getEndpointId()const;
void setEndpointId(const std::string& endpointId);
long getEndpointOwnerId()const;
void setEndpointOwnerId(long endpointOwnerId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
std::string getConnectionStatus()const;
void setConnectionStatus(const std::string& connectionStatus);
int getMaxResults()const;
void setMaxResults(int maxResults);
std::string getServiceId()const;
void setServiceId(const std::string& serviceId);
private:
std::string endpointId_;
long endpointOwnerId_;
std::string regionId_;
std::string nextToken_;
std::string connectionStatus_;
int maxResults_;
std::string serviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTCONNECTIONSREQUEST_H_

75
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointConnectionsResult.h Normal file
View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_PRIVATELINK_MODEL_LISTVPCENDPOINTCONNECTIONSRESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTCONNECTIONSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointConnectionsResult : public ServiceResult
{
public:
struct Connection
{
struct Zone
{
std::string zoneId;
std::string eniId;
std::string resourceId;
std::string vSwitchId;
std::string zoneDomain;
};
long endpointOwnerId;
std::string modifiedTime;
std::string endpointId;
int bandwidth;
bool resourceOwner;
std::string endpointVpcId;
std::string connectionStatus;
std::vector<Connection::Zone> zones;
std::string serviceId;
};
ListVpcEndpointConnectionsResult();
explicit ListVpcEndpointConnectionsResult(const std::string &payload);
~ListVpcEndpointConnectionsResult();
std::vector<Connection> getConnections()const;
std::string getNextToken()const;
std::string getMaxResults()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Connection> connections_;
std::string nextToken_;
std::string maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTCONNECTIONSRESULT_H_

57
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointSecurityGroupsRequest.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_PRIVATELINK_MODEL_LISTVPCENDPOINTSECURITYGROUPSREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSECURITYGROUPSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointSecurityGroupsRequest : public RpcServiceRequest
{
public:
ListVpcEndpointSecurityGroupsRequest();
~ListVpcEndpointSecurityGroupsRequest();
std::string getEndpointId()const;
void setEndpointId(const std::string& endpointId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
int getMaxResults()const;
void setMaxResults(int maxResults);
private:
std::string endpointId_;
std::string regionId_;
std::string nextToken_;
int maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSECURITYGROUPSREQUEST_H_

59
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointSecurityGroupsResult.h Normal file
View File

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

57
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServiceResourcesRequest.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_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICERESOURCESREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICERESOURCESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointServiceResourcesRequest : public RpcServiceRequest
{
public:
ListVpcEndpointServiceResourcesRequest();
~ListVpcEndpointServiceResourcesRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
int getMaxResults()const;
void setMaxResults(int maxResults);
std::string getServiceId()const;
void setServiceId(const std::string& serviceId);
private:
std::string regionId_;
std::string nextToken_;
int maxResults_;
std::string serviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICERESOURCESREQUEST_H_

65
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServiceResourcesResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICERESOURCESRESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICERESOURCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointServiceResourcesResult : public ServiceResult
{
public:
struct Resource
{
std::string zoneId;
std::string vpcId;
std::string resourceId;
std::string ip;
std::string vSwitchId;
std::string resourceType;
std::string regionId;
};
ListVpcEndpointServiceResourcesResult();
explicit ListVpcEndpointServiceResourcesResult(const std::string &payload);
~ListVpcEndpointServiceResourcesResult();
std::string getNextToken()const;
std::string getMaxResults()const;
std::vector<Resource> getResources()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
std::string maxResults_;
std::vector<Resource> resources_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICERESOURCESRESULT_H_

60
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServiceUsersRequest.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_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICEUSERSREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICEUSERSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointServiceUsersRequest : public RpcServiceRequest
{
public:
ListVpcEndpointServiceUsersRequest();
~ListVpcEndpointServiceUsersRequest();
long getUserId()const;
void setUserId(long userId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
int getMaxResults()const;
void setMaxResults(int maxResults);
std::string getServiceId()const;
void setServiceId(const std::string& serviceId);
private:
long userId_;
std::string regionId_;
std::string nextToken_;
int maxResults_;
std::string serviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICEUSERSREQUEST_H_

59
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServiceUsersResult.h Normal file
View File

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

60
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServicesByEndUserRequest.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_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESBYENDUSERREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESBYENDUSERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointServicesByEndUserRequest : public RpcServiceRequest
{
public:
ListVpcEndpointServicesByEndUserRequest();
~ListVpcEndpointServicesByEndUserRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
std::string getServiceName()const;
void setServiceName(const std::string& serviceName);
int getMaxResults()const;
void setMaxResults(int maxResults);
std::string getServiceId()const;
void setServiceId(const std::string& serviceId);
private:
std::string regionId_;
std::string nextToken_;
std::string serviceName_;
int maxResults_;
std::string serviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESBYENDUSERREQUEST_H_

63
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServicesByEndUserResult.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_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESBYENDUSERRESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESBYENDUSERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointServicesByEndUserResult : public ServiceResult
{
public:
struct Service
{
std::string payer;
std::string serviceName;
std::string serviceDomain;
std::string serviceId;
std::vector<std::string> zones;
};
ListVpcEndpointServicesByEndUserResult();
explicit ListVpcEndpointServicesByEndUserResult(const std::string &payload);
~ListVpcEndpointServicesByEndUserResult();
std::vector<Service> getServices()const;
std::string getNextToken()const;
std::string getMaxResults()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Service> services_;
std::string nextToken_;
std::string maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESBYENDUSERRESULT_H_

69
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServicesRequest.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointServicesRequest : public RpcServiceRequest
{
public:
ListVpcEndpointServicesRequest();
~ListVpcEndpointServicesRequest();
std::string getServiceBusinessStatus()const;
void setServiceBusinessStatus(const std::string& serviceBusinessStatus);
bool getAutoAcceptEnabled()const;
void setAutoAcceptEnabled(bool autoAcceptEnabled);
std::string getServiceStatus()const;
void setServiceStatus(const std::string& serviceStatus);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
std::string getServiceName()const;
void setServiceName(const std::string& serviceName);
int getMaxResults()const;
void setMaxResults(int maxResults);
std::string getServiceId()const;
void setServiceId(const std::string& serviceId);
private:
std::string serviceBusinessStatus_;
bool autoAcceptEnabled_;
std::string serviceStatus_;
std::string regionId_;
std::string nextToken_;
std::string serviceName_;
int maxResults_;
std::string serviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESREQUEST_H_

71
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServicesResult.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESRESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointServicesResult : public ServiceResult
{
public:
struct Service
{
std::string payer;
std::string serviceDescription;
std::string createTime;
int maxBandwidth;
int minBandwidth;
std::string serviceDomain;
bool autoAcceptEnabled;
std::string serviceId;
std::string serviceBusinessStatus;
std::string serviceName;
std::string serviceStatus;
int connectBandwidth;
std::string regionId;
};
ListVpcEndpointServicesResult();
explicit ListVpcEndpointServicesResult(const std::string &payload);
~ListVpcEndpointServicesResult();
std::vector<Service> getServices()const;
std::string getNextToken()const;
std::string getMaxResults()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Service> services_;
std::string nextToken_;
std::string maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESRESULT_H_

57
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointZonesRequest.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_PRIVATELINK_MODEL_LISTVPCENDPOINTZONESREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTZONESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointZonesRequest : public RpcServiceRequest
{
public:
ListVpcEndpointZonesRequest();
~ListVpcEndpointZonesRequest();
std::string getEndpointId()const;
void setEndpointId(const std::string& endpointId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
int getMaxResults()const;
void setMaxResults(int maxResults);
private:
std::string endpointId_;
std::string regionId_;
std::string nextToken_;
int maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTZONESREQUEST_H_

65
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointZonesResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTZONESRESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTZONESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointZonesResult : public ServiceResult
{
public:
struct Zone
{
std::string eniId;
std::string zoneId;
std::string vSwitchId;
std::string eniIp;
std::string zoneStatus;
std::string regionId;
std::string zoneDomain;
};
ListVpcEndpointZonesResult();
explicit ListVpcEndpointZonesResult(const std::string &payload);
~ListVpcEndpointZonesResult();
std::string getNextToken()const;
std::string getMaxResults()const;
std::vector<Zone> getZones()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
std::string maxResults_;
std::vector<Zone> zones_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTZONESRESULT_H_

72
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointsRequest.h Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointsRequest : public RpcServiceRequest
{
public:
ListVpcEndpointsRequest();
~ListVpcEndpointsRequest();
std::string getEndpointId()const;
void setEndpointId(const std::string& endpointId);
std::string getEndpointStatus()const;
void setEndpointStatus(const std::string& endpointStatus);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNextToken()const;
void setNextToken(const std::string& nextToken);
std::string getServiceName()const;
void setServiceName(const std::string& serviceName);
std::string getConnectionStatus()const;
void setConnectionStatus(const std::string& connectionStatus);
std::string getVpcId()const;
void setVpcId(const std::string& vpcId);
std::string getEndpointName()const;
void setEndpointName(const std::string& endpointName);
int getMaxResults()const;
void setMaxResults(int maxResults);
private:
std::string endpointId_;
std::string endpointStatus_;
std::string regionId_;
std::string nextToken_;
std::string serviceName_;
std::string connectionStatus_;
std::string vpcId_;
std::string endpointName_;
int maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSREQUEST_H_

72
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointsResult.h Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSRESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT ListVpcEndpointsResult : public ServiceResult
{
public:
struct Endpoint
{
std::string endpointDomain;
std::string createTime;
bool resourceOwner;
std::string endpointBusinessStatus;
std::string endpointDescription;
std::string serviceId;
std::string endpointStatus;
std::string endpointName;
std::string vpcId;
std::string serviceName;
std::string endpointId;
long bandwidth;
std::string regionId;
std::string connectionStatus;
};
ListVpcEndpointsResult();
explicit ListVpcEndpointsResult(const std::string &payload);
~ListVpcEndpointsResult();
std::vector<Endpoint> getEndpoints()const;
std::string getNextToken()const;
std::string getMaxResults()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Endpoint> endpoints_;
std::string nextToken_;
std::string maxResults_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSRESULT_H_

48
privatelink/include/alibabacloud/privatelink/model/OpenPrivateLinkServiceRequest.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_PRIVATELINK_MODEL_OPENPRIVATELINKSERVICEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_OPENPRIVATELINKSERVICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT OpenPrivateLinkServiceRequest : public RpcServiceRequest
{
public:
OpenPrivateLinkServiceRequest();
~OpenPrivateLinkServiceRequest();
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_OPENPRIVATELINKSERVICEREQUEST_H_

51
privatelink/include/alibabacloud/privatelink/model/OpenPrivateLinkServiceResult.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_PRIVATELINK_MODEL_OPENPRIVATELINKSERVICERESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_OPENPRIVATELINKSERVICERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT OpenPrivateLinkServiceResult : public ServiceResult
{
public:
OpenPrivateLinkServiceResult();
explicit OpenPrivateLinkServiceResult(const std::string &payload);
~OpenPrivateLinkServiceResult();
std::string getOrderId()const;
protected:
void parse(const std::string &payload);
private:
std::string orderId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_OPENPRIVATELINKSERVICERESULT_H_

60
privatelink/include/alibabacloud/privatelink/model/RemoveUserFromVpcEndpointServiceRequest.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_PRIVATELINK_MODEL_REMOVEUSERFROMVPCENDPOINTSERVICEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEUSERFROMVPCENDPOINTSERVICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT RemoveUserFromVpcEndpointServiceRequest : public RpcServiceRequest
{
public:
RemoveUserFromVpcEndpointServiceRequest();
~RemoveUserFromVpcEndpointServiceRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
long getUserId()const;
void setUserId(long userId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getDryRun()const;
void setDryRun(bool dryRun);
std::string getServiceId()const;
void setServiceId(const std::string& serviceId);
private:
std::string clientToken_;
long userId_;
std::string regionId_;
bool dryRun_;
std::string serviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEUSERFROMVPCENDPOINTSERVICEREQUEST_H_

49
privatelink/include/alibabacloud/privatelink/model/RemoveUserFromVpcEndpointServiceResult.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_PRIVATELINK_MODEL_REMOVEUSERFROMVPCENDPOINTSERVICERESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEUSERFROMVPCENDPOINTSERVICERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT RemoveUserFromVpcEndpointServiceResult : public ServiceResult
{
public:
RemoveUserFromVpcEndpointServiceResult();
explicit RemoveUserFromVpcEndpointServiceResult(const std::string &payload);
~RemoveUserFromVpcEndpointServiceResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEUSERFROMVPCENDPOINTSERVICERESULT_H_

60
privatelink/include/alibabacloud/privatelink/model/RemoveZoneFromVpcEndpointRequest.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_PRIVATELINK_MODEL_REMOVEZONEFROMVPCENDPOINTREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEZONEFROMVPCENDPOINTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT RemoveZoneFromVpcEndpointRequest : public RpcServiceRequest
{
public:
RemoveZoneFromVpcEndpointRequest();
~RemoveZoneFromVpcEndpointRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getEndpointId()const;
void setEndpointId(const std::string& endpointId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getDryRun()const;
void setDryRun(bool dryRun);
std::string getZoneId()const;
void setZoneId(const std::string& zoneId);
private:
std::string clientToken_;
std::string endpointId_;
std::string regionId_;
bool dryRun_;
std::string zoneId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEZONEFROMVPCENDPOINTREQUEST_H_

49
privatelink/include/alibabacloud/privatelink/model/RemoveZoneFromVpcEndpointResult.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_PRIVATELINK_MODEL_REMOVEZONEFROMVPCENDPOINTRESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEZONEFROMVPCENDPOINTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT RemoveZoneFromVpcEndpointResult : public ServiceResult
{
public:
RemoveZoneFromVpcEndpointResult();
explicit RemoveZoneFromVpcEndpointResult(const std::string &payload);
~RemoveZoneFromVpcEndpointResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEZONEFROMVPCENDPOINTRESULT_H_

63
privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointAttributeRequest.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_PRIVATELINK_MODEL_UPDATEVPCENDPOINTATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT UpdateVpcEndpointAttributeRequest : public RpcServiceRequest
{
public:
UpdateVpcEndpointAttributeRequest();
~UpdateVpcEndpointAttributeRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getEndpointId()const;
void setEndpointId(const std::string& endpointId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getDryRun()const;
void setDryRun(bool dryRun);
std::string getEndpointDescription()const;
void setEndpointDescription(const std::string& endpointDescription);
std::string getEndpointName()const;
void setEndpointName(const std::string& endpointName);
private:
std::string clientToken_;
std::string endpointId_;
std::string regionId_;
bool dryRun_;
std::string endpointDescription_;
std::string endpointName_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTATTRIBUTEREQUEST_H_

49
privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointAttributeResult.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_PRIVATELINK_MODEL_UPDATEVPCENDPOINTATTRIBUTERESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT UpdateVpcEndpointAttributeResult : public ServiceResult
{
public:
UpdateVpcEndpointAttributeResult();
explicit UpdateVpcEndpointAttributeResult(const std::string &payload);
~UpdateVpcEndpointAttributeResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTATTRIBUTERESULT_H_

63
privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointConnectionAttributeRequest.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_PRIVATELINK_MODEL_UPDATEVPCENDPOINTCONNECTIONATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTCONNECTIONATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT UpdateVpcEndpointConnectionAttributeRequest : public RpcServiceRequest
{
public:
UpdateVpcEndpointConnectionAttributeRequest();
~UpdateVpcEndpointConnectionAttributeRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getEndpointId()const;
void setEndpointId(const std::string& endpointId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getDryRun()const;
void setDryRun(bool dryRun);
int getBandwidth()const;
void setBandwidth(int bandwidth);
std::string getServiceId()const;
void setServiceId(const std::string& serviceId);
private:
std::string clientToken_;
std::string endpointId_;
std::string regionId_;
bool dryRun_;
int bandwidth_;
std::string serviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTCONNECTIONATTRIBUTEREQUEST_H_

49
privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointConnectionAttributeResult.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_PRIVATELINK_MODEL_UPDATEVPCENDPOINTCONNECTIONATTRIBUTERESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTCONNECTIONATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT UpdateVpcEndpointConnectionAttributeResult : public ServiceResult
{
public:
UpdateVpcEndpointConnectionAttributeResult();
explicit UpdateVpcEndpointConnectionAttributeResult(const std::string &payload);
~UpdateVpcEndpointConnectionAttributeResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTCONNECTIONATTRIBUTERESULT_H_

66
privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointServiceAttributeRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICEATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICEATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT UpdateVpcEndpointServiceAttributeRequest : public RpcServiceRequest
{
public:
UpdateVpcEndpointServiceAttributeRequest();
~UpdateVpcEndpointServiceAttributeRequest();
bool getAutoAcceptEnabled()const;
void setAutoAcceptEnabled(bool autoAcceptEnabled);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
int getConnectBandwidth()const;
void setConnectBandwidth(int connectBandwidth);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
bool getDryRun()const;
void setDryRun(bool dryRun);
std::string getServiceDescription()const;
void setServiceDescription(const std::string& serviceDescription);
std::string getServiceId()const;
void setServiceId(const std::string& serviceId);
private:
bool autoAcceptEnabled_;
std::string clientToken_;
int connectBandwidth_;
std::string regionId_;
bool dryRun_;
std::string serviceDescription_;
std::string serviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICEATTRIBUTEREQUEST_H_

49
privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointServiceAttributeResult.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_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICEATTRIBUTERESULT_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICEATTRIBUTERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/privatelink/PrivatelinkExport.h>
namespace AlibabaCloud
{
namespace Privatelink
{
namespace Model
{
class ALIBABACLOUD_PRIVATELINK_EXPORT UpdateVpcEndpointServiceAttributeResult : public ServiceResult
{
public:
UpdateVpcEndpointServiceAttributeResult();
explicit UpdateVpcEndpointServiceAttributeResult(const std::string &payload);
~UpdateVpcEndpointServiceAttributeResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICEATTRIBUTERESULT_H_