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

Support cloud disk.

Browse Source
This commit is contained in:
sdk-team
2022-01-28 07:59:04 +00:00
parent d78148b8be
commit a09a6e094a
658 changed files with 47846 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1350
ens/include/alibabacloud/ens/EnsClient.h Normal file
View File

File diff suppressed because it is too large Load Diff

32
ens/include/alibabacloud/ens/EnsExport.h Normal file
View File

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

52
ens/include/alibabacloud/ens/model/AddBackendServersRequest.h Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_ENS_MODEL_ADDBACKENDSERVERSREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_ADDBACKENDSERVERSREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT AddBackendServersRequest : public RpcServiceRequest {
public:
struct BackendServers {
int port;
std::string ip;
int weight;
std::string type;
std::string serverId;
};
AddBackendServersRequest();
~AddBackendServersRequest();
std::vector<BackendServers> getBackendServers() const;
void setBackendServers(const std::vector<BackendServers> &backendServers);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
private:
std::vector<BackendServers> backendServers_;
std::string loadBalancerId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_ADDBACKENDSERVERSREQUEST_H_

59
ens/include/alibabacloud/ens/model/AddBackendServersResult.h Normal file
View File

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

57
ens/include/alibabacloud/ens/model/AddDeviceInternetPortRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_ADDDEVICEINTERNETPORTREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_ADDDEVICEINTERNETPORTREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT AddDeviceInternetPortRequest : public RpcServiceRequest {
public:
AddDeviceInternetPortRequest();
~AddDeviceInternetPortRequest();
std::string getISP() const;
void setISP(const std::string &iSP);
std::string getInternalIp() const;
void setInternalIp(const std::string &internalIp);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getNatType() const;
void setNatType(const std::string &natType);
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
std::string getInternalPort() const;
void setInternalPort(const std::string &internalPort);
private:
std::string iSP_;
std::string internalIp_;
std::string regionId_;
std::string natType_;
std::string instanceId_;
std::string internalPort_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_ADDDEVICEINTERNETPORTREQUEST_H_

51
ens/include/alibabacloud/ens/model/AddDeviceInternetPortResult.h Normal file
View File

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

48
ens/include/alibabacloud/ens/model/AddNetworkInterfaceToInstanceRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_ADDNETWORKINTERFACETOINSTANCEREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_ADDNETWORKINTERFACETOINSTANCEREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT AddNetworkInterfaceToInstanceRequest : public RpcServiceRequest {
public:
AddNetworkInterfaceToInstanceRequest();
~AddNetworkInterfaceToInstanceRequest();
std::string getNetworks() const;
void setNetworks(const std::string &networks);
bool getAutoStart() const;
void setAutoStart(bool autoStart);
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
private:
std::string networks_;
bool autoStart_;
std::string instanceId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_ADDNETWORKINTERFACETOINSTANCEREQUEST_H_

49
ens/include/alibabacloud/ens/model/AddNetworkInterfaceToInstanceResult.h Normal file
View File

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

48
ens/include/alibabacloud/ens/model/AllocateEipAddressRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_ALLOCATEEIPADDRESSREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_ALLOCATEEIPADDRESSREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT AllocateEipAddressRequest : public RpcServiceRequest {
public:
AllocateEipAddressRequest();
~AllocateEipAddressRequest();
int getMinCount() const;
void setMinCount(int minCount);
std::string getEnsRegionId() const;
void setEnsRegionId(const std::string &ensRegionId);
int getCount() const;
void setCount(int count);
private:
int minCount_;
std::string ensRegionId_;
int count_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_ALLOCATEEIPADDRESSREQUEST_H_

57
ens/include/alibabacloud/ens/model/AllocateEipAddressResult.h Normal file
View File

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

48
ens/include/alibabacloud/ens/model/AssociateEipAddressRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_ASSOCIATEEIPADDRESSREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_ASSOCIATEEIPADDRESSREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT AssociateEipAddressRequest : public RpcServiceRequest {
public:
AssociateEipAddressRequest();
~AssociateEipAddressRequest();
std::string getEip() const;
void setEip(const std::string &eip);
std::string getEnsRegionId() const;
void setEnsRegionId(const std::string &ensRegionId);
std::string getInstanceIdInternetIp() const;
void setInstanceIdInternetIp(const std::string &instanceIdInternetIp);
private:
std::string eip_;
std::string ensRegionId_;
std::string instanceIdInternetIp_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_ASSOCIATEEIPADDRESSREQUEST_H_

49
ens/include/alibabacloud/ens/model/AssociateEipAddressResult.h Normal file
View File

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

48
ens/include/alibabacloud/ens/model/AssociateEnsEipAddressRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_ASSOCIATEENSEIPADDRESSREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_ASSOCIATEENSEIPADDRESSREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT AssociateEnsEipAddressRequest : public RpcServiceRequest {
public:
AssociateEnsEipAddressRequest();
~AssociateEnsEipAddressRequest();
std::string getAllocationId() const;
void setAllocationId(const std::string &allocationId);
std::string getInstanceType() const;
void setInstanceType(const std::string &instanceType);
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
private:
std::string allocationId_;
std::string instanceType_;
std::string instanceId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_ASSOCIATEENSEIPADDRESSREQUEST_H_

49
ens/include/alibabacloud/ens/model/AssociateEnsEipAddressResult.h Normal file
View File

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

48
ens/include/alibabacloud/ens/model/AttachDiskRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_ATTACHDISKREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_ATTACHDISKREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT AttachDiskRequest : public RpcServiceRequest {
public:
AttachDiskRequest();
~AttachDiskRequest();
std::string getDiskId() const;
void setDiskId(const std::string &diskId);
std::string getDeleteWithInstance() const;
void setDeleteWithInstance(const std::string &deleteWithInstance);
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
private:
std::string diskId_;
std::string deleteWithInstance_;
std::string instanceId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_ATTACHDISKREQUEST_H_

51
ens/include/alibabacloud/ens/model/AttachDiskResult.h Normal file
View File

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

45
ens/include/alibabacloud/ens/model/AttachEnsInstancesRequest.h Normal file
View File

@@ -0,0 +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_ENS_MODEL_ATTACHENSINSTANCESREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_ATTACHENSINSTANCESREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT AttachEnsInstancesRequest : public RpcServiceRequest {
public:
AttachEnsInstancesRequest();
~AttachEnsInstancesRequest();
std::string getScripts() const;
void setScripts(const std::string &scripts);
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
private:
std::string scripts_;
std::string instanceId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_ATTACHENSINSTANCESREQUEST_H_

49
ens/include/alibabacloud/ens/model/AttachEnsInstancesResult.h Normal file
View File

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

60
ens/include/alibabacloud/ens/model/AuthorizeSecurityGroupEgressRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_AUTHORIZESECURITYGROUPEGRESSREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_AUTHORIZESECURITYGROUPEGRESSREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT AuthorizeSecurityGroupEgressRequest : public RpcServiceRequest {
public:
AuthorizeSecurityGroupEgressRequest();
~AuthorizeSecurityGroupEgressRequest();
std::string getSourcePortRange() const;
void setSourcePortRange(const std::string &sourcePortRange);
std::string getPortRange() const;
void setPortRange(const std::string &portRange);
std::string getIpProtocol() const;
void setIpProtocol(const std::string &ipProtocol);
int getPriority() const;
void setPriority(int priority);
std::string getDestCidrIp() const;
void setDestCidrIp(const std::string &destCidrIp);
std::string getSecurityGroupId() const;
void setSecurityGroupId(const std::string &securityGroupId);
std::string getPolicy() const;
void setPolicy(const std::string &policy);
private:
std::string sourcePortRange_;
std::string portRange_;
std::string ipProtocol_;
int priority_;
std::string destCidrIp_;
std::string securityGroupId_;
std::string policy_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_AUTHORIZESECURITYGROUPEGRESSREQUEST_H_

49
ens/include/alibabacloud/ens/model/AuthorizeSecurityGroupEgressResult.h Normal file
View File

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

60
ens/include/alibabacloud/ens/model/AuthorizeSecurityGroupRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_AUTHORIZESECURITYGROUPREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_AUTHORIZESECURITYGROUPREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT AuthorizeSecurityGroupRequest : public RpcServiceRequest {
public:
AuthorizeSecurityGroupRequest();
~AuthorizeSecurityGroupRequest();
std::string getSourcePortRange() const;
void setSourcePortRange(const std::string &sourcePortRange);
std::string getPortRange() const;
void setPortRange(const std::string &portRange);
std::string getIpProtocol() const;
void setIpProtocol(const std::string &ipProtocol);
std::string getSourceCidrIp() const;
void setSourceCidrIp(const std::string &sourceCidrIp);
int getPriority() const;
void setPriority(int priority);
std::string getSecurityGroupId() const;
void setSecurityGroupId(const std::string &securityGroupId);
std::string getPolicy() const;
void setPolicy(const std::string &policy);
private:
std::string sourcePortRange_;
std::string portRange_;
std::string ipProtocol_;
std::string sourceCidrIp_;
int priority_;
std::string securityGroupId_;
std::string policy_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_AUTHORIZESECURITYGROUPREQUEST_H_

49
ens/include/alibabacloud/ens/model/AuthorizeSecurityGroupResult.h Normal file
View File

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

48
ens/include/alibabacloud/ens/model/CheckQuotaRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_CHECKQUOTAREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CHECKQUOTAREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CheckQuotaRequest : public RpcServiceRequest {
public:
CheckQuotaRequest();
~CheckQuotaRequest();
std::string getGroupUuid() const;
void setGroupUuid(const std::string &groupUuid);
std::string getResourceAttribute() const;
void setResourceAttribute(const std::string &resourceAttribute);
long getAliUid() const;
void setAliUid(long aliUid);
private:
std::string groupUuid_;
std::string resourceAttribute_;
long aliUid_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CHECKQUOTAREQUEST_H_

57
ens/include/alibabacloud/ens/model/CheckQuotaResult.h Normal file
View File

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

69
ens/include/alibabacloud/ens/model/ConfigureSecurityGroupPermissionsRequest.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_CONFIGURESECURITYGROUPPERMISSIONSREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CONFIGURESECURITYGROUPPERMISSIONSREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT ConfigureSecurityGroupPermissionsRequest : public RpcServiceRequest {
public:
struct RevokePermissions {
std::string sourcePortRange;
std::string portRange;
std::string ipProtocol;
std::string sourceCidrIp;
int priority;
std::string destCidrIp;
std::string direction;
std::string policy;
};
struct AuthorizePermissions {
std::string sourcePortRange;
std::string portRange;
std::string ipProtocol;
std::string sourceCidrIp;
std::string description;
int priority;
std::string destCidrIp;
std::string direction;
std::string policy;
};
ConfigureSecurityGroupPermissionsRequest();
~ConfigureSecurityGroupPermissionsRequest();
std::string getSecurityGroupId() const;
void setSecurityGroupId(const std::string &securityGroupId);
std::vector<RevokePermissions> getRevokePermissions() const;
void setRevokePermissions(const std::vector<RevokePermissions> &revokePermissions);
std::vector<AuthorizePermissions> getAuthorizePermissions() const;
void setAuthorizePermissions(const std::vector<AuthorizePermissions> &authorizePermissions);
private:
std::string securityGroupId_;
std::vector<RevokePermissions> revokePermissions_;
std::vector<AuthorizePermissions> authorizePermissions_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CONFIGURESECURITYGROUPPERMISSIONSREQUEST_H_

49
ens/include/alibabacloud/ens/model/ConfigureSecurityGroupPermissionsResult.h Normal file
View File

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

45
ens/include/alibabacloud/ens/model/CreateApplicationRequest.h Normal file
View File

@@ -0,0 +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_ENS_MODEL_CREATEAPPLICATIONREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATEAPPLICATIONREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateApplicationRequest : public RpcServiceRequest {
public:
CreateApplicationRequest();
~CreateApplicationRequest();
std::string get_Template() const;
void set_Template(const std::string &_template);
int getTimeout() const;
void setTimeout(int timeout);
private:
std::string _template_;
int timeout_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATEAPPLICATIONREQUEST_H_

51
ens/include/alibabacloud/ens/model/CreateApplicationResult.h Normal file
View File

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

42
ens/include/alibabacloud/ens/model/CreateDiskBuyOrderRequest.h Normal file
View File

@@ -0,0 +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_ENS_MODEL_CREATEDISKBUYORDERREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATEDISKBUYORDERREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateDiskBuyOrderRequest : public RpcServiceRequest {
public:
CreateDiskBuyOrderRequest();
~CreateDiskBuyOrderRequest();
std::string getOrderDetails() const;
void setOrderDetails(const std::string &orderDetails);
private:
std::string orderDetails_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATEDISKBUYORDERREQUEST_H_

51
ens/include/alibabacloud/ens/model/CreateDiskBuyOrderResult.h Normal file
View File

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

51
ens/include/alibabacloud/ens/model/CreateDiskRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_CREATEDISKREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATEDISKREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateDiskRequest : public RpcServiceRequest {
public:
CreateDiskRequest();
~CreateDiskRequest();
std::string getEnsRegionId() const;
void setEnsRegionId(const std::string &ensRegionId);
std::string getInstanceChargeType() const;
void setInstanceChargeType(const std::string &instanceChargeType);
std::string getSize() const;
void setSize(const std::string &size);
std::string getCategory() const;
void setCategory(const std::string &category);
private:
std::string ensRegionId_;
std::string instanceChargeType_;
std::string size_;
std::string category_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATEDISKREQUEST_H_

53
ens/include/alibabacloud/ens/model/CreateDiskResult.h Normal file
View File

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

54
ens/include/alibabacloud/ens/model/CreateEPInstanceRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_CREATEEPINSTANCEREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATEEPINSTANCEREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateEPInstanceRequest : public RpcServiceRequest {
public:
CreateEPInstanceRequest();
~CreateEPInstanceRequest();
std::string getNetworkingModel() const;
void setNetworkingModel(const std::string &networkingModel);
int getInternetMaxBandwidthOut() const;
void setInternetMaxBandwidthOut(int internetMaxBandwidthOut);
std::string getEPNInstanceType() const;
void setEPNInstanceType(const std::string &ePNInstanceType);
std::string getInternetChargeType() const;
void setInternetChargeType(const std::string &internetChargeType);
std::string getEPNInstanceName() const;
void setEPNInstanceName(const std::string &ePNInstanceName);
private:
std::string networkingModel_;
int internetMaxBandwidthOut_;
std::string ePNInstanceType_;
std::string internetChargeType_;
std::string ePNInstanceName_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATEEPINSTANCEREQUEST_H_

51
ens/include/alibabacloud/ens/model/CreateEPInstanceResult.h Normal file
View File

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

57
ens/include/alibabacloud/ens/model/CreateEipInstanceRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_CREATEEIPINSTANCEREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATEEIPINSTANCEREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateEipInstanceRequest : public RpcServiceRequest {
public:
CreateEipInstanceRequest();
~CreateEipInstanceRequest();
std::string getIsp() const;
void setIsp(const std::string &isp);
std::string getEnsRegionId() const;
void setEnsRegionId(const std::string &ensRegionId);
std::string getInstanceChargeType() const;
void setInstanceChargeType(const std::string &instanceChargeType);
long getBandwidth() const;
void setBandwidth(long bandwidth);
std::string getInternetChargeType() const;
void setInternetChargeType(const std::string &internetChargeType);
std::string getName() const;
void setName(const std::string &name);
private:
std::string isp_;
std::string ensRegionId_;
std::string instanceChargeType_;
long bandwidth_;
std::string internetChargeType_;
std::string name_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATEEIPINSTANCEREQUEST_H_

51
ens/include/alibabacloud/ens/model/CreateEipInstanceResult.h Normal file
View File

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

42
ens/include/alibabacloud/ens/model/CreateElbBuyOrderRequest.h Normal file
View File

@@ -0,0 +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_ENS_MODEL_CREATEELBBUYORDERREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATEELBBUYORDERREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateElbBuyOrderRequest : public RpcServiceRequest {
public:
CreateElbBuyOrderRequest();
~CreateElbBuyOrderRequest();
std::string getOrderDetails() const;
void setOrderDetails(const std::string &orderDetails);
private:
std::string orderDetails_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATEELBBUYORDERREQUEST_H_

51
ens/include/alibabacloud/ens/model/CreateElbBuyOrderResult.h Normal file
View File

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

45
ens/include/alibabacloud/ens/model/CreateEnsServiceRequest.h Normal file
View File

@@ -0,0 +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_ENS_MODEL_CREATEENSSERVICEREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATEENSSERVICEREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateEnsServiceRequest : public RpcServiceRequest {
public:
CreateEnsServiceRequest();
~CreateEnsServiceRequest();
std::string getEnsServiceId() const;
void setEnsServiceId(const std::string &ensServiceId);
std::string getOrderType() const;
void setOrderType(const std::string &orderType);
private:
std::string ensServiceId_;
std::string orderType_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATEENSSERVICEREQUEST_H_

51
ens/include/alibabacloud/ens/model/CreateEnsServiceResult.h Normal file
View File

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

54
ens/include/alibabacloud/ens/model/CreateEpnInstanceRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_CREATEEPNINSTANCEREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATEEPNINSTANCEREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateEpnInstanceRequest : public RpcServiceRequest {
public:
CreateEpnInstanceRequest();
~CreateEpnInstanceRequest();
std::string getNetworkingModel() const;
void setNetworkingModel(const std::string &networkingModel);
int getInternetMaxBandwidthOut() const;
void setInternetMaxBandwidthOut(int internetMaxBandwidthOut);
std::string getEPNInstanceType() const;
void setEPNInstanceType(const std::string &ePNInstanceType);
std::string getInternetChargeType() const;
void setInternetChargeType(const std::string &internetChargeType);
std::string getEPNInstanceName() const;
void setEPNInstanceName(const std::string &ePNInstanceName);
private:
std::string networkingModel_;
int internetMaxBandwidthOut_;
std::string ePNInstanceType_;
std::string internetChargeType_;
std::string ePNInstanceName_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATEEPNINSTANCEREQUEST_H_

51
ens/include/alibabacloud/ens/model/CreateEpnInstanceResult.h Normal file
View File

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

51
ens/include/alibabacloud/ens/model/CreateImageRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_CREATEIMAGEREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATEIMAGEREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateImageRequest : public RpcServiceRequest {
public:
CreateImageRequest();
~CreateImageRequest();
std::string getDeleteAfterImageUpload() const;
void setDeleteAfterImageUpload(const std::string &deleteAfterImageUpload);
std::string getImageName() const;
void setImageName(const std::string &imageName);
std::string getProduct() const;
void setProduct(const std::string &product);
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
private:
std::string deleteAfterImageUpload_;
std::string imageName_;
std::string product_;
std::string instanceId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATEIMAGEREQUEST_H_

53
ens/include/alibabacloud/ens/model/CreateImageResult.h Normal file
View File

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

105
ens/include/alibabacloud/ens/model/CreateInstanceRequest.h Normal file
View File

@@ -0,0 +1,105 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_ENS_MODEL_CREATEINSTANCEREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATEINSTANCEREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateInstanceRequest : public RpcServiceRequest {
public:
CreateInstanceRequest();
~CreateInstanceRequest();
bool getUniqueSuffix() const;
void setUniqueSuffix(bool uniqueSuffix);
std::string getKeyPairName() const;
void setKeyPairName(const std::string &keyPairName);
std::string getPassword() const;
void setPassword(const std::string &password);
std::string getHostName() const;
void setHostName(const std::string &hostName);
std::string getEnsRegionId() const;
void setEnsRegionId(const std::string &ensRegionId);
std::string getAutoRenewPeriod() const;
void setAutoRenewPeriod(const std::string &autoRenewPeriod);
std::string getPeriod() const;
void setPeriod(const std::string &period);
bool getPublicIpIdentification() const;
void setPublicIpIdentification(bool publicIpIdentification);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getVSwitchId() const;
void setVSwitchId(const std::string &vSwitchId);
std::string getPrivateIpAddress() const;
void setPrivateIpAddress(const std::string &privateIpAddress);
std::string getInstanceName() const;
void setInstanceName(const std::string &instanceName);
std::string getAutoRenew() const;
void setAutoRenew(const std::string &autoRenew);
std::string getInternetChargeType() const;
void setInternetChargeType(const std::string &internetChargeType);
std::string getImageId() const;
void setImageId(const std::string &imageId);
std::string getUserData() const;
void setUserData(const std::string &userData);
std::string getInstanceType() const;
void setInstanceType(const std::string &instanceType);
std::string getDataDisk1Size() const;
void setDataDisk1Size(const std::string &dataDisk1Size);
std::string getQuantity() const;
void setQuantity(const std::string &quantity);
std::string getIpType() const;
void setIpType(const std::string &ipType);
std::string getSystemDiskSize() const;
void setSystemDiskSize(const std::string &systemDiskSize);
std::string getPaymentType() const;
void setPaymentType(const std::string &paymentType);
private:
bool uniqueSuffix_;
std::string keyPairName_;
std::string password_;
std::string hostName_;
std::string ensRegionId_;
std::string autoRenewPeriod_;
std::string period_;
bool publicIpIdentification_;
long ownerId_;
std::string vSwitchId_;
std::string privateIpAddress_;
std::string instanceName_;
std::string autoRenew_;
std::string internetChargeType_;
std::string imageId_;
std::string userData_;
std::string instanceType_;
std::string dataDisk1Size_;
std::string quantity_;
std::string ipType_;
std::string systemDiskSize_;
std::string paymentType_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATEINSTANCEREQUEST_H_

53
ens/include/alibabacloud/ens/model/CreateInstanceResult.h Normal file
View File

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

42
ens/include/alibabacloud/ens/model/CreateKeyPairRequest.h Normal file
View File

@@ -0,0 +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_ENS_MODEL_CREATEKEYPAIRREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATEKEYPAIRREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateKeyPairRequest : public RpcServiceRequest {
public:
CreateKeyPairRequest();
~CreateKeyPairRequest();
std::string getKeyPairName() const;
void setKeyPairName(const std::string &keyPairName);
private:
std::string keyPairName_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATEKEYPAIRREQUEST_H_

57
ens/include/alibabacloud/ens/model/CreateKeyPairResult.h Normal file
View File

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

111
ens/include/alibabacloud/ens/model/CreateLoadBalancerHTTPListenerRequest.h Normal file
View File

@@ -0,0 +1,111 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_ENS_MODEL_CREATELOADBALANCERHTTPLISTENERREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATELOADBALANCERHTTPLISTENERREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateLoadBalancerHTTPListenerRequest : public RpcServiceRequest {
public:
CreateLoadBalancerHTTPListenerRequest();
~CreateLoadBalancerHTTPListenerRequest();
std::string getListenerForward() const;
void setListenerForward(const std::string &listenerForward);
int getHealthCheckTimeout() const;
void setHealthCheckTimeout(int healthCheckTimeout);
std::string getXForwardedFor() const;
void setXForwardedFor(const std::string &xForwardedFor);
std::string getHealthCheckURI() const;
void setHealthCheckURI(const std::string &healthCheckURI);
std::string getHealthCheck() const;
void setHealthCheck(const std::string &healthCheck);
std::string getProtocol() const;
void setProtocol(const std::string &protocol);
std::string getCookie() const;
void setCookie(const std::string &cookie);
std::string getHealthCheckMethod() const;
void setHealthCheckMethod(const std::string &healthCheckMethod);
std::string getHealthCheckDomain() const;
void setHealthCheckDomain(const std::string &healthCheckDomain);
int getRequestTimeout() const;
void setRequestTimeout(int requestTimeout);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
int getHealthCheckInterval() const;
void setHealthCheckInterval(int healthCheckInterval);
std::string getDescription() const;
void setDescription(const std::string &description);
int getUnhealthyThreshold() const;
void setUnhealthyThreshold(int unhealthyThreshold);
int getHealthyThreshold() const;
void setHealthyThreshold(int healthyThreshold);
std::string getScheduler() const;
void setScheduler(const std::string &scheduler);
int getForwardPort() const;
void setForwardPort(int forwardPort);
int getCookieTimeout() const;
void setCookieTimeout(int cookieTimeout);
std::string getStickySessionType() const;
void setStickySessionType(const std::string &stickySessionType);
int getListenerPort() const;
void setListenerPort(int listenerPort);
std::string getStickySession() const;
void setStickySession(const std::string &stickySession);
int getIdleTimeout() const;
void setIdleTimeout(int idleTimeout);
int getHealthCheckConnectPort() const;
void setHealthCheckConnectPort(int healthCheckConnectPort);
std::string getHealthCheckHttpCode() const;
void setHealthCheckHttpCode(const std::string &healthCheckHttpCode);
private:
std::string listenerForward_;
int healthCheckTimeout_;
std::string xForwardedFor_;
std::string healthCheckURI_;
std::string healthCheck_;
std::string protocol_;
std::string cookie_;
std::string healthCheckMethod_;
std::string healthCheckDomain_;
int requestTimeout_;
std::string loadBalancerId_;
int healthCheckInterval_;
std::string description_;
int unhealthyThreshold_;
int healthyThreshold_;
std::string scheduler_;
int forwardPort_;
int cookieTimeout_;
std::string stickySessionType_;
int listenerPort_;
std::string stickySession_;
int idleTimeout_;
int healthCheckConnectPort_;
std::string healthCheckHttpCode_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATELOADBALANCERHTTPLISTENERREQUEST_H_

49
ens/include/alibabacloud/ens/model/CreateLoadBalancerHTTPListenerResult.h Normal file
View File

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

111
ens/include/alibabacloud/ens/model/CreateLoadBalancerHTTPSListenerRequest.h Normal file
View File

@@ -0,0 +1,111 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_ENS_MODEL_CREATELOADBALANCERHTTPSLISTENERREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATELOADBALANCERHTTPSLISTENERREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateLoadBalancerHTTPSListenerRequest : public RpcServiceRequest {
public:
CreateLoadBalancerHTTPSListenerRequest();
~CreateLoadBalancerHTTPSListenerRequest();
std::string getListenerForward() const;
void setListenerForward(const std::string &listenerForward);
int getHealthCheckTimeout() const;
void setHealthCheckTimeout(int healthCheckTimeout);
std::string getHealthCheckURI() const;
void setHealthCheckURI(const std::string &healthCheckURI);
std::string getHealthCheck() const;
void setHealthCheck(const std::string &healthCheck);
std::string getProtocol() const;
void setProtocol(const std::string &protocol);
std::string getCookie() const;
void setCookie(const std::string &cookie);
std::string getHealthCheckMethod() const;
void setHealthCheckMethod(const std::string &healthCheckMethod);
std::string getHealthCheckDomain() const;
void setHealthCheckDomain(const std::string &healthCheckDomain);
int getRequestTimeout() const;
void setRequestTimeout(int requestTimeout);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
int getHealthCheckInterval() const;
void setHealthCheckInterval(int healthCheckInterval);
std::string getDescription() const;
void setDescription(const std::string &description);
int getUnhealthyThreshold() const;
void setUnhealthyThreshold(int unhealthyThreshold);
int getHealthyThreshold() const;
void setHealthyThreshold(int healthyThreshold);
std::string getScheduler() const;
void setScheduler(const std::string &scheduler);
int getForwardPort() const;
void setForwardPort(int forwardPort);
int getCookieTimeout() const;
void setCookieTimeout(int cookieTimeout);
std::string getStickySessionType() const;
void setStickySessionType(const std::string &stickySessionType);
int getListenerPort() const;
void setListenerPort(int listenerPort);
std::string getStickySession() const;
void setStickySession(const std::string &stickySession);
std::string getServerCertificateId() const;
void setServerCertificateId(const std::string &serverCertificateId);
int getIdleTimeout() const;
void setIdleTimeout(int idleTimeout);
int getHealthCheckConnectPort() const;
void setHealthCheckConnectPort(int healthCheckConnectPort);
std::string getHealthCheckHttpCode() const;
void setHealthCheckHttpCode(const std::string &healthCheckHttpCode);
private:
std::string listenerForward_;
int healthCheckTimeout_;
std::string healthCheckURI_;
std::string healthCheck_;
std::string protocol_;
std::string cookie_;
std::string healthCheckMethod_;
std::string healthCheckDomain_;
int requestTimeout_;
std::string loadBalancerId_;
int healthCheckInterval_;
std::string description_;
int unhealthyThreshold_;
int healthyThreshold_;
std::string scheduler_;
int forwardPort_;
int cookieTimeout_;
std::string stickySessionType_;
int listenerPort_;
std::string stickySession_;
std::string serverCertificateId_;
int idleTimeout_;
int healthCheckConnectPort_;
std::string healthCheckHttpCode_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATELOADBALANCERHTTPSLISTENERREQUEST_H_

49
ens/include/alibabacloud/ens/model/CreateLoadBalancerHTTPSListenerResult.h Normal file
View File

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

57
ens/include/alibabacloud/ens/model/CreateLoadBalancerRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_CREATELOADBALANCERREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATELOADBALANCERREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateLoadBalancerRequest : public RpcServiceRequest {
public:
CreateLoadBalancerRequest();
~CreateLoadBalancerRequest();
std::string getLoadBalancerName() const;
void setLoadBalancerName(const std::string &loadBalancerName);
std::string getEnsRegionId() const;
void setEnsRegionId(const std::string &ensRegionId);
std::string getLoadBalancerSpec() const;
void setLoadBalancerSpec(const std::string &loadBalancerSpec);
std::string getVSwitchId() const;
void setVSwitchId(const std::string &vSwitchId);
std::string getNetworkId() const;
void setNetworkId(const std::string &networkId);
std::string getPayType() const;
void setPayType(const std::string &payType);
private:
std::string loadBalancerName_;
std::string ensRegionId_;
std::string loadBalancerSpec_;
std::string vSwitchId_;
std::string networkId_;
std::string payType_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATELOADBALANCERREQUEST_H_

57
ens/include/alibabacloud/ens/model/CreateLoadBalancerResult.h Normal file
View File

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

93
ens/include/alibabacloud/ens/model/CreateLoadBalancerTCPListenerRequest.h Normal file
View File

@@ -0,0 +1,93 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_ENS_MODEL_CREATELOADBALANCERTCPLISTENERREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATELOADBALANCERTCPLISTENERREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateLoadBalancerTCPListenerRequest : public RpcServiceRequest {
public:
CreateLoadBalancerTCPListenerRequest();
~CreateLoadBalancerTCPListenerRequest();
std::string getHealthCheckURI() const;
void setHealthCheckURI(const std::string &healthCheckURI);
std::string getProtocol() const;
void setProtocol(const std::string &protocol);
int getEstablishedTimeout() const;
void setEstablishedTimeout(int establishedTimeout);
int getPersistenceTimeout() const;
void setPersistenceTimeout(int persistenceTimeout);
std::string getHealthCheckDomain() const;
void setHealthCheckDomain(const std::string &healthCheckDomain);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
int getHealthCheckInterval() const;
void setHealthCheckInterval(int healthCheckInterval);
int getBackendServerPort() const;
void setBackendServerPort(int backendServerPort);
int getHealthCheckConnectTimeout() const;
void setHealthCheckConnectTimeout(int healthCheckConnectTimeout);
std::string getDescription() const;
void setDescription(const std::string &description);
int getUnhealthyThreshold() const;
void setUnhealthyThreshold(int unhealthyThreshold);
int getHealthyThreshold() const;
void setHealthyThreshold(int healthyThreshold);
std::string getScheduler() const;
void setScheduler(const std::string &scheduler);
std::string getEipTransmit() const;
void setEipTransmit(const std::string &eipTransmit);
int getListenerPort() const;
void setListenerPort(int listenerPort);
std::string getHealthCheckType() const;
void setHealthCheckType(const std::string &healthCheckType);
std::string getHealthCheckHttpCode() const;
void setHealthCheckHttpCode(const std::string &healthCheckHttpCode);
int getHealthCheckConnectPort() const;
void setHealthCheckConnectPort(int healthCheckConnectPort);
private:
std::string healthCheckURI_;
std::string protocol_;
int establishedTimeout_;
int persistenceTimeout_;
std::string healthCheckDomain_;
std::string loadBalancerId_;
int healthCheckInterval_;
int backendServerPort_;
int healthCheckConnectTimeout_;
std::string description_;
int unhealthyThreshold_;
int healthyThreshold_;
std::string scheduler_;
std::string eipTransmit_;
int listenerPort_;
std::string healthCheckType_;
std::string healthCheckHttpCode_;
int healthCheckConnectPort_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATELOADBALANCERTCPLISTENERREQUEST_H_

49
ens/include/alibabacloud/ens/model/CreateLoadBalancerTCPListenerResult.h Normal file
View File

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

81
ens/include/alibabacloud/ens/model/CreateLoadBalancerUDPListenerRequest.h Normal file
View File

@@ -0,0 +1,81 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_CREATELOADBALANCERUDPLISTENERREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATELOADBALANCERUDPLISTENERREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateLoadBalancerUDPListenerRequest : public RpcServiceRequest {
public:
CreateLoadBalancerUDPListenerRequest();
~CreateLoadBalancerUDPListenerRequest();
std::string getProtocol() const;
void setProtocol(const std::string &protocol);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
std::string getHealthCheckReq() const;
void setHealthCheckReq(const std::string &healthCheckReq);
int getHealthCheckInterval() const;
void setHealthCheckInterval(int healthCheckInterval);
int getBackendServerPort() const;
void setBackendServerPort(int backendServerPort);
std::string getHealthCheckExp() const;
void setHealthCheckExp(const std::string &healthCheckExp);
int getHealthCheckConnectTimeout() const;
void setHealthCheckConnectTimeout(int healthCheckConnectTimeout);
std::string getDescription() const;
void setDescription(const std::string &description);
int getUnhealthyThreshold() const;
void setUnhealthyThreshold(int unhealthyThreshold);
int getHealthyThreshold() const;
void setHealthyThreshold(int healthyThreshold);
std::string getScheduler() const;
void setScheduler(const std::string &scheduler);
std::string getEipTransmit() const;
void setEipTransmit(const std::string &eipTransmit);
int getListenerPort() const;
void setListenerPort(int listenerPort);
int getHealthCheckConnectPort() const;
void setHealthCheckConnectPort(int healthCheckConnectPort);
private:
std::string protocol_;
std::string loadBalancerId_;
std::string healthCheckReq_;
int healthCheckInterval_;
int backendServerPort_;
std::string healthCheckExp_;
int healthCheckConnectTimeout_;
std::string description_;
int unhealthyThreshold_;
int healthyThreshold_;
std::string scheduler_;
std::string eipTransmit_;
int listenerPort_;
int healthCheckConnectPort_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATELOADBALANCERUDPLISTENERREQUEST_H_

49
ens/include/alibabacloud/ens/model/CreateLoadBalancerUDPListenerResult.h Normal file
View File

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

51
ens/include/alibabacloud/ens/model/CreateNetworkRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_CREATENETWORKREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATENETWORKREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateNetworkRequest : public RpcServiceRequest {
public:
CreateNetworkRequest();
~CreateNetworkRequest();
std::string getDescription() const;
void setDescription(const std::string &description);
std::string getEnsRegionId() const;
void setEnsRegionId(const std::string &ensRegionId);
std::string getNetworkName() const;
void setNetworkName(const std::string &networkName);
std::string getCidrBlock() const;
void setCidrBlock(const std::string &cidrBlock);
private:
std::string description_;
std::string ensRegionId_;
std::string networkName_;
std::string cidrBlock_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATENETWORKREQUEST_H_

51
ens/include/alibabacloud/ens/model/CreateNetworkResult.h Normal file
View File

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

45
ens/include/alibabacloud/ens/model/CreateSecurityGroupRequest.h Normal file
View File

@@ -0,0 +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_ENS_MODEL_CREATESECURITYGROUPREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATESECURITYGROUPREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateSecurityGroupRequest : public RpcServiceRequest {
public:
CreateSecurityGroupRequest();
~CreateSecurityGroupRequest();
std::string getDescription() const;
void setDescription(const std::string &description);
std::string getSecurityGroupName() const;
void setSecurityGroupName(const std::string &securityGroupName);
private:
std::string description_;
std::string securityGroupName_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATESECURITYGROUPREQUEST_H_

51
ens/include/alibabacloud/ens/model/CreateSecurityGroupResult.h Normal file
View File

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

54
ens/include/alibabacloud/ens/model/CreateVSwitchRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_CREATEVSWITCHREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATEVSWITCHREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateVSwitchRequest : public RpcServiceRequest {
public:
CreateVSwitchRequest();
~CreateVSwitchRequest();
std::string getDescription() const;
void setDescription(const std::string &description);
std::string getEnsRegionId() const;
void setEnsRegionId(const std::string &ensRegionId);
std::string getVSwitchName() const;
void setVSwitchName(const std::string &vSwitchName);
std::string getCidrBlock() const;
void setCidrBlock(const std::string &cidrBlock);
std::string getNetworkId() const;
void setNetworkId(const std::string &networkId);
private:
std::string description_;
std::string ensRegionId_;
std::string vSwitchName_;
std::string cidrBlock_;
std::string networkId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATEVSWITCHREQUEST_H_

51
ens/include/alibabacloud/ens/model/CreateVSwitchResult.h Normal file
View File

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

54
ens/include/alibabacloud/ens/model/CreateVmAndSaveStockRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_CREATEVMANDSAVESTOCKREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_CREATEVMANDSAVESTOCKREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT CreateVmAndSaveStockRequest : public RpcServiceRequest {
public:
CreateVmAndSaveStockRequest();
~CreateVmAndSaveStockRequest();
std::string getGroupUuid() const;
void setGroupUuid(const std::string &groupUuid);
std::string getResourceAttribute() const;
void setResourceAttribute(const std::string &resourceAttribute);
long getAliUid() const;
void setAliUid(long aliUid);
std::string getTenant() const;
void setTenant(const std::string &tenant);
std::string getWorkloadUuid() const;
void setWorkloadUuid(const std::string &workloadUuid);
private:
std::string groupUuid_;
std::string resourceAttribute_;
long aliUid_;
std::string tenant_;
std::string workloadUuid_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_CREATEVMANDSAVESTOCKREQUEST_H_

57
ens/include/alibabacloud/ens/model/CreateVmAndSaveStockResult.h Normal file
View File

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

45
ens/include/alibabacloud/ens/model/DeleteApplicationRequest.h Normal file
View File

@@ -0,0 +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_ENS_MODEL_DELETEAPPLICATIONREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DELETEAPPLICATIONREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DeleteApplicationRequest : public RpcServiceRequest {
public:
DeleteApplicationRequest();
~DeleteApplicationRequest();
int getTimeout() const;
void setTimeout(int timeout);
std::string getAppId() const;
void setAppId(const std::string &appId);
private:
int timeout_;
std::string appId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DELETEAPPLICATIONREQUEST_H_

49
ens/include/alibabacloud/ens/model/DeleteApplicationResult.h Normal file
View File

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

48
ens/include/alibabacloud/ens/model/DeleteDeviceInternetPortRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_DELETEDEVICEINTERNETPORTREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DELETEDEVICEINTERNETPORTREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DeleteDeviceInternetPortRequest : public RpcServiceRequest {
public:
DeleteDeviceInternetPortRequest();
~DeleteDeviceInternetPortRequest();
std::string getNatType() const;
void setNatType(const std::string &natType);
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
std::string getRuleId() const;
void setRuleId(const std::string &ruleId);
private:
std::string natType_;
std::string instanceId_;
std::string ruleId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DELETEDEVICEINTERNETPORTREQUEST_H_

51
ens/include/alibabacloud/ens/model/DeleteDeviceInternetPortResult.h Normal file
View File

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

42
ens/include/alibabacloud/ens/model/DeleteEpnInstanceRequest.h Normal file
View File

@@ -0,0 +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_ENS_MODEL_DELETEEPNINSTANCEREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DELETEEPNINSTANCEREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DeleteEpnInstanceRequest : public RpcServiceRequest {
public:
DeleteEpnInstanceRequest();
~DeleteEpnInstanceRequest();
std::string getEPNInstanceId() const;
void setEPNInstanceId(const std::string &ePNInstanceId);
private:
std::string ePNInstanceId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DELETEEPNINSTANCEREQUEST_H_

49
ens/include/alibabacloud/ens/model/DeleteEpnInstanceResult.h Normal file
View File

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

42
ens/include/alibabacloud/ens/model/DeleteKeyPairsRequest.h Normal file
View File

@@ -0,0 +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_ENS_MODEL_DELETEKEYPAIRSREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DELETEKEYPAIRSREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DeleteKeyPairsRequest : public RpcServiceRequest {
public:
DeleteKeyPairsRequest();
~DeleteKeyPairsRequest();
std::string getKeyPairName() const;
void setKeyPairName(const std::string &keyPairName);
private:
std::string keyPairName_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DELETEKEYPAIRSREQUEST_H_

49
ens/include/alibabacloud/ens/model/DeleteKeyPairsResult.h Normal file
View File

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

45
ens/include/alibabacloud/ens/model/DeleteLoadBalancerListenerRequest.h Normal file
View File

@@ -0,0 +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_ENS_MODEL_DELETELOADBALANCERLISTENERREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DELETELOADBALANCERLISTENERREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DeleteLoadBalancerListenerRequest : public RpcServiceRequest {
public:
DeleteLoadBalancerListenerRequest();
~DeleteLoadBalancerListenerRequest();
int getListenerPort() const;
void setListenerPort(int listenerPort);
std::string getLoadBalancerId() const;
void setLoadBalancerId(const std::string &loadBalancerId);
private:
int listenerPort_;
std::string loadBalancerId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DELETELOADBALANCERLISTENERREQUEST_H_

49
ens/include/alibabacloud/ens/model/DeleteLoadBalancerListenerResult.h Normal file
View File

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

42
ens/include/alibabacloud/ens/model/DeleteNetworkRequest.h Normal file
View File

@@ -0,0 +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_ENS_MODEL_DELETENETWORKREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DELETENETWORKREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DeleteNetworkRequest : public RpcServiceRequest {
public:
DeleteNetworkRequest();
~DeleteNetworkRequest();
std::string getNetworkId() const;
void setNetworkId(const std::string &networkId);
private:
std::string networkId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DELETENETWORKREQUEST_H_

49
ens/include/alibabacloud/ens/model/DeleteNetworkResult.h Normal file
View File

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

42
ens/include/alibabacloud/ens/model/DeleteSecurityGroupRequest.h Normal file
View File

@@ -0,0 +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_ENS_MODEL_DELETESECURITYGROUPREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DELETESECURITYGROUPREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DeleteSecurityGroupRequest : public RpcServiceRequest {
public:
DeleteSecurityGroupRequest();
~DeleteSecurityGroupRequest();
std::string getSecurityGroupId() const;
void setSecurityGroupId(const std::string &securityGroupId);
private:
std::string securityGroupId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DELETESECURITYGROUPREQUEST_H_

49
ens/include/alibabacloud/ens/model/DeleteSecurityGroupResult.h Normal file
View File

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

42
ens/include/alibabacloud/ens/model/DeleteVSwitchRequest.h Normal file
View File

@@ -0,0 +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_ENS_MODEL_DELETEVSWITCHREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DELETEVSWITCHREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DeleteVSwitchRequest : public RpcServiceRequest {
public:
DeleteVSwitchRequest();
~DeleteVSwitchRequest();
std::string getVSwitchId() const;
void setVSwitchId(const std::string &vSwitchId);
private:
std::string vSwitchId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DELETEVSWITCHREQUEST_H_

49
ens/include/alibabacloud/ens/model/DeleteVSwitchResult.h Normal file
View File

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

45
ens/include/alibabacloud/ens/model/DeleteVmRequest.h Normal file
View File

@@ -0,0 +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_ENS_MODEL_DELETEVMREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DELETEVMREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DeleteVmRequest : public RpcServiceRequest {
public:
DeleteVmRequest();
~DeleteVmRequest();
long getAliUid() const;
void setAliUid(long aliUid);
std::string getWorkloadUuid() const;
void setWorkloadUuid(const std::string &workloadUuid);
private:
long aliUid_;
std::string workloadUuid_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DELETEVMREQUEST_H_

57
ens/include/alibabacloud/ens/model/DeleteVmResult.h Normal file
View File

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

51
ens/include/alibabacloud/ens/model/DescribeApplicationRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_DESCRIBEAPPLICATIONREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DESCRIBEAPPLICATIONREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DescribeApplicationRequest : public RpcServiceRequest {
public:
DescribeApplicationRequest();
~DescribeApplicationRequest();
std::string getAppVersions() const;
void setAppVersions(const std::string &appVersions);
std::string getOutDetailStatParams() const;
void setOutDetailStatParams(const std::string &outDetailStatParams);
std::string getLevel() const;
void setLevel(const std::string &level);
std::string getAppId() const;
void setAppId(const std::string &appId);
private:
std::string appVersions_;
std::string outDetailStatParams_;
std::string level_;
std::string appId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBEAPPLICATIONREQUEST_H_

45
ens/include/alibabacloud/ens/model/DescribeApplicationResourceSummaryRequest.h Normal file
View File

@@ -0,0 +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_ENS_MODEL_DESCRIBEAPPLICATIONRESOURCESUMMARYREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DESCRIBEAPPLICATIONRESOURCESUMMARYREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DescribeApplicationResourceSummaryRequest : public RpcServiceRequest {
public:
DescribeApplicationResourceSummaryRequest();
~DescribeApplicationResourceSummaryRequest();
std::string getLevel() const;
void setLevel(const std::string &level);
std::string getResourceType() const;
void setResourceType(const std::string &resourceType);
private:
std::string level_;
std::string resourceType_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBEAPPLICATIONRESOURCESUMMARYREQUEST_H_

51
ens/include/alibabacloud/ens/model/DescribeApplicationResourceSummaryResult.h Normal file
View File

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

51
ens/include/alibabacloud/ens/model/DescribeApplicationResult.h Normal file
View File

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

39
ens/include/alibabacloud/ens/model/DescribeAvailableResourceInfoRequest.h Normal file
View File

@@ -0,0 +1,39 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_ENS_MODEL_DESCRIBEAVAILABLERESOURCEINFOREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DESCRIBEAVAILABLERESOURCEINFOREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DescribeAvailableResourceInfoRequest : public RpcServiceRequest {
public:
DescribeAvailableResourceInfoRequest();
~DescribeAvailableResourceInfoRequest();
private:
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBEAVAILABLERESOURCEINFOREQUEST_H_

78
ens/include/alibabacloud/ens/model/DescribeAvailableResourceInfoResult.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_ENS_MODEL_DESCRIBEAVAILABLERESOURCEINFORESULT_H_
#define ALIBABACLOUD_ENS_MODEL_DESCRIBEAVAILABLERESOURCEINFORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ens/EnsExport.h>
namespace AlibabaCloud
{
namespace Ens
{
namespace Model
{
class ALIBABACLOUD_ENS_EXPORT DescribeAvailableResourceInfoResult : public ServiceResult
{
public:
struct Image
{
std::string imageName;
int imageSize;
std::string imageId;
};
struct SupportResource
{
struct EnsRegionId
{
std::string area;
std::string enName;
std::string ensRegionId;
std::string province;
std::string name;
};
int dataDiskMinSize;
int systemDiskMinSize;
std::vector<std::string> bandwidthTypes;
std::vector<std::string> instanceSpeces;
int systemDiskMaxSize;
std::vector<SupportResource::EnsRegionId> ensRegionIdsExtends;
int dataDiskMaxSize;
std::vector<std::string> ensRegionIds;
};
DescribeAvailableResourceInfoResult();
explicit DescribeAvailableResourceInfoResult(const std::string &payload);
~DescribeAvailableResourceInfoResult();
std::vector<Image> getImages()const;
std::vector<SupportResource> getSupportResources()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Image> images_;
std::vector<SupportResource> supportResources_;
};
}
}
}
#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBEAVAILABLERESOURCEINFORESULT_H_

39
ens/include/alibabacloud/ens/model/DescribeAvailableResourceRequest.h Normal file
View File

@@ -0,0 +1,39 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_ENS_MODEL_DESCRIBEAVAILABLERESOURCEREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DESCRIBEAVAILABLERESOURCEREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DescribeAvailableResourceRequest : public RpcServiceRequest {
public:
DescribeAvailableResourceRequest();
~DescribeAvailableResourceRequest();
private:
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBEAVAILABLERESOURCEREQUEST_H_

68
ens/include/alibabacloud/ens/model/DescribeAvailableResourceResult.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_DESCRIBEAVAILABLERESOURCERESULT_H_
#define ALIBABACLOUD_ENS_MODEL_DESCRIBEAVAILABLERESOURCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ens/EnsExport.h>
namespace AlibabaCloud
{
namespace Ens
{
namespace Model
{
class ALIBABACLOUD_ENS_EXPORT DescribeAvailableResourceResult : public ServiceResult
{
public:
struct Image
{
std::string imageName;
std::string imageId;
};
struct SupportResource
{
std::string instanceSpec;
std::string supportResourcesCount;
std::string systemDiskSize;
std::string dataDiskSize;
std::string ensRegionId;
};
DescribeAvailableResourceResult();
explicit DescribeAvailableResourceResult(const std::string &payload);
~DescribeAvailableResourceResult();
std::vector<Image> getImages()const;
std::vector<SupportResource> getSupportResources()const;
int getCode()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Image> images_;
std::vector<SupportResource> supportResources_;
int code_;
};
}
}
}
#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBEAVAILABLERESOURCERESULT_H_

39
ens/include/alibabacloud/ens/model/DescribeBandWithdChargeTypeRequest.h Normal file
View File

@@ -0,0 +1,39 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_ENS_MODEL_DESCRIBEBANDWITHDCHARGETYPEREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DESCRIBEBANDWITHDCHARGETYPEREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DescribeBandWithdChargeTypeRequest : public RpcServiceRequest {
public:
DescribeBandWithdChargeTypeRequest();
~DescribeBandWithdChargeTypeRequest();
private:
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBEBANDWITHDCHARGETYPEREQUEST_H_

57
ens/include/alibabacloud/ens/model/DescribeBandWithdChargeTypeResult.h Normal file
View File

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

51
ens/include/alibabacloud/ens/model/DescribeBandwitdhByInternetChargeTypeRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_DESCRIBEBANDWITDHBYINTERNETCHARGETYPEREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DESCRIBEBANDWITDHBYINTERNETCHARGETYPEREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DescribeBandwitdhByInternetChargeTypeRequest : public RpcServiceRequest {
public:
DescribeBandwitdhByInternetChargeTypeRequest();
~DescribeBandwitdhByInternetChargeTypeRequest();
std::string getIsp() const;
void setIsp(const std::string &isp);
std::string getStartTime() const;
void setStartTime(const std::string &startTime);
std::string getEnsRegionId() const;
void setEnsRegionId(const std::string &ensRegionId);
std::string getEndTime() const;
void setEndTime(const std::string &endTime);
private:
std::string isp_;
std::string startTime_;
std::string ensRegionId_;
std::string endTime_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBEBANDWITDHBYINTERNETCHARGETYPEREQUEST_H_

55
ens/include/alibabacloud/ens/model/DescribeBandwitdhByInternetChargeTypeResult.h Normal file
View File

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

39
ens/include/alibabacloud/ens/model/DescribeCloudDiskAvailableResourceInfoRequest.h Normal file
View File

@@ -0,0 +1,39 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_ENS_MODEL_DESCRIBECLOUDDISKAVAILABLERESOURCEINFOREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DESCRIBECLOUDDISKAVAILABLERESOURCEINFOREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DescribeCloudDiskAvailableResourceInfoRequest : public RpcServiceRequest {
public:
DescribeCloudDiskAvailableResourceInfoRequest();
~DescribeCloudDiskAvailableResourceInfoRequest();
private:
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBECLOUDDISKAVAILABLERESOURCEINFOREQUEST_H_

61
ens/include/alibabacloud/ens/model/DescribeCloudDiskAvailableResourceInfoResult.h Normal file
View File

@@ -0,0 +1,61 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_ENS_MODEL_DESCRIBECLOUDDISKAVAILABLERESOURCEINFORESULT_H_
#define ALIBABACLOUD_ENS_MODEL_DESCRIBECLOUDDISKAVAILABLERESOURCEINFORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ens/EnsExport.h>
namespace AlibabaCloud
{
namespace Ens
{
namespace Model
{
class ALIBABACLOUD_ENS_EXPORT DescribeCloudDiskAvailableResourceInfoResult : public ServiceResult
{
public:
struct SupportResource
{
long canBuyCount;
std::string category;
std::string ensRegionName;
long defaultDiskSize;
long diskMinSize;
long diskMaxSize;
std::string ensRegionId;
};
DescribeCloudDiskAvailableResourceInfoResult();
explicit DescribeCloudDiskAvailableResourceInfoResult(const std::string &payload);
~DescribeCloudDiskAvailableResourceInfoResult();
std::vector<SupportResource> getSupportResources()const;
protected:
void parse(const std::string &payload);
private:
std::vector<SupportResource> supportResources_;
};
}
}
}
#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBECLOUDDISKAVAILABLERESOURCEINFORESULT_H_

42
ens/include/alibabacloud/ens/model/DescribeCloudDiskTypesRequest.h Normal file
View File

@@ -0,0 +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_ENS_MODEL_DESCRIBECLOUDDISKTYPESREQUEST_H_
#define ALIBABACLOUD_ENS_MODEL_DESCRIBECLOUDDISKTYPESREQUEST_H_
#include <alibabacloud/ens/EnsExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ens {
namespace Model {
class ALIBABACLOUD_ENS_EXPORT DescribeCloudDiskTypesRequest : public RpcServiceRequest {
public:
DescribeCloudDiskTypesRequest();
~DescribeCloudDiskTypesRequest();
std::string getEnsRegionId() const;
void setEnsRegionId(const std::string &ensRegionId);
private:
std::string ensRegionId_;
};
} // namespace Model
} // namespace Ens
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_ENS_MODEL_DESCRIBECLOUDDISKTYPESREQUEST_H_

56
ens/include/alibabacloud/ens/model/DescribeCloudDiskTypesResult.h Normal file
View File

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

Some files were not shown because too many files have changed in this diff Show More