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

Adjust some param.

Browse Source
This commit is contained in:
sdk-team
2021-11-04 08:44:54 +00:00
parent 3d527e15e0
commit 3a7cca96e3
88 changed files with 3169 additions and 3409 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -1,3 +1,6 @@
2021-11-04 Version: 1.36.921
- Adjust some param.
2021-11-02 Version: 1.36.920
- Add GetVideoPlayAuth API parameter.

2
VERSION
View File

@@ -1 +1 @@
1.36.920
1.36.921

92
privatelink/include/alibabacloud/privatelink/model/AddUserToVpcEndpointServiceRequest.h
View File

@@ -1,60 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_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);
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_ADDUSERTOVPCENDPOINTSERVICEREQUEST_H_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_ADDUSERTOVPCENDPOINTSERVICEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_ADDUSERTOVPCENDPOINTSERVICEREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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);
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_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ADDUSERTOVPCENDPOINTSERVICEREQUEST_H_

104
privatelink/include/alibabacloud/privatelink/model/AddZoneToVpcEndpointRequest.h
View File

@@ -1,66 +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_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 getIp()const;
void setIp(const std::string& ip);
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 ip_;
std::string vSwitchId_;
std::string zoneId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ADDZONETOVPCENDPOINTREQUEST_H_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_ADDZONETOVPCENDPOINTREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_ADDZONETOVPCENDPOINTREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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 getIp() const;
void setIp(const std::string &ip);
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 ip_;
std::string vSwitchId_;
std::string zoneId_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ADDZONETOVPCENDPOINTREQUEST_H_

98
privatelink/include/alibabacloud/privatelink/model/AttachResourceToVpcEndpointServiceRequest.h
View File

@@ -1,63 +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_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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHRESOURCETOVPCENDPOINTSERVICEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHRESOURCETOVPCENDPOINTSERVICEREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHRESOURCETOVPCENDPOINTSERVICEREQUEST_H_

92
privatelink/include/alibabacloud/privatelink/model/AttachSecurityGroupToVpcEndpointRequest.h
View File

@@ -1,60 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHSECURITYGROUPTOVPCENDPOINTREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHSECURITYGROUPTOVPCENDPOINTREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ATTACHSECURITYGROUPTOVPCENDPOINTREQUEST_H_

68
privatelink/include/alibabacloud/privatelink/model/CheckProductOpenRequest.h
View File

@@ -1,48 +1,42 @@
/*
* 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_CHECKPRODUCTOPENREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_CHECKPRODUCTOPENREQUEST_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 CheckProductOpenRequest : public RpcServiceRequest
{
public:
CheckProductOpenRequest();
~CheckProductOpenRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_CHECKPRODUCTOPENREQUEST_H_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_CHECKPRODUCTOPENREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_CHECKPRODUCTOPENREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Privatelink {
namespace Model {
class ALIBABACLOUD_PRIVATELINK_EXPORT CheckProductOpenRequest : public RpcServiceRequest {
public:
CheckProductOpenRequest();
~CheckProductOpenRequest();
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string regionId_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_CHECKPRODUCTOPENREQUEST_H_

143
privatelink/include/alibabacloud/privatelink/model/CreateVpcEndpointRequest.h
View File

@@ -1,82 +1,83 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_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;
std::string ip;
};
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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Privatelink {
namespace Model {
class ALIBABACLOUD_PRIVATELINK_EXPORT CreateVpcEndpointRequest : public RpcServiceRequest {
public:
struct Zone {
std::string vSwitchId;
std::string zoneId;
std::string ip;
};
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::string getEndpointType() const;
void setEndpointType(const std::string &endpointType);
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);
long getZonePrivateIpAddressCount() const;
void setZonePrivateIpAddressCount(long zonePrivateIpAddressCount);
bool getProtectedEnabled() const;
void setProtectedEnabled(bool protectedEnabled);
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::string endpointType_;
std::vector<Zone> zone_;
std::string serviceName_;
bool dryRun_;
std::string endpointDescription_;
long zonePrivateIpAddressCount_;
bool protectedEnabled_;
std::string endpointName_;
std::string vpcId_;
std::string serviceId_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTREQUEST_H_

16
privatelink/include/alibabacloud/privatelink/model/CreateVpcEndpointResult.h
View File

@@ -38,13 +38,13 @@ namespace AlibabaCloud
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 getVpcId()const;
std::string getEndpointName()const;
std::string getServiceName()const;
std::string getEndpointId()const;
long getBandwidth()const;
std::string getCreateTime()const;
long getBandwidth()const;
std::string getEndpointId()const;
std::string getEndpointBusinessStatus()const;
std::string getEndpointDescription()const;
std::string getConnectionStatus()const;
@@ -54,13 +54,13 @@ namespace AlibabaCloud
void parse(const std::string &payload);
private:
std::string endpointStatus_;
std::string endpointName_;
std::string vpcId_;
std::string endpointDomain_;
std::string vpcId_;
std::string endpointName_;
std::string serviceName_;
std::string endpointId_;
long bandwidth_;
std::string createTime_;
long bandwidth_;
std::string endpointId_;
std::string endpointBusinessStatus_;
std::string endpointDescription_;
std::string connectionStatus_;

129
privatelink/include/alibabacloud/privatelink/model/CreateVpcEndpointServiceRequest.h
View File

@@ -1,75 +1,76 @@
/*
* 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 resourceType;
std::string resourceId;
};
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 getZoneAffinityEnabled()const;
void setZoneAffinityEnabled(bool zoneAffinityEnabled);
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 zoneAffinityEnabled_;
bool dryRun_;
std::vector<Resource> resource_;
std::string serviceDescription_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTSERVICEREQUEST_H_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTSERVICEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTSERVICEREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Privatelink {
namespace Model {
class ALIBABACLOUD_PRIVATELINK_EXPORT CreateVpcEndpointServiceRequest : public RpcServiceRequest {
public:
struct Resource {
std::string resourceType;
std::string resourceId;
};
CreateVpcEndpointServiceRequest();
~CreateVpcEndpointServiceRequest();
bool getPrivateServiceDomainEnabled() const;
void setPrivateServiceDomainEnabled(bool privateServiceDomainEnabled);
std::string getPrivateServiceDomain() const;
void setPrivateServiceDomain(const std::string &privateServiceDomain);
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 getZoneAffinityEnabled() const;
void setZoneAffinityEnabled(bool zoneAffinityEnabled);
bool getDryRun() const;
void setDryRun(bool dryRun);
std::vector<Resource> getResource() const;
void setResource(const std::vector<Resource> &resource);
std::string getServiceResourceType() const;
void setServiceResourceType(const std::string &serviceResourceType);
std::string getServiceDescription() const;
void setServiceDescription(const std::string &serviceDescription);
private:
bool privateServiceDomainEnabled_;
std::string privateServiceDomain_;
bool autoAcceptEnabled_;
std::string clientToken_;
std::string payer_;
std::string regionId_;
bool zoneAffinityEnabled_;
bool dryRun_;
std::vector<Resource> resource_;
std::string serviceResourceType_;
std::string serviceDescription_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_CREATEVPCENDPOINTSERVICEREQUEST_H_

12
privatelink/include/alibabacloud/privatelink/model/CreateVpcEndpointServiceResult.h
View File

@@ -39,26 +39,26 @@ namespace AlibabaCloud
~CreateVpcEndpointServiceResult();
std::string getServiceBusinessStatus()const;
std::string getServiceName()const;
std::string getServiceDescription()const;
std::string getServiceStatus()const;
std::string getServiceDescription()const;
std::string getCreateTime()const;
bool getZoneAffinityEnabled()const;
std::string getServiceDomain()const;
std::string getServiceId()const;
bool getZoneAffinityEnabled()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 serviceDescription_;
std::string createTime_;
bool zoneAffinityEnabled_;
std::string serviceDomain_;
std::string serviceId_;
bool zoneAffinityEnabled_;
bool autoAcceptEnabled_;
std::string serviceId_;
};
}

89
privatelink/include/alibabacloud/privatelink/model/DeleteVpcEndpointRequest.h
View File

@@ -1,57 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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);
bool getForce() const;
void setForce(bool force);
private:
std::string clientToken_;
std::string endpointId_;
std::string regionId_;
bool dryRun_;
bool force_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTREQUEST_H_

86
privatelink/include/alibabacloud/privatelink/model/DeleteVpcEndpointServiceRequest.h
View File

@@ -1,57 +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_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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTSERVICEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTSERVICEREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DELETEVPCENDPOINTSERVICEREQUEST_H_

68
privatelink/include/alibabacloud/privatelink/model/DescribeRegionsRequest.h
View File

@@ -1,48 +1,42 @@
/*
* 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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_DESCRIBEREGIONSREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_DESCRIBEREGIONSREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DESCRIBEREGIONSREQUEST_H_

68
privatelink/include/alibabacloud/privatelink/model/DescribeZonesRequest.h
View File

@@ -1,48 +1,42 @@
/*
* 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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_DESCRIBEZONESREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_DESCRIBEZONESREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DESCRIBEZONESREQUEST_H_

98
privatelink/include/alibabacloud/privatelink/model/DetachResourceFromVpcEndpointServiceRequest.h
View File

@@ -1,63 +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_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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_DETACHRESOURCEFROMVPCENDPOINTSERVICEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_DETACHRESOURCEFROMVPCENDPOINTSERVICEREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DETACHRESOURCEFROMVPCENDPOINTSERVICEREQUEST_H_

92
privatelink/include/alibabacloud/privatelink/model/DetachSecurityGroupFromVpcEndpointRequest.h
View File

@@ -1,60 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_DETACHSECURITYGROUPFROMVPCENDPOINTREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_DETACHSECURITYGROUPFROMVPCENDPOINTREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DETACHSECURITYGROUPFROMVPCENDPOINTREQUEST_H_

92
privatelink/include/alibabacloud/privatelink/model/DisableVpcEndpointConnectionRequest.h
View File

@@ -1,60 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_DISABLEVPCENDPOINTCONNECTIONREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_DISABLEVPCENDPOINTCONNECTIONREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_DISABLEVPCENDPOINTCONNECTIONREQUEST_H_

98
privatelink/include/alibabacloud/privatelink/model/EnableVpcEndpointConnectionRequest.h
View File

@@ -1,63 +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_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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_ENABLEVPCENDPOINTCONNECTIONREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_ENABLEVPCENDPOINTCONNECTIONREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_ENABLEVPCENDPOINTCONNECTIONREQUEST_H_

74
privatelink/include/alibabacloud/privatelink/model/GetVpcEndpointAttributeRequest.h
View File

@@ -1,51 +1,45 @@
/*
* 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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTATTRIBUTEREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTATTRIBUTEREQUEST_H_

16
privatelink/include/alibabacloud/privatelink/model/GetVpcEndpointAttributeResult.h
View File

@@ -39,17 +39,19 @@ namespace AlibabaCloud
~GetVpcEndpointAttributeResult();
std::string getPayer()const;
std::string getEndpointDomain()const;
bool getResourceOwner()const;
std::string getCreateTime()const;
bool getResourceOwner()const;
long getZonePrivateIpAddressCount()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 getEndpointName()const;
std::string getServiceName()const;
std::string getEndpointId()const;
int getBandwidth()const;
std::string getEndpointId()const;
std::string getEndpointType()const;
std::string getRegionId()const;
std::string getConnectionStatus()const;
bool getZoneAffinityEnabled()const;
@@ -59,17 +61,19 @@ namespace AlibabaCloud
private:
std::string payer_;
std::string endpointDomain_;
bool resourceOwner_;
std::string createTime_;
bool resourceOwner_;
long zonePrivateIpAddressCount_;
std::string endpointBusinessStatus_;
std::string endpointDescription_;
std::string serviceId_;
std::string endpointStatus_;
std::string endpointName_;
std::string vpcId_;
std::string endpointName_;
std::string serviceName_;
std::string endpointId_;
int bandwidth_;
std::string endpointId_;
std::string endpointType_;
std::string regionId_;
std::string connectionStatus_;
bool zoneAffinityEnabled_;

74
privatelink/include/alibabacloud/privatelink/model/GetVpcEndpointServiceAttributeRequest.h
View File

@@ -1,51 +1,45 @@
/*
* 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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTSERVICEATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTSERVICEATTRIBUTEREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_GETVPCENDPOINTSERVICEATTRIBUTEREQUEST_H_

30
privatelink/include/alibabacloud/privatelink/model/GetVpcEndpointServiceAttributeResult.h
View File

@@ -38,39 +38,57 @@ namespace AlibabaCloud
explicit GetVpcEndpointServiceAttributeResult(const std::string &payload);
~GetVpcEndpointServiceAttributeResult();
std::string getPayer()const;
std::string getPrivateServiceDomainBusinessStatus()const;
std::string getServiceDescription()const;
int getMaxBandwidth()const;
std::string getCreateTime()const;
std::string getServiceDomain()const;
int getMaxBandwidth()const;
std::string getPrivateServiceDomain()const;
bool getPrivateServiceDomainEnabled()const;
int getMinBandwidth()const;
std::string getServiceDomain()const;
std::vector<std::string> getZones()const;
std::string getServiceId()const;
bool getAutoAcceptEnabled()const;
std::string getServiceId()const;
std::string getPrivateServiceDomainVerifyStatus()const;
std::string getServiceBusinessStatus()const;
std::string getPrivateServiceDomainVerifyName()const;
std::string getServiceName()const;
std::string getServiceStatus()const;
std::string getServiceType()const;
int getConnectBandwidth()const;
std::string getServiceResourceType()const;
std::string getPrivateServiceName()const;
std::string getRegionId()const;
bool getZoneAffinityEnabled()const;
std::string getPrivateServiceDomainVerifyValue()const;
protected:
void parse(const std::string &payload);
private:
std::string payer_;
std::string privateServiceDomainBusinessStatus_;
std::string serviceDescription_;
int maxBandwidth_;
std::string createTime_;
std::string serviceDomain_;
int maxBandwidth_;
std::string privateServiceDomain_;
bool privateServiceDomainEnabled_;
int minBandwidth_;
std::string serviceDomain_;
std::vector<std::string> zones_;
std::string serviceId_;
bool autoAcceptEnabled_;
std::string serviceId_;
std::string privateServiceDomainVerifyStatus_;
std::string serviceBusinessStatus_;
std::string privateServiceDomainVerifyName_;
std::string serviceName_;
std::string serviceStatus_;
std::string serviceType_;
int connectBandwidth_;
std::string serviceResourceType_;
std::string privateServiceName_;
std::string regionId_;
bool zoneAffinityEnabled_;
std::string privateServiceDomainVerifyValue_;
};
}

110
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointConnectionsRequest.h
View File

@@ -1,66 +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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTCONNECTIONSREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTCONNECTIONSREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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 getResourceId() const;
void setResourceId(const std::string &resourceId);
std::string getConnectionStatus() const;
void setConnectionStatus(const std::string &connectionStatus);
int getMaxResults() const;
void setMaxResults(int maxResults);
std::string getEniId() const;
void setEniId(const std::string &eniId);
std::string getServiceId() const;
void setServiceId(const std::string &serviceId);
private:
std::string endpointId_;
long endpointOwnerId_;
std::string regionId_;
std::string nextToken_;
std::string resourceId_;
std::string connectionStatus_;
int maxResults_;
std::string eniId_;
std::string serviceId_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTCONNECTIONSREQUEST_H_

8
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointConnectionsResult.h
View File

@@ -39,14 +39,18 @@ namespace AlibabaCloud
std::string zoneId;
std::string eniId;
std::string resourceId;
std::string statusInfo;
std::string vSwitchId;
std::string replacedResourceId;
std::string zoneStatus;
std::string zoneDomain;
std::string replacedEniId;
};
long endpointOwnerId;
std::string modifiedTime;
std::string endpointId;
int bandwidth;
bool resourceOwner;
int bandwidth;
std::string endpointId;
std::string endpointVpcId;
std::string connectionStatus;
std::vector<Connection::Zone> zones;

86
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointSecurityGroupsRequest.h
View File

@@ -1,57 +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_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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSECURITYGROUPSREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSECURITYGROUPSREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSECURITYGROUPSREQUEST_H_

89
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServiceResourcesRequest.h
View File

@@ -1,57 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICERESOURCESREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICERESOURCESREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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 getZoneId() const;
void setZoneId(const std::string &zoneId);
std::string getServiceId() const;
void setServiceId(const std::string &serviceId);
private:
std::string regionId_;
std::string nextToken_;
int maxResults_;
std::string zoneId_;
std::string serviceId_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICERESOURCESREQUEST_H_

7
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServiceResourcesResult.h
View File

@@ -34,13 +34,16 @@ namespace AlibabaCloud
public:
struct Resource
{
std::string zoneId;
long relatedEndpointCount;
std::string vpcId;
std::string zoneId;
std::string resourceId;
std::string ip;
std::string statusInfo;
std::string vSwitchId;
std::string ip;
std::string resourceType;
std::string regionId;
bool autoAllocatedEnabled;
};

92
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServiceUsersRequest.h
View File

@@ -1,60 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICEUSERSREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICEUSERSREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICEUSERSREQUEST_H_

95
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServicesByEndUserRequest.h
View File

@@ -1,60 +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_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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESBYENDUSERREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESBYENDUSERREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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);
std::string getServiceType() const;
void setServiceType(const std::string &serviceType);
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_;
std::string serviceType_;
int maxResults_;
std::string serviceId_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESBYENDUSERREQUEST_H_

1
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServicesByEndUserResult.h
View File

@@ -36,6 +36,7 @@ namespace AlibabaCloud
{
std::string payer;
std::string serviceName;
std::string serviceType;
std::string serviceDomain;
std::string serviceId;
std::vector<std::string> zones;

122
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServicesRequest.h
View File

@@ -1,72 +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_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);
bool getZoneAffinityEnabled()const;
void setZoneAffinityEnabled(bool zoneAffinityEnabled);
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_;
bool zoneAffinityEnabled_;
std::string serviceName_;
int maxResults_;
std::string serviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESREQUEST_H_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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);
bool getZoneAffinityEnabled() const;
void setZoneAffinityEnabled(bool zoneAffinityEnabled);
std::string getServiceName() const;
void setServiceName(const std::string &serviceName);
std::string getResourceId() const;
void setResourceId(const std::string &resourceId);
std::string getServiceResourceType() const;
void setServiceResourceType(const std::string &serviceResourceType);
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_;
bool zoneAffinityEnabled_;
std::string serviceName_;
std::string resourceId_;
std::string serviceResourceType_;
int maxResults_;
std::string serviceId_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSERVICESREQUEST_H_

8
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointServicesResult.h
View File

@@ -36,16 +36,18 @@ namespace AlibabaCloud
{
std::string payer;
std::string serviceDescription;
int maxBandwidth;
std::string createTime;
std::string serviceDomain;
int maxBandwidth;
int minBandwidth;
std::string serviceId;
std::string serviceDomain;
bool autoAcceptEnabled;
std::string serviceId;
std::string serviceBusinessStatus;
std::string serviceName;
std::string serviceStatus;
std::string serviceType;
int connectBandwidth;
std::string serviceResourceType;
std::string regionId;
bool zoneAffinityEnabled;
};

86
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointZonesRequest.h
View File

@@ -1,57 +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_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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTZONESREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTZONESREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTZONESREQUEST_H_

2
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointZonesResult.h
View File

@@ -34,8 +34,8 @@ namespace AlibabaCloud
public:
struct Zone
{
std::string eniId;
std::string zoneId;
std::string eniId;
std::string serviceStatus;
std::string vSwitchId;
std::string eniIp;

119
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointsRequest.h
View File

@@ -1,72 +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_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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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 getEndpointType() const;
void setEndpointType(const std::string &endpointType);
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 endpointType_;
std::string serviceName_;
std::string connectionStatus_;
std::string vpcId_;
std::string endpointName_;
int maxResults_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_LISTVPCENDPOINTSREQUEST_H_

7
privatelink/include/alibabacloud/privatelink/model/ListVpcEndpointsResult.h
View File

@@ -35,17 +35,18 @@ namespace AlibabaCloud
struct Endpoint
{
std::string endpointDomain;
bool resourceOwner;
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 endpointName;
std::string serviceName;
std::string endpointId;
long bandwidth;
std::string endpointId;
std::string endpointType;
std::string regionId;
std::string connectionStatus;
bool zoneAffinityEnabled;

68
privatelink/include/alibabacloud/privatelink/model/OpenPrivateLinkServiceRequest.h
View File

@@ -1,48 +1,42 @@
/*
* 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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_OPENPRIVATELINKSERVICEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_OPENPRIVATELINKSERVICEREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_OPENPRIVATELINKSERVICEREQUEST_H_

92
privatelink/include/alibabacloud/privatelink/model/RemoveUserFromVpcEndpointServiceRequest.h
View File

@@ -1,60 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEUSERFROMVPCENDPOINTSERVICEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEUSERFROMVPCENDPOINTSERVICEREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEUSERFROMVPCENDPOINTSERVICEREQUEST_H_

92
privatelink/include/alibabacloud/privatelink/model/RemoveZoneFromVpcEndpointRequest.h
View File

@@ -1,60 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEZONEFROMVPCENDPOINTREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEZONEFROMVPCENDPOINTREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_REMOVEZONEFROMVPCENDPOINTREQUEST_H_

98
privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointAttributeRequest.h
View File

@@ -1,63 +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_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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTATTRIBUTEREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTATTRIBUTEREQUEST_H_

98
privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointConnectionAttributeRequest.h
View File

@@ -1,63 +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_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_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTCONNECTIONATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTCONNECTIONATTRIBUTEREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTCONNECTIONATTRIBUTEREQUEST_H_

116
privatelink/include/alibabacloud/privatelink/model/UpdateVpcEndpointServiceAttributeRequest.h
View File

@@ -1,69 +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_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 getZoneAffinityEnabled()const;
void setZoneAffinityEnabled(bool zoneAffinityEnabled);
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 zoneAffinityEnabled_;
bool dryRun_;
std::string serviceDescription_;
std::string serviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICEATTRIBUTEREQUEST_H_
*/
#ifndef ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICEATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICEATTRIBUTEREQUEST_H_
#include <alibabacloud/privatelink/PrivatelinkExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Privatelink {
namespace Model {
class ALIBABACLOUD_PRIVATELINK_EXPORT UpdateVpcEndpointServiceAttributeRequest : public RpcServiceRequest {
public:
UpdateVpcEndpointServiceAttributeRequest();
~UpdateVpcEndpointServiceAttributeRequest();
bool getPrivateServiceDomainEnabled() const;
void setPrivateServiceDomainEnabled(bool privateServiceDomainEnabled);
std::string getPrivateServiceDomain() const;
void setPrivateServiceDomain(const std::string &privateServiceDomain);
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 getZoneAffinityEnabled() const;
void setZoneAffinityEnabled(bool zoneAffinityEnabled);
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 privateServiceDomainEnabled_;
std::string privateServiceDomain_;
bool autoAcceptEnabled_;
std::string clientToken_;
int connectBandwidth_;
std::string regionId_;
bool zoneAffinityEnabled_;
bool dryRun_;
std::string serviceDescription_;
std::string serviceId_;
};
} // namespace Model
} // namespace Privatelink
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_PRIVATELINK_MODEL_UPDATEVPCENDPOINTSERVICEATTRIBUTEREQUEST_H_

94
privatelink/src/model/AddUserToVpcEndpointServiceRequest.cc
View File

@@ -1,84 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/AddUserToVpcEndpointServiceRequest.h>
using AlibabaCloud::Privatelink::Model::AddUserToVpcEndpointServiceRequest;
AddUserToVpcEndpointServiceRequest::AddUserToVpcEndpointServiceRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "AddUserToVpcEndpointService")
{
setMethod(HttpRequest::Method::Post);
}
AddUserToVpcEndpointServiceRequest::~AddUserToVpcEndpointServiceRequest()
{}
std::string AddUserToVpcEndpointServiceRequest::getClientToken()const
{
return clientToken_;
*/
#include <alibabacloud/privatelink/model/AddUserToVpcEndpointServiceRequest.h>
using AlibabaCloud::Privatelink::Model::AddUserToVpcEndpointServiceRequest;
AddUserToVpcEndpointServiceRequest::AddUserToVpcEndpointServiceRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "AddUserToVpcEndpointService") {
setMethod(HttpRequest::Method::Post);
}
void AddUserToVpcEndpointServiceRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
AddUserToVpcEndpointServiceRequest::~AddUserToVpcEndpointServiceRequest() {}
std::string AddUserToVpcEndpointServiceRequest::getClientToken() const {
return clientToken_;
}
long AddUserToVpcEndpointServiceRequest::getUserId()const
{
return userId_;
void AddUserToVpcEndpointServiceRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
void AddUserToVpcEndpointServiceRequest::setUserId(long userId)
{
userId_ = userId;
setParameter("UserId", std::to_string(userId));
long AddUserToVpcEndpointServiceRequest::getUserId() const {
return userId_;
}
std::string AddUserToVpcEndpointServiceRequest::getRegionId()const
{
return regionId_;
void AddUserToVpcEndpointServiceRequest::setUserId(long userId) {
userId_ = userId;
setParameter(std::string("UserId"), std::to_string(userId));
}
void AddUserToVpcEndpointServiceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string AddUserToVpcEndpointServiceRequest::getRegionId() const {
return regionId_;
}
bool AddUserToVpcEndpointServiceRequest::getDryRun()const
{
return dryRun_;
void AddUserToVpcEndpointServiceRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void AddUserToVpcEndpointServiceRequest::setDryRun(bool dryRun)
{
dryRun_ = dryRun;
setParameter("DryRun", dryRun ? "true" : "false");
bool AddUserToVpcEndpointServiceRequest::getDryRun() const {
return dryRun_;
}
std::string AddUserToVpcEndpointServiceRequest::getServiceId()const
{
return serviceId_;
void AddUserToVpcEndpointServiceRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
void AddUserToVpcEndpointServiceRequest::setServiceId(const std::string& serviceId)
{
serviceId_ = serviceId;
setParameter("ServiceId", serviceId);
std::string AddUserToVpcEndpointServiceRequest::getServiceId() const {
return serviceId_;
}
void AddUserToVpcEndpointServiceRequest::setServiceId(const std::string &serviceId) {
serviceId_ = serviceId;
setParameter(std::string("ServiceId"), serviceId);
}

118
privatelink/src/model/AddZoneToVpcEndpointRequest.cc
View File

@@ -1,106 +1,90 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/AddZoneToVpcEndpointRequest.h>
using AlibabaCloud::Privatelink::Model::AddZoneToVpcEndpointRequest;
AddZoneToVpcEndpointRequest::AddZoneToVpcEndpointRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "AddZoneToVpcEndpoint")
{
setMethod(HttpRequest::Method::Post);
}
AddZoneToVpcEndpointRequest::~AddZoneToVpcEndpointRequest()
{}
std::string AddZoneToVpcEndpointRequest::getClientToken()const
{
return clientToken_;
*/
#include <alibabacloud/privatelink/model/AddZoneToVpcEndpointRequest.h>
using AlibabaCloud::Privatelink::Model::AddZoneToVpcEndpointRequest;
AddZoneToVpcEndpointRequest::AddZoneToVpcEndpointRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "AddZoneToVpcEndpoint") {
setMethod(HttpRequest::Method::Post);
}
void AddZoneToVpcEndpointRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
AddZoneToVpcEndpointRequest::~AddZoneToVpcEndpointRequest() {}
std::string AddZoneToVpcEndpointRequest::getClientToken() const {
return clientToken_;
}
std::string AddZoneToVpcEndpointRequest::getEndpointId()const
{
return endpointId_;
void AddZoneToVpcEndpointRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
void AddZoneToVpcEndpointRequest::setEndpointId(const std::string& endpointId)
{
endpointId_ = endpointId;
setParameter("EndpointId", endpointId);
std::string AddZoneToVpcEndpointRequest::getEndpointId() const {
return endpointId_;
}
std::string AddZoneToVpcEndpointRequest::getRegionId()const
{
return regionId_;
void AddZoneToVpcEndpointRequest::setEndpointId(const std::string &endpointId) {
endpointId_ = endpointId;
setParameter(std::string("EndpointId"), endpointId);
}
void AddZoneToVpcEndpointRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string AddZoneToVpcEndpointRequest::getRegionId() const {
return regionId_;
}
bool AddZoneToVpcEndpointRequest::getDryRun()const
{
return dryRun_;
void AddZoneToVpcEndpointRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void AddZoneToVpcEndpointRequest::setDryRun(bool dryRun)
{
dryRun_ = dryRun;
setParameter("DryRun", dryRun ? "true" : "false");
bool AddZoneToVpcEndpointRequest::getDryRun() const {
return dryRun_;
}
std::string AddZoneToVpcEndpointRequest::getIp()const
{
return ip_;
void AddZoneToVpcEndpointRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
void AddZoneToVpcEndpointRequest::setIp(const std::string& ip)
{
ip_ = ip;
setParameter("Ip", ip);
std::string AddZoneToVpcEndpointRequest::getIp() const {
return ip_;
}
std::string AddZoneToVpcEndpointRequest::getVSwitchId()const
{
return vSwitchId_;
void AddZoneToVpcEndpointRequest::setIp(const std::string &ip) {
ip_ = ip;
setParameter(std::string("ip"), ip);
}
void AddZoneToVpcEndpointRequest::setVSwitchId(const std::string& vSwitchId)
{
vSwitchId_ = vSwitchId;
setParameter("VSwitchId", vSwitchId);
std::string AddZoneToVpcEndpointRequest::getVSwitchId() const {
return vSwitchId_;
}
std::string AddZoneToVpcEndpointRequest::getZoneId()const
{
return zoneId_;
void AddZoneToVpcEndpointRequest::setVSwitchId(const std::string &vSwitchId) {
vSwitchId_ = vSwitchId;
setParameter(std::string("VSwitchId"), vSwitchId);
}
void AddZoneToVpcEndpointRequest::setZoneId(const std::string& zoneId)
{
zoneId_ = zoneId;
setParameter("ZoneId", zoneId);
std::string AddZoneToVpcEndpointRequest::getZoneId() const {
return zoneId_;
}
void AddZoneToVpcEndpointRequest::setZoneId(const std::string &zoneId) {
zoneId_ = zoneId;
setParameter(std::string("ZoneId"), zoneId);
}

106
privatelink/src/model/AttachResourceToVpcEndpointServiceRequest.cc
View File

@@ -1,95 +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.
*/
#include <alibabacloud/privatelink/model/AttachResourceToVpcEndpointServiceRequest.h>
using AlibabaCloud::Privatelink::Model::AttachResourceToVpcEndpointServiceRequest;
AttachResourceToVpcEndpointServiceRequest::AttachResourceToVpcEndpointServiceRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "AttachResourceToVpcEndpointService")
{
setMethod(HttpRequest::Method::Post);
}
AttachResourceToVpcEndpointServiceRequest::~AttachResourceToVpcEndpointServiceRequest()
{}
std::string AttachResourceToVpcEndpointServiceRequest::getClientToken()const
{
return clientToken_;
*/
#include <alibabacloud/privatelink/model/AttachResourceToVpcEndpointServiceRequest.h>
using AlibabaCloud::Privatelink::Model::AttachResourceToVpcEndpointServiceRequest;
AttachResourceToVpcEndpointServiceRequest::AttachResourceToVpcEndpointServiceRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "AttachResourceToVpcEndpointService") {
setMethod(HttpRequest::Method::Post);
}
void AttachResourceToVpcEndpointServiceRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
AttachResourceToVpcEndpointServiceRequest::~AttachResourceToVpcEndpointServiceRequest() {}
std::string AttachResourceToVpcEndpointServiceRequest::getClientToken() const {
return clientToken_;
}
std::string AttachResourceToVpcEndpointServiceRequest::getRegionId()const
{
return regionId_;
void AttachResourceToVpcEndpointServiceRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
void AttachResourceToVpcEndpointServiceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string AttachResourceToVpcEndpointServiceRequest::getRegionId() const {
return regionId_;
}
std::string AttachResourceToVpcEndpointServiceRequest::getResourceId()const
{
return resourceId_;
void AttachResourceToVpcEndpointServiceRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void AttachResourceToVpcEndpointServiceRequest::setResourceId(const std::string& resourceId)
{
resourceId_ = resourceId;
setParameter("ResourceId", resourceId);
std::string AttachResourceToVpcEndpointServiceRequest::getResourceId() const {
return resourceId_;
}
bool AttachResourceToVpcEndpointServiceRequest::getDryRun()const
{
return dryRun_;
void AttachResourceToVpcEndpointServiceRequest::setResourceId(const std::string &resourceId) {
resourceId_ = resourceId;
setParameter(std::string("ResourceId"), resourceId);
}
void AttachResourceToVpcEndpointServiceRequest::setDryRun(bool dryRun)
{
dryRun_ = dryRun;
setParameter("DryRun", dryRun ? "true" : "false");
bool AttachResourceToVpcEndpointServiceRequest::getDryRun() const {
return dryRun_;
}
std::string AttachResourceToVpcEndpointServiceRequest::getResourceType()const
{
return resourceType_;
void AttachResourceToVpcEndpointServiceRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
void AttachResourceToVpcEndpointServiceRequest::setResourceType(const std::string& resourceType)
{
resourceType_ = resourceType;
setParameter("ResourceType", resourceType);
std::string AttachResourceToVpcEndpointServiceRequest::getResourceType() const {
return resourceType_;
}
std::string AttachResourceToVpcEndpointServiceRequest::getServiceId()const
{
return serviceId_;
void AttachResourceToVpcEndpointServiceRequest::setResourceType(const std::string &resourceType) {
resourceType_ = resourceType;
setParameter(std::string("ResourceType"), resourceType);
}
void AttachResourceToVpcEndpointServiceRequest::setServiceId(const std::string& serviceId)
{
serviceId_ = serviceId;
setParameter("ServiceId", serviceId);
std::string AttachResourceToVpcEndpointServiceRequest::getServiceId() const {
return serviceId_;
}
void AttachResourceToVpcEndpointServiceRequest::setServiceId(const std::string &serviceId) {
serviceId_ = serviceId;
setParameter(std::string("ServiceId"), serviceId);
}

94
privatelink/src/model/AttachSecurityGroupToVpcEndpointRequest.cc
View File

@@ -1,84 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/AttachSecurityGroupToVpcEndpointRequest.h>
using AlibabaCloud::Privatelink::Model::AttachSecurityGroupToVpcEndpointRequest;
AttachSecurityGroupToVpcEndpointRequest::AttachSecurityGroupToVpcEndpointRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "AttachSecurityGroupToVpcEndpoint")
{
setMethod(HttpRequest::Method::Post);
}
AttachSecurityGroupToVpcEndpointRequest::~AttachSecurityGroupToVpcEndpointRequest()
{}
std::string AttachSecurityGroupToVpcEndpointRequest::getClientToken()const
{
return clientToken_;
*/
#include <alibabacloud/privatelink/model/AttachSecurityGroupToVpcEndpointRequest.h>
using AlibabaCloud::Privatelink::Model::AttachSecurityGroupToVpcEndpointRequest;
AttachSecurityGroupToVpcEndpointRequest::AttachSecurityGroupToVpcEndpointRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "AttachSecurityGroupToVpcEndpoint") {
setMethod(HttpRequest::Method::Post);
}
void AttachSecurityGroupToVpcEndpointRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
AttachSecurityGroupToVpcEndpointRequest::~AttachSecurityGroupToVpcEndpointRequest() {}
std::string AttachSecurityGroupToVpcEndpointRequest::getClientToken() const {
return clientToken_;
}
std::string AttachSecurityGroupToVpcEndpointRequest::getEndpointId()const
{
return endpointId_;
void AttachSecurityGroupToVpcEndpointRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
void AttachSecurityGroupToVpcEndpointRequest::setEndpointId(const std::string& endpointId)
{
endpointId_ = endpointId;
setParameter("EndpointId", endpointId);
std::string AttachSecurityGroupToVpcEndpointRequest::getEndpointId() const {
return endpointId_;
}
std::string AttachSecurityGroupToVpcEndpointRequest::getSecurityGroupId()const
{
return securityGroupId_;
void AttachSecurityGroupToVpcEndpointRequest::setEndpointId(const std::string &endpointId) {
endpointId_ = endpointId;
setParameter(std::string("EndpointId"), endpointId);
}
void AttachSecurityGroupToVpcEndpointRequest::setSecurityGroupId(const std::string& securityGroupId)
{
securityGroupId_ = securityGroupId;
setParameter("SecurityGroupId", securityGroupId);
std::string AttachSecurityGroupToVpcEndpointRequest::getSecurityGroupId() const {
return securityGroupId_;
}
std::string AttachSecurityGroupToVpcEndpointRequest::getRegionId()const
{
return regionId_;
void AttachSecurityGroupToVpcEndpointRequest::setSecurityGroupId(const std::string &securityGroupId) {
securityGroupId_ = securityGroupId;
setParameter(std::string("SecurityGroupId"), securityGroupId);
}
void AttachSecurityGroupToVpcEndpointRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string AttachSecurityGroupToVpcEndpointRequest::getRegionId() const {
return regionId_;
}
bool AttachSecurityGroupToVpcEndpointRequest::getDryRun()const
{
return dryRun_;
void AttachSecurityGroupToVpcEndpointRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void AttachSecurityGroupToVpcEndpointRequest::setDryRun(bool dryRun)
{
dryRun_ = dryRun;
setParameter("DryRun", dryRun ? "true" : "false");
bool AttachSecurityGroupToVpcEndpointRequest::getDryRun() const {
return dryRun_;
}
void AttachSecurityGroupToVpcEndpointRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}

46
privatelink/src/model/CheckProductOpenRequest.cc
View File

@@ -1,40 +1,36 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/CheckProductOpenRequest.h>
using AlibabaCloud::Privatelink::Model::CheckProductOpenRequest;
CheckProductOpenRequest::CheckProductOpenRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "CheckProductOpen")
{
setMethod(HttpRequest::Method::Post);
}
CheckProductOpenRequest::~CheckProductOpenRequest()
{}
std::string CheckProductOpenRequest::getRegionId()const
{
return regionId_;
*/
#include <alibabacloud/privatelink/model/CheckProductOpenRequest.h>
using AlibabaCloud::Privatelink::Model::CheckProductOpenRequest;
CheckProductOpenRequest::CheckProductOpenRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "CheckProductOpen") {
setMethod(HttpRequest::Method::Post);
}
void CheckProductOpenRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
CheckProductOpenRequest::~CheckProductOpenRequest() {}
std::string CheckProductOpenRequest::getRegionId() const {
return regionId_;
}
void CheckProductOpenRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}

194
privatelink/src/model/CreateVpcEndpointRequest.cc
View File

@@ -1,147 +1,149 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/CreateVpcEndpointRequest.h>
using AlibabaCloud::Privatelink::Model::CreateVpcEndpointRequest;
CreateVpcEndpointRequest::CreateVpcEndpointRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "CreateVpcEndpoint")
{
setMethod(HttpRequest::Method::Post);
}
CreateVpcEndpointRequest::~CreateVpcEndpointRequest()
{}
std::string CreateVpcEndpointRequest::getClientToken()const
{
return clientToken_;
*/
#include <alibabacloud/privatelink/model/CreateVpcEndpointRequest.h>
using AlibabaCloud::Privatelink::Model::CreateVpcEndpointRequest;
CreateVpcEndpointRequest::CreateVpcEndpointRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "CreateVpcEndpoint") {
setMethod(HttpRequest::Method::Post);
}
void CreateVpcEndpointRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
CreateVpcEndpointRequest::~CreateVpcEndpointRequest() {}
std::string CreateVpcEndpointRequest::getClientToken() const {
return clientToken_;
}
std::vector<std::string> CreateVpcEndpointRequest::getSecurityGroupId()const
{
return securityGroupId_;
void CreateVpcEndpointRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
void CreateVpcEndpointRequest::setSecurityGroupId(const std::vector<std::string>& securityGroupId)
{
securityGroupId_ = securityGroupId;
for(int dep1 = 0; dep1!= securityGroupId.size(); dep1++) {
setParameter("SecurityGroupId."+ std::to_string(dep1), securityGroupId.at(dep1));
}
std::vector<std::string> CreateVpcEndpointRequest::getSecurityGroupId() const {
return securityGroupId_;
}
std::string CreateVpcEndpointRequest::getRegionId()const
{
return regionId_;
void CreateVpcEndpointRequest::setSecurityGroupId(const std::vector<std::string> &securityGroupId) {
securityGroupId_ = securityGroupId;
}
void CreateVpcEndpointRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string CreateVpcEndpointRequest::getRegionId() const {
return regionId_;
}
std::vector<CreateVpcEndpointRequest::Zone> CreateVpcEndpointRequest::getZone()const
{
return zone_;
void CreateVpcEndpointRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void CreateVpcEndpointRequest::setZone(const std::vector<Zone>& zone)
{
zone_ = zone;
for(int dep1 = 0; dep1!= zone.size(); dep1++) {
auto zoneObj = zone.at(dep1);
std::string zoneObjStr = "Zone." + std::to_string(dep1 + 1);
setParameter(zoneObjStr + ".VSwitchId", zoneObj.vSwitchId);
setParameter(zoneObjStr + ".ZoneId", zoneObj.zoneId);
setParameter(zoneObjStr + ".Ip", zoneObj.ip);
}
std::string CreateVpcEndpointRequest::getEndpointType() const {
return endpointType_;
}
std::string CreateVpcEndpointRequest::getServiceName()const
{
return serviceName_;
void CreateVpcEndpointRequest::setEndpointType(const std::string &endpointType) {
endpointType_ = endpointType;
setParameter(std::string("EndpointType"), endpointType);
}
void CreateVpcEndpointRequest::setServiceName(const std::string& serviceName)
{
serviceName_ = serviceName;
setParameter("ServiceName", serviceName);
std::vector<CreateVpcEndpointRequest::Zone> CreateVpcEndpointRequest::getZone() const {
return zone_;
}
bool CreateVpcEndpointRequest::getDryRun()const
{
return dryRun_;
void CreateVpcEndpointRequest::setZone(const std::vector<CreateVpcEndpointRequest::Zone> &zone) {
zone_ = zone;
for(int dep1 = 0; dep1 != zone.size(); dep1++) {
auto zoneObj = zone.at(dep1);
std::string zoneObjStr = std::string("Zone") + "." + std::to_string(dep1 + 1);
setParameter(zoneObjStr + ".VSwitchId", zoneObj.vSwitchId);
setParameter(zoneObjStr + ".ZoneId", zoneObj.zoneId);
setParameter(zoneObjStr + ".ip", zoneObj.ip);
}
}
void CreateVpcEndpointRequest::setDryRun(bool dryRun)
{
dryRun_ = dryRun;
setParameter("DryRun", dryRun ? "true" : "false");
std::string CreateVpcEndpointRequest::getServiceName() const {
return serviceName_;
}
std::string CreateVpcEndpointRequest::getEndpointDescription()const
{
return endpointDescription_;
void CreateVpcEndpointRequest::setServiceName(const std::string &serviceName) {
serviceName_ = serviceName;
setParameter(std::string("ServiceName"), serviceName);
}
void CreateVpcEndpointRequest::setEndpointDescription(const std::string& endpointDescription)
{
endpointDescription_ = endpointDescription;
setParameter("EndpointDescription", endpointDescription);
bool CreateVpcEndpointRequest::getDryRun() const {
return dryRun_;
}
std::string CreateVpcEndpointRequest::getEndpointName()const
{
return endpointName_;
void CreateVpcEndpointRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
void CreateVpcEndpointRequest::setEndpointName(const std::string& endpointName)
{
endpointName_ = endpointName;
setParameter("EndpointName", endpointName);
std::string CreateVpcEndpointRequest::getEndpointDescription() const {
return endpointDescription_;
}
std::string CreateVpcEndpointRequest::getVpcId()const
{
return vpcId_;
void CreateVpcEndpointRequest::setEndpointDescription(const std::string &endpointDescription) {
endpointDescription_ = endpointDescription;
setParameter(std::string("EndpointDescription"), endpointDescription);
}
void CreateVpcEndpointRequest::setVpcId(const std::string& vpcId)
{
vpcId_ = vpcId;
setParameter("VpcId", vpcId);
long CreateVpcEndpointRequest::getZonePrivateIpAddressCount() const {
return zonePrivateIpAddressCount_;
}
std::string CreateVpcEndpointRequest::getServiceId()const
{
return serviceId_;
void CreateVpcEndpointRequest::setZonePrivateIpAddressCount(long zonePrivateIpAddressCount) {
zonePrivateIpAddressCount_ = zonePrivateIpAddressCount;
setParameter(std::string("ZonePrivateIpAddressCount"), std::to_string(zonePrivateIpAddressCount));
}
void CreateVpcEndpointRequest::setServiceId(const std::string& serviceId)
{
serviceId_ = serviceId;
setParameter("ServiceId", serviceId);
bool CreateVpcEndpointRequest::getProtectedEnabled() const {
return protectedEnabled_;
}
void CreateVpcEndpointRequest::setProtectedEnabled(bool protectedEnabled) {
protectedEnabled_ = protectedEnabled;
setParameter(std::string("ProtectedEnabled"), protectedEnabled ? "true" : "false");
}
std::string CreateVpcEndpointRequest::getEndpointName() const {
return endpointName_;
}
void CreateVpcEndpointRequest::setEndpointName(const std::string &endpointName) {
endpointName_ = endpointName;
setParameter(std::string("EndpointName"), endpointName);
}
std::string CreateVpcEndpointRequest::getVpcId() const {
return vpcId_;
}
void CreateVpcEndpointRequest::setVpcId(const std::string &vpcId) {
vpcId_ = vpcId;
setParameter(std::string("VpcId"), vpcId);
}
std::string CreateVpcEndpointRequest::getServiceId() const {
return serviceId_;
}
void CreateVpcEndpointRequest::setServiceId(const std::string &serviceId) {
serviceId_ = serviceId;
setParameter(std::string("ServiceId"), serviceId);
}

44
privatelink/src/model/CreateVpcEndpointResult.cc
View File

@@ -39,30 +39,30 @@ void CreateVpcEndpointResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["EndpointStatus"].isNull())
endpointStatus_ = value["EndpointStatus"].asString();
if(!value["EndpointName"].isNull())
endpointName_ = value["EndpointName"].asString();
if(!value["VpcId"].isNull())
vpcId_ = value["VpcId"].asString();
if(!value["EndpointDomain"].isNull())
endpointDomain_ = value["EndpointDomain"].asString();
if(!value["ServiceName"].isNull())
serviceName_ = value["ServiceName"].asString();
if(!value["EndpointId"].isNull())
endpointId_ = value["EndpointId"].asString();
if(!value["Bandwidth"].isNull())
bandwidth_ = std::stol(value["Bandwidth"].asString());
if(!value["CreateTime"].isNull())
createTime_ = value["CreateTime"].asString();
if(!value["EndpointBusinessStatus"].isNull())
endpointBusinessStatus_ = value["EndpointBusinessStatus"].asString();
if(!value["EndpointDescription"].isNull())
endpointDescription_ = value["EndpointDescription"].asString();
if(!value["ConnectionStatus"].isNull())
connectionStatus_ = value["ConnectionStatus"].asString();
if(!value["ServiceId"].isNull())
serviceId_ = value["ServiceId"].asString();
if(!value["EndpointStatus"].isNull())
endpointStatus_ = value["EndpointStatus"].asString();
if(!value["VpcId"].isNull())
vpcId_ = value["VpcId"].asString();
if(!value["EndpointName"].isNull())
endpointName_ = value["EndpointName"].asString();
if(!value["ServiceName"].isNull())
serviceName_ = value["ServiceName"].asString();
if(!value["Bandwidth"].isNull())
bandwidth_ = std::stol(value["Bandwidth"].asString());
if(!value["EndpointId"].isNull())
endpointId_ = value["EndpointId"].asString();
if(!value["ConnectionStatus"].isNull())
connectionStatus_ = value["ConnectionStatus"].asString();
}
@@ -71,9 +71,9 @@ std::string CreateVpcEndpointResult::getEndpointStatus()const
return endpointStatus_;
}
std::string CreateVpcEndpointResult::getEndpointName()const
std::string CreateVpcEndpointResult::getEndpointDomain()const
{
return endpointName_;
return endpointDomain_;
}
std::string CreateVpcEndpointResult::getVpcId()const
@@ -81,9 +81,9 @@ std::string CreateVpcEndpointResult::getVpcId()const
return vpcId_;
}
std::string CreateVpcEndpointResult::getEndpointDomain()const
std::string CreateVpcEndpointResult::getEndpointName()const
{
return endpointDomain_;
return endpointName_;
}
std::string CreateVpcEndpointResult::getServiceName()const
@@ -91,9 +91,9 @@ std::string CreateVpcEndpointResult::getServiceName()const
return serviceName_;
}
std::string CreateVpcEndpointResult::getEndpointId()const
std::string CreateVpcEndpointResult::getCreateTime()const
{
return endpointId_;
return createTime_;
}
long CreateVpcEndpointResult::getBandwidth()const
@@ -101,9 +101,9 @@ long CreateVpcEndpointResult::getBandwidth()const
return bandwidth_;
}
std::string CreateVpcEndpointResult::getCreateTime()const
std::string CreateVpcEndpointResult::getEndpointId()const
{
return createTime_;
return endpointId_;
}
std::string CreateVpcEndpointResult::getEndpointBusinessStatus()const

167
privatelink/src/model/CreateVpcEndpointServiceRequest.cc
View File

@@ -1,122 +1,131 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/CreateVpcEndpointServiceRequest.h>
using AlibabaCloud::Privatelink::Model::CreateVpcEndpointServiceRequest;
CreateVpcEndpointServiceRequest::CreateVpcEndpointServiceRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "CreateVpcEndpointService")
{
setMethod(HttpRequest::Method::Post);
}
CreateVpcEndpointServiceRequest::~CreateVpcEndpointServiceRequest()
{}
bool CreateVpcEndpointServiceRequest::getAutoAcceptEnabled()const
{
return autoAcceptEnabled_;
*/
#include <alibabacloud/privatelink/model/CreateVpcEndpointServiceRequest.h>
using AlibabaCloud::Privatelink::Model::CreateVpcEndpointServiceRequest;
CreateVpcEndpointServiceRequest::CreateVpcEndpointServiceRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "CreateVpcEndpointService") {
setMethod(HttpRequest::Method::Post);
}
void CreateVpcEndpointServiceRequest::setAutoAcceptEnabled(bool autoAcceptEnabled)
{
autoAcceptEnabled_ = autoAcceptEnabled;
setParameter("AutoAcceptEnabled", autoAcceptEnabled ? "true" : "false");
CreateVpcEndpointServiceRequest::~CreateVpcEndpointServiceRequest() {}
bool CreateVpcEndpointServiceRequest::getPrivateServiceDomainEnabled() const {
return privateServiceDomainEnabled_;
}
std::string CreateVpcEndpointServiceRequest::getClientToken()const
{
return clientToken_;
void CreateVpcEndpointServiceRequest::setPrivateServiceDomainEnabled(bool privateServiceDomainEnabled) {
privateServiceDomainEnabled_ = privateServiceDomainEnabled;
setParameter(std::string("PrivateServiceDomainEnabled"), privateServiceDomainEnabled ? "true" : "false");
}
void CreateVpcEndpointServiceRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
std::string CreateVpcEndpointServiceRequest::getPrivateServiceDomain() const {
return privateServiceDomain_;
}
std::string CreateVpcEndpointServiceRequest::getPayer()const
{
return payer_;
void CreateVpcEndpointServiceRequest::setPrivateServiceDomain(const std::string &privateServiceDomain) {
privateServiceDomain_ = privateServiceDomain;
setParameter(std::string("PrivateServiceDomain"), privateServiceDomain);
}
void CreateVpcEndpointServiceRequest::setPayer(const std::string& payer)
{
payer_ = payer;
setParameter("Payer", payer);
bool CreateVpcEndpointServiceRequest::getAutoAcceptEnabled() const {
return autoAcceptEnabled_;
}
std::string CreateVpcEndpointServiceRequest::getRegionId()const
{
return regionId_;
void CreateVpcEndpointServiceRequest::setAutoAcceptEnabled(bool autoAcceptEnabled) {
autoAcceptEnabled_ = autoAcceptEnabled;
setParameter(std::string("AutoAcceptEnabled"), autoAcceptEnabled ? "true" : "false");
}
void CreateVpcEndpointServiceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string CreateVpcEndpointServiceRequest::getClientToken() const {
return clientToken_;
}
bool CreateVpcEndpointServiceRequest::getZoneAffinityEnabled()const
{
return zoneAffinityEnabled_;
void CreateVpcEndpointServiceRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
void CreateVpcEndpointServiceRequest::setZoneAffinityEnabled(bool zoneAffinityEnabled)
{
zoneAffinityEnabled_ = zoneAffinityEnabled;
setParameter("ZoneAffinityEnabled", zoneAffinityEnabled ? "true" : "false");
std::string CreateVpcEndpointServiceRequest::getPayer() const {
return payer_;
}
bool CreateVpcEndpointServiceRequest::getDryRun()const
{
return dryRun_;
void CreateVpcEndpointServiceRequest::setPayer(const std::string &payer) {
payer_ = payer;
setParameter(std::string("Payer"), payer);
}
void CreateVpcEndpointServiceRequest::setDryRun(bool dryRun)
{
dryRun_ = dryRun;
setParameter("DryRun", dryRun ? "true" : "false");
std::string CreateVpcEndpointServiceRequest::getRegionId() const {
return regionId_;
}
std::vector<CreateVpcEndpointServiceRequest::Resource> CreateVpcEndpointServiceRequest::getResource()const
{
return resource_;
void CreateVpcEndpointServiceRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void CreateVpcEndpointServiceRequest::setResource(const std::vector<Resource>& resource)
{
resource_ = resource;
for(int dep1 = 0; dep1!= resource.size(); dep1++) {
auto resourceObj = resource.at(dep1);
std::string resourceObjStr = "Resource." + std::to_string(dep1 + 1);
setParameter(resourceObjStr + ".ResourceType", resourceObj.resourceType);
setParameter(resourceObjStr + ".ResourceId", resourceObj.resourceId);
}
bool CreateVpcEndpointServiceRequest::getZoneAffinityEnabled() const {
return zoneAffinityEnabled_;
}
std::string CreateVpcEndpointServiceRequest::getServiceDescription()const
{
return serviceDescription_;
void CreateVpcEndpointServiceRequest::setZoneAffinityEnabled(bool zoneAffinityEnabled) {
zoneAffinityEnabled_ = zoneAffinityEnabled;
setParameter(std::string("ZoneAffinityEnabled"), zoneAffinityEnabled ? "true" : "false");
}
void CreateVpcEndpointServiceRequest::setServiceDescription(const std::string& serviceDescription)
{
serviceDescription_ = serviceDescription;
setParameter("ServiceDescription", serviceDescription);
bool CreateVpcEndpointServiceRequest::getDryRun() const {
return dryRun_;
}
void CreateVpcEndpointServiceRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
std::vector<CreateVpcEndpointServiceRequest::Resource> CreateVpcEndpointServiceRequest::getResource() const {
return resource_;
}
void CreateVpcEndpointServiceRequest::setResource(const std::vector<CreateVpcEndpointServiceRequest::Resource> &resource) {
resource_ = resource;
for(int dep1 = 0; dep1 != resource.size(); dep1++) {
auto resourceObj = resource.at(dep1);
std::string resourceObjStr = std::string("Resource") + "." + std::to_string(dep1 + 1);
setParameter(resourceObjStr + ".ResourceType", resourceObj.resourceType);
setParameter(resourceObjStr + ".ResourceId", resourceObj.resourceId);
}
}
std::string CreateVpcEndpointServiceRequest::getServiceResourceType() const {
return serviceResourceType_;
}
void CreateVpcEndpointServiceRequest::setServiceResourceType(const std::string &serviceResourceType) {
serviceResourceType_ = serviceResourceType;
setParameter(std::string("ServiceResourceType"), serviceResourceType);
}
std::string CreateVpcEndpointServiceRequest::getServiceDescription() const {
return serviceDescription_;
}
void CreateVpcEndpointServiceRequest::setServiceDescription(const std::string &serviceDescription) {
serviceDescription_ = serviceDescription;
setParameter(std::string("ServiceDescription"), serviceDescription);
}

36
privatelink/src/model/CreateVpcEndpointServiceResult.cc
View File

@@ -43,20 +43,20 @@ void CreateVpcEndpointServiceResult::parse(const std::string &payload)
serviceBusinessStatus_ = value["ServiceBusinessStatus"].asString();
if(!value["ServiceName"].isNull())
serviceName_ = value["ServiceName"].asString();
if(!value["ServiceDescription"].isNull())
serviceDescription_ = value["ServiceDescription"].asString();
if(!value["ServiceStatus"].isNull())
serviceStatus_ = value["ServiceStatus"].asString();
if(!value["ServiceDescription"].isNull())
serviceDescription_ = value["ServiceDescription"].asString();
if(!value["CreateTime"].isNull())
createTime_ = value["CreateTime"].asString();
if(!value["ZoneAffinityEnabled"].isNull())
zoneAffinityEnabled_ = value["ZoneAffinityEnabled"].asString() == "true";
if(!value["ServiceDomain"].isNull())
serviceDomain_ = value["ServiceDomain"].asString();
if(!value["ServiceId"].isNull())
serviceId_ = value["ServiceId"].asString();
if(!value["ZoneAffinityEnabled"].isNull())
zoneAffinityEnabled_ = value["ZoneAffinityEnabled"].asString() == "true";
if(!value["AutoAcceptEnabled"].isNull())
autoAcceptEnabled_ = value["AutoAcceptEnabled"].asString() == "true";
if(!value["ServiceId"].isNull())
serviceId_ = value["ServiceId"].asString();
}
@@ -70,34 +70,29 @@ std::string CreateVpcEndpointServiceResult::getServiceName()const
return serviceName_;
}
std::string CreateVpcEndpointServiceResult::getServiceDescription()const
{
return serviceDescription_;
}
std::string CreateVpcEndpointServiceResult::getServiceStatus()const
{
return serviceStatus_;
}
std::string CreateVpcEndpointServiceResult::getServiceDescription()const
{
return serviceDescription_;
}
std::string CreateVpcEndpointServiceResult::getCreateTime()const
{
return createTime_;
}
bool CreateVpcEndpointServiceResult::getZoneAffinityEnabled()const
{
return zoneAffinityEnabled_;
}
std::string CreateVpcEndpointServiceResult::getServiceDomain()const
{
return serviceDomain_;
}
std::string CreateVpcEndpointServiceResult::getServiceId()const
bool CreateVpcEndpointServiceResult::getZoneAffinityEnabled()const
{
return serviceId_;
return zoneAffinityEnabled_;
}
bool CreateVpcEndpointServiceResult::getAutoAcceptEnabled()const
@@ -105,3 +100,8 @@ bool CreateVpcEndpointServiceResult::getAutoAcceptEnabled()const
return autoAcceptEnabled_;
}
std::string CreateVpcEndpointServiceResult::getServiceId()const
{
return serviceId_;
}

91
privatelink/src/model/DeleteVpcEndpointRequest.cc
View File

@@ -1,73 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/DeleteVpcEndpointRequest.h>
using AlibabaCloud::Privatelink::Model::DeleteVpcEndpointRequest;
DeleteVpcEndpointRequest::DeleteVpcEndpointRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "DeleteVpcEndpoint")
{
setMethod(HttpRequest::Method::Post);
}
DeleteVpcEndpointRequest::~DeleteVpcEndpointRequest()
{}
std::string DeleteVpcEndpointRequest::getClientToken()const
{
return clientToken_;
*/
#include <alibabacloud/privatelink/model/DeleteVpcEndpointRequest.h>
using AlibabaCloud::Privatelink::Model::DeleteVpcEndpointRequest;
DeleteVpcEndpointRequest::DeleteVpcEndpointRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "DeleteVpcEndpoint") {
setMethod(HttpRequest::Method::Post);
}
void DeleteVpcEndpointRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
DeleteVpcEndpointRequest::~DeleteVpcEndpointRequest() {}
std::string DeleteVpcEndpointRequest::getClientToken() const {
return clientToken_;
}
std::string DeleteVpcEndpointRequest::getEndpointId()const
{
return endpointId_;
void DeleteVpcEndpointRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
void DeleteVpcEndpointRequest::setEndpointId(const std::string& endpointId)
{
endpointId_ = endpointId;
setParameter("EndpointId", endpointId);
std::string DeleteVpcEndpointRequest::getEndpointId() const {
return endpointId_;
}
std::string DeleteVpcEndpointRequest::getRegionId()const
{
return regionId_;
void DeleteVpcEndpointRequest::setEndpointId(const std::string &endpointId) {
endpointId_ = endpointId;
setParameter(std::string("EndpointId"), endpointId);
}
void DeleteVpcEndpointRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string DeleteVpcEndpointRequest::getRegionId() const {
return regionId_;
}
bool DeleteVpcEndpointRequest::getDryRun()const
{
return dryRun_;
void DeleteVpcEndpointRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void DeleteVpcEndpointRequest::setDryRun(bool dryRun)
{
dryRun_ = dryRun;
setParameter("DryRun", dryRun ? "true" : "false");
bool DeleteVpcEndpointRequest::getDryRun() const {
return dryRun_;
}
void DeleteVpcEndpointRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
bool DeleteVpcEndpointRequest::getForce() const {
return force_;
}
void DeleteVpcEndpointRequest::setForce(bool force) {
force_ = force;
setParameter(std::string("Force"), force ? "true" : "false");
}

82
privatelink/src/model/DeleteVpcEndpointServiceRequest.cc
View File

@@ -1,73 +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.
*/
#include <alibabacloud/privatelink/model/DeleteVpcEndpointServiceRequest.h>
using AlibabaCloud::Privatelink::Model::DeleteVpcEndpointServiceRequest;
DeleteVpcEndpointServiceRequest::DeleteVpcEndpointServiceRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "DeleteVpcEndpointService")
{
setMethod(HttpRequest::Method::Post);
}
DeleteVpcEndpointServiceRequest::~DeleteVpcEndpointServiceRequest()
{}
std::string DeleteVpcEndpointServiceRequest::getClientToken()const
{
return clientToken_;
*/
#include <alibabacloud/privatelink/model/DeleteVpcEndpointServiceRequest.h>
using AlibabaCloud::Privatelink::Model::DeleteVpcEndpointServiceRequest;
DeleteVpcEndpointServiceRequest::DeleteVpcEndpointServiceRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "DeleteVpcEndpointService") {
setMethod(HttpRequest::Method::Post);
}
void DeleteVpcEndpointServiceRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
DeleteVpcEndpointServiceRequest::~DeleteVpcEndpointServiceRequest() {}
std::string DeleteVpcEndpointServiceRequest::getClientToken() const {
return clientToken_;
}
std::string DeleteVpcEndpointServiceRequest::getRegionId()const
{
return regionId_;
void DeleteVpcEndpointServiceRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
void DeleteVpcEndpointServiceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string DeleteVpcEndpointServiceRequest::getRegionId() const {
return regionId_;
}
bool DeleteVpcEndpointServiceRequest::getDryRun()const
{
return dryRun_;
void DeleteVpcEndpointServiceRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void DeleteVpcEndpointServiceRequest::setDryRun(bool dryRun)
{
dryRun_ = dryRun;
setParameter("DryRun", dryRun ? "true" : "false");
bool DeleteVpcEndpointServiceRequest::getDryRun() const {
return dryRun_;
}
std::string DeleteVpcEndpointServiceRequest::getServiceId()const
{
return serviceId_;
void DeleteVpcEndpointServiceRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
void DeleteVpcEndpointServiceRequest::setServiceId(const std::string& serviceId)
{
serviceId_ = serviceId;
setParameter("ServiceId", serviceId);
std::string DeleteVpcEndpointServiceRequest::getServiceId() const {
return serviceId_;
}
void DeleteVpcEndpointServiceRequest::setServiceId(const std::string &serviceId) {
serviceId_ = serviceId;
setParameter(std::string("ServiceId"), serviceId);
}

46
privatelink/src/model/DescribeRegionsRequest.cc
View File

@@ -1,40 +1,36 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/DescribeRegionsRequest.h>
using AlibabaCloud::Privatelink::Model::DescribeRegionsRequest;
DescribeRegionsRequest::DescribeRegionsRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "DescribeRegions")
{
setMethod(HttpRequest::Method::Post);
}
DescribeRegionsRequest::~DescribeRegionsRequest()
{}
std::string DescribeRegionsRequest::getRegionId()const
{
return regionId_;
*/
#include <alibabacloud/privatelink/model/DescribeRegionsRequest.h>
using AlibabaCloud::Privatelink::Model::DescribeRegionsRequest;
DescribeRegionsRequest::DescribeRegionsRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "DescribeRegions") {
setMethod(HttpRequest::Method::Post);
}
void DescribeRegionsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
DescribeRegionsRequest::~DescribeRegionsRequest() {}
std::string DescribeRegionsRequest::getRegionId() const {
return regionId_;
}
void DescribeRegionsRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}

4
privatelink/src/model/DescribeRegionsResult.cc
View File

@@ -43,12 +43,12 @@ void DescribeRegionsResult::parse(const std::string &payload)
for (auto valueRegionsRegion : allRegionsNode)
{
Region regionsObject;
if(!valueRegionsRegion["RegionId"].isNull())
regionsObject.regionId = valueRegionsRegion["RegionId"].asString();
if(!valueRegionsRegion["LocalName"].isNull())
regionsObject.localName = valueRegionsRegion["LocalName"].asString();
if(!valueRegionsRegion["RegionEndpoint"].isNull())
regionsObject.regionEndpoint = valueRegionsRegion["RegionEndpoint"].asString();
if(!valueRegionsRegion["RegionId"].isNull())
regionsObject.regionId = valueRegionsRegion["RegionId"].asString();
regions_.push_back(regionsObject);
}

46
privatelink/src/model/DescribeZonesRequest.cc
View File

@@ -1,40 +1,36 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/DescribeZonesRequest.h>
using AlibabaCloud::Privatelink::Model::DescribeZonesRequest;
DescribeZonesRequest::DescribeZonesRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "DescribeZones")
{
setMethod(HttpRequest::Method::Post);
}
DescribeZonesRequest::~DescribeZonesRequest()
{}
std::string DescribeZonesRequest::getRegionId()const
{
return regionId_;
*/
#include <alibabacloud/privatelink/model/DescribeZonesRequest.h>
using AlibabaCloud::Privatelink::Model::DescribeZonesRequest;
DescribeZonesRequest::DescribeZonesRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "DescribeZones") {
setMethod(HttpRequest::Method::Post);
}
void DescribeZonesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
DescribeZonesRequest::~DescribeZonesRequest() {}
std::string DescribeZonesRequest::getRegionId() const {
return regionId_;
}
void DescribeZonesRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}

4
privatelink/src/model/DescribeZonesResult.cc
View File

@@ -43,10 +43,10 @@ void DescribeZonesResult::parse(const std::string &payload)
for (auto valueZonesZone : allZonesNode)
{
Zone zonesObject;
if(!valueZonesZone["ZoneId"].isNull())
zonesObject.zoneId = valueZonesZone["ZoneId"].asString();
if(!valueZonesZone["LocalName"].isNull())
zonesObject.localName = valueZonesZone["LocalName"].asString();
if(!valueZonesZone["ZoneId"].isNull())
zonesObject.zoneId = valueZonesZone["ZoneId"].asString();
zones_.push_back(zonesObject);
}

106
privatelink/src/model/DetachResourceFromVpcEndpointServiceRequest.cc
View File

@@ -1,95 +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.
*/
#include <alibabacloud/privatelink/model/DetachResourceFromVpcEndpointServiceRequest.h>
using AlibabaCloud::Privatelink::Model::DetachResourceFromVpcEndpointServiceRequest;
DetachResourceFromVpcEndpointServiceRequest::DetachResourceFromVpcEndpointServiceRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "DetachResourceFromVpcEndpointService")
{
setMethod(HttpRequest::Method::Post);
}
DetachResourceFromVpcEndpointServiceRequest::~DetachResourceFromVpcEndpointServiceRequest()
{}
std::string DetachResourceFromVpcEndpointServiceRequest::getClientToken()const
{
return clientToken_;
*/
#include <alibabacloud/privatelink/model/DetachResourceFromVpcEndpointServiceRequest.h>
using AlibabaCloud::Privatelink::Model::DetachResourceFromVpcEndpointServiceRequest;
DetachResourceFromVpcEndpointServiceRequest::DetachResourceFromVpcEndpointServiceRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "DetachResourceFromVpcEndpointService") {
setMethod(HttpRequest::Method::Post);
}
void DetachResourceFromVpcEndpointServiceRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
DetachResourceFromVpcEndpointServiceRequest::~DetachResourceFromVpcEndpointServiceRequest() {}
std::string DetachResourceFromVpcEndpointServiceRequest::getClientToken() const {
return clientToken_;
}
std::string DetachResourceFromVpcEndpointServiceRequest::getRegionId()const
{
return regionId_;
void DetachResourceFromVpcEndpointServiceRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
void DetachResourceFromVpcEndpointServiceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string DetachResourceFromVpcEndpointServiceRequest::getRegionId() const {
return regionId_;
}
std::string DetachResourceFromVpcEndpointServiceRequest::getResourceId()const
{
return resourceId_;
void DetachResourceFromVpcEndpointServiceRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void DetachResourceFromVpcEndpointServiceRequest::setResourceId(const std::string& resourceId)
{
resourceId_ = resourceId;
setParameter("ResourceId", resourceId);
std::string DetachResourceFromVpcEndpointServiceRequest::getResourceId() const {
return resourceId_;
}
bool DetachResourceFromVpcEndpointServiceRequest::getDryRun()const
{
return dryRun_;
void DetachResourceFromVpcEndpointServiceRequest::setResourceId(const std::string &resourceId) {
resourceId_ = resourceId;
setParameter(std::string("ResourceId"), resourceId);
}
void DetachResourceFromVpcEndpointServiceRequest::setDryRun(bool dryRun)
{
dryRun_ = dryRun;
setParameter("DryRun", dryRun ? "true" : "false");
bool DetachResourceFromVpcEndpointServiceRequest::getDryRun() const {
return dryRun_;
}
std::string DetachResourceFromVpcEndpointServiceRequest::getResourceType()const
{
return resourceType_;
void DetachResourceFromVpcEndpointServiceRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
void DetachResourceFromVpcEndpointServiceRequest::setResourceType(const std::string& resourceType)
{
resourceType_ = resourceType;
setParameter("ResourceType", resourceType);
std::string DetachResourceFromVpcEndpointServiceRequest::getResourceType() const {
return resourceType_;
}
std::string DetachResourceFromVpcEndpointServiceRequest::getServiceId()const
{
return serviceId_;
void DetachResourceFromVpcEndpointServiceRequest::setResourceType(const std::string &resourceType) {
resourceType_ = resourceType;
setParameter(std::string("ResourceType"), resourceType);
}
void DetachResourceFromVpcEndpointServiceRequest::setServiceId(const std::string& serviceId)
{
serviceId_ = serviceId;
setParameter("ServiceId", serviceId);
std::string DetachResourceFromVpcEndpointServiceRequest::getServiceId() const {
return serviceId_;
}
void DetachResourceFromVpcEndpointServiceRequest::setServiceId(const std::string &serviceId) {
serviceId_ = serviceId;
setParameter(std::string("ServiceId"), serviceId);
}

94
privatelink/src/model/DetachSecurityGroupFromVpcEndpointRequest.cc
View File

@@ -1,84 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/DetachSecurityGroupFromVpcEndpointRequest.h>
using AlibabaCloud::Privatelink::Model::DetachSecurityGroupFromVpcEndpointRequest;
DetachSecurityGroupFromVpcEndpointRequest::DetachSecurityGroupFromVpcEndpointRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "DetachSecurityGroupFromVpcEndpoint")
{
setMethod(HttpRequest::Method::Post);
}
DetachSecurityGroupFromVpcEndpointRequest::~DetachSecurityGroupFromVpcEndpointRequest()
{}
std::string DetachSecurityGroupFromVpcEndpointRequest::getClientToken()const
{
return clientToken_;
*/
#include <alibabacloud/privatelink/model/DetachSecurityGroupFromVpcEndpointRequest.h>
using AlibabaCloud::Privatelink::Model::DetachSecurityGroupFromVpcEndpointRequest;
DetachSecurityGroupFromVpcEndpointRequest::DetachSecurityGroupFromVpcEndpointRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "DetachSecurityGroupFromVpcEndpoint") {
setMethod(HttpRequest::Method::Post);
}
void DetachSecurityGroupFromVpcEndpointRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
DetachSecurityGroupFromVpcEndpointRequest::~DetachSecurityGroupFromVpcEndpointRequest() {}
std::string DetachSecurityGroupFromVpcEndpointRequest::getClientToken() const {
return clientToken_;
}
std::string DetachSecurityGroupFromVpcEndpointRequest::getEndpointId()const
{
return endpointId_;
void DetachSecurityGroupFromVpcEndpointRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
void DetachSecurityGroupFromVpcEndpointRequest::setEndpointId(const std::string& endpointId)
{
endpointId_ = endpointId;
setParameter("EndpointId", endpointId);
std::string DetachSecurityGroupFromVpcEndpointRequest::getEndpointId() const {
return endpointId_;
}
std::string DetachSecurityGroupFromVpcEndpointRequest::getSecurityGroupId()const
{
return securityGroupId_;
void DetachSecurityGroupFromVpcEndpointRequest::setEndpointId(const std::string &endpointId) {
endpointId_ = endpointId;
setParameter(std::string("EndpointId"), endpointId);
}
void DetachSecurityGroupFromVpcEndpointRequest::setSecurityGroupId(const std::string& securityGroupId)
{
securityGroupId_ = securityGroupId;
setParameter("SecurityGroupId", securityGroupId);
std::string DetachSecurityGroupFromVpcEndpointRequest::getSecurityGroupId() const {
return securityGroupId_;
}
std::string DetachSecurityGroupFromVpcEndpointRequest::getRegionId()const
{
return regionId_;
void DetachSecurityGroupFromVpcEndpointRequest::setSecurityGroupId(const std::string &securityGroupId) {
securityGroupId_ = securityGroupId;
setParameter(std::string("SecurityGroupId"), securityGroupId);
}
void DetachSecurityGroupFromVpcEndpointRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string DetachSecurityGroupFromVpcEndpointRequest::getRegionId() const {
return regionId_;
}
bool DetachSecurityGroupFromVpcEndpointRequest::getDryRun()const
{
return dryRun_;
void DetachSecurityGroupFromVpcEndpointRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void DetachSecurityGroupFromVpcEndpointRequest::setDryRun(bool dryRun)
{
dryRun_ = dryRun;
setParameter("DryRun", dryRun ? "true" : "false");
bool DetachSecurityGroupFromVpcEndpointRequest::getDryRun() const {
return dryRun_;
}
void DetachSecurityGroupFromVpcEndpointRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}

94
privatelink/src/model/DisableVpcEndpointConnectionRequest.cc
View File

@@ -1,84 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/DisableVpcEndpointConnectionRequest.h>
using AlibabaCloud::Privatelink::Model::DisableVpcEndpointConnectionRequest;
DisableVpcEndpointConnectionRequest::DisableVpcEndpointConnectionRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "DisableVpcEndpointConnection")
{
setMethod(HttpRequest::Method::Post);
}
DisableVpcEndpointConnectionRequest::~DisableVpcEndpointConnectionRequest()
{}
std::string DisableVpcEndpointConnectionRequest::getClientToken()const
{
return clientToken_;
*/
#include <alibabacloud/privatelink/model/DisableVpcEndpointConnectionRequest.h>
using AlibabaCloud::Privatelink::Model::DisableVpcEndpointConnectionRequest;
DisableVpcEndpointConnectionRequest::DisableVpcEndpointConnectionRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "DisableVpcEndpointConnection") {
setMethod(HttpRequest::Method::Post);
}
void DisableVpcEndpointConnectionRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
DisableVpcEndpointConnectionRequest::~DisableVpcEndpointConnectionRequest() {}
std::string DisableVpcEndpointConnectionRequest::getClientToken() const {
return clientToken_;
}
std::string DisableVpcEndpointConnectionRequest::getEndpointId()const
{
return endpointId_;
void DisableVpcEndpointConnectionRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
void DisableVpcEndpointConnectionRequest::setEndpointId(const std::string& endpointId)
{
endpointId_ = endpointId;
setParameter("EndpointId", endpointId);
std::string DisableVpcEndpointConnectionRequest::getEndpointId() const {
return endpointId_;
}
std::string DisableVpcEndpointConnectionRequest::getRegionId()const
{
return regionId_;
void DisableVpcEndpointConnectionRequest::setEndpointId(const std::string &endpointId) {
endpointId_ = endpointId;
setParameter(std::string("EndpointId"), endpointId);
}
void DisableVpcEndpointConnectionRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string DisableVpcEndpointConnectionRequest::getRegionId() const {
return regionId_;
}
bool DisableVpcEndpointConnectionRequest::getDryRun()const
{
return dryRun_;
void DisableVpcEndpointConnectionRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void DisableVpcEndpointConnectionRequest::setDryRun(bool dryRun)
{
dryRun_ = dryRun;
setParameter("DryRun", dryRun ? "true" : "false");
bool DisableVpcEndpointConnectionRequest::getDryRun() const {
return dryRun_;
}
std::string DisableVpcEndpointConnectionRequest::getServiceId()const
{
return serviceId_;
void DisableVpcEndpointConnectionRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
void DisableVpcEndpointConnectionRequest::setServiceId(const std::string& serviceId)
{
serviceId_ = serviceId;
setParameter("ServiceId", serviceId);
std::string DisableVpcEndpointConnectionRequest::getServiceId() const {
return serviceId_;
}
void DisableVpcEndpointConnectionRequest::setServiceId(const std::string &serviceId) {
serviceId_ = serviceId;
setParameter(std::string("ServiceId"), serviceId);
}

106
privatelink/src/model/EnableVpcEndpointConnectionRequest.cc
View File

@@ -1,95 +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.
*/
#include <alibabacloud/privatelink/model/EnableVpcEndpointConnectionRequest.h>
using AlibabaCloud::Privatelink::Model::EnableVpcEndpointConnectionRequest;
EnableVpcEndpointConnectionRequest::EnableVpcEndpointConnectionRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "EnableVpcEndpointConnection")
{
setMethod(HttpRequest::Method::Post);
}
EnableVpcEndpointConnectionRequest::~EnableVpcEndpointConnectionRequest()
{}
std::string EnableVpcEndpointConnectionRequest::getClientToken()const
{
return clientToken_;
*/
#include <alibabacloud/privatelink/model/EnableVpcEndpointConnectionRequest.h>
using AlibabaCloud::Privatelink::Model::EnableVpcEndpointConnectionRequest;
EnableVpcEndpointConnectionRequest::EnableVpcEndpointConnectionRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "EnableVpcEndpointConnection") {
setMethod(HttpRequest::Method::Post);
}
void EnableVpcEndpointConnectionRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
EnableVpcEndpointConnectionRequest::~EnableVpcEndpointConnectionRequest() {}
std::string EnableVpcEndpointConnectionRequest::getClientToken() const {
return clientToken_;
}
std::string EnableVpcEndpointConnectionRequest::getEndpointId()const
{
return endpointId_;
void EnableVpcEndpointConnectionRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
void EnableVpcEndpointConnectionRequest::setEndpointId(const std::string& endpointId)
{
endpointId_ = endpointId;
setParameter("EndpointId", endpointId);
std::string EnableVpcEndpointConnectionRequest::getEndpointId() const {
return endpointId_;
}
std::string EnableVpcEndpointConnectionRequest::getRegionId()const
{
return regionId_;
void EnableVpcEndpointConnectionRequest::setEndpointId(const std::string &endpointId) {
endpointId_ = endpointId;
setParameter(std::string("EndpointId"), endpointId);
}
void EnableVpcEndpointConnectionRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string EnableVpcEndpointConnectionRequest::getRegionId() const {
return regionId_;
}
bool EnableVpcEndpointConnectionRequest::getDryRun()const
{
return dryRun_;
void EnableVpcEndpointConnectionRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void EnableVpcEndpointConnectionRequest::setDryRun(bool dryRun)
{
dryRun_ = dryRun;
setParameter("DryRun", dryRun ? "true" : "false");
bool EnableVpcEndpointConnectionRequest::getDryRun() const {
return dryRun_;
}
int EnableVpcEndpointConnectionRequest::getBandwidth()const
{
return bandwidth_;
void EnableVpcEndpointConnectionRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
void EnableVpcEndpointConnectionRequest::setBandwidth(int bandwidth)
{
bandwidth_ = bandwidth;
setParameter("Bandwidth", std::to_string(bandwidth));
int EnableVpcEndpointConnectionRequest::getBandwidth() const {
return bandwidth_;
}
std::string EnableVpcEndpointConnectionRequest::getServiceId()const
{
return serviceId_;
void EnableVpcEndpointConnectionRequest::setBandwidth(int bandwidth) {
bandwidth_ = bandwidth;
setParameter(std::string("Bandwidth"), std::to_string(bandwidth));
}
void EnableVpcEndpointConnectionRequest::setServiceId(const std::string& serviceId)
{
serviceId_ = serviceId;
setParameter("ServiceId", serviceId);
std::string EnableVpcEndpointConnectionRequest::getServiceId() const {
return serviceId_;
}
void EnableVpcEndpointConnectionRequest::setServiceId(const std::string &serviceId) {
serviceId_ = serviceId;
setParameter(std::string("ServiceId"), serviceId);
}

58
privatelink/src/model/GetVpcEndpointAttributeRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/GetVpcEndpointAttributeRequest.h>
using AlibabaCloud::Privatelink::Model::GetVpcEndpointAttributeRequest;
GetVpcEndpointAttributeRequest::GetVpcEndpointAttributeRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "GetVpcEndpointAttribute")
{
setMethod(HttpRequest::Method::Post);
}
GetVpcEndpointAttributeRequest::~GetVpcEndpointAttributeRequest()
{}
std::string GetVpcEndpointAttributeRequest::getEndpointId()const
{
return endpointId_;
*/
#include <alibabacloud/privatelink/model/GetVpcEndpointAttributeRequest.h>
using AlibabaCloud::Privatelink::Model::GetVpcEndpointAttributeRequest;
GetVpcEndpointAttributeRequest::GetVpcEndpointAttributeRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "GetVpcEndpointAttribute") {
setMethod(HttpRequest::Method::Post);
}
void GetVpcEndpointAttributeRequest::setEndpointId(const std::string& endpointId)
{
endpointId_ = endpointId;
setParameter("EndpointId", endpointId);
GetVpcEndpointAttributeRequest::~GetVpcEndpointAttributeRequest() {}
std::string GetVpcEndpointAttributeRequest::getEndpointId() const {
return endpointId_;
}
std::string GetVpcEndpointAttributeRequest::getRegionId()const
{
return regionId_;
void GetVpcEndpointAttributeRequest::setEndpointId(const std::string &endpointId) {
endpointId_ = endpointId;
setParameter(std::string("EndpointId"), endpointId);
}
void GetVpcEndpointAttributeRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string GetVpcEndpointAttributeRequest::getRegionId() const {
return regionId_;
}
void GetVpcEndpointAttributeRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}

44
privatelink/src/model/GetVpcEndpointAttributeResult.cc
View File

@@ -43,10 +43,10 @@ void GetVpcEndpointAttributeResult::parse(const std::string &payload)
payer_ = value["Payer"].asString();
if(!value["EndpointDomain"].isNull())
endpointDomain_ = value["EndpointDomain"].asString();
if(!value["ResourceOwner"].isNull())
resourceOwner_ = value["ResourceOwner"].asString() == "true";
if(!value["CreateTime"].isNull())
createTime_ = value["CreateTime"].asString();
if(!value["ResourceOwner"].isNull())
resourceOwner_ = value["ResourceOwner"].asString() == "true";
if(!value["EndpointBusinessStatus"].isNull())
endpointBusinessStatus_ = value["EndpointBusinessStatus"].asString();
if(!value["EndpointDescription"].isNull())
@@ -55,16 +55,20 @@ void GetVpcEndpointAttributeResult::parse(const std::string &payload)
serviceId_ = value["ServiceId"].asString();
if(!value["EndpointStatus"].isNull())
endpointStatus_ = value["EndpointStatus"].asString();
if(!value["EndpointName"].isNull())
endpointName_ = value["EndpointName"].asString();
if(!value["VpcId"].isNull())
vpcId_ = value["VpcId"].asString();
if(!value["EndpointName"].isNull())
endpointName_ = value["EndpointName"].asString();
if(!value["ZonePrivateIpAddressCount"].isNull())
zonePrivateIpAddressCount_ = std::stol(value["ZonePrivateIpAddressCount"].asString());
if(!value["EndpointType"].isNull())
endpointType_ = value["EndpointType"].asString();
if(!value["ServiceName"].isNull())
serviceName_ = value["ServiceName"].asString();
if(!value["EndpointId"].isNull())
endpointId_ = value["EndpointId"].asString();
if(!value["Bandwidth"].isNull())
bandwidth_ = std::stoi(value["Bandwidth"].asString());
if(!value["EndpointId"].isNull())
endpointId_ = value["EndpointId"].asString();
if(!value["RegionId"].isNull())
regionId_ = value["RegionId"].asString();
if(!value["ConnectionStatus"].isNull())
@@ -84,14 +88,19 @@ std::string GetVpcEndpointAttributeResult::getEndpointDomain()const
return endpointDomain_;
}
std::string GetVpcEndpointAttributeResult::getCreateTime()const
{
return createTime_;
}
bool GetVpcEndpointAttributeResult::getResourceOwner()const
{
return resourceOwner_;
}
std::string GetVpcEndpointAttributeResult::getCreateTime()const
long GetVpcEndpointAttributeResult::getZonePrivateIpAddressCount()const
{
return createTime_;
return zonePrivateIpAddressCount_;
}
std::string GetVpcEndpointAttributeResult::getEndpointBusinessStatus()const
@@ -114,29 +123,34 @@ std::string GetVpcEndpointAttributeResult::getEndpointStatus()const
return endpointStatus_;
}
std::string GetVpcEndpointAttributeResult::getEndpointName()const
{
return endpointName_;
}
std::string GetVpcEndpointAttributeResult::getVpcId()const
{
return vpcId_;
}
std::string GetVpcEndpointAttributeResult::getEndpointName()const
{
return endpointName_;
}
std::string GetVpcEndpointAttributeResult::getServiceName()const
{
return serviceName_;
}
int GetVpcEndpointAttributeResult::getBandwidth()const
{
return bandwidth_;
}
std::string GetVpcEndpointAttributeResult::getEndpointId()const
{
return endpointId_;
}
int GetVpcEndpointAttributeResult::getBandwidth()const
std::string GetVpcEndpointAttributeResult::getEndpointType()const
{
return bandwidth_;
return endpointType_;
}
std::string GetVpcEndpointAttributeResult::getRegionId()const

58
privatelink/src/model/GetVpcEndpointServiceAttributeRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/GetVpcEndpointServiceAttributeRequest.h>
using AlibabaCloud::Privatelink::Model::GetVpcEndpointServiceAttributeRequest;
GetVpcEndpointServiceAttributeRequest::GetVpcEndpointServiceAttributeRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "GetVpcEndpointServiceAttribute")
{
setMethod(HttpRequest::Method::Post);
}
GetVpcEndpointServiceAttributeRequest::~GetVpcEndpointServiceAttributeRequest()
{}
std::string GetVpcEndpointServiceAttributeRequest::getRegionId()const
{
return regionId_;
*/
#include <alibabacloud/privatelink/model/GetVpcEndpointServiceAttributeRequest.h>
using AlibabaCloud::Privatelink::Model::GetVpcEndpointServiceAttributeRequest;
GetVpcEndpointServiceAttributeRequest::GetVpcEndpointServiceAttributeRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "GetVpcEndpointServiceAttribute") {
setMethod(HttpRequest::Method::Post);
}
void GetVpcEndpointServiceAttributeRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
GetVpcEndpointServiceAttributeRequest::~GetVpcEndpointServiceAttributeRequest() {}
std::string GetVpcEndpointServiceAttributeRequest::getRegionId() const {
return regionId_;
}
std::string GetVpcEndpointServiceAttributeRequest::getServiceId()const
{
return serviceId_;
void GetVpcEndpointServiceAttributeRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void GetVpcEndpointServiceAttributeRequest::setServiceId(const std::string& serviceId)
{
serviceId_ = serviceId;
setParameter("ServiceId", serviceId);
std::string GetVpcEndpointServiceAttributeRequest::getServiceId() const {
return serviceId_;
}
void GetVpcEndpointServiceAttributeRequest::setServiceId(const std::string &serviceId) {
serviceId_ = serviceId;
setParameter(std::string("ServiceId"), serviceId);
}

103
privatelink/src/model/GetVpcEndpointServiceAttributeResult.cc
View File

@@ -46,18 +46,20 @@ void GetVpcEndpointServiceAttributeResult::parse(const std::string &payload)
payer_ = value["Payer"].asString();
if(!value["ServiceDescription"].isNull())
serviceDescription_ = value["ServiceDescription"].asString();
if(!value["MaxBandwidth"].isNull())
maxBandwidth_ = std::stoi(value["MaxBandwidth"].asString());
if(!value["CreateTime"].isNull())
createTime_ = value["CreateTime"].asString();
if(!value["ServiceDomain"].isNull())
serviceDomain_ = value["ServiceDomain"].asString();
if(!value["MaxBandwidth"].isNull())
maxBandwidth_ = std::stoi(value["MaxBandwidth"].asString());
if(!value["MinBandwidth"].isNull())
minBandwidth_ = std::stoi(value["MinBandwidth"].asString());
if(!value["ServiceId"].isNull())
serviceId_ = value["ServiceId"].asString();
if(!value["ServiceDomain"].isNull())
serviceDomain_ = value["ServiceDomain"].asString();
if(!value["AutoAcceptEnabled"].isNull())
autoAcceptEnabled_ = value["AutoAcceptEnabled"].asString() == "true";
if(!value["ZoneAffinityEnabled"].isNull())
zoneAffinityEnabled_ = value["ZoneAffinityEnabled"].asString() == "true";
if(!value["ServiceId"].isNull())
serviceId_ = value["ServiceId"].asString();
if(!value["ServiceBusinessStatus"].isNull())
serviceBusinessStatus_ = value["ServiceBusinessStatus"].asString();
if(!value["ServiceName"].isNull())
@@ -68,8 +70,24 @@ void GetVpcEndpointServiceAttributeResult::parse(const std::string &payload)
connectBandwidth_ = std::stoi(value["ConnectBandwidth"].asString());
if(!value["RegionId"].isNull())
regionId_ = value["RegionId"].asString();
if(!value["ZoneAffinityEnabled"].isNull())
zoneAffinityEnabled_ = value["ZoneAffinityEnabled"].asString() == "true";
if(!value["ServiceType"].isNull())
serviceType_ = value["ServiceType"].asString();
if(!value["ServiceResourceType"].isNull())
serviceResourceType_ = value["ServiceResourceType"].asString();
if(!value["PrivateServiceDomainEnabled"].isNull())
privateServiceDomainEnabled_ = value["PrivateServiceDomainEnabled"].asString() == "true";
if(!value["PrivateServiceDomain"].isNull())
privateServiceDomain_ = value["PrivateServiceDomain"].asString();
if(!value["PrivateServiceDomainVerifyStatus"].isNull())
privateServiceDomainVerifyStatus_ = value["PrivateServiceDomainVerifyStatus"].asString();
if(!value["PrivateServiceDomainBusinessStatus"].isNull())
privateServiceDomainBusinessStatus_ = value["PrivateServiceDomainBusinessStatus"].asString();
if(!value["PrivateServiceDomainVerifyName"].isNull())
privateServiceDomainVerifyName_ = value["PrivateServiceDomainVerifyName"].asString();
if(!value["PrivateServiceDomainVerifyValue"].isNull())
privateServiceDomainVerifyValue_ = value["PrivateServiceDomainVerifyValue"].asString();
if(!value["PrivateServiceName"].isNull())
privateServiceName_ = value["PrivateServiceName"].asString();
}
@@ -78,24 +96,34 @@ std::string GetVpcEndpointServiceAttributeResult::getPayer()const
return payer_;
}
std::string GetVpcEndpointServiceAttributeResult::getPrivateServiceDomainBusinessStatus()const
{
return privateServiceDomainBusinessStatus_;
}
std::string GetVpcEndpointServiceAttributeResult::getServiceDescription()const
{
return serviceDescription_;
}
int GetVpcEndpointServiceAttributeResult::getMaxBandwidth()const
{
return maxBandwidth_;
}
std::string GetVpcEndpointServiceAttributeResult::getCreateTime()const
{
return createTime_;
}
std::string GetVpcEndpointServiceAttributeResult::getServiceDomain()const
int GetVpcEndpointServiceAttributeResult::getMaxBandwidth()const
{
return serviceDomain_;
return maxBandwidth_;
}
std::string GetVpcEndpointServiceAttributeResult::getPrivateServiceDomain()const
{
return privateServiceDomain_;
}
bool GetVpcEndpointServiceAttributeResult::getPrivateServiceDomainEnabled()const
{
return privateServiceDomainEnabled_;
}
int GetVpcEndpointServiceAttributeResult::getMinBandwidth()const
@@ -103,26 +131,41 @@ int GetVpcEndpointServiceAttributeResult::getMinBandwidth()const
return minBandwidth_;
}
std::string GetVpcEndpointServiceAttributeResult::getServiceDomain()const
{
return serviceDomain_;
}
std::vector<std::string> GetVpcEndpointServiceAttributeResult::getZones()const
{
return zones_;
}
std::string GetVpcEndpointServiceAttributeResult::getServiceId()const
{
return serviceId_;
}
bool GetVpcEndpointServiceAttributeResult::getAutoAcceptEnabled()const
{
return autoAcceptEnabled_;
}
std::string GetVpcEndpointServiceAttributeResult::getServiceId()const
{
return serviceId_;
}
std::string GetVpcEndpointServiceAttributeResult::getPrivateServiceDomainVerifyStatus()const
{
return privateServiceDomainVerifyStatus_;
}
std::string GetVpcEndpointServiceAttributeResult::getServiceBusinessStatus()const
{
return serviceBusinessStatus_;
}
std::string GetVpcEndpointServiceAttributeResult::getPrivateServiceDomainVerifyName()const
{
return privateServiceDomainVerifyName_;
}
std::string GetVpcEndpointServiceAttributeResult::getServiceName()const
{
return serviceName_;
@@ -133,11 +176,26 @@ std::string GetVpcEndpointServiceAttributeResult::getServiceStatus()const
return serviceStatus_;
}
std::string GetVpcEndpointServiceAttributeResult::getServiceType()const
{
return serviceType_;
}
int GetVpcEndpointServiceAttributeResult::getConnectBandwidth()const
{
return connectBandwidth_;
}
std::string GetVpcEndpointServiceAttributeResult::getServiceResourceType()const
{
return serviceResourceType_;
}
std::string GetVpcEndpointServiceAttributeResult::getPrivateServiceName()const
{
return privateServiceName_;
}
std::string GetVpcEndpointServiceAttributeResult::getRegionId()const
{
return regionId_;
@@ -148,3 +206,8 @@ bool GetVpcEndpointServiceAttributeResult::getZoneAffinityEnabled()const
return zoneAffinityEnabled_;
}
std::string GetVpcEndpointServiceAttributeResult::getPrivateServiceDomainVerifyValue()const
{
return privateServiceDomainVerifyValue_;
}

136
privatelink/src/model/ListVpcEndpointConnectionsRequest.cc
View File

@@ -1,106 +1,108 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/ListVpcEndpointConnectionsRequest.h>
using AlibabaCloud::Privatelink::Model::ListVpcEndpointConnectionsRequest;
ListVpcEndpointConnectionsRequest::ListVpcEndpointConnectionsRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "ListVpcEndpointConnections")
{
setMethod(HttpRequest::Method::Post);
}
ListVpcEndpointConnectionsRequest::~ListVpcEndpointConnectionsRequest()
{}
std::string ListVpcEndpointConnectionsRequest::getEndpointId()const
{
return endpointId_;
*/
#include <alibabacloud/privatelink/model/ListVpcEndpointConnectionsRequest.h>
using AlibabaCloud::Privatelink::Model::ListVpcEndpointConnectionsRequest;
ListVpcEndpointConnectionsRequest::ListVpcEndpointConnectionsRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "ListVpcEndpointConnections") {
setMethod(HttpRequest::Method::Post);
}
void ListVpcEndpointConnectionsRequest::setEndpointId(const std::string& endpointId)
{
endpointId_ = endpointId;
setParameter("EndpointId", endpointId);
ListVpcEndpointConnectionsRequest::~ListVpcEndpointConnectionsRequest() {}
std::string ListVpcEndpointConnectionsRequest::getEndpointId() const {
return endpointId_;
}
long ListVpcEndpointConnectionsRequest::getEndpointOwnerId()const
{
return endpointOwnerId_;
void ListVpcEndpointConnectionsRequest::setEndpointId(const std::string &endpointId) {
endpointId_ = endpointId;
setParameter(std::string("EndpointId"), endpointId);
}
void ListVpcEndpointConnectionsRequest::setEndpointOwnerId(long endpointOwnerId)
{
endpointOwnerId_ = endpointOwnerId;
setParameter("EndpointOwnerId", std::to_string(endpointOwnerId));
long ListVpcEndpointConnectionsRequest::getEndpointOwnerId() const {
return endpointOwnerId_;
}
std::string ListVpcEndpointConnectionsRequest::getRegionId()const
{
return regionId_;
void ListVpcEndpointConnectionsRequest::setEndpointOwnerId(long endpointOwnerId) {
endpointOwnerId_ = endpointOwnerId;
setParameter(std::string("EndpointOwnerId"), std::to_string(endpointOwnerId));
}
void ListVpcEndpointConnectionsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string ListVpcEndpointConnectionsRequest::getRegionId() const {
return regionId_;
}
std::string ListVpcEndpointConnectionsRequest::getNextToken()const
{
return nextToken_;
void ListVpcEndpointConnectionsRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void ListVpcEndpointConnectionsRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
std::string ListVpcEndpointConnectionsRequest::getNextToken() const {
return nextToken_;
}
std::string ListVpcEndpointConnectionsRequest::getConnectionStatus()const
{
return connectionStatus_;
void ListVpcEndpointConnectionsRequest::setNextToken(const std::string &nextToken) {
nextToken_ = nextToken;
setParameter(std::string("NextToken"), nextToken);
}
void ListVpcEndpointConnectionsRequest::setConnectionStatus(const std::string& connectionStatus)
{
connectionStatus_ = connectionStatus;
setParameter("ConnectionStatus", connectionStatus);
std::string ListVpcEndpointConnectionsRequest::getResourceId() const {
return resourceId_;
}
int ListVpcEndpointConnectionsRequest::getMaxResults()const
{
return maxResults_;
void ListVpcEndpointConnectionsRequest::setResourceId(const std::string &resourceId) {
resourceId_ = resourceId;
setParameter(std::string("ResourceId"), resourceId);
}
void ListVpcEndpointConnectionsRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
std::string ListVpcEndpointConnectionsRequest::getConnectionStatus() const {
return connectionStatus_;
}
std::string ListVpcEndpointConnectionsRequest::getServiceId()const
{
return serviceId_;
void ListVpcEndpointConnectionsRequest::setConnectionStatus(const std::string &connectionStatus) {
connectionStatus_ = connectionStatus;
setParameter(std::string("ConnectionStatus"), connectionStatus);
}
void ListVpcEndpointConnectionsRequest::setServiceId(const std::string& serviceId)
{
serviceId_ = serviceId;
setParameter("ServiceId", serviceId);
int ListVpcEndpointConnectionsRequest::getMaxResults() const {
return maxResults_;
}
void ListVpcEndpointConnectionsRequest::setMaxResults(int maxResults) {
maxResults_ = maxResults;
setParameter(std::string("MaxResults"), std::to_string(maxResults));
}
std::string ListVpcEndpointConnectionsRequest::getEniId() const {
return eniId_;
}
void ListVpcEndpointConnectionsRequest::setEniId(const std::string &eniId) {
eniId_ = eniId;
setParameter(std::string("EniId"), eniId);
}
std::string ListVpcEndpointConnectionsRequest::getServiceId() const {
return serviceId_;
}
void ListVpcEndpointConnectionsRequest::setServiceId(const std::string &serviceId) {
serviceId_ = serviceId;
setParameter(std::string("ServiceId"), serviceId);
}

48
privatelink/src/model/ListVpcEndpointConnectionsResult.cc
View File

@@ -43,44 +43,52 @@ void ListVpcEndpointConnectionsResult::parse(const std::string &payload)
for (auto valueConnectionsConnection : allConnectionsNode)
{
Connection connectionsObject;
if(!valueConnectionsConnection["ServiceId"].isNull())
connectionsObject.serviceId = valueConnectionsConnection["ServiceId"].asString();
if(!valueConnectionsConnection["EndpointId"].isNull())
connectionsObject.endpointId = valueConnectionsConnection["EndpointId"].asString();
if(!valueConnectionsConnection["EndpointOwnerId"].isNull())
connectionsObject.endpointOwnerId = std::stol(valueConnectionsConnection["EndpointOwnerId"].asString());
if(!valueConnectionsConnection["ConnectionStatus"].isNull())
connectionsObject.connectionStatus = valueConnectionsConnection["ConnectionStatus"].asString();
if(!valueConnectionsConnection["EndpointVpcId"].isNull())
connectionsObject.endpointVpcId = valueConnectionsConnection["EndpointVpcId"].asString();
if(!valueConnectionsConnection["Bandwidth"].isNull())
connectionsObject.bandwidth = std::stoi(valueConnectionsConnection["Bandwidth"].asString());
if(!valueConnectionsConnection["ModifiedTime"].isNull())
connectionsObject.modifiedTime = valueConnectionsConnection["ModifiedTime"].asString();
if(!valueConnectionsConnection["ResourceOwner"].isNull())
connectionsObject.resourceOwner = valueConnectionsConnection["ResourceOwner"].asString() == "true";
if(!valueConnectionsConnection["ModifiedTime"].isNull())
connectionsObject.modifiedTime = valueConnectionsConnection["ModifiedTime"].asString();
if(!valueConnectionsConnection["Bandwidth"].isNull())
connectionsObject.bandwidth = std::stoi(valueConnectionsConnection["Bandwidth"].asString());
if(!valueConnectionsConnection["EndpointOwnerId"].isNull())
connectionsObject.endpointOwnerId = std::stol(valueConnectionsConnection["EndpointOwnerId"].asString());
if(!valueConnectionsConnection["ServiceId"].isNull())
connectionsObject.serviceId = valueConnectionsConnection["ServiceId"].asString();
if(!valueConnectionsConnection["ConnectionStatus"].isNull())
connectionsObject.connectionStatus = valueConnectionsConnection["ConnectionStatus"].asString();
if(!valueConnectionsConnection["EndpointId"].isNull())
connectionsObject.endpointId = valueConnectionsConnection["EndpointId"].asString();
if(!valueConnectionsConnection["EndpointVpcId"].isNull())
connectionsObject.endpointVpcId = valueConnectionsConnection["EndpointVpcId"].asString();
auto allZonesNode = valueConnectionsConnection["Zones"]["Zone"];
for (auto valueConnectionsConnectionZonesZone : allZonesNode)
{
Connection::Zone zonesObject;
if(!valueConnectionsConnectionZonesZone["VSwitchId"].isNull())
zonesObject.vSwitchId = valueConnectionsConnectionZonesZone["VSwitchId"].asString();
if(!valueConnectionsConnectionZonesZone["ZoneId"].isNull())
zonesObject.zoneId = valueConnectionsConnectionZonesZone["ZoneId"].asString();
if(!valueConnectionsConnectionZonesZone["ResourceId"].isNull())
zonesObject.resourceId = valueConnectionsConnectionZonesZone["ResourceId"].asString();
if(!valueConnectionsConnectionZonesZone["EniId"].isNull())
zonesObject.eniId = valueConnectionsConnectionZonesZone["EniId"].asString();
if(!valueConnectionsConnectionZonesZone["ZoneDomain"].isNull())
zonesObject.zoneDomain = valueConnectionsConnectionZonesZone["ZoneDomain"].asString();
if(!valueConnectionsConnectionZonesZone["VSwitchId"].isNull())
zonesObject.vSwitchId = valueConnectionsConnectionZonesZone["VSwitchId"].asString();
if(!valueConnectionsConnectionZonesZone["ResourceId"].isNull())
zonesObject.resourceId = valueConnectionsConnectionZonesZone["ResourceId"].asString();
if(!valueConnectionsConnectionZonesZone["ZoneStatus"].isNull())
zonesObject.zoneStatus = valueConnectionsConnectionZonesZone["ZoneStatus"].asString();
if(!valueConnectionsConnectionZonesZone["ReplacedResourceId"].isNull())
zonesObject.replacedResourceId = valueConnectionsConnectionZonesZone["ReplacedResourceId"].asString();
if(!valueConnectionsConnectionZonesZone["ReplacedEniId"].isNull())
zonesObject.replacedEniId = valueConnectionsConnectionZonesZone["ReplacedEniId"].asString();
if(!valueConnectionsConnectionZonesZone["StatusInfo"].isNull())
zonesObject.statusInfo = valueConnectionsConnectionZonesZone["StatusInfo"].asString();
connectionsObject.zones.push_back(zonesObject);
}
connections_.push_back(connectionsObject);
}
if(!value["MaxResults"].isNull())
maxResults_ = value["MaxResults"].asString();
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
if(!value["MaxResults"].isNull())
maxResults_ = value["MaxResults"].asString();
}

82
privatelink/src/model/ListVpcEndpointSecurityGroupsRequest.cc
View File

@@ -1,73 +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.
*/
#include <alibabacloud/privatelink/model/ListVpcEndpointSecurityGroupsRequest.h>
using AlibabaCloud::Privatelink::Model::ListVpcEndpointSecurityGroupsRequest;
ListVpcEndpointSecurityGroupsRequest::ListVpcEndpointSecurityGroupsRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "ListVpcEndpointSecurityGroups")
{
setMethod(HttpRequest::Method::Post);
}
ListVpcEndpointSecurityGroupsRequest::~ListVpcEndpointSecurityGroupsRequest()
{}
std::string ListVpcEndpointSecurityGroupsRequest::getEndpointId()const
{
return endpointId_;
*/
#include <alibabacloud/privatelink/model/ListVpcEndpointSecurityGroupsRequest.h>
using AlibabaCloud::Privatelink::Model::ListVpcEndpointSecurityGroupsRequest;
ListVpcEndpointSecurityGroupsRequest::ListVpcEndpointSecurityGroupsRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "ListVpcEndpointSecurityGroups") {
setMethod(HttpRequest::Method::Post);
}
void ListVpcEndpointSecurityGroupsRequest::setEndpointId(const std::string& endpointId)
{
endpointId_ = endpointId;
setParameter("EndpointId", endpointId);
ListVpcEndpointSecurityGroupsRequest::~ListVpcEndpointSecurityGroupsRequest() {}
std::string ListVpcEndpointSecurityGroupsRequest::getEndpointId() const {
return endpointId_;
}
std::string ListVpcEndpointSecurityGroupsRequest::getRegionId()const
{
return regionId_;
void ListVpcEndpointSecurityGroupsRequest::setEndpointId(const std::string &endpointId) {
endpointId_ = endpointId;
setParameter(std::string("EndpointId"), endpointId);
}
void ListVpcEndpointSecurityGroupsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string ListVpcEndpointSecurityGroupsRequest::getRegionId() const {
return regionId_;
}
std::string ListVpcEndpointSecurityGroupsRequest::getNextToken()const
{
return nextToken_;
void ListVpcEndpointSecurityGroupsRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void ListVpcEndpointSecurityGroupsRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
std::string ListVpcEndpointSecurityGroupsRequest::getNextToken() const {
return nextToken_;
}
int ListVpcEndpointSecurityGroupsRequest::getMaxResults()const
{
return maxResults_;
void ListVpcEndpointSecurityGroupsRequest::setNextToken(const std::string &nextToken) {
nextToken_ = nextToken;
setParameter(std::string("NextToken"), nextToken);
}
void ListVpcEndpointSecurityGroupsRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
int ListVpcEndpointSecurityGroupsRequest::getMaxResults() const {
return maxResults_;
}
void ListVpcEndpointSecurityGroupsRequest::setMaxResults(int maxResults) {
maxResults_ = maxResults;
setParameter(std::string("MaxResults"), std::to_string(maxResults));
}

4
privatelink/src/model/ListVpcEndpointSecurityGroupsResult.cc
View File

@@ -47,10 +47,10 @@ void ListVpcEndpointSecurityGroupsResult::parse(const std::string &payload)
securityGroupsObject.securityGroupId = valueSecurityGroupsSecurityGroup["SecurityGroupId"].asString();
securityGroups_.push_back(securityGroupsObject);
}
if(!value["MaxResults"].isNull())
maxResults_ = value["MaxResults"].asString();
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
if(!value["MaxResults"].isNull())
maxResults_ = value["MaxResults"].asString();
}

91
privatelink/src/model/ListVpcEndpointServiceResourcesRequest.cc
View File

@@ -1,73 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/ListVpcEndpointServiceResourcesRequest.h>
using AlibabaCloud::Privatelink::Model::ListVpcEndpointServiceResourcesRequest;
ListVpcEndpointServiceResourcesRequest::ListVpcEndpointServiceResourcesRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "ListVpcEndpointServiceResources")
{
setMethod(HttpRequest::Method::Post);
}
ListVpcEndpointServiceResourcesRequest::~ListVpcEndpointServiceResourcesRequest()
{}
std::string ListVpcEndpointServiceResourcesRequest::getRegionId()const
{
return regionId_;
*/
#include <alibabacloud/privatelink/model/ListVpcEndpointServiceResourcesRequest.h>
using AlibabaCloud::Privatelink::Model::ListVpcEndpointServiceResourcesRequest;
ListVpcEndpointServiceResourcesRequest::ListVpcEndpointServiceResourcesRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "ListVpcEndpointServiceResources") {
setMethod(HttpRequest::Method::Post);
}
void ListVpcEndpointServiceResourcesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
ListVpcEndpointServiceResourcesRequest::~ListVpcEndpointServiceResourcesRequest() {}
std::string ListVpcEndpointServiceResourcesRequest::getRegionId() const {
return regionId_;
}
std::string ListVpcEndpointServiceResourcesRequest::getNextToken()const
{
return nextToken_;
void ListVpcEndpointServiceResourcesRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void ListVpcEndpointServiceResourcesRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
std::string ListVpcEndpointServiceResourcesRequest::getNextToken() const {
return nextToken_;
}
int ListVpcEndpointServiceResourcesRequest::getMaxResults()const
{
return maxResults_;
void ListVpcEndpointServiceResourcesRequest::setNextToken(const std::string &nextToken) {
nextToken_ = nextToken;
setParameter(std::string("NextToken"), nextToken);
}
void ListVpcEndpointServiceResourcesRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
int ListVpcEndpointServiceResourcesRequest::getMaxResults() const {
return maxResults_;
}
std::string ListVpcEndpointServiceResourcesRequest::getServiceId()const
{
return serviceId_;
void ListVpcEndpointServiceResourcesRequest::setMaxResults(int maxResults) {
maxResults_ = maxResults;
setParameter(std::string("MaxResults"), std::to_string(maxResults));
}
void ListVpcEndpointServiceResourcesRequest::setServiceId(const std::string& serviceId)
{
serviceId_ = serviceId;
setParameter("ServiceId", serviceId);
std::string ListVpcEndpointServiceResourcesRequest::getZoneId() const {
return zoneId_;
}
void ListVpcEndpointServiceResourcesRequest::setZoneId(const std::string &zoneId) {
zoneId_ = zoneId;
setParameter(std::string("ZoneId"), zoneId);
}
std::string ListVpcEndpointServiceResourcesRequest::getServiceId() const {
return serviceId_;
}
void ListVpcEndpointServiceResourcesRequest::setServiceId(const std::string &serviceId) {
serviceId_ = serviceId;
setParameter(std::string("ServiceId"), serviceId);
}

26
privatelink/src/model/ListVpcEndpointServiceResourcesResult.cc
View File

@@ -43,26 +43,32 @@ void ListVpcEndpointServiceResourcesResult::parse(const std::string &payload)
for (auto valueResourcesResource : allResourcesNode)
{
Resource resourcesObject;
if(!valueResourcesResource["ZoneId"].isNull())
resourcesObject.zoneId = valueResourcesResource["ZoneId"].asString();
if(!valueResourcesResource["ResourceId"].isNull())
resourcesObject.resourceId = valueResourcesResource["ResourceId"].asString();
if(!valueResourcesResource["ResourceType"].isNull())
resourcesObject.resourceType = valueResourcesResource["ResourceType"].asString();
if(!valueResourcesResource["Ip"].isNull())
resourcesObject.ip = valueResourcesResource["Ip"].asString();
if(!valueResourcesResource["VpcId"].isNull())
resourcesObject.vpcId = valueResourcesResource["VpcId"].asString();
if(!valueResourcesResource["VSwitchId"].isNull())
resourcesObject.vSwitchId = valueResourcesResource["VSwitchId"].asString();
if(!valueResourcesResource["ResourceType"].isNull())
resourcesObject.resourceType = valueResourcesResource["ResourceType"].asString();
if(!valueResourcesResource["ZoneId"].isNull())
resourcesObject.zoneId = valueResourcesResource["ZoneId"].asString();
if(!valueResourcesResource["Ip"].isNull())
resourcesObject.ip = valueResourcesResource["Ip"].asString();
if(!valueResourcesResource["ResourceId"].isNull())
resourcesObject.resourceId = valueResourcesResource["ResourceId"].asString();
if(!valueResourcesResource["RegionId"].isNull())
resourcesObject.regionId = valueResourcesResource["RegionId"].asString();
if(!valueResourcesResource["RelatedEndpointCount"].isNull())
resourcesObject.relatedEndpointCount = std::stol(valueResourcesResource["RelatedEndpointCount"].asString());
if(!valueResourcesResource["AutoAllocatedEnabled"].isNull())
resourcesObject.autoAllocatedEnabled = valueResourcesResource["AutoAllocatedEnabled"].asString() == "true";
if(!valueResourcesResource["StatusInfo"].isNull())
resourcesObject.statusInfo = valueResourcesResource["StatusInfo"].asString();
resources_.push_back(resourcesObject);
}
if(!value["MaxResults"].isNull())
maxResults_ = value["MaxResults"].asString();
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
if(!value["MaxResults"].isNull())
maxResults_ = value["MaxResults"].asString();
}

94
privatelink/src/model/ListVpcEndpointServiceUsersRequest.cc
View File

@@ -1,84 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/ListVpcEndpointServiceUsersRequest.h>
using AlibabaCloud::Privatelink::Model::ListVpcEndpointServiceUsersRequest;
ListVpcEndpointServiceUsersRequest::ListVpcEndpointServiceUsersRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "ListVpcEndpointServiceUsers")
{
setMethod(HttpRequest::Method::Post);
}
ListVpcEndpointServiceUsersRequest::~ListVpcEndpointServiceUsersRequest()
{}
long ListVpcEndpointServiceUsersRequest::getUserId()const
{
return userId_;
*/
#include <alibabacloud/privatelink/model/ListVpcEndpointServiceUsersRequest.h>
using AlibabaCloud::Privatelink::Model::ListVpcEndpointServiceUsersRequest;
ListVpcEndpointServiceUsersRequest::ListVpcEndpointServiceUsersRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "ListVpcEndpointServiceUsers") {
setMethod(HttpRequest::Method::Post);
}
void ListVpcEndpointServiceUsersRequest::setUserId(long userId)
{
userId_ = userId;
setParameter("UserId", std::to_string(userId));
ListVpcEndpointServiceUsersRequest::~ListVpcEndpointServiceUsersRequest() {}
long ListVpcEndpointServiceUsersRequest::getUserId() const {
return userId_;
}
std::string ListVpcEndpointServiceUsersRequest::getRegionId()const
{
return regionId_;
void ListVpcEndpointServiceUsersRequest::setUserId(long userId) {
userId_ = userId;
setParameter(std::string("UserId"), std::to_string(userId));
}
void ListVpcEndpointServiceUsersRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string ListVpcEndpointServiceUsersRequest::getRegionId() const {
return regionId_;
}
std::string ListVpcEndpointServiceUsersRequest::getNextToken()const
{
return nextToken_;
void ListVpcEndpointServiceUsersRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void ListVpcEndpointServiceUsersRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
std::string ListVpcEndpointServiceUsersRequest::getNextToken() const {
return nextToken_;
}
int ListVpcEndpointServiceUsersRequest::getMaxResults()const
{
return maxResults_;
void ListVpcEndpointServiceUsersRequest::setNextToken(const std::string &nextToken) {
nextToken_ = nextToken;
setParameter(std::string("NextToken"), nextToken);
}
void ListVpcEndpointServiceUsersRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
int ListVpcEndpointServiceUsersRequest::getMaxResults() const {
return maxResults_;
}
std::string ListVpcEndpointServiceUsersRequest::getServiceId()const
{
return serviceId_;
void ListVpcEndpointServiceUsersRequest::setMaxResults(int maxResults) {
maxResults_ = maxResults;
setParameter(std::string("MaxResults"), std::to_string(maxResults));
}
void ListVpcEndpointServiceUsersRequest::setServiceId(const std::string& serviceId)
{
serviceId_ = serviceId;
setParameter("ServiceId", serviceId);
std::string ListVpcEndpointServiceUsersRequest::getServiceId() const {
return serviceId_;
}
void ListVpcEndpointServiceUsersRequest::setServiceId(const std::string &serviceId) {
serviceId_ = serviceId;
setParameter(std::string("ServiceId"), serviceId);
}

4
privatelink/src/model/ListVpcEndpointServiceUsersResult.cc
View File

@@ -47,10 +47,10 @@ void ListVpcEndpointServiceUsersResult::parse(const std::string &payload)
usersObject.userId = std::stol(valueUsersUser["UserId"].asString());
users_.push_back(usersObject);
}
if(!value["MaxResults"].isNull())
maxResults_ = value["MaxResults"].asString();
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
if(!value["MaxResults"].isNull())
maxResults_ = value["MaxResults"].asString();
}

103
privatelink/src/model/ListVpcEndpointServicesByEndUserRequest.cc
View File

@@ -1,84 +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.
*/
#include <alibabacloud/privatelink/model/ListVpcEndpointServicesByEndUserRequest.h>
using AlibabaCloud::Privatelink::Model::ListVpcEndpointServicesByEndUserRequest;
ListVpcEndpointServicesByEndUserRequest::ListVpcEndpointServicesByEndUserRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "ListVpcEndpointServicesByEndUser")
{
setMethod(HttpRequest::Method::Post);
}
ListVpcEndpointServicesByEndUserRequest::~ListVpcEndpointServicesByEndUserRequest()
{}
std::string ListVpcEndpointServicesByEndUserRequest::getRegionId()const
{
return regionId_;
*/
#include <alibabacloud/privatelink/model/ListVpcEndpointServicesByEndUserRequest.h>
using AlibabaCloud::Privatelink::Model::ListVpcEndpointServicesByEndUserRequest;
ListVpcEndpointServicesByEndUserRequest::ListVpcEndpointServicesByEndUserRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "ListVpcEndpointServicesByEndUser") {
setMethod(HttpRequest::Method::Post);
}
void ListVpcEndpointServicesByEndUserRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
ListVpcEndpointServicesByEndUserRequest::~ListVpcEndpointServicesByEndUserRequest() {}
std::string ListVpcEndpointServicesByEndUserRequest::getRegionId() const {
return regionId_;
}
std::string ListVpcEndpointServicesByEndUserRequest::getNextToken()const
{
return nextToken_;
void ListVpcEndpointServicesByEndUserRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void ListVpcEndpointServicesByEndUserRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
std::string ListVpcEndpointServicesByEndUserRequest::getNextToken() const {
return nextToken_;
}
std::string ListVpcEndpointServicesByEndUserRequest::getServiceName()const
{
return serviceName_;
void ListVpcEndpointServicesByEndUserRequest::setNextToken(const std::string &nextToken) {
nextToken_ = nextToken;
setParameter(std::string("NextToken"), nextToken);
}
void ListVpcEndpointServicesByEndUserRequest::setServiceName(const std::string& serviceName)
{
serviceName_ = serviceName;
setParameter("ServiceName", serviceName);
std::string ListVpcEndpointServicesByEndUserRequest::getServiceName() const {
return serviceName_;
}
int ListVpcEndpointServicesByEndUserRequest::getMaxResults()const
{
return maxResults_;
void ListVpcEndpointServicesByEndUserRequest::setServiceName(const std::string &serviceName) {
serviceName_ = serviceName;
setParameter(std::string("ServiceName"), serviceName);
}
void ListVpcEndpointServicesByEndUserRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
std::string ListVpcEndpointServicesByEndUserRequest::getServiceType() const {
return serviceType_;
}
std::string ListVpcEndpointServicesByEndUserRequest::getServiceId()const
{
return serviceId_;
void ListVpcEndpointServicesByEndUserRequest::setServiceType(const std::string &serviceType) {
serviceType_ = serviceType;
setParameter(std::string("ServiceType"), serviceType);
}
void ListVpcEndpointServicesByEndUserRequest::setServiceId(const std::string& serviceId)
{
serviceId_ = serviceId;
setParameter("ServiceId", serviceId);
int ListVpcEndpointServicesByEndUserRequest::getMaxResults() const {
return maxResults_;
}
void ListVpcEndpointServicesByEndUserRequest::setMaxResults(int maxResults) {
maxResults_ = maxResults;
setParameter(std::string("MaxResults"), std::to_string(maxResults));
}
std::string ListVpcEndpointServicesByEndUserRequest::getServiceId() const {
return serviceId_;
}
void ListVpcEndpointServicesByEndUserRequest::setServiceId(const std::string &serviceId) {
serviceId_ = serviceId;
setParameter(std::string("ServiceId"), serviceId);
}

10
privatelink/src/model/ListVpcEndpointServicesByEndUserResult.cc
View File

@@ -43,23 +43,25 @@ void ListVpcEndpointServicesByEndUserResult::parse(const std::string &payload)
for (auto valueServicesService : allServicesNode)
{
Service servicesObject;
if(!valueServicesService["Payer"].isNull())
servicesObject.payer = valueServicesService["Payer"].asString();
if(!valueServicesService["ServiceDomain"].isNull())
servicesObject.serviceDomain = valueServicesService["ServiceDomain"].asString();
if(!valueServicesService["ServiceId"].isNull())
servicesObject.serviceId = valueServicesService["ServiceId"].asString();
if(!valueServicesService["ServiceName"].isNull())
servicesObject.serviceName = valueServicesService["ServiceName"].asString();
if(!valueServicesService["Payer"].isNull())
servicesObject.payer = valueServicesService["Payer"].asString();
if(!valueServicesService["ServiceType"].isNull())
servicesObject.serviceType = valueServicesService["ServiceType"].asString();
auto allZones = value["Zones"]["Zone"];
for (auto value : allZones)
servicesObject.zones.push_back(value.asString());
services_.push_back(servicesObject);
}
if(!value["MaxResults"].isNull())
maxResults_ = value["MaxResults"].asString();
if(!value["NextToken"].isNull())
nextToken_ = value["NextToken"].asString();
if(!value["MaxResults"].isNull())
maxResults_ = value["MaxResults"].asString();
}

160
privatelink/src/model/ListVpcEndpointServicesRequest.cc
View File

@@ -1,128 +1,126 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/ListVpcEndpointServicesRequest.h>
using AlibabaCloud::Privatelink::Model::ListVpcEndpointServicesRequest;
ListVpcEndpointServicesRequest::ListVpcEndpointServicesRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "ListVpcEndpointServices")
{
setMethod(HttpRequest::Method::Post);
}
ListVpcEndpointServicesRequest::~ListVpcEndpointServicesRequest()
{}
std::string ListVpcEndpointServicesRequest::getServiceBusinessStatus()const
{
return serviceBusinessStatus_;
*/
#include <alibabacloud/privatelink/model/ListVpcEndpointServicesRequest.h>
using AlibabaCloud::Privatelink::Model::ListVpcEndpointServicesRequest;
ListVpcEndpointServicesRequest::ListVpcEndpointServicesRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "ListVpcEndpointServices") {
setMethod(HttpRequest::Method::Post);
}
void ListVpcEndpointServicesRequest::setServiceBusinessStatus(const std::string& serviceBusinessStatus)
{
serviceBusinessStatus_ = serviceBusinessStatus;
setParameter("ServiceBusinessStatus", serviceBusinessStatus);
ListVpcEndpointServicesRequest::~ListVpcEndpointServicesRequest() {}
std::string ListVpcEndpointServicesRequest::getServiceBusinessStatus() const {
return serviceBusinessStatus_;
}
bool ListVpcEndpointServicesRequest::getAutoAcceptEnabled()const
{
return autoAcceptEnabled_;
void ListVpcEndpointServicesRequest::setServiceBusinessStatus(const std::string &serviceBusinessStatus) {
serviceBusinessStatus_ = serviceBusinessStatus;
setParameter(std::string("ServiceBusinessStatus"), serviceBusinessStatus);
}
void ListVpcEndpointServicesRequest::setAutoAcceptEnabled(bool autoAcceptEnabled)
{
autoAcceptEnabled_ = autoAcceptEnabled;
setParameter("AutoAcceptEnabled", autoAcceptEnabled ? "true" : "false");
bool ListVpcEndpointServicesRequest::getAutoAcceptEnabled() const {
return autoAcceptEnabled_;
}
std::string ListVpcEndpointServicesRequest::getServiceStatus()const
{
return serviceStatus_;
void ListVpcEndpointServicesRequest::setAutoAcceptEnabled(bool autoAcceptEnabled) {
autoAcceptEnabled_ = autoAcceptEnabled;
setParameter(std::string("AutoAcceptEnabled"), autoAcceptEnabled ? "true" : "false");
}
void ListVpcEndpointServicesRequest::setServiceStatus(const std::string& serviceStatus)
{
serviceStatus_ = serviceStatus;
setParameter("ServiceStatus", serviceStatus);
std::string ListVpcEndpointServicesRequest::getServiceStatus() const {
return serviceStatus_;
}
std::string ListVpcEndpointServicesRequest::getRegionId()const
{
return regionId_;
void ListVpcEndpointServicesRequest::setServiceStatus(const std::string &serviceStatus) {
serviceStatus_ = serviceStatus;
setParameter(std::string("ServiceStatus"), serviceStatus);
}
void ListVpcEndpointServicesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string ListVpcEndpointServicesRequest::getRegionId() const {
return regionId_;
}
std::string ListVpcEndpointServicesRequest::getNextToken()const
{
return nextToken_;
void ListVpcEndpointServicesRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void ListVpcEndpointServicesRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
std::string ListVpcEndpointServicesRequest::getNextToken() const {
return nextToken_;
}
bool ListVpcEndpointServicesRequest::getZoneAffinityEnabled()const
{
return zoneAffinityEnabled_;
void ListVpcEndpointServicesRequest::setNextToken(const std::string &nextToken) {
nextToken_ = nextToken;
setParameter(std::string("NextToken"), nextToken);
}
void ListVpcEndpointServicesRequest::setZoneAffinityEnabled(bool zoneAffinityEnabled)
{
zoneAffinityEnabled_ = zoneAffinityEnabled;
setParameter("ZoneAffinityEnabled", zoneAffinityEnabled ? "true" : "false");
bool ListVpcEndpointServicesRequest::getZoneAffinityEnabled() const {
return zoneAffinityEnabled_;
}
std::string ListVpcEndpointServicesRequest::getServiceName()const
{
return serviceName_;
void ListVpcEndpointServicesRequest::setZoneAffinityEnabled(bool zoneAffinityEnabled) {
zoneAffinityEnabled_ = zoneAffinityEnabled;
setParameter(std::string("ZoneAffinityEnabled"), zoneAffinityEnabled ? "true" : "false");
}
void ListVpcEndpointServicesRequest::setServiceName(const std::string& serviceName)
{
serviceName_ = serviceName;
setParameter("ServiceName", serviceName);
std::string ListVpcEndpointServicesRequest::getServiceName() const {
return serviceName_;
}
int ListVpcEndpointServicesRequest::getMaxResults()const
{
return maxResults_;
void ListVpcEndpointServicesRequest::setServiceName(const std::string &serviceName) {
serviceName_ = serviceName;
setParameter(std::string("ServiceName"), serviceName);
}
void ListVpcEndpointServicesRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
std::string ListVpcEndpointServicesRequest::getResourceId() const {
return resourceId_;
}
std::string ListVpcEndpointServicesRequest::getServiceId()const
{
return serviceId_;
void ListVpcEndpointServicesRequest::setResourceId(const std::string &resourceId) {
resourceId_ = resourceId;
setParameter(std::string("ResourceId"), resourceId);
}
void ListVpcEndpointServicesRequest::setServiceId(const std::string& serviceId)
{
serviceId_ = serviceId;
setParameter("ServiceId", serviceId);
std::string ListVpcEndpointServicesRequest::getServiceResourceType() const {
return serviceResourceType_;
}
void ListVpcEndpointServicesRequest::setServiceResourceType(const std::string &serviceResourceType) {
serviceResourceType_ = serviceResourceType;
setParameter(std::string("ServiceResourceType"), serviceResourceType);
}
int ListVpcEndpointServicesRequest::getMaxResults() const {
return maxResults_;
}
void ListVpcEndpointServicesRequest::setMaxResults(int maxResults) {
maxResults_ = maxResults;
setParameter(std::string("MaxResults"), std::to_string(maxResults));
}
std::string ListVpcEndpointServicesRequest::getServiceId() const {
return serviceId_;
}
void ListVpcEndpointServicesRequest::setServiceId(const std::string &serviceId) {
serviceId_ = serviceId;
setParameter(std::string("ServiceId"), serviceId);
}

48
privatelink/src/model/ListVpcEndpointServicesResult.cc
View File

@@ -43,34 +43,38 @@ void ListVpcEndpointServicesResult::parse(const std::string &payload)
for (auto valueServicesService : allServicesNode)
{
Service servicesObject;
if(!valueServicesService["Payer"].isNull())
servicesObject.payer = valueServicesService["Payer"].asString();
if(!valueServicesService["ServiceDescription"].isNull())
servicesObject.serviceDescription = valueServicesService["ServiceDescription"].asString();
if(!valueServicesService["MaxBandwidth"].isNull())
servicesObject.maxBandwidth = std::stoi(valueServicesService["MaxBandwidth"].asString());
if(!valueServicesService["CreateTime"].isNull())
servicesObject.createTime = valueServicesService["CreateTime"].asString();
if(!valueServicesService["ServiceDomain"].isNull())
servicesObject.serviceDomain = valueServicesService["ServiceDomain"].asString();
if(!valueServicesService["MinBandwidth"].isNull())
servicesObject.minBandwidth = std::stoi(valueServicesService["MinBandwidth"].asString());
if(!valueServicesService["ServiceId"].isNull())
servicesObject.serviceId = valueServicesService["ServiceId"].asString();
if(!valueServicesService["AutoAcceptEnabled"].isNull())
servicesObject.autoAcceptEnabled = valueServicesService["AutoAcceptEnabled"].asString() == "true";
if(!valueServicesService["ServiceBusinessStatus"].isNull())
servicesObject.serviceBusinessStatus = valueServicesService["ServiceBusinessStatus"].asString();
if(!valueServicesService["ServiceName"].isNull())
servicesObject.serviceName = valueServicesService["ServiceName"].asString();
if(!valueServicesService["ServiceId"].isNull())
servicesObject.serviceId = valueServicesService["ServiceId"].asString();
if(!valueServicesService["CreateTime"].isNull())
servicesObject.createTime = valueServicesService["CreateTime"].asString();
if(!valueServicesService["MinBandwidth"].isNull())
servicesObject.minBandwidth = std::stoi(valueServicesService["MinBandwidth"].asString());
if(!valueServicesService["MaxBandwidth"].isNull())
servicesObject.maxBandwidth = std::stoi(valueServicesService["MaxBandwidth"].asString());
if(!valueServicesService["ServiceStatus"].isNull())
servicesObject.serviceStatus = valueServicesService["ServiceStatus"].asString();
if(!valueServicesService["ConnectBandwidth"].isNull())
servicesObject.connectBandwidth = std::stoi(valueServicesService["ConnectBandwidth"].asString());
if(!valueServicesService["RegionId"].isNull())
servicesObject.regionId = valueServicesService["RegionId"].asString();
if(!valueServicesService["ZoneAffinityEnabled"].isNull())
servicesObject.zoneAffinityEnabled = valueServicesService["ZoneAffinityEnabled"].asString() == "true";
if(!valueServicesService["RegionId"].isNull())
servicesObject.regionId = valueServicesService["RegionId"].asString();
if(!valueServicesService["ServiceDomain"].isNull())
servicesObject.serviceDomain = valueServicesService["ServiceDomain"].asString();
if(!valueServicesService["Payer"].isNull())
servicesObject.payer = valueServicesService["Payer"].asString();
if(!valueServicesService["ServiceBusinessStatus"].isNull())
servicesObject.serviceBusinessStatus = valueServicesService["ServiceBusinessStatus"].asString();
if(!valueServicesService["ConnectBandwidth"].isNull())
servicesObject.connectBandwidth = std::stoi(valueServicesService["ConnectBandwidth"].asString());
if(!valueServicesService["ServiceName"].isNull())
servicesObject.serviceName = valueServicesService["ServiceName"].asString();
if(!valueServicesService["ServiceDescription"].isNull())
servicesObject.serviceDescription = valueServicesService["ServiceDescription"].asString();
if(!valueServicesService["ServiceResourceType"].isNull())
servicesObject.serviceResourceType = valueServicesService["ServiceResourceType"].asString();
if(!valueServicesService["ServiceType"].isNull())
servicesObject.serviceType = valueServicesService["ServiceType"].asString();
services_.push_back(servicesObject);
}
if(!value["NextToken"].isNull())

82
privatelink/src/model/ListVpcEndpointZonesRequest.cc
View File

@@ -1,73 +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.
*/
#include <alibabacloud/privatelink/model/ListVpcEndpointZonesRequest.h>
using AlibabaCloud::Privatelink::Model::ListVpcEndpointZonesRequest;
ListVpcEndpointZonesRequest::ListVpcEndpointZonesRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "ListVpcEndpointZones")
{
setMethod(HttpRequest::Method::Post);
}
ListVpcEndpointZonesRequest::~ListVpcEndpointZonesRequest()
{}
std::string ListVpcEndpointZonesRequest::getEndpointId()const
{
return endpointId_;
*/
#include <alibabacloud/privatelink/model/ListVpcEndpointZonesRequest.h>
using AlibabaCloud::Privatelink::Model::ListVpcEndpointZonesRequest;
ListVpcEndpointZonesRequest::ListVpcEndpointZonesRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "ListVpcEndpointZones") {
setMethod(HttpRequest::Method::Post);
}
void ListVpcEndpointZonesRequest::setEndpointId(const std::string& endpointId)
{
endpointId_ = endpointId;
setParameter("EndpointId", endpointId);
ListVpcEndpointZonesRequest::~ListVpcEndpointZonesRequest() {}
std::string ListVpcEndpointZonesRequest::getEndpointId() const {
return endpointId_;
}
std::string ListVpcEndpointZonesRequest::getRegionId()const
{
return regionId_;
void ListVpcEndpointZonesRequest::setEndpointId(const std::string &endpointId) {
endpointId_ = endpointId;
setParameter(std::string("EndpointId"), endpointId);
}
void ListVpcEndpointZonesRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string ListVpcEndpointZonesRequest::getRegionId() const {
return regionId_;
}
std::string ListVpcEndpointZonesRequest::getNextToken()const
{
return nextToken_;
void ListVpcEndpointZonesRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void ListVpcEndpointZonesRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
std::string ListVpcEndpointZonesRequest::getNextToken() const {
return nextToken_;
}
int ListVpcEndpointZonesRequest::getMaxResults()const
{
return maxResults_;
void ListVpcEndpointZonesRequest::setNextToken(const std::string &nextToken) {
nextToken_ = nextToken;
setParameter(std::string("NextToken"), nextToken);
}
void ListVpcEndpointZonesRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
int ListVpcEndpointZonesRequest::getMaxResults() const {
return maxResults_;
}
void ListVpcEndpointZonesRequest::setMaxResults(int maxResults) {
maxResults_ = maxResults;
setParameter(std::string("MaxResults"), std::to_string(maxResults));
}

16
privatelink/src/model/ListVpcEndpointZonesResult.cc
View File

@@ -43,22 +43,22 @@ void ListVpcEndpointZonesResult::parse(const std::string &payload)
for (auto valueZonesZone : allZonesNode)
{
Zone zonesObject;
if(!valueZonesZone["EniId"].isNull())
zonesObject.eniId = valueZonesZone["EniId"].asString();
if(!valueZonesZone["ZoneId"].isNull())
zonesObject.zoneId = valueZonesZone["ZoneId"].asString();
if(!valueZonesZone["ServiceStatus"].isNull())
zonesObject.serviceStatus = valueZonesZone["ServiceStatus"].asString();
if(!valueZonesZone["VSwitchId"].isNull())
zonesObject.vSwitchId = valueZonesZone["VSwitchId"].asString();
if(!valueZonesZone["EniIp"].isNull())
zonesObject.eniIp = valueZonesZone["EniIp"].asString();
if(!valueZonesZone["ZoneStatus"].isNull())
zonesObject.zoneStatus = valueZonesZone["ZoneStatus"].asString();
if(!valueZonesZone["RegionId"].isNull())
zonesObject.regionId = valueZonesZone["RegionId"].asString();
if(!valueZonesZone["ZoneId"].isNull())
zonesObject.zoneId = valueZonesZone["ZoneId"].asString();
if(!valueZonesZone["ServiceStatus"].isNull())
zonesObject.serviceStatus = valueZonesZone["ServiceStatus"].asString();
if(!valueZonesZone["EniId"].isNull())
zonesObject.eniId = valueZonesZone["EniId"].asString();
if(!valueZonesZone["ZoneDomain"].isNull())
zonesObject.zoneDomain = valueZonesZone["ZoneDomain"].asString();
if(!valueZonesZone["RegionId"].isNull())
zonesObject.regionId = valueZonesZone["RegionId"].asString();
zones_.push_back(zonesObject);
}
if(!value["NextToken"].isNull())

151
privatelink/src/model/ListVpcEndpointsRequest.cc
View File

@@ -1,128 +1,117 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/ListVpcEndpointsRequest.h>
using AlibabaCloud::Privatelink::Model::ListVpcEndpointsRequest;
ListVpcEndpointsRequest::ListVpcEndpointsRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "ListVpcEndpoints")
{
setMethod(HttpRequest::Method::Post);
}
ListVpcEndpointsRequest::~ListVpcEndpointsRequest()
{}
std::string ListVpcEndpointsRequest::getEndpointId()const
{
return endpointId_;
*/
#include <alibabacloud/privatelink/model/ListVpcEndpointsRequest.h>
using AlibabaCloud::Privatelink::Model::ListVpcEndpointsRequest;
ListVpcEndpointsRequest::ListVpcEndpointsRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "ListVpcEndpoints") {
setMethod(HttpRequest::Method::Post);
}
void ListVpcEndpointsRequest::setEndpointId(const std::string& endpointId)
{
endpointId_ = endpointId;
setParameter("EndpointId", endpointId);
ListVpcEndpointsRequest::~ListVpcEndpointsRequest() {}
std::string ListVpcEndpointsRequest::getEndpointId() const {
return endpointId_;
}
std::string ListVpcEndpointsRequest::getEndpointStatus()const
{
return endpointStatus_;
void ListVpcEndpointsRequest::setEndpointId(const std::string &endpointId) {
endpointId_ = endpointId;
setParameter(std::string("EndpointId"), endpointId);
}
void ListVpcEndpointsRequest::setEndpointStatus(const std::string& endpointStatus)
{
endpointStatus_ = endpointStatus;
setParameter("EndpointStatus", endpointStatus);
std::string ListVpcEndpointsRequest::getEndpointStatus() const {
return endpointStatus_;
}
std::string ListVpcEndpointsRequest::getRegionId()const
{
return regionId_;
void ListVpcEndpointsRequest::setEndpointStatus(const std::string &endpointStatus) {
endpointStatus_ = endpointStatus;
setParameter(std::string("EndpointStatus"), endpointStatus);
}
void ListVpcEndpointsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string ListVpcEndpointsRequest::getRegionId() const {
return regionId_;
}
std::string ListVpcEndpointsRequest::getNextToken()const
{
return nextToken_;
void ListVpcEndpointsRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void ListVpcEndpointsRequest::setNextToken(const std::string& nextToken)
{
nextToken_ = nextToken;
setParameter("NextToken", nextToken);
std::string ListVpcEndpointsRequest::getNextToken() const {
return nextToken_;
}
std::string ListVpcEndpointsRequest::getServiceName()const
{
return serviceName_;
void ListVpcEndpointsRequest::setNextToken(const std::string &nextToken) {
nextToken_ = nextToken;
setParameter(std::string("NextToken"), nextToken);
}
void ListVpcEndpointsRequest::setServiceName(const std::string& serviceName)
{
serviceName_ = serviceName;
setParameter("ServiceName", serviceName);
std::string ListVpcEndpointsRequest::getEndpointType() const {
return endpointType_;
}
std::string ListVpcEndpointsRequest::getConnectionStatus()const
{
return connectionStatus_;
void ListVpcEndpointsRequest::setEndpointType(const std::string &endpointType) {
endpointType_ = endpointType;
setParameter(std::string("EndpointType"), endpointType);
}
void ListVpcEndpointsRequest::setConnectionStatus(const std::string& connectionStatus)
{
connectionStatus_ = connectionStatus;
setParameter("ConnectionStatus", connectionStatus);
std::string ListVpcEndpointsRequest::getServiceName() const {
return serviceName_;
}
std::string ListVpcEndpointsRequest::getVpcId()const
{
return vpcId_;
void ListVpcEndpointsRequest::setServiceName(const std::string &serviceName) {
serviceName_ = serviceName;
setParameter(std::string("ServiceName"), serviceName);
}
void ListVpcEndpointsRequest::setVpcId(const std::string& vpcId)
{
vpcId_ = vpcId;
setParameter("VpcId", vpcId);
std::string ListVpcEndpointsRequest::getConnectionStatus() const {
return connectionStatus_;
}
std::string ListVpcEndpointsRequest::getEndpointName()const
{
return endpointName_;
void ListVpcEndpointsRequest::setConnectionStatus(const std::string &connectionStatus) {
connectionStatus_ = connectionStatus;
setParameter(std::string("ConnectionStatus"), connectionStatus);
}
void ListVpcEndpointsRequest::setEndpointName(const std::string& endpointName)
{
endpointName_ = endpointName;
setParameter("EndpointName", endpointName);
std::string ListVpcEndpointsRequest::getVpcId() const {
return vpcId_;
}
int ListVpcEndpointsRequest::getMaxResults()const
{
return maxResults_;
void ListVpcEndpointsRequest::setVpcId(const std::string &vpcId) {
vpcId_ = vpcId;
setParameter(std::string("VpcId"), vpcId);
}
void ListVpcEndpointsRequest::setMaxResults(int maxResults)
{
maxResults_ = maxResults;
setParameter("MaxResults", std::to_string(maxResults));
std::string ListVpcEndpointsRequest::getEndpointName() const {
return endpointName_;
}
void ListVpcEndpointsRequest::setEndpointName(const std::string &endpointName) {
endpointName_ = endpointName;
setParameter(std::string("EndpointName"), endpointName);
}
int ListVpcEndpointsRequest::getMaxResults() const {
return maxResults_;
}
void ListVpcEndpointsRequest::setMaxResults(int maxResults) {
maxResults_ = maxResults;
setParameter(std::string("MaxResults"), std::to_string(maxResults));
}

54
privatelink/src/model/ListVpcEndpointsResult.cc
View File

@@ -43,36 +43,38 @@ void ListVpcEndpointsResult::parse(const std::string &payload)
for (auto valueEndpointsEndpoint : allEndpointsNode)
{
Endpoint endpointsObject;
if(!valueEndpointsEndpoint["EndpointDomain"].isNull())
endpointsObject.endpointDomain = valueEndpointsEndpoint["EndpointDomain"].asString();
if(!valueEndpointsEndpoint["ResourceOwner"].isNull())
endpointsObject.resourceOwner = valueEndpointsEndpoint["ResourceOwner"].asString() == "true";
if(!valueEndpointsEndpoint["CreateTime"].isNull())
endpointsObject.createTime = valueEndpointsEndpoint["CreateTime"].asString();
if(!valueEndpointsEndpoint["EndpointBusinessStatus"].isNull())
endpointsObject.endpointBusinessStatus = valueEndpointsEndpoint["EndpointBusinessStatus"].asString();
if(!valueEndpointsEndpoint["EndpointDescription"].isNull())
endpointsObject.endpointDescription = valueEndpointsEndpoint["EndpointDescription"].asString();
if(!valueEndpointsEndpoint["ServiceId"].isNull())
endpointsObject.serviceId = valueEndpointsEndpoint["ServiceId"].asString();
if(!valueEndpointsEndpoint["EndpointStatus"].isNull())
endpointsObject.endpointStatus = valueEndpointsEndpoint["EndpointStatus"].asString();
if(!valueEndpointsEndpoint["EndpointName"].isNull())
endpointsObject.endpointName = valueEndpointsEndpoint["EndpointName"].asString();
if(!valueEndpointsEndpoint["VpcId"].isNull())
endpointsObject.vpcId = valueEndpointsEndpoint["VpcId"].asString();
if(!valueEndpointsEndpoint["ServiceName"].isNull())
endpointsObject.serviceName = valueEndpointsEndpoint["ServiceName"].asString();
if(!valueEndpointsEndpoint["EndpointId"].isNull())
endpointsObject.endpointId = valueEndpointsEndpoint["EndpointId"].asString();
if(!valueEndpointsEndpoint["Bandwidth"].isNull())
endpointsObject.bandwidth = std::stol(valueEndpointsEndpoint["Bandwidth"].asString());
if(!valueEndpointsEndpoint["RegionId"].isNull())
endpointsObject.regionId = valueEndpointsEndpoint["RegionId"].asString();
if(!valueEndpointsEndpoint["ConnectionStatus"].isNull())
endpointsObject.connectionStatus = valueEndpointsEndpoint["ConnectionStatus"].asString();
if(!valueEndpointsEndpoint["EndpointName"].isNull())
endpointsObject.endpointName = valueEndpointsEndpoint["EndpointName"].asString();
if(!valueEndpointsEndpoint["EndpointType"].isNull())
endpointsObject.endpointType = valueEndpointsEndpoint["EndpointType"].asString();
if(!valueEndpointsEndpoint["CreateTime"].isNull())
endpointsObject.createTime = valueEndpointsEndpoint["CreateTime"].asString();
if(!valueEndpointsEndpoint["ServiceId"].isNull())
endpointsObject.serviceId = valueEndpointsEndpoint["ServiceId"].asString();
if(!valueEndpointsEndpoint["ZoneAffinityEnabled"].isNull())
endpointsObject.zoneAffinityEnabled = valueEndpointsEndpoint["ZoneAffinityEnabled"].asString() == "true";
if(!valueEndpointsEndpoint["EndpointDomain"].isNull())
endpointsObject.endpointDomain = valueEndpointsEndpoint["EndpointDomain"].asString();
if(!valueEndpointsEndpoint["EndpointStatus"].isNull())
endpointsObject.endpointStatus = valueEndpointsEndpoint["EndpointStatus"].asString();
if(!valueEndpointsEndpoint["RegionId"].isNull())
endpointsObject.regionId = valueEndpointsEndpoint["RegionId"].asString();
if(!valueEndpointsEndpoint["ResourceOwner"].isNull())
endpointsObject.resourceOwner = valueEndpointsEndpoint["ResourceOwner"].asString() == "true";
if(!valueEndpointsEndpoint["Bandwidth"].isNull())
endpointsObject.bandwidth = std::stol(valueEndpointsEndpoint["Bandwidth"].asString());
if(!valueEndpointsEndpoint["ConnectionStatus"].isNull())
endpointsObject.connectionStatus = valueEndpointsEndpoint["ConnectionStatus"].asString();
if(!valueEndpointsEndpoint["EndpointDescription"].isNull())
endpointsObject.endpointDescription = valueEndpointsEndpoint["EndpointDescription"].asString();
if(!valueEndpointsEndpoint["EndpointId"].isNull())
endpointsObject.endpointId = valueEndpointsEndpoint["EndpointId"].asString();
if(!valueEndpointsEndpoint["EndpointBusinessStatus"].isNull())
endpointsObject.endpointBusinessStatus = valueEndpointsEndpoint["EndpointBusinessStatus"].asString();
if(!valueEndpointsEndpoint["ServiceName"].isNull())
endpointsObject.serviceName = valueEndpointsEndpoint["ServiceName"].asString();
endpoints_.push_back(endpointsObject);
}
if(!value["NextToken"].isNull())

46
privatelink/src/model/OpenPrivateLinkServiceRequest.cc
View File

@@ -1,40 +1,36 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/OpenPrivateLinkServiceRequest.h>
using AlibabaCloud::Privatelink::Model::OpenPrivateLinkServiceRequest;
OpenPrivateLinkServiceRequest::OpenPrivateLinkServiceRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "OpenPrivateLinkService")
{
setMethod(HttpRequest::Method::Post);
}
OpenPrivateLinkServiceRequest::~OpenPrivateLinkServiceRequest()
{}
long OpenPrivateLinkServiceRequest::getOwnerId()const
{
return ownerId_;
*/
#include <alibabacloud/privatelink/model/OpenPrivateLinkServiceRequest.h>
using AlibabaCloud::Privatelink::Model::OpenPrivateLinkServiceRequest;
OpenPrivateLinkServiceRequest::OpenPrivateLinkServiceRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "OpenPrivateLinkService") {
setMethod(HttpRequest::Method::Post);
}
void OpenPrivateLinkServiceRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
OpenPrivateLinkServiceRequest::~OpenPrivateLinkServiceRequest() {}
long OpenPrivateLinkServiceRequest::getOwnerId() const {
return ownerId_;
}
void OpenPrivateLinkServiceRequest::setOwnerId(long ownerId) {
ownerId_ = ownerId;
setParameter(std::string("OwnerId"), std::to_string(ownerId));
}

94
privatelink/src/model/RemoveUserFromVpcEndpointServiceRequest.cc
View File

@@ -1,84 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/RemoveUserFromVpcEndpointServiceRequest.h>
using AlibabaCloud::Privatelink::Model::RemoveUserFromVpcEndpointServiceRequest;
RemoveUserFromVpcEndpointServiceRequest::RemoveUserFromVpcEndpointServiceRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "RemoveUserFromVpcEndpointService")
{
setMethod(HttpRequest::Method::Post);
}
RemoveUserFromVpcEndpointServiceRequest::~RemoveUserFromVpcEndpointServiceRequest()
{}
std::string RemoveUserFromVpcEndpointServiceRequest::getClientToken()const
{
return clientToken_;
*/
#include <alibabacloud/privatelink/model/RemoveUserFromVpcEndpointServiceRequest.h>
using AlibabaCloud::Privatelink::Model::RemoveUserFromVpcEndpointServiceRequest;
RemoveUserFromVpcEndpointServiceRequest::RemoveUserFromVpcEndpointServiceRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "RemoveUserFromVpcEndpointService") {
setMethod(HttpRequest::Method::Post);
}
void RemoveUserFromVpcEndpointServiceRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
RemoveUserFromVpcEndpointServiceRequest::~RemoveUserFromVpcEndpointServiceRequest() {}
std::string RemoveUserFromVpcEndpointServiceRequest::getClientToken() const {
return clientToken_;
}
long RemoveUserFromVpcEndpointServiceRequest::getUserId()const
{
return userId_;
void RemoveUserFromVpcEndpointServiceRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
void RemoveUserFromVpcEndpointServiceRequest::setUserId(long userId)
{
userId_ = userId;
setParameter("UserId", std::to_string(userId));
long RemoveUserFromVpcEndpointServiceRequest::getUserId() const {
return userId_;
}
std::string RemoveUserFromVpcEndpointServiceRequest::getRegionId()const
{
return regionId_;
void RemoveUserFromVpcEndpointServiceRequest::setUserId(long userId) {
userId_ = userId;
setParameter(std::string("UserId"), std::to_string(userId));
}
void RemoveUserFromVpcEndpointServiceRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string RemoveUserFromVpcEndpointServiceRequest::getRegionId() const {
return regionId_;
}
bool RemoveUserFromVpcEndpointServiceRequest::getDryRun()const
{
return dryRun_;
void RemoveUserFromVpcEndpointServiceRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void RemoveUserFromVpcEndpointServiceRequest::setDryRun(bool dryRun)
{
dryRun_ = dryRun;
setParameter("DryRun", dryRun ? "true" : "false");
bool RemoveUserFromVpcEndpointServiceRequest::getDryRun() const {
return dryRun_;
}
std::string RemoveUserFromVpcEndpointServiceRequest::getServiceId()const
{
return serviceId_;
void RemoveUserFromVpcEndpointServiceRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
void RemoveUserFromVpcEndpointServiceRequest::setServiceId(const std::string& serviceId)
{
serviceId_ = serviceId;
setParameter("ServiceId", serviceId);
std::string RemoveUserFromVpcEndpointServiceRequest::getServiceId() const {
return serviceId_;
}
void RemoveUserFromVpcEndpointServiceRequest::setServiceId(const std::string &serviceId) {
serviceId_ = serviceId;
setParameter(std::string("ServiceId"), serviceId);
}

94
privatelink/src/model/RemoveZoneFromVpcEndpointRequest.cc
View File

@@ -1,84 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/RemoveZoneFromVpcEndpointRequest.h>
using AlibabaCloud::Privatelink::Model::RemoveZoneFromVpcEndpointRequest;
RemoveZoneFromVpcEndpointRequest::RemoveZoneFromVpcEndpointRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "RemoveZoneFromVpcEndpoint")
{
setMethod(HttpRequest::Method::Post);
}
RemoveZoneFromVpcEndpointRequest::~RemoveZoneFromVpcEndpointRequest()
{}
std::string RemoveZoneFromVpcEndpointRequest::getClientToken()const
{
return clientToken_;
*/
#include <alibabacloud/privatelink/model/RemoveZoneFromVpcEndpointRequest.h>
using AlibabaCloud::Privatelink::Model::RemoveZoneFromVpcEndpointRequest;
RemoveZoneFromVpcEndpointRequest::RemoveZoneFromVpcEndpointRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "RemoveZoneFromVpcEndpoint") {
setMethod(HttpRequest::Method::Post);
}
void RemoveZoneFromVpcEndpointRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
RemoveZoneFromVpcEndpointRequest::~RemoveZoneFromVpcEndpointRequest() {}
std::string RemoveZoneFromVpcEndpointRequest::getClientToken() const {
return clientToken_;
}
std::string RemoveZoneFromVpcEndpointRequest::getEndpointId()const
{
return endpointId_;
void RemoveZoneFromVpcEndpointRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
void RemoveZoneFromVpcEndpointRequest::setEndpointId(const std::string& endpointId)
{
endpointId_ = endpointId;
setParameter("EndpointId", endpointId);
std::string RemoveZoneFromVpcEndpointRequest::getEndpointId() const {
return endpointId_;
}
std::string RemoveZoneFromVpcEndpointRequest::getRegionId()const
{
return regionId_;
void RemoveZoneFromVpcEndpointRequest::setEndpointId(const std::string &endpointId) {
endpointId_ = endpointId;
setParameter(std::string("EndpointId"), endpointId);
}
void RemoveZoneFromVpcEndpointRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string RemoveZoneFromVpcEndpointRequest::getRegionId() const {
return regionId_;
}
bool RemoveZoneFromVpcEndpointRequest::getDryRun()const
{
return dryRun_;
void RemoveZoneFromVpcEndpointRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void RemoveZoneFromVpcEndpointRequest::setDryRun(bool dryRun)
{
dryRun_ = dryRun;
setParameter("DryRun", dryRun ? "true" : "false");
bool RemoveZoneFromVpcEndpointRequest::getDryRun() const {
return dryRun_;
}
std::string RemoveZoneFromVpcEndpointRequest::getZoneId()const
{
return zoneId_;
void RemoveZoneFromVpcEndpointRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
void RemoveZoneFromVpcEndpointRequest::setZoneId(const std::string& zoneId)
{
zoneId_ = zoneId;
setParameter("ZoneId", zoneId);
std::string RemoveZoneFromVpcEndpointRequest::getZoneId() const {
return zoneId_;
}
void RemoveZoneFromVpcEndpointRequest::setZoneId(const std::string &zoneId) {
zoneId_ = zoneId;
setParameter(std::string("ZoneId"), zoneId);
}

106
privatelink/src/model/UpdateVpcEndpointAttributeRequest.cc
View File

@@ -1,95 +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.
*/
#include <alibabacloud/privatelink/model/UpdateVpcEndpointAttributeRequest.h>
using AlibabaCloud::Privatelink::Model::UpdateVpcEndpointAttributeRequest;
UpdateVpcEndpointAttributeRequest::UpdateVpcEndpointAttributeRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "UpdateVpcEndpointAttribute")
{
setMethod(HttpRequest::Method::Post);
}
UpdateVpcEndpointAttributeRequest::~UpdateVpcEndpointAttributeRequest()
{}
std::string UpdateVpcEndpointAttributeRequest::getClientToken()const
{
return clientToken_;
*/
#include <alibabacloud/privatelink/model/UpdateVpcEndpointAttributeRequest.h>
using AlibabaCloud::Privatelink::Model::UpdateVpcEndpointAttributeRequest;
UpdateVpcEndpointAttributeRequest::UpdateVpcEndpointAttributeRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "UpdateVpcEndpointAttribute") {
setMethod(HttpRequest::Method::Post);
}
void UpdateVpcEndpointAttributeRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
UpdateVpcEndpointAttributeRequest::~UpdateVpcEndpointAttributeRequest() {}
std::string UpdateVpcEndpointAttributeRequest::getClientToken() const {
return clientToken_;
}
std::string UpdateVpcEndpointAttributeRequest::getEndpointId()const
{
return endpointId_;
void UpdateVpcEndpointAttributeRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
void UpdateVpcEndpointAttributeRequest::setEndpointId(const std::string& endpointId)
{
endpointId_ = endpointId;
setParameter("EndpointId", endpointId);
std::string UpdateVpcEndpointAttributeRequest::getEndpointId() const {
return endpointId_;
}
std::string UpdateVpcEndpointAttributeRequest::getRegionId()const
{
return regionId_;
void UpdateVpcEndpointAttributeRequest::setEndpointId(const std::string &endpointId) {
endpointId_ = endpointId;
setParameter(std::string("EndpointId"), endpointId);
}
void UpdateVpcEndpointAttributeRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string UpdateVpcEndpointAttributeRequest::getRegionId() const {
return regionId_;
}
bool UpdateVpcEndpointAttributeRequest::getDryRun()const
{
return dryRun_;
void UpdateVpcEndpointAttributeRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void UpdateVpcEndpointAttributeRequest::setDryRun(bool dryRun)
{
dryRun_ = dryRun;
setParameter("DryRun", dryRun ? "true" : "false");
bool UpdateVpcEndpointAttributeRequest::getDryRun() const {
return dryRun_;
}
std::string UpdateVpcEndpointAttributeRequest::getEndpointDescription()const
{
return endpointDescription_;
void UpdateVpcEndpointAttributeRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
void UpdateVpcEndpointAttributeRequest::setEndpointDescription(const std::string& endpointDescription)
{
endpointDescription_ = endpointDescription;
setParameter("EndpointDescription", endpointDescription);
std::string UpdateVpcEndpointAttributeRequest::getEndpointDescription() const {
return endpointDescription_;
}
std::string UpdateVpcEndpointAttributeRequest::getEndpointName()const
{
return endpointName_;
void UpdateVpcEndpointAttributeRequest::setEndpointDescription(const std::string &endpointDescription) {
endpointDescription_ = endpointDescription;
setParameter(std::string("EndpointDescription"), endpointDescription);
}
void UpdateVpcEndpointAttributeRequest::setEndpointName(const std::string& endpointName)
{
endpointName_ = endpointName;
setParameter("EndpointName", endpointName);
std::string UpdateVpcEndpointAttributeRequest::getEndpointName() const {
return endpointName_;
}
void UpdateVpcEndpointAttributeRequest::setEndpointName(const std::string &endpointName) {
endpointName_ = endpointName;
setParameter(std::string("EndpointName"), endpointName);
}

106
privatelink/src/model/UpdateVpcEndpointConnectionAttributeRequest.cc
View File

@@ -1,95 +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.
*/
#include <alibabacloud/privatelink/model/UpdateVpcEndpointConnectionAttributeRequest.h>
using AlibabaCloud::Privatelink::Model::UpdateVpcEndpointConnectionAttributeRequest;
UpdateVpcEndpointConnectionAttributeRequest::UpdateVpcEndpointConnectionAttributeRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "UpdateVpcEndpointConnectionAttribute")
{
setMethod(HttpRequest::Method::Post);
}
UpdateVpcEndpointConnectionAttributeRequest::~UpdateVpcEndpointConnectionAttributeRequest()
{}
std::string UpdateVpcEndpointConnectionAttributeRequest::getClientToken()const
{
return clientToken_;
*/
#include <alibabacloud/privatelink/model/UpdateVpcEndpointConnectionAttributeRequest.h>
using AlibabaCloud::Privatelink::Model::UpdateVpcEndpointConnectionAttributeRequest;
UpdateVpcEndpointConnectionAttributeRequest::UpdateVpcEndpointConnectionAttributeRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "UpdateVpcEndpointConnectionAttribute") {
setMethod(HttpRequest::Method::Post);
}
void UpdateVpcEndpointConnectionAttributeRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
UpdateVpcEndpointConnectionAttributeRequest::~UpdateVpcEndpointConnectionAttributeRequest() {}
std::string UpdateVpcEndpointConnectionAttributeRequest::getClientToken() const {
return clientToken_;
}
std::string UpdateVpcEndpointConnectionAttributeRequest::getEndpointId()const
{
return endpointId_;
void UpdateVpcEndpointConnectionAttributeRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
void UpdateVpcEndpointConnectionAttributeRequest::setEndpointId(const std::string& endpointId)
{
endpointId_ = endpointId;
setParameter("EndpointId", endpointId);
std::string UpdateVpcEndpointConnectionAttributeRequest::getEndpointId() const {
return endpointId_;
}
std::string UpdateVpcEndpointConnectionAttributeRequest::getRegionId()const
{
return regionId_;
void UpdateVpcEndpointConnectionAttributeRequest::setEndpointId(const std::string &endpointId) {
endpointId_ = endpointId;
setParameter(std::string("EndpointId"), endpointId);
}
void UpdateVpcEndpointConnectionAttributeRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string UpdateVpcEndpointConnectionAttributeRequest::getRegionId() const {
return regionId_;
}
bool UpdateVpcEndpointConnectionAttributeRequest::getDryRun()const
{
return dryRun_;
void UpdateVpcEndpointConnectionAttributeRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void UpdateVpcEndpointConnectionAttributeRequest::setDryRun(bool dryRun)
{
dryRun_ = dryRun;
setParameter("DryRun", dryRun ? "true" : "false");
bool UpdateVpcEndpointConnectionAttributeRequest::getDryRun() const {
return dryRun_;
}
int UpdateVpcEndpointConnectionAttributeRequest::getBandwidth()const
{
return bandwidth_;
void UpdateVpcEndpointConnectionAttributeRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
void UpdateVpcEndpointConnectionAttributeRequest::setBandwidth(int bandwidth)
{
bandwidth_ = bandwidth;
setParameter("Bandwidth", std::to_string(bandwidth));
int UpdateVpcEndpointConnectionAttributeRequest::getBandwidth() const {
return bandwidth_;
}
std::string UpdateVpcEndpointConnectionAttributeRequest::getServiceId()const
{
return serviceId_;
void UpdateVpcEndpointConnectionAttributeRequest::setBandwidth(int bandwidth) {
bandwidth_ = bandwidth;
setParameter(std::string("Bandwidth"), std::to_string(bandwidth));
}
void UpdateVpcEndpointConnectionAttributeRequest::setServiceId(const std::string& serviceId)
{
serviceId_ = serviceId;
setParameter("ServiceId", serviceId);
std::string UpdateVpcEndpointConnectionAttributeRequest::getServiceId() const {
return serviceId_;
}
void UpdateVpcEndpointConnectionAttributeRequest::setServiceId(const std::string &serviceId) {
serviceId_ = serviceId;
setParameter(std::string("ServiceId"), serviceId);
}

148
privatelink/src/model/UpdateVpcEndpointServiceAttributeRequest.cc
View File

@@ -1,117 +1,117 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/privatelink/model/UpdateVpcEndpointServiceAttributeRequest.h>
using AlibabaCloud::Privatelink::Model::UpdateVpcEndpointServiceAttributeRequest;
UpdateVpcEndpointServiceAttributeRequest::UpdateVpcEndpointServiceAttributeRequest() :
RpcServiceRequest("privatelink", "2020-04-15", "UpdateVpcEndpointServiceAttribute")
{
setMethod(HttpRequest::Method::Post);
}
UpdateVpcEndpointServiceAttributeRequest::~UpdateVpcEndpointServiceAttributeRequest()
{}
bool UpdateVpcEndpointServiceAttributeRequest::getAutoAcceptEnabled()const
{
return autoAcceptEnabled_;
*/
#include <alibabacloud/privatelink/model/UpdateVpcEndpointServiceAttributeRequest.h>
using AlibabaCloud::Privatelink::Model::UpdateVpcEndpointServiceAttributeRequest;
UpdateVpcEndpointServiceAttributeRequest::UpdateVpcEndpointServiceAttributeRequest()
: RpcServiceRequest("privatelink", "2020-04-15", "UpdateVpcEndpointServiceAttribute") {
setMethod(HttpRequest::Method::Post);
}
void UpdateVpcEndpointServiceAttributeRequest::setAutoAcceptEnabled(bool autoAcceptEnabled)
{
autoAcceptEnabled_ = autoAcceptEnabled;
setParameter("AutoAcceptEnabled", autoAcceptEnabled ? "true" : "false");
UpdateVpcEndpointServiceAttributeRequest::~UpdateVpcEndpointServiceAttributeRequest() {}
bool UpdateVpcEndpointServiceAttributeRequest::getPrivateServiceDomainEnabled() const {
return privateServiceDomainEnabled_;
}
std::string UpdateVpcEndpointServiceAttributeRequest::getClientToken()const
{
return clientToken_;
void UpdateVpcEndpointServiceAttributeRequest::setPrivateServiceDomainEnabled(bool privateServiceDomainEnabled) {
privateServiceDomainEnabled_ = privateServiceDomainEnabled;
setParameter(std::string("PrivateServiceDomainEnabled"), privateServiceDomainEnabled ? "true" : "false");
}
void UpdateVpcEndpointServiceAttributeRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
std::string UpdateVpcEndpointServiceAttributeRequest::getPrivateServiceDomain() const {
return privateServiceDomain_;
}
int UpdateVpcEndpointServiceAttributeRequest::getConnectBandwidth()const
{
return connectBandwidth_;
void UpdateVpcEndpointServiceAttributeRequest::setPrivateServiceDomain(const std::string &privateServiceDomain) {
privateServiceDomain_ = privateServiceDomain;
setParameter(std::string("PrivateServiceDomain"), privateServiceDomain);
}
void UpdateVpcEndpointServiceAttributeRequest::setConnectBandwidth(int connectBandwidth)
{
connectBandwidth_ = connectBandwidth;
setParameter("ConnectBandwidth", std::to_string(connectBandwidth));
bool UpdateVpcEndpointServiceAttributeRequest::getAutoAcceptEnabled() const {
return autoAcceptEnabled_;
}
std::string UpdateVpcEndpointServiceAttributeRequest::getRegionId()const
{
return regionId_;
void UpdateVpcEndpointServiceAttributeRequest::setAutoAcceptEnabled(bool autoAcceptEnabled) {
autoAcceptEnabled_ = autoAcceptEnabled;
setParameter(std::string("AutoAcceptEnabled"), autoAcceptEnabled ? "true" : "false");
}
void UpdateVpcEndpointServiceAttributeRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
std::string UpdateVpcEndpointServiceAttributeRequest::getClientToken() const {
return clientToken_;
}
bool UpdateVpcEndpointServiceAttributeRequest::getZoneAffinityEnabled()const
{
return zoneAffinityEnabled_;
void UpdateVpcEndpointServiceAttributeRequest::setClientToken(const std::string &clientToken) {
clientToken_ = clientToken;
setParameter(std::string("ClientToken"), clientToken);
}
void UpdateVpcEndpointServiceAttributeRequest::setZoneAffinityEnabled(bool zoneAffinityEnabled)
{
zoneAffinityEnabled_ = zoneAffinityEnabled;
setParameter("ZoneAffinityEnabled", zoneAffinityEnabled ? "true" : "false");
int UpdateVpcEndpointServiceAttributeRequest::getConnectBandwidth() const {
return connectBandwidth_;
}
bool UpdateVpcEndpointServiceAttributeRequest::getDryRun()const
{
return dryRun_;
void UpdateVpcEndpointServiceAttributeRequest::setConnectBandwidth(int connectBandwidth) {
connectBandwidth_ = connectBandwidth;
setParameter(std::string("ConnectBandwidth"), std::to_string(connectBandwidth));
}
void UpdateVpcEndpointServiceAttributeRequest::setDryRun(bool dryRun)
{
dryRun_ = dryRun;
setParameter("DryRun", dryRun ? "true" : "false");
std::string UpdateVpcEndpointServiceAttributeRequest::getRegionId() const {
return regionId_;
}
std::string UpdateVpcEndpointServiceAttributeRequest::getServiceDescription()const
{
return serviceDescription_;
void UpdateVpcEndpointServiceAttributeRequest::setRegionId(const std::string &regionId) {
regionId_ = regionId;
setParameter(std::string("RegionId"), regionId);
}
void UpdateVpcEndpointServiceAttributeRequest::setServiceDescription(const std::string& serviceDescription)
{
serviceDescription_ = serviceDescription;
setParameter("ServiceDescription", serviceDescription);
bool UpdateVpcEndpointServiceAttributeRequest::getZoneAffinityEnabled() const {
return zoneAffinityEnabled_;
}
std::string UpdateVpcEndpointServiceAttributeRequest::getServiceId()const
{
return serviceId_;
void UpdateVpcEndpointServiceAttributeRequest::setZoneAffinityEnabled(bool zoneAffinityEnabled) {
zoneAffinityEnabled_ = zoneAffinityEnabled;
setParameter(std::string("ZoneAffinityEnabled"), zoneAffinityEnabled ? "true" : "false");
}
void UpdateVpcEndpointServiceAttributeRequest::setServiceId(const std::string& serviceId)
{
serviceId_ = serviceId;
setParameter("ServiceId", serviceId);
bool UpdateVpcEndpointServiceAttributeRequest::getDryRun() const {
return dryRun_;
}
void UpdateVpcEndpointServiceAttributeRequest::setDryRun(bool dryRun) {
dryRun_ = dryRun;
setParameter(std::string("DryRun"), dryRun ? "true" : "false");
}
std::string UpdateVpcEndpointServiceAttributeRequest::getServiceDescription() const {
return serviceDescription_;
}
void UpdateVpcEndpointServiceAttributeRequest::setServiceDescription(const std::string &serviceDescription) {
serviceDescription_ = serviceDescription;
setParameter(std::string("ServiceDescription"), serviceDescription);
}
std::string UpdateVpcEndpointServiceAttributeRequest::getServiceId() const {
return serviceId_;
}
void UpdateVpcEndpointServiceAttributeRequest::setServiceId(const std::string &serviceId) {
serviceId_ = serviceId;
setParameter(std::string("ServiceId"), serviceId);
}