7#include <aws/core/client/AWSClient.h>
8#include <aws/core/client/AWSClientAsyncCRTP.h>
9#include <aws/core/client/ClientConfiguration.h>
10#include <aws/core/utils/json/JsonSerializer.h>
11#include <aws/lightsail/LightsailPaginationBase.h>
12#include <aws/lightsail/LightsailServiceClientModel.h>
13#include <aws/lightsail/LightsailWaiter.h>
14#include <aws/lightsail/Lightsail_EXPORTS.h>
54 LightsailClient(
const Aws::Lightsail::LightsailClientConfiguration& clientConfiguration = Aws::Lightsail::LightsailClientConfiguration(),
55 std::shared_ptr<LightsailEndpointProviderBase> endpointProvider =
nullptr);
62 const Aws::Lightsail::LightsailClientConfiguration& clientConfiguration = Aws::Lightsail::LightsailClientConfiguration());
68 LightsailClient(
const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
69 std::shared_ptr<LightsailEndpointProviderBase> endpointProvider =
nullptr,
70 const Aws::Lightsail::LightsailClientConfiguration& clientConfiguration = Aws::Lightsail::LightsailClientConfiguration());
89 LightsailClient(
const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
106 template <
typename AllocateStaticIpRequestT = Model::AllocateStaticIpRequest>
108 return SubmitCallable(&LightsailClient::AllocateStaticIp, request);
115 template <
typename AllocateStaticIpRequestT = Model::AllocateStaticIpRequest>
117 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
118 return SubmitAsync(&LightsailClient::AllocateStaticIp, request, handler, context);
142 template <
typename AttachCertificateToDistributionRequestT = Model::AttachCertificateToDistributionRequest>
144 const AttachCertificateToDistributionRequestT& request)
const {
145 return SubmitCallable(&LightsailClient::AttachCertificateToDistribution, request);
152 template <
typename AttachCertificateToDistributionRequestT = Model::AttachCertificateToDistributionRequest>
155 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
156 return SubmitAsync(&LightsailClient::AttachCertificateToDistribution, request, handler, context);
175 template <
typename AttachDiskRequestT = Model::AttachDiskRequest>
177 return SubmitCallable(&LightsailClient::AttachDisk, request);
184 template <
typename AttachDiskRequestT = Model::AttachDiskRequest>
186 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
187 return SubmitAsync(&LightsailClient::AttachDisk, request, handler, context);
209 template <
typename AttachInstancesToLoadBalancerRequestT = Model::AttachInstancesToLoadBalancerRequest>
211 const AttachInstancesToLoadBalancerRequestT& request)
const {
212 return SubmitCallable(&LightsailClient::AttachInstancesToLoadBalancer, request);
219 template <
typename AttachInstancesToLoadBalancerRequestT = Model::AttachInstancesToLoadBalancerRequest>
222 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
223 return SubmitAsync(&LightsailClient::AttachInstancesToLoadBalancer, request, handler, context);
249 template <
typename AttachLoadBalancerTlsCertificateRequestT = Model::AttachLoadBalancerTlsCertificateRequest>
251 const AttachLoadBalancerTlsCertificateRequestT& request)
const {
252 return SubmitCallable(&LightsailClient::AttachLoadBalancerTlsCertificate, request);
259 template <
typename AttachLoadBalancerTlsCertificateRequestT = Model::AttachLoadBalancerTlsCertificateRequest>
262 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
263 return SubmitAsync(&LightsailClient::AttachLoadBalancerTlsCertificate, request, handler, context);
277 template <
typename AttachStaticIpRequestT = Model::AttachStaticIpRequest>
279 return SubmitCallable(&LightsailClient::AttachStaticIp, request);
286 template <
typename AttachStaticIpRequestT = Model::AttachStaticIpRequest>
288 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
289 return SubmitAsync(&LightsailClient::AttachStaticIp, request, handler, context);
307 template <
typename CheckSubdomainAvailabilityRequestT = Model::CheckSubdomainAvailabilityRequest>
309 const CheckSubdomainAvailabilityRequestT& request)
const {
310 return SubmitCallable(&LightsailClient::CheckSubdomainAvailability, request);
317 template <
typename CheckSubdomainAvailabilityRequestT = Model::CheckSubdomainAvailabilityRequest>
320 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
321 return SubmitAsync(&LightsailClient::CheckSubdomainAvailability, request, handler, context);
340 template <
typename CloseInstancePublicPortsRequestT = Model::CloseInstancePublicPortsRequest>
342 return SubmitCallable(&LightsailClient::CloseInstancePublicPorts, request);
349 template <
typename CloseInstancePublicPortsRequestT = Model::CloseInstancePublicPortsRequest>
352 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
353 return SubmitAsync(&LightsailClient::CloseInstancePublicPorts, request, handler, context);
376 template <
typename CopySnapshotRequestT = Model::CopySnapshotRequest>
378 return SubmitCallable(&LightsailClient::CopySnapshot, request);
385 template <
typename CopySnapshotRequestT = Model::CopySnapshotRequest>
387 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
388 return SubmitAsync(&LightsailClient::CopySnapshot, request, handler, context);
407 template <
typename CreateBucketRequestT = Model::CreateBucketRequest>
409 return SubmitCallable(&LightsailClient::CreateBucket, request);
416 template <
typename CreateBucketRequestT = Model::CreateBucketRequest>
418 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
419 return SubmitAsync(&LightsailClient::CreateBucket, request, handler, context);
446 template <
typename CreateBucketAccessKeyRequestT = Model::CreateBucketAccessKeyRequest>
448 return SubmitCallable(&LightsailClient::CreateBucketAccessKey, request);
455 template <
typename CreateBucketAccessKeyRequestT = Model::CreateBucketAccessKeyRequest>
457 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
458 return SubmitAsync(&LightsailClient::CreateBucketAccessKey, request, handler, context);
482 template <
typename CreateCertificateRequestT = Model::CreateCertificateRequest>
484 return SubmitCallable(&LightsailClient::CreateCertificate, request);
491 template <
typename CreateCertificateRequestT = Model::CreateCertificateRequest>
493 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
494 return SubmitAsync(&LightsailClient::CreateCertificate, request, handler, context);
515 template <
typename CreateCloudFormationStackRequestT = Model::CreateCloudFormationStackRequest>
517 const CreateCloudFormationStackRequestT& request)
const {
518 return SubmitCallable(&LightsailClient::CreateCloudFormationStack, request);
525 template <
typename CreateCloudFormationStackRequestT = Model::CreateCloudFormationStackRequest>
528 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
529 return SubmitAsync(&LightsailClient::CreateCloudFormationStack, request, handler, context);
554 template <
typename CreateContactMethodRequestT = Model::CreateContactMethodRequest>
556 return SubmitCallable(&LightsailClient::CreateContactMethod, request);
563 template <
typename CreateContactMethodRequestT = Model::CreateContactMethodRequest>
565 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
566 return SubmitAsync(&LightsailClient::CreateContactMethod, request, handler, context);
585 template <
typename CreateContainerServiceRequestT = Model::CreateContainerServiceRequest>
587 return SubmitCallable(&LightsailClient::CreateContainerService, request);
594 template <
typename CreateContainerServiceRequestT = Model::CreateContainerServiceRequest>
597 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
598 return SubmitAsync(&LightsailClient::CreateContainerService, request, handler, context);
624 template <
typename CreateContainerServiceDeploymentRequestT = Model::CreateContainerServiceDeploymentRequest>
626 const CreateContainerServiceDeploymentRequestT& request)
const {
627 return SubmitCallable(&LightsailClient::CreateContainerServiceDeployment, request);
634 template <
typename CreateContainerServiceDeploymentRequestT = Model::CreateContainerServiceDeploymentRequest>
637 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
638 return SubmitAsync(&LightsailClient::CreateContainerServiceDeployment, request, handler, context);
672 template <
typename CreateContainerServiceRegistryLoginRequestT = Model::CreateContainerServiceRegistryLoginRequest>
674 const CreateContainerServiceRegistryLoginRequestT& request = {})
const {
675 return SubmitCallable(&LightsailClient::CreateContainerServiceRegistryLogin, request);
682 template <
typename CreateContainerServiceRegistryLoginRequestT = Model::CreateContainerServiceRegistryLoginRequest>
684 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
685 const CreateContainerServiceRegistryLoginRequestT& request = {})
const {
686 return SubmitAsync(&LightsailClient::CreateContainerServiceRegistryLogin, request, handler, context);
704 template <
typename CreateDiskRequestT = Model::CreateDiskRequest>
706 return SubmitCallable(&LightsailClient::CreateDisk, request);
713 template <
typename CreateDiskRequestT = Model::CreateDiskRequest>
715 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
716 return SubmitAsync(&LightsailClient::CreateDisk, request, handler, context);
737 template <
typename CreateDiskFromSnapshotRequestT = Model::CreateDiskFromSnapshotRequest>
739 return SubmitCallable(&LightsailClient::CreateDiskFromSnapshot, request);
746 template <
typename CreateDiskFromSnapshotRequestT = Model::CreateDiskFromSnapshotRequest>
749 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
750 return SubmitAsync(&LightsailClient::CreateDiskFromSnapshot, request, handler, context);
786 template <
typename CreateDiskSnapshotRequestT = Model::CreateDiskSnapshotRequest>
788 return SubmitCallable(&LightsailClient::CreateDiskSnapshot, request);
795 template <
typename CreateDiskSnapshotRequestT = Model::CreateDiskSnapshotRequest>
797 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
798 return SubmitAsync(&LightsailClient::CreateDiskSnapshot, request, handler, context);
817 template <
typename CreateDistributionRequestT = Model::CreateDistributionRequest>
819 return SubmitCallable(&LightsailClient::CreateDistribution, request);
826 template <
typename CreateDistributionRequestT = Model::CreateDistributionRequest>
828 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
829 return SubmitAsync(&LightsailClient::CreateDistribution, request, handler, context);
846 template <
typename CreateDomainRequestT = Model::CreateDomainRequest>
848 return SubmitCallable(&LightsailClient::CreateDomain, request);
855 template <
typename CreateDomainRequestT = Model::CreateDomainRequest>
857 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
858 return SubmitAsync(&LightsailClient::CreateDomain, request, handler, context);
879 template <
typename CreateDomainEntryRequestT = Model::CreateDomainEntryRequest>
881 return SubmitCallable(&LightsailClient::CreateDomainEntry, request);
888 template <
typename CreateDomainEntryRequestT = Model::CreateDomainEntryRequest>
890 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
891 return SubmitAsync(&LightsailClient::CreateDomainEntry, request, handler, context);
911 template <
typename CreateGUISessionAccessDetailsRequestT = Model::CreateGUISessionAccessDetailsRequest>
913 const CreateGUISessionAccessDetailsRequestT& request)
const {
914 return SubmitCallable(&LightsailClient::CreateGUISessionAccessDetails, request);
921 template <
typename CreateGUISessionAccessDetailsRequestT = Model::CreateGUISessionAccessDetailsRequest>
924 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
925 return SubmitAsync(&LightsailClient::CreateGUISessionAccessDetails, request, handler, context);
944 template <
typename CreateInstanceSnapshotRequestT = Model::CreateInstanceSnapshotRequest>
946 return SubmitCallable(&LightsailClient::CreateInstanceSnapshot, request);
953 template <
typename CreateInstanceSnapshotRequestT = Model::CreateInstanceSnapshotRequest>
956 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
957 return SubmitAsync(&LightsailClient::CreateInstanceSnapshot, request, handler, context);
974 template <
typename CreateInstancesRequestT = Model::CreateInstancesRequest>
976 return SubmitCallable(&LightsailClient::CreateInstances, request);
983 template <
typename CreateInstancesRequestT = Model::CreateInstancesRequest>
985 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
986 return SubmitAsync(&LightsailClient::CreateInstances, request, handler, context);
1007 template <
typename CreateInstancesFromSnapshotRequestT = Model::CreateInstancesFromSnapshotRequest>
1009 const CreateInstancesFromSnapshotRequestT& request)
const {
1010 return SubmitCallable(&LightsailClient::CreateInstancesFromSnapshot, request);
1017 template <
typename CreateInstancesFromSnapshotRequestT = Model::CreateInstancesFromSnapshotRequest>
1020 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1021 return SubmitAsync(&LightsailClient::CreateInstancesFromSnapshot, request, handler, context);
1042 template <
typename CreateKeyPairRequestT = Model::CreateKeyPairRequest>
1044 return SubmitCallable(&LightsailClient::CreateKeyPair, request);
1051 template <
typename CreateKeyPairRequestT = Model::CreateKeyPairRequest>
1053 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1054 return SubmitAsync(&LightsailClient::CreateKeyPair, request, handler, context);
1078 template <
typename CreateLoadBalancerRequestT = Model::CreateLoadBalancerRequest>
1080 return SubmitCallable(&LightsailClient::CreateLoadBalancer, request);
1087 template <
typename CreateLoadBalancerRequestT = Model::CreateLoadBalancerRequest>
1089 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1090 return SubmitAsync(&LightsailClient::CreateLoadBalancer, request, handler, context);
1111 template <
typename CreateLoadBalancerTlsCertificateRequestT = Model::CreateLoadBalancerTlsCertificateRequest>
1113 const CreateLoadBalancerTlsCertificateRequestT& request)
const {
1114 return SubmitCallable(&LightsailClient::CreateLoadBalancerTlsCertificate, request);
1121 template <
typename CreateLoadBalancerTlsCertificateRequestT = Model::CreateLoadBalancerTlsCertificateRequest>
1124 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1125 return SubmitAsync(&LightsailClient::CreateLoadBalancerTlsCertificate, request, handler, context);
1143 template <
typename CreateRelationalDatabaseRequestT = Model::CreateRelationalDatabaseRequest>
1145 return SubmitCallable(&LightsailClient::CreateRelationalDatabase, request);
1152 template <
typename CreateRelationalDatabaseRequestT = Model::CreateRelationalDatabaseRequest>
1155 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1156 return SubmitAsync(&LightsailClient::CreateRelationalDatabase, request, handler, context);
1179 template <
typename CreateRelationalDatabaseFromSnapshotRequestT = Model::CreateRelationalDatabaseFromSnapshotRequest>
1181 const CreateRelationalDatabaseFromSnapshotRequestT& request)
const {
1182 return SubmitCallable(&LightsailClient::CreateRelationalDatabaseFromSnapshot, request);
1189 template <
typename CreateRelationalDatabaseFromSnapshotRequestT = Model::CreateRelationalDatabaseFromSnapshotRequest>
1192 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1193 return SubmitAsync(&LightsailClient::CreateRelationalDatabaseFromSnapshot, request, handler, context);
1214 template <
typename CreateRelationalDatabaseSnapshotRequestT = Model::CreateRelationalDatabaseSnapshotRequest>
1216 const CreateRelationalDatabaseSnapshotRequestT& request)
const {
1217 return SubmitCallable(&LightsailClient::CreateRelationalDatabaseSnapshot, request);
1224 template <
typename CreateRelationalDatabaseSnapshotRequestT = Model::CreateRelationalDatabaseSnapshotRequest>
1227 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1228 return SubmitAsync(&LightsailClient::CreateRelationalDatabaseSnapshot, request, handler, context);
1251 template <
typename CreateSubdomainRequestT = Model::CreateSubdomainRequest>
1253 return SubmitCallable(&LightsailClient::CreateSubdomain, request);
1260 template <
typename CreateSubdomainRequestT = Model::CreateSubdomainRequest>
1262 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1263 return SubmitAsync(&LightsailClient::CreateSubdomain, request, handler, context);
1281 template <
typename DeleteAlarmRequestT = Model::DeleteAlarmRequest>
1283 return SubmitCallable(&LightsailClient::DeleteAlarm, request);
1290 template <
typename DeleteAlarmRequestT = Model::DeleteAlarmRequest>
1292 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1293 return SubmitAsync(&LightsailClient::DeleteAlarm, request, handler, context);
1310 template <
typename DeleteAutoSnapshotRequestT = Model::DeleteAutoSnapshotRequest>
1312 return SubmitCallable(&LightsailClient::DeleteAutoSnapshot, request);
1319 template <
typename DeleteAutoSnapshotRequestT = Model::DeleteAutoSnapshotRequest>
1321 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1322 return SubmitAsync(&LightsailClient::DeleteAutoSnapshot, request, handler, context);
1337 template <
typename DeleteBucketRequestT = Model::DeleteBucketRequest>
1339 return SubmitCallable(&LightsailClient::DeleteBucket, request);
1346 template <
typename DeleteBucketRequestT = Model::DeleteBucketRequest>
1348 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1349 return SubmitAsync(&LightsailClient::DeleteBucket, request, handler, context);
1368 template <
typename DeleteBucketAccessKeyRequestT = Model::DeleteBucketAccessKeyRequest>
1370 return SubmitCallable(&LightsailClient::DeleteBucketAccessKey, request);
1377 template <
typename DeleteBucketAccessKeyRequestT = Model::DeleteBucketAccessKeyRequest>
1379 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1380 return SubmitAsync(&LightsailClient::DeleteBucketAccessKey, request, handler, context);
1398 template <
typename DeleteCertificateRequestT = Model::DeleteCertificateRequest>
1400 return SubmitCallable(&LightsailClient::DeleteCertificate, request);
1407 template <
typename DeleteCertificateRequestT = Model::DeleteCertificateRequest>
1409 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1410 return SubmitAsync(&LightsailClient::DeleteCertificate, request, handler, context);
1431 template <
typename DeleteContactMethodRequestT = Model::DeleteContactMethodRequest>
1433 return SubmitCallable(&LightsailClient::DeleteContactMethod, request);
1440 template <
typename DeleteContactMethodRequestT = Model::DeleteContactMethodRequest>
1442 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1443 return SubmitAsync(&LightsailClient::DeleteContactMethod, request, handler, context);
1458 template <
typename DeleteContainerImageRequestT = Model::DeleteContainerImageRequest>
1460 return SubmitCallable(&LightsailClient::DeleteContainerImage, request);
1467 template <
typename DeleteContainerImageRequestT = Model::DeleteContainerImageRequest>
1469 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1470 return SubmitAsync(&LightsailClient::DeleteContainerImage, request, handler, context);
1485 template <
typename DeleteContainerServiceRequestT = Model::DeleteContainerServiceRequest>
1487 return SubmitCallable(&LightsailClient::DeleteContainerService, request);
1494 template <
typename DeleteContainerServiceRequestT = Model::DeleteContainerServiceRequest>
1497 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1498 return SubmitAsync(&LightsailClient::DeleteContainerService, request, handler, context);
1518 template <
typename DeleteDiskRequestT = Model::DeleteDiskRequest>
1520 return SubmitCallable(&LightsailClient::DeleteDisk, request);
1527 template <
typename DeleteDiskRequestT = Model::DeleteDiskRequest>
1529 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1530 return SubmitAsync(&LightsailClient::DeleteDisk, request, handler, context);
1554 template <
typename DeleteDiskSnapshotRequestT = Model::DeleteDiskSnapshotRequest>
1556 return SubmitCallable(&LightsailClient::DeleteDiskSnapshot, request);
1563 template <
typename DeleteDiskSnapshotRequestT = Model::DeleteDiskSnapshotRequest>
1565 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1566 return SubmitAsync(&LightsailClient::DeleteDiskSnapshot, request, handler, context);
1581 template <
typename DeleteDistributionRequestT = Model::DeleteDistributionRequest>
1583 return SubmitCallable(&LightsailClient::DeleteDistribution, request);
1590 template <
typename DeleteDistributionRequestT = Model::DeleteDistributionRequest>
1592 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
1593 const DeleteDistributionRequestT& request = {})
const {
1594 return SubmitAsync(&LightsailClient::DeleteDistribution, request, handler, context);
1612 template <
typename DeleteDomainRequestT = Model::DeleteDomainRequest>
1614 return SubmitCallable(&LightsailClient::DeleteDomain, request);
1621 template <
typename DeleteDomainRequestT = Model::DeleteDomainRequest>
1623 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1624 return SubmitAsync(&LightsailClient::DeleteDomain, request, handler, context);
1643 template <
typename DeleteDomainEntryRequestT = Model::DeleteDomainEntryRequest>
1645 return SubmitCallable(&LightsailClient::DeleteDomainEntry, request);
1652 template <
typename DeleteDomainEntryRequestT = Model::DeleteDomainEntryRequest>
1654 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1655 return SubmitAsync(&LightsailClient::DeleteDomainEntry, request, handler, context);
1673 template <
typename DeleteInstanceRequestT = Model::DeleteInstanceRequest>
1675 return SubmitCallable(&LightsailClient::DeleteInstance, request);
1682 template <
typename DeleteInstanceRequestT = Model::DeleteInstanceRequest>
1684 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1685 return SubmitAsync(&LightsailClient::DeleteInstance, request, handler, context);
1705 template <
typename DeleteInstanceSnapshotRequestT = Model::DeleteInstanceSnapshotRequest>
1707 return SubmitCallable(&LightsailClient::DeleteInstanceSnapshot, request);
1714 template <
typename DeleteInstanceSnapshotRequestT = Model::DeleteInstanceSnapshotRequest>
1717 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1718 return SubmitAsync(&LightsailClient::DeleteInstanceSnapshot, request, handler, context);
1744 template <
typename DeleteKeyPairRequestT = Model::DeleteKeyPairRequest>
1746 return SubmitCallable(&LightsailClient::DeleteKeyPair, request);
1753 template <
typename DeleteKeyPairRequestT = Model::DeleteKeyPairRequest>
1755 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1756 return SubmitAsync(&LightsailClient::DeleteKeyPair, request, handler, context);
1779 template <
typename DeleteKnownHostKeysRequestT = Model::DeleteKnownHostKeysRequest>
1781 return SubmitCallable(&LightsailClient::DeleteKnownHostKeys, request);
1788 template <
typename DeleteKnownHostKeysRequestT = Model::DeleteKnownHostKeysRequest>
1790 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1791 return SubmitAsync(&LightsailClient::DeleteKnownHostKeys, request, handler, context);
1812 template <
typename DeleteLoadBalancerRequestT = Model::DeleteLoadBalancerRequest>
1814 return SubmitCallable(&LightsailClient::DeleteLoadBalancer, request);
1821 template <
typename DeleteLoadBalancerRequestT = Model::DeleteLoadBalancerRequest>
1823 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1824 return SubmitAsync(&LightsailClient::DeleteLoadBalancer, request, handler, context);
1844 template <
typename DeleteLoadBalancerTlsCertificateRequestT = Model::DeleteLoadBalancerTlsCertificateRequest>
1846 const DeleteLoadBalancerTlsCertificateRequestT& request)
const {
1847 return SubmitCallable(&LightsailClient::DeleteLoadBalancerTlsCertificate, request);
1854 template <
typename DeleteLoadBalancerTlsCertificateRequestT = Model::DeleteLoadBalancerTlsCertificateRequest>
1857 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1858 return SubmitAsync(&LightsailClient::DeleteLoadBalancerTlsCertificate, request, handler, context);
1877 template <
typename DeleteRelationalDatabaseRequestT = Model::DeleteRelationalDatabaseRequest>
1879 return SubmitCallable(&LightsailClient::DeleteRelationalDatabase, request);
1886 template <
typename DeleteRelationalDatabaseRequestT = Model::DeleteRelationalDatabaseRequest>
1889 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1890 return SubmitAsync(&LightsailClient::DeleteRelationalDatabase, request, handler, context);
1910 template <
typename DeleteRelationalDatabaseSnapshotRequestT = Model::DeleteRelationalDatabaseSnapshotRequest>
1912 const DeleteRelationalDatabaseSnapshotRequestT& request)
const {
1913 return SubmitCallable(&LightsailClient::DeleteRelationalDatabaseSnapshot, request);
1920 template <
typename DeleteRelationalDatabaseSnapshotRequestT = Model::DeleteRelationalDatabaseSnapshotRequest>
1923 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1924 return SubmitAsync(&LightsailClient::DeleteRelationalDatabaseSnapshot, request, handler, context);
1945 template <
typename DeleteSubdomainRequestT = Model::DeleteSubdomainRequest>
1947 return SubmitCallable(&LightsailClient::DeleteSubdomain, request);
1954 template <
typename DeleteSubdomainRequestT = Model::DeleteSubdomainRequest>
1956 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1957 return SubmitAsync(&LightsailClient::DeleteSubdomain, request, handler, context);
1975 template <
typename DetachCertificateFromDistributionRequestT = Model::DetachCertificateFromDistributionRequest>
1977 const DetachCertificateFromDistributionRequestT& request)
const {
1978 return SubmitCallable(&LightsailClient::DetachCertificateFromDistribution, request);
1985 template <
typename DetachCertificateFromDistributionRequestT = Model::DetachCertificateFromDistributionRequest>
1988 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
1989 return SubmitAsync(&LightsailClient::DetachCertificateFromDistribution, request, handler, context);
2009 template <
typename DetachDiskRequestT = Model::DetachDiskRequest>
2011 return SubmitCallable(&LightsailClient::DetachDisk, request);
2018 template <
typename DetachDiskRequestT = Model::DetachDiskRequest>
2020 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
2021 return SubmitAsync(&LightsailClient::DetachDisk, request, handler, context);
2043 template <
typename DetachInstancesFromLoadBalancerRequestT = Model::DetachInstancesFromLoadBalancerRequest>
2045 const DetachInstancesFromLoadBalancerRequestT& request)
const {
2046 return SubmitCallable(&LightsailClient::DetachInstancesFromLoadBalancer, request);
2053 template <
typename DetachInstancesFromLoadBalancerRequestT = Model::DetachInstancesFromLoadBalancerRequest>
2056 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
2057 return SubmitAsync(&LightsailClient::DetachInstancesFromLoadBalancer, request, handler, context);
2071 template <
typename DetachStaticIpRequestT = Model::DetachStaticIpRequest>
2073 return SubmitCallable(&LightsailClient::DetachStaticIp, request);
2080 template <
typename DetachStaticIpRequestT = Model::DetachStaticIpRequest>
2082 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
2083 return SubmitAsync(&LightsailClient::DetachStaticIp, request, handler, context);
2099 template <
typename DisableAddOnRequestT = Model::DisableAddOnRequest>
2101 return SubmitCallable(&LightsailClient::DisableAddOn, request);
2108 template <
typename DisableAddOnRequestT = Model::DisableAddOnRequest>
2110 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
2111 return SubmitAsync(&LightsailClient::DisableAddOn, request, handler, context);
2127 template <
typename DownloadDefaultKeyPairRequestT = Model::DownloadDefaultKeyPairRequest>
2129 return SubmitCallable(&LightsailClient::DownloadDefaultKeyPair, request);
2136 template <
typename DownloadDefaultKeyPairRequestT = Model::DownloadDefaultKeyPairRequest>
2138 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
2139 const DownloadDefaultKeyPairRequestT& request = {})
const {
2140 return SubmitAsync(&LightsailClient::DownloadDefaultKeyPair, request, handler, context);
2156 template <
typename EnableAddOnRequestT = Model::EnableAddOnRequest>
2158 return SubmitCallable(&LightsailClient::EnableAddOn, request);
2165 template <
typename EnableAddOnRequestT = Model::EnableAddOnRequest>
2167 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
2168 return SubmitAsync(&LightsailClient::EnableAddOn, request, handler, context);
2196 template <
typename ExportSnapshotRequestT = Model::ExportSnapshotRequest>
2198 return SubmitCallable(&LightsailClient::ExportSnapshot, request);
2205 template <
typename ExportSnapshotRequestT = Model::ExportSnapshotRequest>
2207 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
2208 return SubmitAsync(&LightsailClient::ExportSnapshot, request, handler, context);
2222 template <
typename GetActiveNamesRequestT = Model::GetActiveNamesRequest>
2224 return SubmitCallable(&LightsailClient::GetActiveNames, request);
2231 template <
typename GetActiveNamesRequestT = Model::GetActiveNamesRequest>
2233 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
2234 const GetActiveNamesRequestT& request = {})
const {
2235 return SubmitAsync(&LightsailClient::GetActiveNames, request, handler, context);
2256 template <
typename GetAlarmsRequestT = Model::GetAlarmsRequest>
2258 return SubmitCallable(&LightsailClient::GetAlarms, request);
2265 template <
typename GetAlarmsRequestT = Model::GetAlarmsRequest>
2267 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
2268 const GetAlarmsRequestT& request = {})
const {
2269 return SubmitAsync(&LightsailClient::GetAlarms, request, handler, context);
2286 template <
typename GetAutoSnapshotsRequestT = Model::GetAutoSnapshotsRequest>
2288 return SubmitCallable(&LightsailClient::GetAutoSnapshots, request);
2295 template <
typename GetAutoSnapshotsRequestT = Model::GetAutoSnapshotsRequest>
2297 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
2298 return SubmitAsync(&LightsailClient::GetAutoSnapshots, request, handler, context);
2319 template <
typename GetBluepr
intsRequestT = Model::GetBluepr
intsRequest>
2321 return SubmitCallable(&LightsailClient::GetBlueprints, request);
2328 template <
typename GetBluepr
intsRequestT = Model::GetBluepr
intsRequest>
2330 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
2331 const GetBlueprintsRequestT& request = {})
const {
2332 return SubmitAsync(&LightsailClient::GetBlueprints, request, handler, context);
2352 template <
typename GetBucketAccessKeysRequestT = Model::GetBucketAccessKeysRequest>
2354 return SubmitCallable(&LightsailClient::GetBucketAccessKeys, request);
2361 template <
typename GetBucketAccessKeysRequestT = Model::GetBucketAccessKeysRequest>
2363 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
2364 return SubmitAsync(&LightsailClient::GetBucketAccessKeys, request, handler, context);
2382 template <
typename GetBucketBundlesRequestT = Model::GetBucketBundlesRequest>
2384 return SubmitCallable(&LightsailClient::GetBucketBundles, request);
2391 template <
typename GetBucketBundlesRequestT = Model::GetBucketBundlesRequest>
2393 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
2394 const GetBucketBundlesRequestT& request = {})
const {
2395 return SubmitAsync(&LightsailClient::GetBucketBundles, request, handler, context);
2413 template <
typename GetBucketMetricDataRequestT = Model::GetBucketMetricDataRequest>
2415 return SubmitCallable(&LightsailClient::GetBucketMetricData, request);
2422 template <
typename GetBucketMetricDataRequestT = Model::GetBucketMetricDataRequest>
2424 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
2425 return SubmitAsync(&LightsailClient::GetBucketMetricData, request, handler, context);
2444 template <
typename GetBucketsRequestT = Model::GetBucketsRequest>
2446 return SubmitCallable(&LightsailClient::GetBuckets, request);
2453 template <
typename GetBucketsRequestT = Model::GetBucketsRequest>
2455 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
2456 const GetBucketsRequestT& request = {})
const {
2457 return SubmitAsync(&LightsailClient::GetBuckets, request, handler, context);
2475 template <
typename GetBundlesRequestT = Model::GetBundlesRequest>
2477 return SubmitCallable(&LightsailClient::GetBundles, request);
2484 template <
typename GetBundlesRequestT = Model::GetBundlesRequest>
2486 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
2487 const GetBundlesRequestT& request = {})
const {
2488 return SubmitAsync(&LightsailClient::GetBundles, request, handler, context);
2505 template <
typename GetCertificatesRequestT = Model::GetCertificatesRequest>
2507 return SubmitCallable(&LightsailClient::GetCertificates, request);
2514 template <
typename GetCertificatesRequestT = Model::GetCertificatesRequest>
2516 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
2517 const GetCertificatesRequestT& request = {})
const {
2518 return SubmitAsync(&LightsailClient::GetCertificates, request, handler, context);
2536 template <
typename GetCloudFormationStackRecordsRequestT = Model::GetCloudFormationStackRecordsRequest>
2538 const GetCloudFormationStackRecordsRequestT& request = {})
const {
2539 return SubmitCallable(&LightsailClient::GetCloudFormationStackRecords, request);
2546 template <
typename GetCloudFormationStackRecordsRequestT = Model::GetCloudFormationStackRecordsRequest>
2548 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
2549 const GetCloudFormationStackRecordsRequestT& request = {})
const {
2550 return SubmitAsync(&LightsailClient::GetCloudFormationStackRecords, request, handler, context);
2572 template <
typename GetContactMethodsRequestT = Model::GetContactMethodsRequest>
2574 return SubmitCallable(&LightsailClient::GetContactMethods, request);
2581 template <
typename GetContactMethodsRequestT = Model::GetContactMethodsRequest>
2583 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
2584 const GetContactMethodsRequestT& request = {})
const {
2585 return SubmitAsync(&LightsailClient::GetContactMethods, request, handler, context);
2601 template <
typename GetContainerAPIMetadataRequestT = Model::GetContainerAPIMetadataRequest>
2603 return SubmitCallable(&LightsailClient::GetContainerAPIMetadata, request);
2610 template <
typename GetContainerAPIMetadataRequestT = Model::GetContainerAPIMetadataRequest>
2612 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
2613 const GetContainerAPIMetadataRequestT& request = {})
const {
2614 return SubmitAsync(&LightsailClient::GetContainerAPIMetadata, request, handler, context);
2633 template <
typename GetContainerImagesRequestT = Model::GetContainerImagesRequest>
2635 return SubmitCallable(&LightsailClient::GetContainerImages, request);
2642 template <
typename GetContainerImagesRequestT = Model::GetContainerImagesRequest>
2644 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
2645 return SubmitAsync(&LightsailClient::GetContainerImages, request, handler, context);
2666 template <
typename GetContainerLogRequestT = Model::GetContainerLogRequest>
2668 return SubmitCallable(&LightsailClient::GetContainerLog, request);
2675 template <
typename GetContainerLogRequestT = Model::GetContainerLogRequest>
2677 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
2678 return SubmitAsync(&LightsailClient::GetContainerLog, request, handler, context);
2701 template <
typename GetContainerServiceDeploymentsRequestT = Model::GetContainerServiceDeploymentsRequest>
2703 const GetContainerServiceDeploymentsRequestT& request)
const {
2704 return SubmitCallable(&LightsailClient::GetContainerServiceDeployments, request);
2711 template <
typename GetContainerServiceDeploymentsRequestT = Model::GetContainerServiceDeploymentsRequest>
2714 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
2715 return SubmitAsync(&LightsailClient::GetContainerServiceDeployments, request, handler, context);
2733 template <
typename GetContainerServiceMetricDataRequestT = Model::GetContainerServiceMetricDataRequest>
2735 const GetContainerServiceMetricDataRequestT& request)
const {
2736 return SubmitCallable(&LightsailClient::GetContainerServiceMetricData, request);
2743 template <
typename GetContainerServiceMetricDataRequestT = Model::GetContainerServiceMetricDataRequest>
2746 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
2747 return SubmitAsync(&LightsailClient::GetContainerServiceMetricData, request, handler, context);
2765 template <
typename GetContainerServicePowersRequestT = Model::GetContainerServicePowersRequest>
2767 const GetContainerServicePowersRequestT& request = {})
const {
2768 return SubmitCallable(&LightsailClient::GetContainerServicePowers, request);
2775 template <
typename GetContainerServicePowersRequestT = Model::GetContainerServicePowersRequest>
2777 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
2778 const GetContainerServicePowersRequestT& request = {})
const {
2779 return SubmitAsync(&LightsailClient::GetContainerServicePowers, request, handler, context);
2794 template <
typename GetContainerServicesRequestT = Model::GetContainerServicesRequest>
2796 return SubmitCallable(&LightsailClient::GetContainerServices, request);
2803 template <
typename GetContainerServicesRequestT = Model::GetContainerServicesRequest>
2805 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
2806 const GetContainerServicesRequestT& request = {})
const {
2807 return SubmitAsync(&LightsailClient::GetContainerServices, request, handler, context);
2822 template <
typename GetCostEstimateRequestT = Model::GetCostEstimateRequest>
2824 return SubmitCallable(&LightsailClient::GetCostEstimate, request);
2831 template <
typename GetCostEstimateRequestT = Model::GetCostEstimateRequest>
2833 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
2834 return SubmitAsync(&LightsailClient::GetCostEstimate, request, handler, context);
2848 template <
typename GetDiskRequestT = Model::GetDiskRequest>
2850 return SubmitCallable(&LightsailClient::GetDisk, request);
2857 template <
typename GetDiskRequestT = Model::GetDiskRequest>
2859 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
2860 return SubmitAsync(&LightsailClient::GetDisk, request, handler, context);
2874 template <
typename GetDiskSnapshotRequestT = Model::GetDiskSnapshotRequest>
2876 return SubmitCallable(&LightsailClient::GetDiskSnapshot, request);
2883 template <
typename GetDiskSnapshotRequestT = Model::GetDiskSnapshotRequest>
2885 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
2886 return SubmitAsync(&LightsailClient::GetDiskSnapshot, request, handler, context);
2901 template <
typename GetDiskSnapshotsRequestT = Model::GetDiskSnapshotsRequest>
2903 return SubmitCallable(&LightsailClient::GetDiskSnapshots, request);
2910 template <
typename GetDiskSnapshotsRequestT = Model::GetDiskSnapshotsRequest>
2912 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
2913 const GetDiskSnapshotsRequestT& request = {})
const {
2914 return SubmitAsync(&LightsailClient::GetDiskSnapshots, request, handler, context);
2928 template <
typename GetDisksRequestT = Model::GetDisksRequest>
2930 return SubmitCallable(&LightsailClient::GetDisks, request);
2937 template <
typename GetDisksRequestT = Model::GetDisksRequest>
2939 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
2940 const GetDisksRequestT& request = {})
const {
2941 return SubmitAsync(&LightsailClient::GetDisks, request, handler, context);
2958 template <
typename GetDistributionBundlesRequestT = Model::GetDistributionBundlesRequest>
2960 return SubmitCallable(&LightsailClient::GetDistributionBundles, request);
2967 template <
typename GetDistributionBundlesRequestT = Model::GetDistributionBundlesRequest>
2969 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
2970 const GetDistributionBundlesRequestT& request = {})
const {
2971 return SubmitAsync(&LightsailClient::GetDistributionBundles, request, handler, context);
2988 template <
typename GetDistributionLatestCacheResetRequestT = Model::GetDistributionLatestCacheResetRequest>
2990 const GetDistributionLatestCacheResetRequestT& request = {})
const {
2991 return SubmitCallable(&LightsailClient::GetDistributionLatestCacheReset, request);
2998 template <
typename GetDistributionLatestCacheResetRequestT = Model::GetDistributionLatestCacheResetRequest>
3000 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
3001 const GetDistributionLatestCacheResetRequestT& request = {})
const {
3002 return SubmitAsync(&LightsailClient::GetDistributionLatestCacheReset, request, handler, context);
3020 template <
typename GetDistributionMetricDataRequestT = Model::GetDistributionMetricDataRequest>
3022 const GetDistributionMetricDataRequestT& request)
const {
3023 return SubmitCallable(&LightsailClient::GetDistributionMetricData, request);
3030 template <
typename GetDistributionMetricDataRequestT = Model::GetDistributionMetricDataRequest>
3033 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
3034 return SubmitAsync(&LightsailClient::GetDistributionMetricData, request, handler, context);
3054 template <
typename GetDistributionsRequestT = Model::GetDistributionsRequest>
3056 return SubmitCallable(&LightsailClient::GetDistributions, request);
3063 template <
typename GetDistributionsRequestT = Model::GetDistributionsRequest>
3065 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
3066 const GetDistributionsRequestT& request = {})
const {
3067 return SubmitAsync(&LightsailClient::GetDistributions, request, handler, context);
3081 template <
typename GetDomainRequestT = Model::GetDomainRequest>
3083 return SubmitCallable(&LightsailClient::GetDomain, request);
3090 template <
typename GetDomainRequestT = Model::GetDomainRequest>
3092 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
3093 return SubmitAsync(&LightsailClient::GetDomain, request, handler, context);
3107 template <
typename GetDomainsRequestT = Model::GetDomainsRequest>
3109 return SubmitCallable(&LightsailClient::GetDomains, request);
3116 template <
typename GetDomainsRequestT = Model::GetDomainsRequest>
3118 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
3119 const GetDomainsRequestT& request = {})
const {
3120 return SubmitAsync(&LightsailClient::GetDomains, request, handler, context);
3138 template <
typename GetExportSnapshotRecordsRequestT = Model::GetExportSnapshotRecordsRequest>
3140 const GetExportSnapshotRecordsRequestT& request = {})
const {
3141 return SubmitCallable(&LightsailClient::GetExportSnapshotRecords, request);
3148 template <
typename GetExportSnapshotRecordsRequestT = Model::GetExportSnapshotRecordsRequest>
3150 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
3151 const GetExportSnapshotRecordsRequestT& request = {})
const {
3152 return SubmitAsync(&LightsailClient::GetExportSnapshotRecords, request, handler, context);
3166 template <
typename GetInstanceRequestT = Model::GetInstanceRequest>
3168 return SubmitCallable(&LightsailClient::GetInstance, request);
3175 template <
typename GetInstanceRequestT = Model::GetInstanceRequest>
3177 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
3178 return SubmitAsync(&LightsailClient::GetInstance, request, handler, context);
3198 template <
typename GetInstanceAccessDetailsRequestT = Model::GetInstanceAccessDetailsRequest>
3200 return SubmitCallable(&LightsailClient::GetInstanceAccessDetails, request);
3207 template <
typename GetInstanceAccessDetailsRequestT = Model::GetInstanceAccessDetailsRequest>
3210 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
3211 return SubmitAsync(&LightsailClient::GetInstanceAccessDetails, request, handler, context);
3229 template <
typename GetInstanceMetricDataRequestT = Model::GetInstanceMetricDataRequest>
3231 return SubmitCallable(&LightsailClient::GetInstanceMetricData, request);
3238 template <
typename GetInstanceMetricDataRequestT = Model::GetInstanceMetricDataRequest>
3240 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
3241 return SubmitAsync(&LightsailClient::GetInstanceMetricData, request, handler, context);
3257 template <
typename GetInstancePortStatesRequestT = Model::GetInstancePortStatesRequest>
3259 return SubmitCallable(&LightsailClient::GetInstancePortStates, request);
3266 template <
typename GetInstancePortStatesRequestT = Model::GetInstancePortStatesRequest>
3268 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
3269 return SubmitAsync(&LightsailClient::GetInstancePortStates, request, handler, context);
3284 template <
typename GetInstanceSnapshotRequestT = Model::GetInstanceSnapshotRequest>
3286 return SubmitCallable(&LightsailClient::GetInstanceSnapshot, request);
3293 template <
typename GetInstanceSnapshotRequestT = Model::GetInstanceSnapshotRequest>
3295 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
3296 return SubmitAsync(&LightsailClient::GetInstanceSnapshot, request, handler, context);
3311 template <
typename GetInstanceSnapshotsRequestT = Model::GetInstanceSnapshotsRequest>
3313 return SubmitCallable(&LightsailClient::GetInstanceSnapshots, request);
3320 template <
typename GetInstanceSnapshotsRequestT = Model::GetInstanceSnapshotsRequest>
3322 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
3323 const GetInstanceSnapshotsRequestT& request = {})
const {
3324 return SubmitAsync(&LightsailClient::GetInstanceSnapshots, request, handler, context);
3339 template <
typename GetInstanceStateRequestT = Model::GetInstanceStateRequest>
3341 return SubmitCallable(&LightsailClient::GetInstanceState, request);
3348 template <
typename GetInstanceStateRequestT = Model::GetInstanceStateRequest>
3350 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
3351 return SubmitAsync(&LightsailClient::GetInstanceState, request, handler, context);
3365 template <
typename GetInstancesRequestT = Model::GetInstancesRequest>
3367 return SubmitCallable(&LightsailClient::GetInstances, request);
3374 template <
typename GetInstancesRequestT = Model::GetInstancesRequest>
3376 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
3377 const GetInstancesRequestT& request = {})
const {
3378 return SubmitAsync(&LightsailClient::GetInstances, request, handler, context);
3391 template <
typename GetKeyPairRequestT = Model::GetKeyPairRequest>
3393 return SubmitCallable(&LightsailClient::GetKeyPair, request);
3400 template <
typename GetKeyPairRequestT = Model::GetKeyPairRequest>
3402 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
3403 return SubmitAsync(&LightsailClient::GetKeyPair, request, handler, context);
3417 template <
typename GetKeyPairsRequestT = Model::GetKeyPairsRequest>
3419 return SubmitCallable(&LightsailClient::GetKeyPairs, request);
3426 template <
typename GetKeyPairsRequestT = Model::GetKeyPairsRequest>
3428 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
3429 const GetKeyPairsRequestT& request = {})
const {
3430 return SubmitAsync(&LightsailClient::GetKeyPairs, request, handler, context);
3444 template <
typename GetLoadBalancerRequestT = Model::GetLoadBalancerRequest>
3446 return SubmitCallable(&LightsailClient::GetLoadBalancer, request);
3453 template <
typename GetLoadBalancerRequestT = Model::GetLoadBalancerRequest>
3455 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
3456 return SubmitAsync(&LightsailClient::GetLoadBalancer, request, handler, context);
3474 template <
typename GetLoadBalancerMetricDataRequestT = Model::GetLoadBalancerMetricDataRequest>
3476 const GetLoadBalancerMetricDataRequestT& request)
const {
3477 return SubmitCallable(&LightsailClient::GetLoadBalancerMetricData, request);
3484 template <
typename GetLoadBalancerMetricDataRequestT = Model::GetLoadBalancerMetricDataRequest>
3487 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
3488 return SubmitAsync(&LightsailClient::GetLoadBalancerMetricData, request, handler, context);
3507 template <
typename GetLoadBalancerTlsCertificatesRequestT = Model::GetLoadBalancerTlsCertificatesRequest>
3509 const GetLoadBalancerTlsCertificatesRequestT& request)
const {
3510 return SubmitCallable(&LightsailClient::GetLoadBalancerTlsCertificates, request);
3517 template <
typename GetLoadBalancerTlsCertificatesRequestT = Model::GetLoadBalancerTlsCertificatesRequest>
3520 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
3521 return SubmitAsync(&LightsailClient::GetLoadBalancerTlsCertificates, request, handler, context);
3541 template <
typename GetLoadBalancerTlsPoliciesRequestT = Model::GetLoadBalancerTlsPoliciesRequest>
3543 const GetLoadBalancerTlsPoliciesRequestT& request = {})
const {
3544 return SubmitCallable(&LightsailClient::GetLoadBalancerTlsPolicies, request);
3551 template <
typename GetLoadBalancerTlsPoliciesRequestT = Model::GetLoadBalancerTlsPoliciesRequest>
3553 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
3554 const GetLoadBalancerTlsPoliciesRequestT& request = {})
const {
3555 return SubmitAsync(&LightsailClient::GetLoadBalancerTlsPolicies, request, handler, context);
3570 template <
typename GetLoadBalancersRequestT = Model::GetLoadBalancersRequest>
3572 return SubmitCallable(&LightsailClient::GetLoadBalancers, request);
3579 template <
typename GetLoadBalancersRequestT = Model::GetLoadBalancersRequest>
3581 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
3582 const GetLoadBalancersRequestT& request = {})
const {
3583 return SubmitAsync(&LightsailClient::GetLoadBalancers, request, handler, context);
3598 template <
typename GetOperationRequestT = Model::GetOperationRequest>
3600 return SubmitCallable(&LightsailClient::GetOperation, request);
3607 template <
typename GetOperationRequestT = Model::GetOperationRequest>
3609 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
3610 return SubmitAsync(&LightsailClient::GetOperation, request, handler, context);
3627 template <
typename GetOperationsRequestT = Model::GetOperationsRequest>
3629 return SubmitCallable(&LightsailClient::GetOperations, request);
3636 template <
typename GetOperationsRequestT = Model::GetOperationsRequest>
3638 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
3639 const GetOperationsRequestT& request = {})
const {
3640 return SubmitAsync(&LightsailClient::GetOperations, request, handler, context);
3655 template <
typename GetOperationsForResourceRequestT = Model::GetOperationsForResourceRequest>
3657 return SubmitCallable(&LightsailClient::GetOperationsForResource, request);
3664 template <
typename GetOperationsForResourceRequestT = Model::GetOperationsForResourceRequest>
3667 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
3668 return SubmitAsync(&LightsailClient::GetOperationsForResource, request, handler, context);
3684 template <
typename GetProfileRequestT = Model::GetProfileRequest>
3686 return SubmitCallable(&LightsailClient::GetProfile, request);
3693 template <
typename GetProfileRequestT = Model::GetProfileRequest>
3695 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
3696 const GetProfileRequestT& request = {})
const {
3697 return SubmitAsync(&LightsailClient::GetProfile, request, handler, context);
3712 template <
typename GetRegionsRequestT = Model::GetRegionsRequest>
3714 return SubmitCallable(&LightsailClient::GetRegions, request);
3721 template <
typename GetRegionsRequestT = Model::GetRegionsRequest>
3723 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
3724 const GetRegionsRequestT& request = {})
const {
3725 return SubmitAsync(&LightsailClient::GetRegions, request, handler, context);
3740 template <
typename GetRelationalDatabaseRequestT = Model::GetRelationalDatabaseRequest>
3742 return SubmitCallable(&LightsailClient::GetRelationalDatabase, request);
3749 template <
typename GetRelationalDatabaseRequestT = Model::GetRelationalDatabaseRequest>
3751 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
3752 return SubmitAsync(&LightsailClient::GetRelationalDatabase, request, handler, context);
3770 template <
typename GetRelationalDatabaseBluepr
intsRequestT = Model::GetRelationalDatabaseBluepr
intsRequest>
3772 const GetRelationalDatabaseBlueprintsRequestT& request = {})
const {
3773 return SubmitCallable(&LightsailClient::GetRelationalDatabaseBlueprints, request);
3780 template <
typename GetRelationalDatabaseBluepr
intsRequestT = Model::GetRelationalDatabaseBluepr
intsRequest>
3782 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
3783 const GetRelationalDatabaseBlueprintsRequestT& request = {})
const {
3784 return SubmitAsync(&LightsailClient::GetRelationalDatabaseBlueprints, request, handler, context);
3802 template <
typename GetRelationalDatabaseBundlesRequestT = Model::GetRelationalDatabaseBundlesRequest>
3804 const GetRelationalDatabaseBundlesRequestT& request = {})
const {
3805 return SubmitCallable(&LightsailClient::GetRelationalDatabaseBundles, request);
3812 template <
typename GetRelationalDatabaseBundlesRequestT = Model::GetRelationalDatabaseBundlesRequest>
3814 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
3815 const GetRelationalDatabaseBundlesRequestT& request = {})
const {
3816 return SubmitAsync(&LightsailClient::GetRelationalDatabaseBundles, request, handler, context);
3832 template <
typename GetRelationalDatabaseEventsRequestT = Model::GetRelationalDatabaseEventsRequest>
3834 const GetRelationalDatabaseEventsRequestT& request)
const {
3835 return SubmitCallable(&LightsailClient::GetRelationalDatabaseEvents, request);
3842 template <
typename GetRelationalDatabaseEventsRequestT = Model::GetRelationalDatabaseEventsRequest>
3845 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
3846 return SubmitAsync(&LightsailClient::GetRelationalDatabaseEvents, request, handler, context);
3862 template <
typename GetRelationalDatabaseLogEventsRequestT = Model::GetRelationalDatabaseLogEventsRequest>
3864 const GetRelationalDatabaseLogEventsRequestT& request)
const {
3865 return SubmitCallable(&LightsailClient::GetRelationalDatabaseLogEvents, request);
3872 template <
typename GetRelationalDatabaseLogEventsRequestT = Model::GetRelationalDatabaseLogEventsRequest>
3875 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
3876 return SubmitAsync(&LightsailClient::GetRelationalDatabaseLogEvents, request, handler, context);
3892 template <
typename GetRelationalDatabaseLogStreamsRequestT = Model::GetRelationalDatabaseLogStreamsRequest>
3894 const GetRelationalDatabaseLogStreamsRequestT& request)
const {
3895 return SubmitCallable(&LightsailClient::GetRelationalDatabaseLogStreams, request);
3902 template <
typename GetRelationalDatabaseLogStreamsRequestT = Model::GetRelationalDatabaseLogStreamsRequest>
3905 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
3906 return SubmitAsync(&LightsailClient::GetRelationalDatabaseLogStreams, request, handler, context);
3925 template <
typename GetRelationalDatabaseMasterUserPasswordRequestT = Model::GetRelationalDatabaseMasterUserPasswordRequest>
3927 const GetRelationalDatabaseMasterUserPasswordRequestT& request)
const {
3928 return SubmitCallable(&LightsailClient::GetRelationalDatabaseMasterUserPassword, request);
3935 template <
typename GetRelationalDatabaseMasterUserPasswordRequestT = Model::GetRelationalDatabaseMasterUserPasswordRequest>
3938 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
3939 return SubmitAsync(&LightsailClient::GetRelationalDatabaseMasterUserPassword, request, handler, context);
3958 template <
typename GetRelationalDatabaseMetricDataRequestT = Model::GetRelationalDatabaseMetricDataRequest>
3960 const GetRelationalDatabaseMetricDataRequestT& request)
const {
3961 return SubmitCallable(&LightsailClient::GetRelationalDatabaseMetricData, request);
3968 template <
typename GetRelationalDatabaseMetricDataRequestT = Model::GetRelationalDatabaseMetricDataRequest>
3971 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
3972 return SubmitAsync(&LightsailClient::GetRelationalDatabaseMetricData, request, handler, context);
3992 template <
typename GetRelationalDatabaseParametersRequestT = Model::GetRelationalDatabaseParametersRequest>
3994 const GetRelationalDatabaseParametersRequestT& request)
const {
3995 return SubmitCallable(&LightsailClient::GetRelationalDatabaseParameters, request);
4002 template <
typename GetRelationalDatabaseParametersRequestT = Model::GetRelationalDatabaseParametersRequest>
4005 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4006 return SubmitAsync(&LightsailClient::GetRelationalDatabaseParameters, request, handler, context);
4022 template <
typename GetRelationalDatabaseSnapshotRequestT = Model::GetRelationalDatabaseSnapshotRequest>
4024 const GetRelationalDatabaseSnapshotRequestT& request)
const {
4025 return SubmitCallable(&LightsailClient::GetRelationalDatabaseSnapshot, request);
4032 template <
typename GetRelationalDatabaseSnapshotRequestT = Model::GetRelationalDatabaseSnapshotRequest>
4035 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4036 return SubmitAsync(&LightsailClient::GetRelationalDatabaseSnapshot, request, handler, context);
4052 template <
typename GetRelationalDatabaseSnapshotsRequestT = Model::GetRelationalDatabaseSnapshotsRequest>
4054 const GetRelationalDatabaseSnapshotsRequestT& request = {})
const {
4055 return SubmitCallable(&LightsailClient::GetRelationalDatabaseSnapshots, request);
4062 template <
typename GetRelationalDatabaseSnapshotsRequestT = Model::GetRelationalDatabaseSnapshotsRequest>
4064 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
4065 const GetRelationalDatabaseSnapshotsRequestT& request = {})
const {
4066 return SubmitAsync(&LightsailClient::GetRelationalDatabaseSnapshots, request, handler, context);
4081 template <
typename GetRelationalDatabasesRequestT = Model::GetRelationalDatabasesRequest>
4083 return SubmitCallable(&LightsailClient::GetRelationalDatabases, request);
4090 template <
typename GetRelationalDatabasesRequestT = Model::GetRelationalDatabasesRequest>
4092 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
4093 const GetRelationalDatabasesRequestT& request = {})
const {
4094 return SubmitAsync(&LightsailClient::GetRelationalDatabases, request, handler, context);
4109 template <
typename GetSetupHistoryRequestT = Model::GetSetupHistoryRequest>
4111 return SubmitCallable(&LightsailClient::GetSetupHistory, request);
4118 template <
typename GetSetupHistoryRequestT = Model::GetSetupHistoryRequest>
4120 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4121 return SubmitAsync(&LightsailClient::GetSetupHistory, request, handler, context);
4135 template <
typename GetStaticIpRequestT = Model::GetStaticIpRequest>
4137 return SubmitCallable(&LightsailClient::GetStaticIp, request);
4144 template <
typename GetStaticIpRequestT = Model::GetStaticIpRequest>
4146 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4147 return SubmitAsync(&LightsailClient::GetStaticIp, request, handler, context);
4161 template <
typename GetStaticIpsRequestT = Model::GetStaticIpsRequest>
4163 return SubmitCallable(&LightsailClient::GetStaticIps, request);
4170 template <
typename GetStaticIpsRequestT = Model::GetStaticIpsRequest>
4172 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
4173 const GetStaticIpsRequestT& request = {})
const {
4174 return SubmitAsync(&LightsailClient::GetStaticIps, request, handler, context);
4191 template <
typename GetSubdomainsRequestT = Model::GetSubdomainsRequest>
4193 return SubmitCallable(&LightsailClient::GetSubdomains, request);
4200 template <
typename GetSubdomainsRequestT = Model::GetSubdomainsRequest>
4202 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
4203 const GetSubdomainsRequestT& request = {})
const {
4204 return SubmitAsync(&LightsailClient::GetSubdomains, request, handler, context);
4218 template <
typename ImportKeyPairRequestT = Model::ImportKeyPairRequest>
4220 return SubmitCallable(&LightsailClient::ImportKeyPair, request);
4227 template <
typename ImportKeyPairRequestT = Model::ImportKeyPairRequest>
4229 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4230 return SubmitAsync(&LightsailClient::ImportKeyPair, request, handler, context);
4244 template <
typename IsVpcPeeredRequestT = Model::IsVpcPeeredRequest>
4246 return SubmitCallable(&LightsailClient::IsVpcPeered, request);
4253 template <
typename IsVpcPeeredRequestT = Model::IsVpcPeeredRequest>
4255 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
4256 const IsVpcPeeredRequestT& request = {})
const {
4257 return SubmitAsync(&LightsailClient::IsVpcPeered, request, handler, context);
4277 template <
typename OpenInstancePublicPortsRequestT = Model::OpenInstancePublicPortsRequest>
4279 return SubmitCallable(&LightsailClient::OpenInstancePublicPorts, request);
4286 template <
typename OpenInstancePublicPortsRequestT = Model::OpenInstancePublicPortsRequest>
4289 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4290 return SubmitAsync(&LightsailClient::OpenInstancePublicPorts, request, handler, context);
4304 template <
typename PeerVpcRequestT = Model::PeerVpcRequest>
4306 return SubmitCallable(&LightsailClient::PeerVpc, request);
4313 template <
typename PeerVpcRequestT = Model::PeerVpcRequest>
4315 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
4316 const PeerVpcRequestT& request = {})
const {
4317 return SubmitAsync(&LightsailClient::PeerVpc, request, handler, context);
4345 template <
typename PutAlarmRequestT = Model::PutAlarmRequest>
4347 return SubmitCallable(&LightsailClient::PutAlarm, request);
4354 template <
typename PutAlarmRequestT = Model::PutAlarmRequest>
4356 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4357 return SubmitAsync(&LightsailClient::PutAlarm, request, handler, context);
4381 template <
typename PutInstancePublicPortsRequestT = Model::PutInstancePublicPortsRequest>
4383 return SubmitCallable(&LightsailClient::PutInstancePublicPorts, request);
4390 template <
typename PutInstancePublicPortsRequestT = Model::PutInstancePublicPortsRequest>
4393 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4394 return SubmitAsync(&LightsailClient::PutInstancePublicPorts, request, handler, context);
4412 template <
typename RebootInstanceRequestT = Model::RebootInstanceRequest>
4414 return SubmitCallable(&LightsailClient::RebootInstance, request);
4421 template <
typename RebootInstanceRequestT = Model::RebootInstanceRequest>
4423 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4424 return SubmitAsync(&LightsailClient::RebootInstance, request, handler, context);
4443 template <
typename RebootRelationalDatabaseRequestT = Model::RebootRelationalDatabaseRequest>
4445 return SubmitCallable(&LightsailClient::RebootRelationalDatabase, request);
4452 template <
typename RebootRelationalDatabaseRequestT = Model::RebootRelationalDatabaseRequest>
4455 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4456 return SubmitAsync(&LightsailClient::RebootRelationalDatabase, request, handler, context);
4477 template <
typename RegisterContainerImageRequestT = Model::RegisterContainerImageRequest>
4479 return SubmitCallable(&LightsailClient::RegisterContainerImage, request);
4486 template <
typename RegisterContainerImageRequestT = Model::RegisterContainerImageRequest>
4489 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4490 return SubmitAsync(&LightsailClient::RegisterContainerImage, request, handler, context);
4503 template <
typename ReleaseStaticIpRequestT = Model::ReleaseStaticIpRequest>
4505 return SubmitCallable(&LightsailClient::ReleaseStaticIp, request);
4512 template <
typename ReleaseStaticIpRequestT = Model::ReleaseStaticIpRequest>
4514 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4515 return SubmitAsync(&LightsailClient::ReleaseStaticIp, request, handler, context);
4532 template <
typename ResetDistributionCacheRequestT = Model::ResetDistributionCacheRequest>
4534 return SubmitCallable(&LightsailClient::ResetDistributionCache, request);
4541 template <
typename ResetDistributionCacheRequestT = Model::ResetDistributionCacheRequest>
4543 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
4544 const ResetDistributionCacheRequestT& request = {})
const {
4545 return SubmitAsync(&LightsailClient::ResetDistributionCache, request, handler, context);
4573 template <
typename SendContactMethodVerificationRequestT = Model::SendContactMethodVerificationRequest>
4575 const SendContactMethodVerificationRequestT& request)
const {
4576 return SubmitCallable(&LightsailClient::SendContactMethodVerification, request);
4583 template <
typename SendContactMethodVerificationRequestT = Model::SendContactMethodVerificationRequest>
4586 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4587 return SubmitAsync(&LightsailClient::SendContactMethodVerification, request, handler, context);
4604 template <
typename SetIpAddressTypeRequestT = Model::SetIpAddressTypeRequest>
4606 return SubmitCallable(&LightsailClient::SetIpAddressType, request);
4613 template <
typename SetIpAddressTypeRequestT = Model::SetIpAddressTypeRequest>
4615 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4616 return SubmitAsync(&LightsailClient::SetIpAddressType, request, handler, context);
4633 template <
typename SetResourceAccessForBucketRequestT = Model::SetResourceAccessForBucketRequest>
4635 const SetResourceAccessForBucketRequestT& request)
const {
4636 return SubmitCallable(&LightsailClient::SetResourceAccessForBucket, request);
4643 template <
typename SetResourceAccessForBucketRequestT = Model::SetResourceAccessForBucketRequest>
4646 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4647 return SubmitAsync(&LightsailClient::SetResourceAccessForBucket, request, handler, context);
4665 template <
typename SetupInstanceHttpsRequestT = Model::SetupInstanceHttpsRequest>
4667 return SubmitCallable(&LightsailClient::SetupInstanceHttps, request);
4674 template <
typename SetupInstanceHttpsRequestT = Model::SetupInstanceHttpsRequest>
4676 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4677 return SubmitAsync(&LightsailClient::SetupInstanceHttps, request, handler, context);
4693 template <
typename StartGUISessionRequestT = Model::StartGUISessionRequest>
4695 return SubmitCallable(&LightsailClient::StartGUISession, request);
4702 template <
typename StartGUISessionRequestT = Model::StartGUISessionRequest>
4704 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4705 return SubmitAsync(&LightsailClient::StartGUISession, request, handler, context);
4730 template <
typename StartInstanceRequestT = Model::StartInstanceRequest>
4732 return SubmitCallable(&LightsailClient::StartInstance, request);
4739 template <
typename StartInstanceRequestT = Model::StartInstanceRequest>
4741 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4742 return SubmitAsync(&LightsailClient::StartInstance, request, handler, context);
4762 template <
typename StartRelationalDatabaseRequestT = Model::StartRelationalDatabaseRequest>
4764 return SubmitCallable(&LightsailClient::StartRelationalDatabase, request);
4771 template <
typename StartRelationalDatabaseRequestT = Model::StartRelationalDatabaseRequest>
4774 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4775 return SubmitAsync(&LightsailClient::StartRelationalDatabase, request, handler, context);
4790 template <
typename StopGUISessionRequestT = Model::StopGUISessionRequest>
4792 return SubmitCallable(&LightsailClient::StopGUISession, request);
4799 template <
typename StopGUISessionRequestT = Model::StopGUISessionRequest>
4801 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4802 return SubmitAsync(&LightsailClient::StopGUISession, request, handler, context);
4826 template <
typename StopInstanceRequestT = Model::StopInstanceRequest>
4828 return SubmitCallable(&LightsailClient::StopInstance, request);
4835 template <
typename StopInstanceRequestT = Model::StopInstanceRequest>
4837 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4838 return SubmitAsync(&LightsailClient::StopInstance, request, handler, context);
4861 template <
typename StopRelationalDatabaseRequestT = Model::StopRelationalDatabaseRequest>
4863 return SubmitCallable(&LightsailClient::StopRelationalDatabase, request);
4870 template <
typename StopRelationalDatabaseRequestT = Model::StopRelationalDatabaseRequest>
4873 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4874 return SubmitAsync(&LightsailClient::StopRelationalDatabase, request, handler, context);
4897 template <
typename TagResourceRequestT = Model::TagResourceRequest>
4899 return SubmitCallable(&LightsailClient::TagResource, request);
4906 template <
typename TagResourceRequestT = Model::TagResourceRequest>
4908 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4909 return SubmitAsync(&LightsailClient::TagResource, request, handler, context);
4930 template <
typename TestAlarmRequestT = Model::TestAlarmRequest>
4932 return SubmitCallable(&LightsailClient::TestAlarm, request);
4939 template <
typename TestAlarmRequestT = Model::TestAlarmRequest>
4941 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
4942 return SubmitAsync(&LightsailClient::TestAlarm, request, handler, context);
4956 template <
typename UnpeerVpcRequestT = Model::UnpeerVpcRequest>
4958 return SubmitCallable(&LightsailClient::UnpeerVpc, request);
4965 template <
typename UnpeerVpcRequestT = Model::UnpeerVpcRequest>
4967 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
4968 const UnpeerVpcRequestT& request = {})
const {
4969 return SubmitAsync(&LightsailClient::UnpeerVpc, request, handler, context);
4988 template <
typename UntagResourceRequestT = Model::UntagResourceRequest>
4990 return SubmitCallable(&LightsailClient::UntagResource, request);
4997 template <
typename UntagResourceRequestT = Model::UntagResourceRequest>
4999 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
5000 return SubmitAsync(&LightsailClient::UntagResource, request, handler, context);
5016 template <
typename UpdateBucketRequestT = Model::UpdateBucketRequest>
5018 return SubmitCallable(&LightsailClient::UpdateBucket, request);
5025 template <
typename UpdateBucketRequestT = Model::UpdateBucketRequest>
5027 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
5028 return SubmitAsync(&LightsailClient::UpdateBucket, request, handler, context);
5057 template <
typename UpdateBucketBundleRequestT = Model::UpdateBucketBundleRequest>
5059 return SubmitCallable(&LightsailClient::UpdateBucketBundle, request);
5066 template <
typename UpdateBucketBundleRequestT = Model::UpdateBucketBundleRequest>
5068 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
5069 return SubmitAsync(&LightsailClient::UpdateBucketBundle, request, handler, context);
5084 template <
typename UpdateContainerServiceRequestT = Model::UpdateContainerServiceRequest>
5086 return SubmitCallable(&LightsailClient::UpdateContainerService, request);
5093 template <
typename UpdateContainerServiceRequestT = Model::UpdateContainerServiceRequest>
5096 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
5097 return SubmitAsync(&LightsailClient::UpdateContainerService, request, handler, context);
5113 template <
typename UpdateDistributionRequestT = Model::UpdateDistributionRequest>
5115 return SubmitCallable(&LightsailClient::UpdateDistribution, request);
5122 template <
typename UpdateDistributionRequestT = Model::UpdateDistributionRequest>
5124 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
5125 return SubmitAsync(&LightsailClient::UpdateDistribution, request, handler, context);
5148 template <
typename UpdateDistributionBundleRequestT = Model::UpdateDistributionBundleRequest>
5150 const UpdateDistributionBundleRequestT& request = {})
const {
5151 return SubmitCallable(&LightsailClient::UpdateDistributionBundle, request);
5158 template <
typename UpdateDistributionBundleRequestT = Model::UpdateDistributionBundleRequest>
5160 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr,
5161 const UpdateDistributionBundleRequestT& request = {})
const {
5162 return SubmitAsync(&LightsailClient::UpdateDistributionBundle, request, handler, context);
5181 template <
typename UpdateDomainEntryRequestT = Model::UpdateDomainEntryRequest>
5183 return SubmitCallable(&LightsailClient::UpdateDomainEntry, request);
5190 template <
typename UpdateDomainEntryRequestT = Model::UpdateDomainEntryRequest>
5192 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
5193 return SubmitAsync(&LightsailClient::UpdateDomainEntry, request, handler, context);
5217 template <
typename UpdateInstanceMetadataOptionsRequestT = Model::UpdateInstanceMetadataOptionsRequest>
5219 const UpdateInstanceMetadataOptionsRequestT& request)
const {
5220 return SubmitCallable(&LightsailClient::UpdateInstanceMetadataOptions, request);
5227 template <
typename UpdateInstanceMetadataOptionsRequestT = Model::UpdateInstanceMetadataOptionsRequest>
5230 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
5231 return SubmitAsync(&LightsailClient::UpdateInstanceMetadataOptions, request, handler, context);
5252 template <
typename UpdateLoadBalancerAttributeRequestT = Model::UpdateLoadBalancerAttributeRequest>
5254 const UpdateLoadBalancerAttributeRequestT& request)
const {
5255 return SubmitCallable(&LightsailClient::UpdateLoadBalancerAttribute, request);
5262 template <
typename UpdateLoadBalancerAttributeRequestT = Model::UpdateLoadBalancerAttributeRequest>
5265 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
5266 return SubmitAsync(&LightsailClient::UpdateLoadBalancerAttribute, request, handler, context);
5287 template <
typename UpdateRelationalDatabaseRequestT = Model::UpdateRelationalDatabaseRequest>
5289 return SubmitCallable(&LightsailClient::UpdateRelationalDatabase, request);
5296 template <
typename UpdateRelationalDatabaseRequestT = Model::UpdateRelationalDatabaseRequest>
5299 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
5300 return SubmitAsync(&LightsailClient::UpdateRelationalDatabase, request, handler, context);
5327 template <
typename UpdateRelationalDatabaseParametersRequestT = Model::UpdateRelationalDatabaseParametersRequest>
5329 const UpdateRelationalDatabaseParametersRequestT& request)
const {
5330 return SubmitCallable(&LightsailClient::UpdateRelationalDatabaseParameters, request);
5337 template <
typename UpdateRelationalDatabaseParametersRequestT = Model::UpdateRelationalDatabaseParametersRequest>
5340 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
5341 return SubmitAsync(&LightsailClient::UpdateRelationalDatabaseParameters, request, handler, context);
5368 template <
typename UpdateSubdomainAssociationRequestT = Model::UpdateSubdomainAssociationRequest>
5370 const UpdateSubdomainAssociationRequestT& request)
const {
5371 return SubmitCallable(&LightsailClient::UpdateSubdomainAssociation, request);
5378 template <
typename UpdateSubdomainAssociationRequestT = Model::UpdateSubdomainAssociationRequest>
5381 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context =
nullptr)
const {
5382 return SubmitAsync(&LightsailClient::UpdateSubdomainAssociation, request, handler, context);
5390 void init(
const LightsailClientConfiguration& clientConfiguration);
5396 LightsailClientConfiguration m_clientConfiguration;
5397 std::shared_ptr<LightsailEndpointProviderBase> m_endpointProvider;
virtual Model::GetSubdomainsOutcome GetSubdomains(const Model::GetSubdomainsRequest &request={}) const
virtual Model::GetRelationalDatabaseSnapshotsOutcome GetRelationalDatabaseSnapshots(const Model::GetRelationalDatabaseSnapshotsRequest &request={}) const
void PutAlarmAsync(const PutAlarmRequestT &request, const PutAlarmResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::AllocateStaticIpOutcome AllocateStaticIp(const Model::AllocateStaticIpRequest &request) const
virtual Model::GetSetupHistoryOutcome GetSetupHistory(const Model::GetSetupHistoryRequest &request) const
void GetProfileAsync(const GetProfileResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetProfileRequestT &request={}) const
virtual Model::UpdateInstanceMetadataOptionsOutcome UpdateInstanceMetadataOptions(const Model::UpdateInstanceMetadataOptionsRequest &request) const
void CreateDiskFromSnapshotAsync(const CreateDiskFromSnapshotRequestT &request, const CreateDiskFromSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::GetAutoSnapshotsOutcomeCallable GetAutoSnapshotsCallable(const GetAutoSnapshotsRequestT &request) const
virtual Model::GetActiveNamesOutcome GetActiveNames(const Model::GetActiveNamesRequest &request={}) const
Model::GetStaticIpOutcomeCallable GetStaticIpCallable(const GetStaticIpRequestT &request) const
virtual Model::CreateDiskFromSnapshotOutcome CreateDiskFromSnapshot(const Model::CreateDiskFromSnapshotRequest &request) const
void GetLoadBalancerTlsCertificatesAsync(const GetLoadBalancerTlsCertificatesRequestT &request, const GetLoadBalancerTlsCertificatesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::GetLoadBalancersOutcome GetLoadBalancers(const Model::GetLoadBalancersRequest &request={}) const
void CreateContainerServiceDeploymentAsync(const CreateContainerServiceDeploymentRequestT &request, const CreateContainerServiceDeploymentResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void DeleteContactMethodAsync(const DeleteContactMethodRequestT &request, const DeleteContactMethodResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::CreateKeyPairOutcome CreateKeyPair(const Model::CreateKeyPairRequest &request) const
void CreateRelationalDatabaseAsync(const CreateRelationalDatabaseRequestT &request, const CreateRelationalDatabaseResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT &request) const
virtual Model::DeleteInstanceOutcome DeleteInstance(const Model::DeleteInstanceRequest &request) const
void CopySnapshotAsync(const CopySnapshotRequestT &request, const CopySnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void GetBucketAccessKeysAsync(const GetBucketAccessKeysRequestT &request, const GetBucketAccessKeysResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::GetDiskSnapshotOutcome GetDiskSnapshot(const Model::GetDiskSnapshotRequest &request) const
Model::IsVpcPeeredOutcomeCallable IsVpcPeeredCallable(const IsVpcPeeredRequestT &request={}) const
Model::CreateInstancesOutcomeCallable CreateInstancesCallable(const CreateInstancesRequestT &request) const
Model::RegisterContainerImageOutcomeCallable RegisterContainerImageCallable(const RegisterContainerImageRequestT &request) const
void CreateLoadBalancerAsync(const CreateLoadBalancerRequestT &request, const CreateLoadBalancerResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::CreateCloudFormationStackOutcome CreateCloudFormationStack(const Model::CreateCloudFormationStackRequest &request) const
Model::UnpeerVpcOutcomeCallable UnpeerVpcCallable(const UnpeerVpcRequestT &request={}) const
Model::DeleteBucketAccessKeyOutcomeCallable DeleteBucketAccessKeyCallable(const DeleteBucketAccessKeyRequestT &request) const
void AllocateStaticIpAsync(const AllocateStaticIpRequestT &request, const AllocateStaticIpResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void GetStaticIpAsync(const GetStaticIpRequestT &request, const GetStaticIpResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT &request) const
virtual Model::GetDiskSnapshotsOutcome GetDiskSnapshots(const Model::GetDiskSnapshotsRequest &request={}) const
Model::UpdateDistributionBundleOutcomeCallable UpdateDistributionBundleCallable(const UpdateDistributionBundleRequestT &request={}) const
virtual Model::GetInstanceSnapshotOutcome GetInstanceSnapshot(const Model::GetInstanceSnapshotRequest &request) const
Model::CreateContainerServiceRegistryLoginOutcomeCallable CreateContainerServiceRegistryLoginCallable(const CreateContainerServiceRegistryLoginRequestT &request={}) const
void GetDistributionsAsync(const GetDistributionsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetDistributionsRequestT &request={}) const
void GetExportSnapshotRecordsAsync(const GetExportSnapshotRecordsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetExportSnapshotRecordsRequestT &request={}) const
virtual Model::GetStaticIpOutcome GetStaticIp(const Model::GetStaticIpRequest &request) const
void UnpeerVpcAsync(const UnpeerVpcResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const UnpeerVpcRequestT &request={}) const
virtual Model::CreateRelationalDatabaseSnapshotOutcome CreateRelationalDatabaseSnapshot(const Model::CreateRelationalDatabaseSnapshotRequest &request) const
virtual Model::GetInstanceStateOutcome GetInstanceState(const Model::GetInstanceStateRequest &request) const
virtual Model::StopGUISessionOutcome StopGUISession(const Model::StopGUISessionRequest &request) const
Model::AttachInstancesToLoadBalancerOutcomeCallable AttachInstancesToLoadBalancerCallable(const AttachInstancesToLoadBalancerRequestT &request) const
Model::CreateDiskOutcomeCallable CreateDiskCallable(const CreateDiskRequestT &request) const
void CreateContainerServiceAsync(const CreateContainerServiceRequestT &request, const CreateContainerServiceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::DeleteSubdomainOutcome DeleteSubdomain(const Model::DeleteSubdomainRequest &request) const
void GetBucketBundlesAsync(const GetBucketBundlesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetBucketBundlesRequestT &request={}) const
Model::GetKeyPairOutcomeCallable GetKeyPairCallable(const GetKeyPairRequestT &request) const
void GetDomainAsync(const GetDomainRequestT &request, const GetDomainResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::GetCertificatesOutcomeCallable GetCertificatesCallable(const GetCertificatesRequestT &request={}) const
virtual Model::StartRelationalDatabaseOutcome StartRelationalDatabase(const Model::StartRelationalDatabaseRequest &request) const
void StartRelationalDatabaseAsync(const StartRelationalDatabaseRequestT &request, const StartRelationalDatabaseResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::DetachInstancesFromLoadBalancerOutcome DetachInstancesFromLoadBalancer(const Model::DetachInstancesFromLoadBalancerRequest &request) const
virtual Model::GetAlarmsOutcome GetAlarms(const Model::GetAlarmsRequest &request={}) const
Model::GetRelationalDatabaseBundlesOutcomeCallable GetRelationalDatabaseBundlesCallable(const GetRelationalDatabaseBundlesRequestT &request={}) const
Model::GetBucketAccessKeysOutcomeCallable GetBucketAccessKeysCallable(const GetBucketAccessKeysRequestT &request) const
virtual Model::GetKeyPairsOutcome GetKeyPairs(const Model::GetKeyPairsRequest &request={}) const
void CreateKeyPairAsync(const CreateKeyPairRequestT &request, const CreateKeyPairResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::GetBucketsOutcome GetBuckets(const Model::GetBucketsRequest &request={}) const
Model::GetOperationsForResourceOutcomeCallable GetOperationsForResourceCallable(const GetOperationsForResourceRequestT &request) const
Model::GetRelationalDatabaseOutcomeCallable GetRelationalDatabaseCallable(const GetRelationalDatabaseRequestT &request) const
virtual Model::EnableAddOnOutcome EnableAddOn(const Model::EnableAddOnRequest &request) const
void GetSetupHistoryAsync(const GetSetupHistoryRequestT &request, const GetSetupHistoryResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::GetRelationalDatabaseSnapshotsOutcomeCallable GetRelationalDatabaseSnapshotsCallable(const GetRelationalDatabaseSnapshotsRequestT &request={}) const
virtual Model::StartInstanceOutcome StartInstance(const Model::StartInstanceRequest &request) const
void GetRelationalDatabaseAsync(const GetRelationalDatabaseRequestT &request, const GetRelationalDatabaseResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void CreateContactMethodAsync(const CreateContactMethodRequestT &request, const CreateContactMethodResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::GetRelationalDatabaseBlueprintsOutcomeCallable GetRelationalDatabaseBlueprintsCallable(const GetRelationalDatabaseBlueprintsRequestT &request={}) const
void GetDistributionMetricDataAsync(const GetDistributionMetricDataRequestT &request, const GetDistributionMetricDataResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::GetRelationalDatabaseLogStreamsOutcomeCallable GetRelationalDatabaseLogStreamsCallable(const GetRelationalDatabaseLogStreamsRequestT &request) const
Model::GetContainerImagesOutcomeCallable GetContainerImagesCallable(const GetContainerImagesRequestT &request) const
virtual Model::GetRelationalDatabaseLogStreamsOutcome GetRelationalDatabaseLogStreams(const Model::GetRelationalDatabaseLogStreamsRequest &request) const
Model::UpdateContainerServiceOutcomeCallable UpdateContainerServiceCallable(const UpdateContainerServiceRequestT &request) const
Model::UpdateDomainEntryOutcomeCallable UpdateDomainEntryCallable(const UpdateDomainEntryRequestT &request) const
Model::DownloadDefaultKeyPairOutcomeCallable DownloadDefaultKeyPairCallable(const DownloadDefaultKeyPairRequestT &request={}) const
Model::GetDiskOutcomeCallable GetDiskCallable(const GetDiskRequestT &request) const
Model::RebootInstanceOutcomeCallable RebootInstanceCallable(const RebootInstanceRequestT &request) const
Model::ResetDistributionCacheOutcomeCallable ResetDistributionCacheCallable(const ResetDistributionCacheRequestT &request={}) const
Model::PutInstancePublicPortsOutcomeCallable PutInstancePublicPortsCallable(const PutInstancePublicPortsRequestT &request) const
void ResetDistributionCacheAsync(const ResetDistributionCacheResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const ResetDistributionCacheRequestT &request={}) const
Model::DeleteDomainEntryOutcomeCallable DeleteDomainEntryCallable(const DeleteDomainEntryRequestT &request) const
virtual Model::GetContactMethodsOutcome GetContactMethods(const Model::GetContactMethodsRequest &request={}) const
void GetRelationalDatabaseMetricDataAsync(const GetRelationalDatabaseMetricDataRequestT &request, const GetRelationalDatabaseMetricDataResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::DeleteBucketOutcomeCallable DeleteBucketCallable(const DeleteBucketRequestT &request) const
Model::GetLoadBalancersOutcomeCallable GetLoadBalancersCallable(const GetLoadBalancersRequestT &request={}) const
Model::ReleaseStaticIpOutcomeCallable ReleaseStaticIpCallable(const ReleaseStaticIpRequestT &request) const
virtual Model::GetCostEstimateOutcome GetCostEstimate(const Model::GetCostEstimateRequest &request) const
void UpdateRelationalDatabaseAsync(const UpdateRelationalDatabaseRequestT &request, const UpdateRelationalDatabaseResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::CreateLoadBalancerTlsCertificateOutcome CreateLoadBalancerTlsCertificate(const Model::CreateLoadBalancerTlsCertificateRequest &request) const
Model::GetContainerServiceMetricDataOutcomeCallable GetContainerServiceMetricDataCallable(const GetContainerServiceMetricDataRequestT &request) const
void UpdateBucketBundleAsync(const UpdateBucketBundleRequestT &request, const UpdateBucketBundleResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void UpdateBucketAsync(const UpdateBucketRequestT &request, const UpdateBucketResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void RebootRelationalDatabaseAsync(const RebootRelationalDatabaseRequestT &request, const RebootRelationalDatabaseResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
LightsailClient(const Aws::Client::ClientConfiguration &clientConfiguration)
virtual Model::CreateContainerServiceRegistryLoginOutcome CreateContainerServiceRegistryLogin(const Model::CreateContainerServiceRegistryLoginRequest &request={}) const
void GetRelationalDatabaseSnapshotAsync(const GetRelationalDatabaseSnapshotRequestT &request, const GetRelationalDatabaseSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
LightsailEndpointProvider EndpointProviderType
void StopInstanceAsync(const StopInstanceRequestT &request, const StopInstanceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::CreateDiskOutcome CreateDisk(const Model::CreateDiskRequest &request) const
Model::PutAlarmOutcomeCallable PutAlarmCallable(const PutAlarmRequestT &request) const
void SendContactMethodVerificationAsync(const SendContactMethodVerificationRequestT &request, const SendContactMethodVerificationResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::GetRelationalDatabasesOutcomeCallable GetRelationalDatabasesCallable(const GetRelationalDatabasesRequestT &request={}) const
Model::GetContainerLogOutcomeCallable GetContainerLogCallable(const GetContainerLogRequestT &request) const
virtual Model::DetachStaticIpOutcome DetachStaticIp(const Model::DetachStaticIpRequest &request) const
Model::DeleteAutoSnapshotOutcomeCallable DeleteAutoSnapshotCallable(const DeleteAutoSnapshotRequestT &request) const
Model::CreateBucketOutcomeCallable CreateBucketCallable(const CreateBucketRequestT &request) const
Model::GetDistributionsOutcomeCallable GetDistributionsCallable(const GetDistributionsRequestT &request={}) const
virtual Model::GetDistributionMetricDataOutcome GetDistributionMetricData(const Model::GetDistributionMetricDataRequest &request) const
virtual Model::DeleteInstanceSnapshotOutcome DeleteInstanceSnapshot(const Model::DeleteInstanceSnapshotRequest &request) const
static const char * GetServiceName()
void DeleteContainerServiceAsync(const DeleteContainerServiceRequestT &request, const DeleteContainerServiceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void GetRelationalDatabaseParametersAsync(const GetRelationalDatabaseParametersRequestT &request, const GetRelationalDatabaseParametersResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::DeleteDomainOutcomeCallable DeleteDomainCallable(const DeleteDomainRequestT &request) const
virtual Model::CreateBucketAccessKeyOutcome CreateBucketAccessKey(const Model::CreateBucketAccessKeyRequest &request) const
Model::DetachStaticIpOutcomeCallable DetachStaticIpCallable(const DetachStaticIpRequestT &request) const
virtual Model::GetRegionsOutcome GetRegions(const Model::GetRegionsRequest &request={}) const
virtual Model::GetLoadBalancerOutcome GetLoadBalancer(const Model::GetLoadBalancerRequest &request) const
void GetRelationalDatabaseEventsAsync(const GetRelationalDatabaseEventsRequestT &request, const GetRelationalDatabaseEventsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void DeleteInstanceSnapshotAsync(const DeleteInstanceSnapshotRequestT &request, const DeleteInstanceSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
LightsailClientConfiguration ClientConfigurationType
virtual Model::GetRelationalDatabaseBundlesOutcome GetRelationalDatabaseBundles(const Model::GetRelationalDatabaseBundlesRequest &request={}) const
void GetCostEstimateAsync(const GetCostEstimateRequestT &request, const GetCostEstimateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::CreateCloudFormationStackOutcomeCallable CreateCloudFormationStackCallable(const CreateCloudFormationStackRequestT &request) const
void UpdateSubdomainAssociationAsync(const UpdateSubdomainAssociationRequestT &request, const UpdateSubdomainAssociationResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void GetRelationalDatabaseMasterUserPasswordAsync(const GetRelationalDatabaseMasterUserPasswordRequestT &request, const GetRelationalDatabaseMasterUserPasswordResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::GetRelationalDatabaseSnapshotOutcomeCallable GetRelationalDatabaseSnapshotCallable(const GetRelationalDatabaseSnapshotRequestT &request) const
virtual Model::CreateDistributionOutcome CreateDistribution(const Model::CreateDistributionRequest &request) const
Model::GetInstancesOutcomeCallable GetInstancesCallable(const GetInstancesRequestT &request={}) const
Model::DeleteInstanceOutcomeCallable DeleteInstanceCallable(const DeleteInstanceRequestT &request) const
Model::StartGUISessionOutcomeCallable StartGUISessionCallable(const StartGUISessionRequestT &request) const
void GetInstanceStateAsync(const GetInstanceStateRequestT &request, const GetInstanceStateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void UntagResourceAsync(const UntagResourceRequestT &request, const UntagResourceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::DeleteRelationalDatabaseOutcome DeleteRelationalDatabase(const Model::DeleteRelationalDatabaseRequest &request) const
virtual std::shared_ptr< LightsailEndpointProviderBase > & accessEndpointProvider()
virtual Model::CreateContainerServiceDeploymentOutcome CreateContainerServiceDeployment(const Model::CreateContainerServiceDeploymentRequest &request) const
Model::CreateBucketAccessKeyOutcomeCallable CreateBucketAccessKeyCallable(const CreateBucketAccessKeyRequestT &request) const
virtual Model::GetLoadBalancerMetricDataOutcome GetLoadBalancerMetricData(const Model::GetLoadBalancerMetricDataRequest &request) const
void DeleteAlarmAsync(const DeleteAlarmRequestT &request, const DeleteAlarmResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::GetInstanceStateOutcomeCallable GetInstanceStateCallable(const GetInstanceStateRequestT &request) const
void GetOperationAsync(const GetOperationRequestT &request, const GetOperationResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::UpdateDistributionBundleOutcome UpdateDistributionBundle(const Model::UpdateDistributionBundleRequest &request={}) const
Model::GetLoadBalancerOutcomeCallable GetLoadBalancerCallable(const GetLoadBalancerRequestT &request) const
virtual Model::UpdateLoadBalancerAttributeOutcome UpdateLoadBalancerAttribute(const Model::UpdateLoadBalancerAttributeRequest &request) const
void DeleteLoadBalancerAsync(const DeleteLoadBalancerRequestT &request, const DeleteLoadBalancerResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void DetachCertificateFromDistributionAsync(const DetachCertificateFromDistributionRequestT &request, const DetachCertificateFromDistributionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::GetRelationalDatabaseMasterUserPasswordOutcomeCallable GetRelationalDatabaseMasterUserPasswordCallable(const GetRelationalDatabaseMasterUserPasswordRequestT &request) const
Model::GetRelationalDatabaseLogEventsOutcomeCallable GetRelationalDatabaseLogEventsCallable(const GetRelationalDatabaseLogEventsRequestT &request) const
void DeleteSubdomainAsync(const DeleteSubdomainRequestT &request, const DeleteSubdomainResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::CreateInstanceSnapshotOutcome CreateInstanceSnapshot(const Model::CreateInstanceSnapshotRequest &request) const
virtual Model::GetInstanceMetricDataOutcome GetInstanceMetricData(const Model::GetInstanceMetricDataRequest &request) const
Model::CreateRelationalDatabaseSnapshotOutcomeCallable CreateRelationalDatabaseSnapshotCallable(const CreateRelationalDatabaseSnapshotRequestT &request) const
void DeleteKnownHostKeysAsync(const DeleteKnownHostKeysRequestT &request, const DeleteKnownHostKeysResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest &request) const
virtual Model::SetupInstanceHttpsOutcome SetupInstanceHttps(const Model::SetupInstanceHttpsRequest &request) const
void GetBundlesAsync(const GetBundlesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetBundlesRequestT &request={}) const
virtual Model::GetInstancePortStatesOutcome GetInstancePortStates(const Model::GetInstancePortStatesRequest &request) const
virtual Model::DetachDiskOutcome DetachDisk(const Model::DetachDiskRequest &request) const
virtual Model::AttachStaticIpOutcome AttachStaticIp(const Model::AttachStaticIpRequest &request) const
virtual Model::CloseInstancePublicPortsOutcome CloseInstancePublicPorts(const Model::CloseInstancePublicPortsRequest &request) const
Model::CreateContainerServiceDeploymentOutcomeCallable CreateContainerServiceDeploymentCallable(const CreateContainerServiceDeploymentRequestT &request) const
virtual Model::GetRelationalDatabaseBlueprintsOutcome GetRelationalDatabaseBlueprints(const Model::GetRelationalDatabaseBlueprintsRequest &request={}) const
virtual Model::PutInstancePublicPortsOutcome PutInstancePublicPorts(const Model::PutInstancePublicPortsRequest &request) const
virtual Model::GetDomainsOutcome GetDomains(const Model::GetDomainsRequest &request={}) const
void CreateSubdomainAsync(const CreateSubdomainRequestT &request, const CreateSubdomainResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::GetDistributionLatestCacheResetOutcome GetDistributionLatestCacheReset(const Model::GetDistributionLatestCacheResetRequest &request={}) const
void DeleteAutoSnapshotAsync(const DeleteAutoSnapshotRequestT &request, const DeleteAutoSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void GetDiskSnapshotAsync(const GetDiskSnapshotRequestT &request, const GetDiskSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void PeerVpcAsync(const PeerVpcResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const PeerVpcRequestT &request={}) const
Model::DetachInstancesFromLoadBalancerOutcomeCallable DetachInstancesFromLoadBalancerCallable(const DetachInstancesFromLoadBalancerRequestT &request) const
void GetLoadBalancersAsync(const GetLoadBalancersResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetLoadBalancersRequestT &request={}) const
void GetAutoSnapshotsAsync(const GetAutoSnapshotsRequestT &request, const GetAutoSnapshotsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::GetBlueprintsOutcome GetBlueprints(const Model::GetBlueprintsRequest &request={}) const
Model::GetDomainsOutcomeCallable GetDomainsCallable(const GetDomainsRequestT &request={}) const
void DownloadDefaultKeyPairAsync(const DownloadDefaultKeyPairResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const DownloadDefaultKeyPairRequestT &request={}) const
Model::UpdateDistributionOutcomeCallable UpdateDistributionCallable(const UpdateDistributionRequestT &request) const
Model::AttachStaticIpOutcomeCallable AttachStaticIpCallable(const AttachStaticIpRequestT &request) const
void GetDistributionBundlesAsync(const GetDistributionBundlesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetDistributionBundlesRequestT &request={}) const
void CreateContainerServiceRegistryLoginAsync(const CreateContainerServiceRegistryLoginResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const CreateContainerServiceRegistryLoginRequestT &request={}) const
void UpdateRelationalDatabaseParametersAsync(const UpdateRelationalDatabaseParametersRequestT &request, const UpdateRelationalDatabaseParametersResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::GetBlueprintsOutcomeCallable GetBlueprintsCallable(const GetBlueprintsRequestT &request={}) const
void GetRelationalDatabaseLogEventsAsync(const GetRelationalDatabaseLogEventsRequestT &request, const GetRelationalDatabaseLogEventsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::GetRelationalDatabaseLogEventsOutcome GetRelationalDatabaseLogEvents(const Model::GetRelationalDatabaseLogEventsRequest &request) const
Model::GetStaticIpsOutcomeCallable GetStaticIpsCallable(const GetStaticIpsRequestT &request={}) const
virtual Model::GetExportSnapshotRecordsOutcome GetExportSnapshotRecords(const Model::GetExportSnapshotRecordsRequest &request={}) const
void CreateCertificateAsync(const CreateCertificateRequestT &request, const CreateCertificateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::DeleteLoadBalancerTlsCertificateOutcome DeleteLoadBalancerTlsCertificate(const Model::DeleteLoadBalancerTlsCertificateRequest &request) const
void SetIpAddressTypeAsync(const SetIpAddressTypeRequestT &request, const SetIpAddressTypeResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::UpdateRelationalDatabaseOutcome UpdateRelationalDatabase(const Model::UpdateRelationalDatabaseRequest &request) const
virtual Model::CreateContainerServiceOutcome CreateContainerService(const Model::CreateContainerServiceRequest &request) const
virtual Model::TestAlarmOutcome TestAlarm(const Model::TestAlarmRequest &request) const
Model::DeleteInstanceSnapshotOutcomeCallable DeleteInstanceSnapshotCallable(const DeleteInstanceSnapshotRequestT &request) const
Model::GetDiskSnapshotsOutcomeCallable GetDiskSnapshotsCallable(const GetDiskSnapshotsRequestT &request={}) const
virtual Model::GetAutoSnapshotsOutcome GetAutoSnapshots(const Model::GetAutoSnapshotsRequest &request) const
void GetStaticIpsAsync(const GetStaticIpsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetStaticIpsRequestT &request={}) const
void ImportKeyPairAsync(const ImportKeyPairRequestT &request, const ImportKeyPairResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual void OverrideEndpoint(const Aws::String &endpoint)
virtual Model::GetContainerLogOutcome GetContainerLog(const Model::GetContainerLogRequest &request) const
void StartGUISessionAsync(const StartGUISessionRequestT &request, const StartGUISessionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::CreateSubdomainOutcomeCallable CreateSubdomainCallable(const CreateSubdomainRequestT &request) const
virtual Model::GetInstanceOutcome GetInstance(const Model::GetInstanceRequest &request) const
Model::GetBucketBundlesOutcomeCallable GetBucketBundlesCallable(const GetBucketBundlesRequestT &request={}) const
Model::UpdateSubdomainAssociationOutcomeCallable UpdateSubdomainAssociationCallable(const UpdateSubdomainAssociationRequestT &request) const
void GetKeyPairsAsync(const GetKeyPairsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetKeyPairsRequestT &request={}) const
virtual Model::PeerVpcOutcome PeerVpc(const Model::PeerVpcRequest &request={}) const
Model::DeleteDiskOutcomeCallable DeleteDiskCallable(const DeleteDiskRequestT &request) const
void StopGUISessionAsync(const StopGUISessionRequestT &request, const StopGUISessionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void SetupInstanceHttpsAsync(const SetupInstanceHttpsRequestT &request, const SetupInstanceHttpsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::GetContainerServicesOutcomeCallable GetContainerServicesCallable(const GetContainerServicesRequestT &request={}) const
Model::DeleteKeyPairOutcomeCallable DeleteKeyPairCallable(const DeleteKeyPairRequestT &request) const
Model::StartRelationalDatabaseOutcomeCallable StartRelationalDatabaseCallable(const StartRelationalDatabaseRequestT &request) const
void GetCloudFormationStackRecordsAsync(const GetCloudFormationStackRecordsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetCloudFormationStackRecordsRequestT &request={}) const
void CreateDiskAsync(const CreateDiskRequestT &request, const CreateDiskResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void GetContainerImagesAsync(const GetContainerImagesRequestT &request, const GetContainerImagesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::GetLoadBalancerTlsCertificatesOutcome GetLoadBalancerTlsCertificates(const Model::GetLoadBalancerTlsCertificatesRequest &request) const
virtual Model::CreateLoadBalancerOutcome CreateLoadBalancer(const Model::CreateLoadBalancerRequest &request) const
Model::AttachCertificateToDistributionOutcomeCallable AttachCertificateToDistributionCallable(const AttachCertificateToDistributionRequestT &request) const
Model::GetInstanceSnapshotOutcomeCallable GetInstanceSnapshotCallable(const GetInstanceSnapshotRequestT &request) const
virtual Model::GetRelationalDatabasesOutcome GetRelationalDatabases(const Model::GetRelationalDatabasesRequest &request={}) const
void GetInstancesAsync(const GetInstancesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetInstancesRequestT &request={}) const
Model::GetLoadBalancerTlsPoliciesOutcomeCallable GetLoadBalancerTlsPoliciesCallable(const GetLoadBalancerTlsPoliciesRequestT &request={}) const
virtual Model::StartGUISessionOutcome StartGUISession(const Model::StartGUISessionRequest &request) const
virtual Model::DeleteBucketAccessKeyOutcome DeleteBucketAccessKey(const Model::DeleteBucketAccessKeyRequest &request) const
void UpdateDomainEntryAsync(const UpdateDomainEntryRequestT &request, const UpdateDomainEntryResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::DeleteRelationalDatabaseSnapshotOutcome DeleteRelationalDatabaseSnapshot(const Model::DeleteRelationalDatabaseSnapshotRequest &request) const
Model::GetBucketsOutcomeCallable GetBucketsCallable(const GetBucketsRequestT &request={}) const
void CreateCloudFormationStackAsync(const CreateCloudFormationStackRequestT &request, const CreateCloudFormationStackResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void GetCertificatesAsync(const GetCertificatesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetCertificatesRequestT &request={}) const
Model::GetBucketMetricDataOutcomeCallable GetBucketMetricDataCallable(const GetBucketMetricDataRequestT &request) const
void ExportSnapshotAsync(const ExportSnapshotRequestT &request, const ExportSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void CreateRelationalDatabaseSnapshotAsync(const CreateRelationalDatabaseSnapshotRequestT &request, const CreateRelationalDatabaseSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void AttachCertificateToDistributionAsync(const AttachCertificateToDistributionRequestT &request, const AttachCertificateToDistributionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void GetInstanceAccessDetailsAsync(const GetInstanceAccessDetailsRequestT &request, const GetInstanceAccessDetailsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::GetInstanceOutcomeCallable GetInstanceCallable(const GetInstanceRequestT &request) const
Model::CreateLoadBalancerTlsCertificateOutcomeCallable CreateLoadBalancerTlsCertificateCallable(const CreateLoadBalancerTlsCertificateRequestT &request) const
void StopRelationalDatabaseAsync(const StopRelationalDatabaseRequestT &request, const StopRelationalDatabaseResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::CreateDomainOutcomeCallable CreateDomainCallable(const CreateDomainRequestT &request) const
Model::DeleteSubdomainOutcomeCallable DeleteSubdomainCallable(const DeleteSubdomainRequestT &request) const
Model::GetContainerAPIMetadataOutcomeCallable GetContainerAPIMetadataCallable(const GetContainerAPIMetadataRequestT &request={}) const
void UpdateDistributionBundleAsync(const UpdateDistributionBundleResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const UpdateDistributionBundleRequestT &request={}) const
Model::DeleteLoadBalancerOutcomeCallable DeleteLoadBalancerCallable(const DeleteLoadBalancerRequestT &request) const
virtual Model::CheckSubdomainAvailabilityOutcome CheckSubdomainAvailability(const Model::CheckSubdomainAvailabilityRequest &request) const
Model::GetInstanceAccessDetailsOutcomeCallable GetInstanceAccessDetailsCallable(const GetInstanceAccessDetailsRequestT &request) const
void GetLoadBalancerMetricDataAsync(const GetLoadBalancerMetricDataRequestT &request, const GetLoadBalancerMetricDataResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::GetRelationalDatabaseMetricDataOutcome GetRelationalDatabaseMetricData(const Model::GetRelationalDatabaseMetricDataRequest &request) const
void GetInstanceMetricDataAsync(const GetInstanceMetricDataRequestT &request, const GetInstanceMetricDataResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::AttachLoadBalancerTlsCertificateOutcome AttachLoadBalancerTlsCertificate(const Model::AttachLoadBalancerTlsCertificateRequest &request) const
virtual Model::DeleteKnownHostKeysOutcome DeleteKnownHostKeys(const Model::DeleteKnownHostKeysRequest &request) const
Model::CreateContactMethodOutcomeCallable CreateContactMethodCallable(const CreateContactMethodRequestT &request) const
virtual Model::UpdateDistributionOutcome UpdateDistribution(const Model::UpdateDistributionRequest &request) const
void DeleteDistributionAsync(const DeleteDistributionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const DeleteDistributionRequestT &request={}) const
virtual Model::GetDistributionBundlesOutcome GetDistributionBundles(const Model::GetDistributionBundlesRequest &request={}) const
Model::GetLoadBalancerTlsCertificatesOutcomeCallable GetLoadBalancerTlsCertificatesCallable(const GetLoadBalancerTlsCertificatesRequestT &request) const
virtual Model::GetContainerAPIMetadataOutcome GetContainerAPIMetadata(const Model::GetContainerAPIMetadataRequest &request={}) const
void DeleteDomainEntryAsync(const DeleteDomainEntryRequestT &request, const DeleteDomainEntryResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::GetDiskOutcome GetDisk(const Model::GetDiskRequest &request) const
virtual Model::UpdateDomainEntryOutcome UpdateDomainEntry(const Model::UpdateDomainEntryRequest &request) const
void UpdateDistributionAsync(const UpdateDistributionRequestT &request, const UpdateDistributionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void UpdateInstanceMetadataOptionsAsync(const UpdateInstanceMetadataOptionsRequestT &request, const UpdateInstanceMetadataOptionsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::CheckSubdomainAvailabilityOutcomeCallable CheckSubdomainAvailabilityCallable(const CheckSubdomainAvailabilityRequestT &request) const
virtual Model::PutAlarmOutcome PutAlarm(const Model::PutAlarmRequest &request) const
Model::GetCloudFormationStackRecordsOutcomeCallable GetCloudFormationStackRecordsCallable(const GetCloudFormationStackRecordsRequestT &request={}) const
Model::GetContactMethodsOutcomeCallable GetContactMethodsCallable(const GetContactMethodsRequestT &request={}) const
Model::GetContainerServiceDeploymentsOutcomeCallable GetContainerServiceDeploymentsCallable(const GetContainerServiceDeploymentsRequestT &request) const
void GetDistributionLatestCacheResetAsync(const GetDistributionLatestCacheResetResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetDistributionLatestCacheResetRequestT &request={}) const
void GetInstanceSnapshotsAsync(const GetInstanceSnapshotsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetInstanceSnapshotsRequestT &request={}) const
void GetContainerAPIMetadataAsync(const GetContainerAPIMetadataResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetContainerAPIMetadataRequestT &request={}) const
void ReleaseStaticIpAsync(const ReleaseStaticIpRequestT &request, const ReleaseStaticIpResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void DeleteBucketAccessKeyAsync(const DeleteBucketAccessKeyRequestT &request, const DeleteBucketAccessKeyResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void GetRelationalDatabaseBundlesAsync(const GetRelationalDatabaseBundlesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetRelationalDatabaseBundlesRequestT &request={}) const
Model::DetachCertificateFromDistributionOutcomeCallable DetachCertificateFromDistributionCallable(const DetachCertificateFromDistributionRequestT &request) const
virtual Model::GetInstancesOutcome GetInstances(const Model::GetInstancesRequest &request={}) const
Model::UpdateRelationalDatabaseOutcomeCallable UpdateRelationalDatabaseCallable(const UpdateRelationalDatabaseRequestT &request) const
void GetDiskSnapshotsAsync(const GetDiskSnapshotsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetDiskSnapshotsRequestT &request={}) const
void DeleteLoadBalancerTlsCertificateAsync(const DeleteLoadBalancerTlsCertificateRequestT &request, const DeleteLoadBalancerTlsCertificateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::GetLoadBalancerTlsPoliciesOutcome GetLoadBalancerTlsPolicies(const Model::GetLoadBalancerTlsPoliciesRequest &request={}) const
Model::GetRegionsOutcomeCallable GetRegionsCallable(const GetRegionsRequestT &request={}) const
void RegisterContainerImageAsync(const RegisterContainerImageRequestT &request, const RegisterContainerImageResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void GetRelationalDatabasesAsync(const GetRelationalDatabasesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetRelationalDatabasesRequestT &request={}) const
void CreateInstancesAsync(const CreateInstancesRequestT &request, const CreateInstancesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::SetResourceAccessForBucketOutcome SetResourceAccessForBucket(const Model::SetResourceAccessForBucketRequest &request) const
virtual Model::StopInstanceOutcome StopInstance(const Model::StopInstanceRequest &request) const
void AttachLoadBalancerTlsCertificateAsync(const AttachLoadBalancerTlsCertificateRequestT &request, const AttachLoadBalancerTlsCertificateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::SetIpAddressTypeOutcome SetIpAddressType(const Model::SetIpAddressTypeRequest &request) const
virtual Model::GetRelationalDatabaseParametersOutcome GetRelationalDatabaseParameters(const Model::GetRelationalDatabaseParametersRequest &request) const
void CloseInstancePublicPortsAsync(const CloseInstancePublicPortsRequestT &request, const CloseInstancePublicPortsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::ImportKeyPairOutcomeCallable ImportKeyPairCallable(const ImportKeyPairRequestT &request) const
Model::GetProfileOutcomeCallable GetProfileCallable(const GetProfileRequestT &request={}) const
void DeleteContainerImageAsync(const DeleteContainerImageRequestT &request, const DeleteContainerImageResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void PutInstancePublicPortsAsync(const PutInstancePublicPortsRequestT &request, const PutInstancePublicPortsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::CopySnapshotOutcomeCallable CopySnapshotCallable(const CopySnapshotRequestT &request) const
void DisableAddOnAsync(const DisableAddOnRequestT &request, const DisableAddOnResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::CreateDomainEntryOutcome CreateDomainEntry(const Model::CreateDomainEntryRequest &request) const
virtual Model::DeleteDomainOutcome DeleteDomain(const Model::DeleteDomainRequest &request) const
virtual Model::UnpeerVpcOutcome UnpeerVpc(const Model::UnpeerVpcRequest &request={}) const
Model::UpdateRelationalDatabaseParametersOutcomeCallable UpdateRelationalDatabaseParametersCallable(const UpdateRelationalDatabaseParametersRequestT &request) const
void OpenInstancePublicPortsAsync(const OpenInstancePublicPortsRequestT &request, const OpenInstancePublicPortsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::CreateGUISessionAccessDetailsOutcomeCallable CreateGUISessionAccessDetailsCallable(const CreateGUISessionAccessDetailsRequestT &request) const
virtual Model::DownloadDefaultKeyPairOutcome DownloadDefaultKeyPair(const Model::DownloadDefaultKeyPairRequest &request={}) const
void DeleteRelationalDatabaseAsync(const DeleteRelationalDatabaseRequestT &request, const DeleteRelationalDatabaseResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::GetKeyPairsOutcomeCallable GetKeyPairsCallable(const GetKeyPairsRequestT &request={}) const
virtual Model::RegisterContainerImageOutcome RegisterContainerImage(const Model::RegisterContainerImageRequest &request) const
void CreateDomainEntryAsync(const CreateDomainEntryRequestT &request, const CreateDomainEntryResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::CreateBucketOutcome CreateBucket(const Model::CreateBucketRequest &request) const
virtual Model::ResetDistributionCacheOutcome ResetDistributionCache(const Model::ResetDistributionCacheRequest &request={}) const
LightsailClient(const Aws::Lightsail::LightsailClientConfiguration &clientConfiguration=Aws::Lightsail::LightsailClientConfiguration(), std::shared_ptr< LightsailEndpointProviderBase > endpointProvider=nullptr)
virtual Model::DisableAddOnOutcome DisableAddOn(const Model::DisableAddOnRequest &request) const
Model::TestAlarmOutcomeCallable TestAlarmCallable(const TestAlarmRequestT &request) const
Model::DeleteLoadBalancerTlsCertificateOutcomeCallable DeleteLoadBalancerTlsCertificateCallable(const DeleteLoadBalancerTlsCertificateRequestT &request) const
Model::GetInstanceSnapshotsOutcomeCallable GetInstanceSnapshotsCallable(const GetInstanceSnapshotsRequestT &request={}) const
Model::CreateRelationalDatabaseFromSnapshotOutcomeCallable CreateRelationalDatabaseFromSnapshotCallable(const CreateRelationalDatabaseFromSnapshotRequestT &request) const
Model::AttachLoadBalancerTlsCertificateOutcomeCallable AttachLoadBalancerTlsCertificateCallable(const AttachLoadBalancerTlsCertificateRequestT &request) const
Model::DeleteDiskSnapshotOutcomeCallable DeleteDiskSnapshotCallable(const DeleteDiskSnapshotRequestT &request) const
virtual Model::DeleteAutoSnapshotOutcome DeleteAutoSnapshot(const Model::DeleteAutoSnapshotRequest &request) const
Model::DeleteCertificateOutcomeCallable DeleteCertificateCallable(const DeleteCertificateRequestT &request) const
void SetResourceAccessForBucketAsync(const SetResourceAccessForBucketRequestT &request, const SetResourceAccessForBucketResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
LightsailClient(const Aws::Auth::AWSCredentials &credentials, std::shared_ptr< LightsailEndpointProviderBase > endpointProvider=nullptr, const Aws::Lightsail::LightsailClientConfiguration &clientConfiguration=Aws::Lightsail::LightsailClientConfiguration())
virtual Model::DetachCertificateFromDistributionOutcome DetachCertificateFromDistribution(const Model::DetachCertificateFromDistributionRequest &request) const
virtual Model::CreateCertificateOutcome CreateCertificate(const Model::CreateCertificateRequest &request) const
virtual Model::GetContainerServicePowersOutcome GetContainerServicePowers(const Model::GetContainerServicePowersRequest &request={}) const
LightsailClient(const std::shared_ptr< Aws::Auth::AWSCredentialsProvider > &credentialsProvider, std::shared_ptr< LightsailEndpointProviderBase > endpointProvider=nullptr, const Aws::Lightsail::LightsailClientConfiguration &clientConfiguration=Aws::Lightsail::LightsailClientConfiguration())
void CreateBucketAccessKeyAsync(const CreateBucketAccessKeyRequestT &request, const CreateBucketAccessKeyResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::CreateContactMethodOutcome CreateContactMethod(const Model::CreateContactMethodRequest &request) const
virtual Model::GetInstanceAccessDetailsOutcome GetInstanceAccessDetails(const Model::GetInstanceAccessDetailsRequest &request) const
Model::UpdateLoadBalancerAttributeOutcomeCallable UpdateLoadBalancerAttributeCallable(const UpdateLoadBalancerAttributeRequestT &request) const
virtual Model::GetBucketAccessKeysOutcome GetBucketAccessKeys(const Model::GetBucketAccessKeysRequest &request) const
virtual Model::DeleteDiskSnapshotOutcome DeleteDiskSnapshot(const Model::DeleteDiskSnapshotRequest &request) const
virtual Model::CreateRelationalDatabaseFromSnapshotOutcome CreateRelationalDatabaseFromSnapshot(const Model::CreateRelationalDatabaseFromSnapshotRequest &request) const
virtual Model::IsVpcPeeredOutcome IsVpcPeered(const Model::IsVpcPeeredRequest &request={}) const
Model::SendContactMethodVerificationOutcomeCallable SendContactMethodVerificationCallable(const SendContactMethodVerificationRequestT &request) const
virtual Model::RebootRelationalDatabaseOutcome RebootRelationalDatabase(const Model::RebootRelationalDatabaseRequest &request) const
Model::CreateInstancesFromSnapshotOutcomeCallable CreateInstancesFromSnapshotCallable(const CreateInstancesFromSnapshotRequestT &request) const
void GetOperationsForResourceAsync(const GetOperationsForResourceRequestT &request, const GetOperationsForResourceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual ~LightsailClient()
Model::CreateCertificateOutcomeCallable CreateCertificateCallable(const CreateCertificateRequestT &request) const
Model::GetLoadBalancerMetricDataOutcomeCallable GetLoadBalancerMetricDataCallable(const GetLoadBalancerMetricDataRequestT &request) const
Model::DetachDiskOutcomeCallable DetachDiskCallable(const DetachDiskRequestT &request) const
virtual Model::DeleteContactMethodOutcome DeleteContactMethod(const Model::DeleteContactMethodRequest &request) const
virtual Model::GetCloudFormationStackRecordsOutcome GetCloudFormationStackRecords(const Model::GetCloudFormationStackRecordsRequest &request={}) const
virtual Model::CreateGUISessionAccessDetailsOutcome CreateGUISessionAccessDetails(const Model::CreateGUISessionAccessDetailsRequest &request) const
void DeleteDomainAsync(const DeleteDomainRequestT &request, const DeleteDomainResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::AllocateStaticIpOutcomeCallable AllocateStaticIpCallable(const AllocateStaticIpRequestT &request) const
Model::CreateContainerServiceOutcomeCallable CreateContainerServiceCallable(const CreateContainerServiceRequestT &request) const
virtual Model::UpdateContainerServiceOutcome UpdateContainerService(const Model::UpdateContainerServiceRequest &request) const
Model::GetOperationsOutcomeCallable GetOperationsCallable(const GetOperationsRequestT &request={}) const
void CreateInstanceSnapshotAsync(const CreateInstanceSnapshotRequestT &request, const CreateInstanceSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::GetRelationalDatabaseMasterUserPasswordOutcome GetRelationalDatabaseMasterUserPassword(const Model::GetRelationalDatabaseMasterUserPasswordRequest &request) const
void TestAlarmAsync(const TestAlarmRequestT &request, const TestAlarmResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::CreateInstancesOutcome CreateInstances(const Model::CreateInstancesRequest &request) const
Model::OpenInstancePublicPortsOutcomeCallable OpenInstancePublicPortsCallable(const OpenInstancePublicPortsRequestT &request) const
virtual Model::GetRelationalDatabaseEventsOutcome GetRelationalDatabaseEvents(const Model::GetRelationalDatabaseEventsRequest &request) const
Model::GetSetupHistoryOutcomeCallable GetSetupHistoryCallable(const GetSetupHistoryRequestT &request) const
Model::GetContainerServicePowersOutcomeCallable GetContainerServicePowersCallable(const GetContainerServicePowersRequestT &request={}) const
void GetSubdomainsAsync(const GetSubdomainsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetSubdomainsRequestT &request={}) const
Model::UpdateBucketOutcomeCallable UpdateBucketCallable(const UpdateBucketRequestT &request) const
Model::DeleteRelationalDatabaseOutcomeCallable DeleteRelationalDatabaseCallable(const DeleteRelationalDatabaseRequestT &request) const
virtual Model::GetOperationOutcome GetOperation(const Model::GetOperationRequest &request) const
void GetRelationalDatabaseLogStreamsAsync(const GetRelationalDatabaseLogStreamsRequestT &request, const GetRelationalDatabaseLogStreamsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void TagResourceAsync(const TagResourceRequestT &request, const TagResourceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::RebootRelationalDatabaseOutcomeCallable RebootRelationalDatabaseCallable(const RebootRelationalDatabaseRequestT &request) const
void AttachDiskAsync(const AttachDiskRequestT &request, const AttachDiskResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::DeleteDiskOutcome DeleteDisk(const Model::DeleteDiskRequest &request) const
virtual Model::DeleteBucketOutcome DeleteBucket(const Model::DeleteBucketRequest &request) const
Model::SetIpAddressTypeOutcomeCallable SetIpAddressTypeCallable(const SetIpAddressTypeRequestT &request) const
Model::CreateRelationalDatabaseOutcomeCallable CreateRelationalDatabaseCallable(const CreateRelationalDatabaseRequestT &request) const
void CheckSubdomainAvailabilityAsync(const CheckSubdomainAvailabilityRequestT &request, const CheckSubdomainAvailabilityResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::PeerVpcOutcomeCallable PeerVpcCallable(const PeerVpcRequestT &request={}) const
void CreateRelationalDatabaseFromSnapshotAsync(const CreateRelationalDatabaseFromSnapshotRequestT &request, const CreateRelationalDatabaseFromSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::CreateDiskFromSnapshotOutcomeCallable CreateDiskFromSnapshotCallable(const CreateDiskFromSnapshotRequestT &request) const
void CreateDistributionAsync(const CreateDistributionRequestT &request, const CreateDistributionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::UpdateInstanceMetadataOptionsOutcomeCallable UpdateInstanceMetadataOptionsCallable(const UpdateInstanceMetadataOptionsRequestT &request) const
void EnableAddOnAsync(const EnableAddOnRequestT &request, const EnableAddOnResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void GetContainerServiceMetricDataAsync(const GetContainerServiceMetricDataRequestT &request, const GetContainerServiceMetricDataResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::GetDistributionLatestCacheResetOutcomeCallable GetDistributionLatestCacheResetCallable(const GetDistributionLatestCacheResetRequestT &request={}) const
Model::StopInstanceOutcomeCallable StopInstanceCallable(const StopInstanceRequestT &request) const
void StartInstanceAsync(const StartInstanceRequestT &request, const StartInstanceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void DeleteRelationalDatabaseSnapshotAsync(const DeleteRelationalDatabaseSnapshotRequestT &request, const DeleteRelationalDatabaseSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::GetBucketMetricDataOutcome GetBucketMetricData(const Model::GetBucketMetricDataRequest &request) const
virtual Model::DeleteContainerImageOutcome DeleteContainerImage(const Model::DeleteContainerImageRequest &request) const
Model::GetDomainOutcomeCallable GetDomainCallable(const GetDomainRequestT &request) const
Model::SetupInstanceHttpsOutcomeCallable SetupInstanceHttpsCallable(const SetupInstanceHttpsRequestT &request) const
void GetContainerServiceDeploymentsAsync(const GetContainerServiceDeploymentsRequestT &request, const GetContainerServiceDeploymentsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::GetDiskSnapshotOutcomeCallable GetDiskSnapshotCallable(const GetDiskSnapshotRequestT &request) const
Model::GetOperationOutcomeCallable GetOperationCallable(const GetOperationRequestT &request) const
Model::CreateDiskSnapshotOutcomeCallable CreateDiskSnapshotCallable(const CreateDiskSnapshotRequestT &request) const
Model::StopRelationalDatabaseOutcomeCallable StopRelationalDatabaseCallable(const StopRelationalDatabaseRequestT &request) const
virtual Model::GetOperationsForResourceOutcome GetOperationsForResource(const Model::GetOperationsForResourceRequest &request) const
virtual Model::GetBundlesOutcome GetBundles(const Model::GetBundlesRequest &request={}) const
virtual Model::UpdateSubdomainAssociationOutcome UpdateSubdomainAssociation(const Model::UpdateSubdomainAssociationRequest &request) const
void IsVpcPeeredAsync(const IsVpcPeeredResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const IsVpcPeeredRequestT &request={}) const
void GetContainerServicesAsync(const GetContainerServicesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetContainerServicesRequestT &request={}) const
Model::StopGUISessionOutcomeCallable StopGUISessionCallable(const StopGUISessionRequestT &request) const
Model::EnableAddOnOutcomeCallable EnableAddOnCallable(const EnableAddOnRequestT &request) const
Model::GetRelationalDatabaseMetricDataOutcomeCallable GetRelationalDatabaseMetricDataCallable(const GetRelationalDatabaseMetricDataRequestT &request) const
void CreateGUISessionAccessDetailsAsync(const CreateGUISessionAccessDetailsRequestT &request, const CreateGUISessionAccessDetailsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::DisableAddOnOutcomeCallable DisableAddOnCallable(const DisableAddOnRequestT &request) const
virtual Model::GetBucketBundlesOutcome GetBucketBundles(const Model::GetBucketBundlesRequest &request={}) const
void AttachInstancesToLoadBalancerAsync(const AttachInstancesToLoadBalancerRequestT &request, const AttachInstancesToLoadBalancerResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::RebootInstanceOutcome RebootInstance(const Model::RebootInstanceRequest &request) const
void CreateDomainAsync(const CreateDomainRequestT &request, const CreateDomainResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest &request) const
LightsailClient(const std::shared_ptr< Aws::Auth::AWSCredentialsProvider > &credentialsProvider, const Aws::Client::ClientConfiguration &clientConfiguration)
virtual Model::CreateInstancesFromSnapshotOutcome CreateInstancesFromSnapshot(const Model::CreateInstancesFromSnapshotRequest &request) const
virtual Model::DeleteContainerServiceOutcome DeleteContainerService(const Model::DeleteContainerServiceRequest &request) const
virtual Model::UpdateBucketBundleOutcome UpdateBucketBundle(const Model::UpdateBucketBundleRequest &request) const
virtual Model::GetDisksOutcome GetDisks(const Model::GetDisksRequest &request={}) const
void GetInstanceSnapshotAsync(const GetInstanceSnapshotRequestT &request, const GetInstanceSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::CopySnapshotOutcome CopySnapshot(const Model::CopySnapshotRequest &request) const
void CreateLoadBalancerTlsCertificateAsync(const CreateLoadBalancerTlsCertificateRequestT &request, const CreateLoadBalancerTlsCertificateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void DeleteDiskSnapshotAsync(const DeleteDiskSnapshotRequestT &request, const DeleteDiskSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void GetRegionsAsync(const GetRegionsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetRegionsRequestT &request={}) const
virtual Model::GetDistributionsOutcome GetDistributions(const Model::GetDistributionsRequest &request={}) const
Model::DeleteContainerServiceOutcomeCallable DeleteContainerServiceCallable(const DeleteContainerServiceRequestT &request) const
void GetContactMethodsAsync(const GetContactMethodsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetContactMethodsRequestT &request={}) const
void CreateInstancesFromSnapshotAsync(const CreateInstancesFromSnapshotRequestT &request, const CreateInstancesFromSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void GetLoadBalancerAsync(const GetLoadBalancerRequestT &request, const GetLoadBalancerResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::CreateDiskSnapshotOutcome CreateDiskSnapshot(const Model::CreateDiskSnapshotRequest &request) const
virtual Model::ImportKeyPairOutcome ImportKeyPair(const Model::ImportKeyPairRequest &request) const
void GetBlueprintsAsync(const GetBlueprintsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetBlueprintsRequestT &request={}) const
void DeleteKeyPairAsync(const DeleteKeyPairRequestT &request, const DeleteKeyPairResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::UpdateRelationalDatabaseParametersOutcome UpdateRelationalDatabaseParameters(const Model::UpdateRelationalDatabaseParametersRequest &request) const
virtual Model::GetDomainOutcome GetDomain(const Model::GetDomainRequest &request) const
Model::GetInstanceMetricDataOutcomeCallable GetInstanceMetricDataCallable(const GetInstanceMetricDataRequestT &request) const
void GetRelationalDatabaseSnapshotsAsync(const GetRelationalDatabaseSnapshotsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetRelationalDatabaseSnapshotsRequestT &request={}) const
virtual Model::GetRelationalDatabaseSnapshotOutcome GetRelationalDatabaseSnapshot(const Model::GetRelationalDatabaseSnapshotRequest &request) const
virtual Model::GetContainerServiceDeploymentsOutcome GetContainerServiceDeployments(const Model::GetContainerServiceDeploymentsRequest &request) const
Model::GetCostEstimateOutcomeCallable GetCostEstimateCallable(const GetCostEstimateRequestT &request) const
virtual Model::CreateDomainOutcome CreateDomain(const Model::CreateDomainRequest &request) const
virtual Model::GetContainerServicesOutcome GetContainerServices(const Model::GetContainerServicesRequest &request={}) const
void GetInstanceAsync(const GetInstanceRequestT &request, const GetInstanceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void GetAlarmsAsync(const GetAlarmsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetAlarmsRequestT &request={}) const
Model::GetRelationalDatabaseEventsOutcomeCallable GetRelationalDatabaseEventsCallable(const GetRelationalDatabaseEventsRequestT &request) const
Model::CreateDistributionOutcomeCallable CreateDistributionCallable(const CreateDistributionRequestT &request) const
Model::GetDistributionMetricDataOutcomeCallable GetDistributionMetricDataCallable(const GetDistributionMetricDataRequestT &request) const
Model::ExportSnapshotOutcomeCallable ExportSnapshotCallable(const ExportSnapshotRequestT &request) const
virtual Model::DeleteKeyPairOutcome DeleteKeyPair(const Model::DeleteKeyPairRequest &request) const
virtual Model::GetProfileOutcome GetProfile(const Model::GetProfileRequest &request={}) const
static const char * GetAllocationTag()
Aws::Client::AWSJsonClient BASECLASS
virtual Model::ReleaseStaticIpOutcome ReleaseStaticIp(const Model::ReleaseStaticIpRequest &request) const
virtual Model::GetInstanceSnapshotsOutcome GetInstanceSnapshots(const Model::GetInstanceSnapshotsRequest &request={}) const
Model::GetRelationalDatabaseParametersOutcomeCallable GetRelationalDatabaseParametersCallable(const GetRelationalDatabaseParametersRequestT &request) const
virtual Model::GetCertificatesOutcome GetCertificates(const Model::GetCertificatesRequest &request={}) const
void GetBucketMetricDataAsync(const GetBucketMetricDataRequestT &request, const GetBucketMetricDataResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::GetRelationalDatabaseOutcome GetRelationalDatabase(const Model::GetRelationalDatabaseRequest &request) const
virtual Model::UpdateBucketOutcome UpdateBucket(const Model::UpdateBucketRequest &request) const
void GetDiskAsync(const GetDiskRequestT &request, const GetDiskResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
LightsailClient(const Aws::Auth::AWSCredentials &credentials, const Aws::Client::ClientConfiguration &clientConfiguration)
Model::GetExportSnapshotRecordsOutcomeCallable GetExportSnapshotRecordsCallable(const GetExportSnapshotRecordsRequestT &request={}) const
Model::GetAlarmsOutcomeCallable GetAlarmsCallable(const GetAlarmsRequestT &request={}) const
void GetInstancePortStatesAsync(const GetInstancePortStatesRequestT &request, const GetInstancePortStatesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::ExportSnapshotOutcome ExportSnapshot(const Model::ExportSnapshotRequest &request) const
virtual Model::AttachDiskOutcome AttachDisk(const Model::AttachDiskRequest &request) const
Model::AttachDiskOutcomeCallable AttachDiskCallable(const AttachDiskRequestT &request) const
Model::GetSubdomainsOutcomeCallable GetSubdomainsCallable(const GetSubdomainsRequestT &request={}) const
virtual Model::OpenInstancePublicPortsOutcome OpenInstancePublicPorts(const Model::OpenInstancePublicPortsRequest &request) const
Model::SetResourceAccessForBucketOutcomeCallable SetResourceAccessForBucketCallable(const SetResourceAccessForBucketRequestT &request) const
void GetBucketsAsync(const GetBucketsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetBucketsRequestT &request={}) const
Model::GetInstancePortStatesOutcomeCallable GetInstancePortStatesCallable(const GetInstancePortStatesRequestT &request) const
virtual Model::GetContainerServiceMetricDataOutcome GetContainerServiceMetricData(const Model::GetContainerServiceMetricDataRequest &request) const
void CreateDiskSnapshotAsync(const CreateDiskSnapshotRequestT &request, const CreateDiskSnapshotResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::GetDisksOutcomeCallable GetDisksCallable(const GetDisksRequestT &request={}) const
void DetachInstancesFromLoadBalancerAsync(const DetachInstancesFromLoadBalancerRequestT &request, const DetachInstancesFromLoadBalancerResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::DeleteKnownHostKeysOutcomeCallable DeleteKnownHostKeysCallable(const DeleteKnownHostKeysRequestT &request) const
virtual Model::DeleteCertificateOutcome DeleteCertificate(const Model::DeleteCertificateRequest &request) const
void DeleteBucketAsync(const DeleteBucketRequestT &request, const DeleteBucketResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::CreateSubdomainOutcome CreateSubdomain(const Model::CreateSubdomainRequest &request) const
virtual Model::DeleteDomainEntryOutcome DeleteDomainEntry(const Model::DeleteDomainEntryRequest &request) const
virtual Model::DeleteAlarmOutcome DeleteAlarm(const Model::DeleteAlarmRequest &request) const
void GetDomainsAsync(const GetDomainsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetDomainsRequestT &request={}) const
void DeleteCertificateAsync(const DeleteCertificateRequestT &request, const DeleteCertificateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void AttachStaticIpAsync(const AttachStaticIpRequestT &request, const AttachStaticIpResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::GetOperationsOutcome GetOperations(const Model::GetOperationsRequest &request={}) const
virtual Model::SendContactMethodVerificationOutcome SendContactMethodVerification(const Model::SendContactMethodVerificationRequest &request) const
Model::UpdateBucketBundleOutcomeCallable UpdateBucketBundleCallable(const UpdateBucketBundleRequestT &request) const
Model::CreateLoadBalancerOutcomeCallable CreateLoadBalancerCallable(const CreateLoadBalancerRequestT &request) const
void UpdateContainerServiceAsync(const UpdateContainerServiceRequestT &request, const UpdateContainerServiceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::CreateRelationalDatabaseOutcome CreateRelationalDatabase(const Model::CreateRelationalDatabaseRequest &request) const
Model::GetBundlesOutcomeCallable GetBundlesCallable(const GetBundlesRequestT &request={}) const
Model::DeleteRelationalDatabaseSnapshotOutcomeCallable DeleteRelationalDatabaseSnapshotCallable(const DeleteRelationalDatabaseSnapshotRequestT &request) const
void GetContainerServicePowersAsync(const GetContainerServicePowersResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetContainerServicePowersRequestT &request={}) const
void UpdateLoadBalancerAttributeAsync(const UpdateLoadBalancerAttributeRequestT &request, const UpdateLoadBalancerAttributeResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::StopRelationalDatabaseOutcome StopRelationalDatabase(const Model::StopRelationalDatabaseRequest &request) const
void GetDisksAsync(const GetDisksResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetDisksRequestT &request={}) const
void CreateBucketAsync(const CreateBucketRequestT &request, const CreateBucketResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::DeleteLoadBalancerOutcome DeleteLoadBalancer(const Model::DeleteLoadBalancerRequest &request) const
virtual Model::AttachInstancesToLoadBalancerOutcome AttachInstancesToLoadBalancer(const Model::AttachInstancesToLoadBalancerRequest &request) const
virtual Model::AttachCertificateToDistributionOutcome AttachCertificateToDistribution(const Model::AttachCertificateToDistributionRequest &request) const
virtual Model::GetKeyPairOutcome GetKeyPair(const Model::GetKeyPairRequest &request) const
Model::StartInstanceOutcomeCallable StartInstanceCallable(const StartInstanceRequestT &request) const
void DeleteInstanceAsync(const DeleteInstanceRequestT &request, const DeleteInstanceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::CreateInstanceSnapshotOutcomeCallable CreateInstanceSnapshotCallable(const CreateInstanceSnapshotRequestT &request) const
void DetachDiskAsync(const DetachDiskRequestT &request, const DetachDiskResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::CloseInstancePublicPortsOutcomeCallable CloseInstancePublicPortsCallable(const CloseInstancePublicPortsRequestT &request) const
Model::DeleteDistributionOutcomeCallable DeleteDistributionCallable(const DeleteDistributionRequestT &request={}) const
void DetachStaticIpAsync(const DetachStaticIpRequestT &request, const DetachStaticIpResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
virtual Model::DeleteDistributionOutcome DeleteDistribution(const Model::DeleteDistributionRequest &request={}) const
Model::DeleteAlarmOutcomeCallable DeleteAlarmCallable(const DeleteAlarmRequestT &request) const
Model::DeleteContactMethodOutcomeCallable DeleteContactMethodCallable(const DeleteContactMethodRequestT &request) const
Model::GetDistributionBundlesOutcomeCallable GetDistributionBundlesCallable(const GetDistributionBundlesRequestT &request={}) const
Model::CreateKeyPairOutcomeCallable CreateKeyPairCallable(const CreateKeyPairRequestT &request) const
void RebootInstanceAsync(const RebootInstanceRequestT &request, const RebootInstanceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void DeleteDiskAsync(const DeleteDiskRequestT &request, const DeleteDiskResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
Model::DeleteContainerImageOutcomeCallable DeleteContainerImageCallable(const DeleteContainerImageRequestT &request) const
void GetLoadBalancerTlsPoliciesAsync(const GetLoadBalancerTlsPoliciesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetLoadBalancerTlsPoliciesRequestT &request={}) const
Model::CreateDomainEntryOutcomeCallable CreateDomainEntryCallable(const CreateDomainEntryRequestT &request) const
void GetActiveNamesAsync(const GetActiveNamesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetActiveNamesRequestT &request={}) const
virtual Model::GetStaticIpsOutcome GetStaticIps(const Model::GetStaticIpsRequest &request={}) const
void GetContainerLogAsync(const GetContainerLogRequestT &request, const GetContainerLogResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
void GetRelationalDatabaseBlueprintsAsync(const GetRelationalDatabaseBlueprintsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetRelationalDatabaseBlueprintsRequestT &request={}) const
void GetOperationsAsync(const GetOperationsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetOperationsRequestT &request={}) const
Model::GetActiveNamesOutcomeCallable GetActiveNamesCallable(const GetActiveNamesRequestT &request={}) const
virtual Model::GetContainerImagesOutcome GetContainerImages(const Model::GetContainerImagesRequest &request) const
void GetKeyPairAsync(const GetKeyPairRequestT &request, const GetKeyPairResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
std::future< RebootInstanceOutcome > RebootInstanceOutcomeCallable
std::future< TestAlarmOutcome > TestAlarmOutcomeCallable
std::future< StartRelationalDatabaseOutcome > StartRelationalDatabaseOutcomeCallable
std::future< GetActiveNamesOutcome > GetActiveNamesOutcomeCallable
std::future< GetKeyPairOutcome > GetKeyPairOutcomeCallable
std::future< StopInstanceOutcome > StopInstanceOutcomeCallable
std::future< AttachDiskOutcome > AttachDiskOutcomeCallable
std::future< SetupInstanceHttpsOutcome > SetupInstanceHttpsOutcomeCallable
std::future< UpdateLoadBalancerAttributeOutcome > UpdateLoadBalancerAttributeOutcomeCallable
std::future< GetLoadBalancerTlsPoliciesOutcome > GetLoadBalancerTlsPoliciesOutcomeCallable
std::future< GetOperationsOutcome > GetOperationsOutcomeCallable
std::future< GetRegionsOutcome > GetRegionsOutcomeCallable
std::future< CloseInstancePublicPortsOutcome > CloseInstancePublicPortsOutcomeCallable
std::future< PeerVpcOutcome > PeerVpcOutcomeCallable
std::future< CreateDiskFromSnapshotOutcome > CreateDiskFromSnapshotOutcomeCallable
std::future< CreateContainerServiceRegistryLoginOutcome > CreateContainerServiceRegistryLoginOutcomeCallable
std::future< UpdateDomainEntryOutcome > UpdateDomainEntryOutcomeCallable
std::future< GetInstanceAccessDetailsOutcome > GetInstanceAccessDetailsOutcomeCallable
std::future< DeleteContainerImageOutcome > DeleteContainerImageOutcomeCallable
std::future< PutInstancePublicPortsOutcome > PutInstancePublicPortsOutcomeCallable
std::future< DetachCertificateFromDistributionOutcome > DetachCertificateFromDistributionOutcomeCallable
std::future< GetContainerServicesOutcome > GetContainerServicesOutcomeCallable
std::future< CreateContainerServiceOutcome > CreateContainerServiceOutcomeCallable
std::future< DownloadDefaultKeyPairOutcome > DownloadDefaultKeyPairOutcomeCallable
std::future< CreateDomainOutcome > CreateDomainOutcomeCallable
std::future< CreateContainerServiceDeploymentOutcome > CreateContainerServiceDeploymentOutcomeCallable
std::future< GetContainerServiceDeploymentsOutcome > GetContainerServiceDeploymentsOutcomeCallable
std::future< GetDomainsOutcome > GetDomainsOutcomeCallable
std::future< CreateDomainEntryOutcome > CreateDomainEntryOutcomeCallable
std::future< ImportKeyPairOutcome > ImportKeyPairOutcomeCallable
std::future< CreateRelationalDatabaseFromSnapshotOutcome > CreateRelationalDatabaseFromSnapshotOutcomeCallable
std::future< UpdateSubdomainAssociationOutcome > UpdateSubdomainAssociationOutcomeCallable
std::future< GetLoadBalancerMetricDataOutcome > GetLoadBalancerMetricDataOutcomeCallable
std::future< DeleteContainerServiceOutcome > DeleteContainerServiceOutcomeCallable
std::future< DeleteKnownHostKeysOutcome > DeleteKnownHostKeysOutcomeCallable
std::future< AllocateStaticIpOutcome > AllocateStaticIpOutcomeCallable
std::future< ExportSnapshotOutcome > ExportSnapshotOutcomeCallable
std::future< GetDiskSnapshotsOutcome > GetDiskSnapshotsOutcomeCallable
std::future< DeleteAlarmOutcome > DeleteAlarmOutcomeCallable
std::future< CreateLoadBalancerTlsCertificateOutcome > CreateLoadBalancerTlsCertificateOutcomeCallable
std::future< SetIpAddressTypeOutcome > SetIpAddressTypeOutcomeCallable
std::future< CreateLoadBalancerOutcome > CreateLoadBalancerOutcomeCallable
std::future< GetInstanceSnapshotsOutcome > GetInstanceSnapshotsOutcomeCallable
std::future< DetachStaticIpOutcome > DetachStaticIpOutcomeCallable
std::future< DeleteLoadBalancerOutcome > DeleteLoadBalancerOutcomeCallable
std::future< AttachStaticIpOutcome > AttachStaticIpOutcomeCallable
std::future< GetExportSnapshotRecordsOutcome > GetExportSnapshotRecordsOutcomeCallable
std::future< CreateRelationalDatabaseSnapshotOutcome > CreateRelationalDatabaseSnapshotOutcomeCallable
std::future< GetDistributionLatestCacheResetOutcome > GetDistributionLatestCacheResetOutcomeCallable
std::future< CreateDiskOutcome > CreateDiskOutcomeCallable
std::future< AttachInstancesToLoadBalancerOutcome > AttachInstancesToLoadBalancerOutcomeCallable
std::future< PutAlarmOutcome > PutAlarmOutcomeCallable
std::future< GetCostEstimateOutcome > GetCostEstimateOutcomeCallable
std::future< GetInstanceMetricDataOutcome > GetInstanceMetricDataOutcomeCallable
std::future< DeleteContactMethodOutcome > DeleteContactMethodOutcomeCallable
std::future< GetContainerAPIMetadataOutcome > GetContainerAPIMetadataOutcomeCallable
std::future< GetLoadBalancersOutcome > GetLoadBalancersOutcomeCallable
std::future< CreateInstancesFromSnapshotOutcome > CreateInstancesFromSnapshotOutcomeCallable
std::future< UpdateRelationalDatabaseOutcome > UpdateRelationalDatabaseOutcomeCallable
std::future< CreateInstancesOutcome > CreateInstancesOutcomeCallable
std::future< GetContainerServiceMetricDataOutcome > GetContainerServiceMetricDataOutcomeCallable
std::future< IsVpcPeeredOutcome > IsVpcPeeredOutcomeCallable
std::future< DisableAddOnOutcome > DisableAddOnOutcomeCallable
std::future< AttachLoadBalancerTlsCertificateOutcome > AttachLoadBalancerTlsCertificateOutcomeCallable
std::future< TagResourceOutcome > TagResourceOutcomeCallable
std::future< CreateKeyPairOutcome > CreateKeyPairOutcomeCallable
std::future< GetBucketAccessKeysOutcome > GetBucketAccessKeysOutcomeCallable
std::future< CreateInstanceSnapshotOutcome > CreateInstanceSnapshotOutcomeCallable
std::future< UpdateInstanceMetadataOptionsOutcome > UpdateInstanceMetadataOptionsOutcomeCallable
std::future< GetBucketBundlesOutcome > GetBucketBundlesOutcomeCallable
std::future< GetProfileOutcome > GetProfileOutcomeCallable
std::future< DeleteInstanceSnapshotOutcome > DeleteInstanceSnapshotOutcomeCallable
std::future< GetKeyPairsOutcome > GetKeyPairsOutcomeCallable
std::future< UntagResourceOutcome > UntagResourceOutcomeCallable
std::future< CopySnapshotOutcome > CopySnapshotOutcomeCallable
std::future< GetRelationalDatabaseMetricDataOutcome > GetRelationalDatabaseMetricDataOutcomeCallable
std::future< GetInstancesOutcome > GetInstancesOutcomeCallable
std::future< DeleteLoadBalancerTlsCertificateOutcome > DeleteLoadBalancerTlsCertificateOutcomeCallable
std::future< CreateBucketOutcome > CreateBucketOutcomeCallable
std::future< GetRelationalDatabaseSnapshotsOutcome > GetRelationalDatabaseSnapshotsOutcomeCallable
std::future< RebootRelationalDatabaseOutcome > RebootRelationalDatabaseOutcomeCallable
std::future< DeleteDiskSnapshotOutcome > DeleteDiskSnapshotOutcomeCallable
std::future< CreateCloudFormationStackOutcome > CreateCloudFormationStackOutcomeCallable
std::future< GetBlueprintsOutcome > GetBlueprintsOutcomeCallable
std::future< AttachCertificateToDistributionOutcome > AttachCertificateToDistributionOutcomeCallable
std::future< GetOperationOutcome > GetOperationOutcomeCallable
std::future< GetContainerImagesOutcome > GetContainerImagesOutcomeCallable
std::future< GetRelationalDatabaseParametersOutcome > GetRelationalDatabaseParametersOutcomeCallable
std::future< GetRelationalDatabaseLogStreamsOutcome > GetRelationalDatabaseLogStreamsOutcomeCallable
std::future< StartGUISessionOutcome > StartGUISessionOutcomeCallable
std::future< GetContainerServicePowersOutcome > GetContainerServicePowersOutcomeCallable
std::future< RegisterContainerImageOutcome > RegisterContainerImageOutcomeCallable
std::future< UpdateDistributionBundleOutcome > UpdateDistributionBundleOutcomeCallable
std::future< CreateGUISessionAccessDetailsOutcome > CreateGUISessionAccessDetailsOutcomeCallable
std::future< GetBucketsOutcome > GetBucketsOutcomeCallable
std::future< GetDistributionMetricDataOutcome > GetDistributionMetricDataOutcomeCallable
std::future< DeleteRelationalDatabaseSnapshotOutcome > DeleteRelationalDatabaseSnapshotOutcomeCallable
std::future< GetInstancePortStatesOutcome > GetInstancePortStatesOutcomeCallable
std::future< GetAlarmsOutcome > GetAlarmsOutcomeCallable
std::future< GetDistributionBundlesOutcome > GetDistributionBundlesOutcomeCallable
std::future< CreateSubdomainOutcome > CreateSubdomainOutcomeCallable
std::future< UpdateRelationalDatabaseParametersOutcome > UpdateRelationalDatabaseParametersOutcomeCallable
std::future< DeleteAutoSnapshotOutcome > DeleteAutoSnapshotOutcomeCallable
std::future< DeleteCertificateOutcome > DeleteCertificateOutcomeCallable
std::future< UnpeerVpcOutcome > UnpeerVpcOutcomeCallable
std::future< GetRelationalDatabaseBlueprintsOutcome > GetRelationalDatabaseBlueprintsOutcomeCallable
std::future< GetDiskSnapshotOutcome > GetDiskSnapshotOutcomeCallable
std::future< CreateRelationalDatabaseOutcome > CreateRelationalDatabaseOutcomeCallable
std::future< GetBucketMetricDataOutcome > GetBucketMetricDataOutcomeCallable
std::future< DeleteSubdomainOutcome > DeleteSubdomainOutcomeCallable
std::future< GetCloudFormationStackRecordsOutcome > GetCloudFormationStackRecordsOutcomeCallable
std::future< GetRelationalDatabaseOutcome > GetRelationalDatabaseOutcomeCallable
std::future< SetResourceAccessForBucketOutcome > SetResourceAccessForBucketOutcomeCallable
std::future< GetAutoSnapshotsOutcome > GetAutoSnapshotsOutcomeCallable
std::future< CreateDiskSnapshotOutcome > CreateDiskSnapshotOutcomeCallable
std::future< GetSetupHistoryOutcome > GetSetupHistoryOutcomeCallable
std::future< GetLoadBalancerTlsCertificatesOutcome > GetLoadBalancerTlsCertificatesOutcomeCallable
std::future< DeleteInstanceOutcome > DeleteInstanceOutcomeCallable
std::future< GetContainerLogOutcome > GetContainerLogOutcomeCallable
std::future< GetRelationalDatabaseSnapshotOutcome > GetRelationalDatabaseSnapshotOutcomeCallable
std::future< DeleteDistributionOutcome > DeleteDistributionOutcomeCallable
std::future< GetRelationalDatabaseMasterUserPasswordOutcome > GetRelationalDatabaseMasterUserPasswordOutcomeCallable
std::future< GetBundlesOutcome > GetBundlesOutcomeCallable
std::future< GetLoadBalancerOutcome > GetLoadBalancerOutcomeCallable
std::future< GetStaticIpsOutcome > GetStaticIpsOutcomeCallable
std::future< GetDistributionsOutcome > GetDistributionsOutcomeCallable
std::future< DeleteBucketAccessKeyOutcome > DeleteBucketAccessKeyOutcomeCallable
std::future< SendContactMethodVerificationOutcome > SendContactMethodVerificationOutcomeCallable
std::future< ResetDistributionCacheOutcome > ResetDistributionCacheOutcomeCallable
std::future< GetRelationalDatabasesOutcome > GetRelationalDatabasesOutcomeCallable
std::future< DeleteDomainEntryOutcome > DeleteDomainEntryOutcomeCallable
std::future< DetachDiskOutcome > DetachDiskOutcomeCallable
std::future< UpdateDistributionOutcome > UpdateDistributionOutcomeCallable
std::future< DeleteRelationalDatabaseOutcome > DeleteRelationalDatabaseOutcomeCallable
std::future< ReleaseStaticIpOutcome > ReleaseStaticIpOutcomeCallable
std::future< CreateCertificateOutcome > CreateCertificateOutcomeCallable
std::future< UpdateContainerServiceOutcome > UpdateContainerServiceOutcomeCallable
std::future< GetRelationalDatabaseBundlesOutcome > GetRelationalDatabaseBundlesOutcomeCallable
std::future< CreateContactMethodOutcome > CreateContactMethodOutcomeCallable
std::future< GetStaticIpOutcome > GetStaticIpOutcomeCallable
std::future< GetContactMethodsOutcome > GetContactMethodsOutcomeCallable
std::future< GetDisksOutcome > GetDisksOutcomeCallable
std::future< DetachInstancesFromLoadBalancerOutcome > DetachInstancesFromLoadBalancerOutcomeCallable
std::future< OpenInstancePublicPortsOutcome > OpenInstancePublicPortsOutcomeCallable
std::future< CreateBucketAccessKeyOutcome > CreateBucketAccessKeyOutcomeCallable
std::future< UpdateBucketBundleOutcome > UpdateBucketBundleOutcomeCallable
std::future< CreateDistributionOutcome > CreateDistributionOutcomeCallable
std::future< StopRelationalDatabaseOutcome > StopRelationalDatabaseOutcomeCallable
std::future< GetRelationalDatabaseLogEventsOutcome > GetRelationalDatabaseLogEventsOutcomeCallable
std::future< StartInstanceOutcome > StartInstanceOutcomeCallable
std::future< GetDomainOutcome > GetDomainOutcomeCallable
std::future< DeleteKeyPairOutcome > DeleteKeyPairOutcomeCallable
std::future< DeleteDiskOutcome > DeleteDiskOutcomeCallable
std::future< GetDiskOutcome > GetDiskOutcomeCallable
std::future< CheckSubdomainAvailabilityOutcome > CheckSubdomainAvailabilityOutcomeCallable
std::future< StopGUISessionOutcome > StopGUISessionOutcomeCallable
std::future< GetOperationsForResourceOutcome > GetOperationsForResourceOutcomeCallable
std::future< GetSubdomainsOutcome > GetSubdomainsOutcomeCallable
std::future< UpdateBucketOutcome > UpdateBucketOutcomeCallable
std::future< GetInstanceOutcome > GetInstanceOutcomeCallable
std::future< GetInstanceSnapshotOutcome > GetInstanceSnapshotOutcomeCallable
std::future< GetRelationalDatabaseEventsOutcome > GetRelationalDatabaseEventsOutcomeCallable
std::future< DeleteDomainOutcome > DeleteDomainOutcomeCallable
std::future< GetCertificatesOutcome > GetCertificatesOutcomeCallable
std::future< DeleteBucketOutcome > DeleteBucketOutcomeCallable
std::future< EnableAddOnOutcome > EnableAddOnOutcomeCallable
std::future< GetInstanceStateOutcome > GetInstanceStateOutcomeCallable
std::function< void(const LightsailClient *, const Model::CreateDiskRequest &, const Model::CreateDiskOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateDiskResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateInstanceSnapshotRequest &, const Model::CreateInstanceSnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateInstanceSnapshotResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::AllocateStaticIpRequest &, const Model::AllocateStaticIpOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> AllocateStaticIpResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetSetupHistoryRequest &, const Model::GetSetupHistoryOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetSetupHistoryResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateBucketRequest &, const Model::CreateBucketOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateBucketResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DetachStaticIpRequest &, const Model::DetachStaticIpOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DetachStaticIpResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetRelationalDatabaseMetricDataRequest &, const Model::GetRelationalDatabaseMetricDataOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetRelationalDatabaseMetricDataResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteContainerImageRequest &, const Model::DeleteContainerImageOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteContainerImageResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteLoadBalancerRequest &, const Model::DeleteLoadBalancerOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteLoadBalancerResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteContainerServiceRequest &, const Model::DeleteContainerServiceOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteContainerServiceResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::TagResourceRequest &, const Model::TagResourceOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> TagResourceResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetLoadBalancersRequest &, const Model::GetLoadBalancersOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetLoadBalancersResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::RebootInstanceRequest &, const Model::RebootInstanceOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> RebootInstanceResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DetachDiskRequest &, const Model::DetachDiskOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DetachDiskResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetProfileRequest &, const Model::GetProfileOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetProfileResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetBucketAccessKeysRequest &, const Model::GetBucketAccessKeysOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetBucketAccessKeysResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::UpdateDistributionBundleRequest &, const Model::UpdateDistributionBundleOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> UpdateDistributionBundleResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateCloudFormationStackRequest &, const Model::CreateCloudFormationStackOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateCloudFormationStackResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateRelationalDatabaseSnapshotRequest &, const Model::CreateRelationalDatabaseSnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateRelationalDatabaseSnapshotResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::OpenInstancePublicPortsRequest &, const Model::OpenInstancePublicPortsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> OpenInstancePublicPortsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetContainerLogRequest &, const Model::GetContainerLogOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetContainerLogResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetBlueprintsRequest &, const Model::GetBlueprintsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetBlueprintsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetLoadBalancerTlsCertificatesRequest &, const Model::GetLoadBalancerTlsCertificatesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetLoadBalancerTlsCertificatesResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetLoadBalancerRequest &, const Model::GetLoadBalancerOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetLoadBalancerResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetContainerServicesRequest &, const Model::GetContainerServicesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetContainerServicesResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetRelationalDatabaseLogEventsRequest &, const Model::GetRelationalDatabaseLogEventsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetRelationalDatabaseLogEventsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetLoadBalancerMetricDataRequest &, const Model::GetLoadBalancerMetricDataOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetLoadBalancerMetricDataResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetRelationalDatabaseEventsRequest &, const Model::GetRelationalDatabaseEventsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetRelationalDatabaseEventsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetBucketMetricDataRequest &, const Model::GetBucketMetricDataOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetBucketMetricDataResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetCloudFormationStackRecordsRequest &, const Model::GetCloudFormationStackRecordsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetCloudFormationStackRecordsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetInstancesRequest &, const Model::GetInstancesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetInstancesResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetInstanceStateRequest &, const Model::GetInstanceStateOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetInstanceStateResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateInstancesRequest &, const Model::CreateInstancesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateInstancesResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteCertificateRequest &, const Model::DeleteCertificateOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteCertificateResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteBucketRequest &, const Model::DeleteBucketOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteBucketResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetDisksRequest &, const Model::GetDisksOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetDisksResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CloseInstancePublicPortsRequest &, const Model::CloseInstancePublicPortsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CloseInstancePublicPortsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::ExportSnapshotRequest &, const Model::ExportSnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> ExportSnapshotResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateContainerServiceRegistryLoginRequest &, const Model::CreateContainerServiceRegistryLoginOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateContainerServiceRegistryLoginResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteRelationalDatabaseRequest &, const Model::DeleteRelationalDatabaseOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteRelationalDatabaseResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateDistributionRequest &, const Model::CreateDistributionOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateDistributionResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetDistributionLatestCacheResetRequest &, const Model::GetDistributionLatestCacheResetOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetDistributionLatestCacheResetResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::StartGUISessionRequest &, const Model::StartGUISessionOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> StartGUISessionResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetCertificatesRequest &, const Model::GetCertificatesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetCertificatesResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetContainerAPIMetadataRequest &, const Model::GetContainerAPIMetadataOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetContainerAPIMetadataResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteInstanceRequest &, const Model::DeleteInstanceOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteInstanceResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetStaticIpsRequest &, const Model::GetStaticIpsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetStaticIpsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateContactMethodRequest &, const Model::CreateContactMethodOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateContactMethodResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::UpdateBucketBundleRequest &, const Model::UpdateBucketBundleOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> UpdateBucketBundleResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetRelationalDatabaseSnapshotsRequest &, const Model::GetRelationalDatabaseSnapshotsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetRelationalDatabaseSnapshotsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetRelationalDatabasesRequest &, const Model::GetRelationalDatabasesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetRelationalDatabasesResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::TestAlarmRequest &, const Model::TestAlarmOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> TestAlarmResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteDiskRequest &, const Model::DeleteDiskOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteDiskResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteDomainRequest &, const Model::DeleteDomainOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteDomainResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::StopInstanceRequest &, const Model::StopInstanceOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> StopInstanceResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CheckSubdomainAvailabilityRequest &, const Model::CheckSubdomainAvailabilityOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CheckSubdomainAvailabilityResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::StartRelationalDatabaseRequest &, const Model::StartRelationalDatabaseOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> StartRelationalDatabaseResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::IsVpcPeeredRequest &, const Model::IsVpcPeeredOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> IsVpcPeeredResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetOperationRequest &, const Model::GetOperationOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetOperationResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::UpdateSubdomainAssociationRequest &, const Model::UpdateSubdomainAssociationOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> UpdateSubdomainAssociationResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetRelationalDatabaseRequest &, const Model::GetRelationalDatabaseOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetRelationalDatabaseResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::ResetDistributionCacheRequest &, const Model::ResetDistributionCacheOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> ResetDistributionCacheResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::AttachDiskRequest &, const Model::AttachDiskOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> AttachDiskResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::EnableAddOnRequest &, const Model::EnableAddOnOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> EnableAddOnResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateRelationalDatabaseRequest &, const Model::CreateRelationalDatabaseOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateRelationalDatabaseResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateContainerServiceRequest &, const Model::CreateContainerServiceOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateContainerServiceResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetRelationalDatabaseBlueprintsRequest &, const Model::GetRelationalDatabaseBlueprintsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetRelationalDatabaseBlueprintsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteKnownHostKeysRequest &, const Model::DeleteKnownHostKeysOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteKnownHostKeysResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetBucketBundlesRequest &, const Model::GetBucketBundlesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetBucketBundlesResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::RebootRelationalDatabaseRequest &, const Model::RebootRelationalDatabaseOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> RebootRelationalDatabaseResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetStaticIpRequest &, const Model::GetStaticIpOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetStaticIpResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetContainerServicePowersRequest &, const Model::GetContainerServicePowersOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetContainerServicePowersResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteRelationalDatabaseSnapshotRequest &, const Model::DeleteRelationalDatabaseSnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteRelationalDatabaseSnapshotResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateLoadBalancerRequest &, const Model::CreateLoadBalancerOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateLoadBalancerResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::StartInstanceRequest &, const Model::StartInstanceOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> StartInstanceResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::UpdateRelationalDatabaseParametersRequest &, const Model::UpdateRelationalDatabaseParametersOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> UpdateRelationalDatabaseParametersResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetDomainRequest &, const Model::GetDomainOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetDomainResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteInstanceSnapshotRequest &, const Model::DeleteInstanceSnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteInstanceSnapshotResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateDomainEntryRequest &, const Model::CreateDomainEntryOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateDomainEntryResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::SendContactMethodVerificationRequest &, const Model::SendContactMethodVerificationOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> SendContactMethodVerificationResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::AttachLoadBalancerTlsCertificateRequest &, const Model::AttachLoadBalancerTlsCertificateOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> AttachLoadBalancerTlsCertificateResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteAlarmRequest &, const Model::DeleteAlarmOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteAlarmResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::StopGUISessionRequest &, const Model::StopGUISessionOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> StopGUISessionResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteDistributionRequest &, const Model::DeleteDistributionOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteDistributionResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::SetIpAddressTypeRequest &, const Model::SetIpAddressTypeOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> SetIpAddressTypeResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateRelationalDatabaseFromSnapshotRequest &, const Model::CreateRelationalDatabaseFromSnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateRelationalDatabaseFromSnapshotResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetRelationalDatabaseSnapshotRequest &, const Model::GetRelationalDatabaseSnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetRelationalDatabaseSnapshotResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::UpdateRelationalDatabaseRequest &, const Model::UpdateRelationalDatabaseOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> UpdateRelationalDatabaseResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::UntagResourceRequest &, const Model::UntagResourceOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> UntagResourceResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::UpdateBucketRequest &, const Model::UpdateBucketOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> UpdateBucketResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetInstancePortStatesRequest &, const Model::GetInstancePortStatesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetInstancePortStatesResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::AttachStaticIpRequest &, const Model::AttachStaticIpOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> AttachStaticIpResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetLoadBalancerTlsPoliciesRequest &, const Model::GetLoadBalancerTlsPoliciesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetLoadBalancerTlsPoliciesResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetInstanceRequest &, const Model::GetInstanceOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetInstanceResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::SetupInstanceHttpsRequest &, const Model::SetupInstanceHttpsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> SetupInstanceHttpsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateDiskFromSnapshotRequest &, const Model::CreateDiskFromSnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateDiskFromSnapshotResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetRelationalDatabaseMasterUserPasswordRequest &, const Model::GetRelationalDatabaseMasterUserPasswordOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetRelationalDatabaseMasterUserPasswordResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetRelationalDatabaseLogStreamsRequest &, const Model::GetRelationalDatabaseLogStreamsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetRelationalDatabaseLogStreamsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateDomainRequest &, const Model::CreateDomainOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateDomainResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::AttachCertificateToDistributionRequest &, const Model::AttachCertificateToDistributionOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> AttachCertificateToDistributionResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::UpdateDomainEntryRequest &, const Model::UpdateDomainEntryOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> UpdateDomainEntryResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetContainerServiceDeploymentsRequest &, const Model::GetContainerServiceDeploymentsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetContainerServiceDeploymentsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DetachInstancesFromLoadBalancerRequest &, const Model::DetachInstancesFromLoadBalancerOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DetachInstancesFromLoadBalancerResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteDiskSnapshotRequest &, const Model::DeleteDiskSnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteDiskSnapshotResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::PutAlarmRequest &, const Model::PutAlarmOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> PutAlarmResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::UpdateInstanceMetadataOptionsRequest &, const Model::UpdateInstanceMetadataOptionsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> UpdateInstanceMetadataOptionsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateGUISessionAccessDetailsRequest &, const Model::CreateGUISessionAccessDetailsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateGUISessionAccessDetailsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetDistributionBundlesRequest &, const Model::GetDistributionBundlesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetDistributionBundlesResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetBundlesRequest &, const Model::GetBundlesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetBundlesResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DisableAddOnRequest &, const Model::DisableAddOnOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DisableAddOnResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::UnpeerVpcRequest &, const Model::UnpeerVpcOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> UnpeerVpcResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateDiskSnapshotRequest &, const Model::CreateDiskSnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateDiskSnapshotResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetKeyPairsRequest &, const Model::GetKeyPairsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetKeyPairsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetOperationsForResourceRequest &, const Model::GetOperationsForResourceOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetOperationsForResourceResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteSubdomainRequest &, const Model::DeleteSubdomainOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteSubdomainResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::RegisterContainerImageRequest &, const Model::RegisterContainerImageOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> RegisterContainerImageResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteDomainEntryRequest &, const Model::DeleteDomainEntryOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteDomainEntryResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::StopRelationalDatabaseRequest &, const Model::StopRelationalDatabaseOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> StopRelationalDatabaseResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetActiveNamesRequest &, const Model::GetActiveNamesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetActiveNamesResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetAlarmsRequest &, const Model::GetAlarmsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetAlarmsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateLoadBalancerTlsCertificateRequest &, const Model::CreateLoadBalancerTlsCertificateOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateLoadBalancerTlsCertificateResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetAutoSnapshotsRequest &, const Model::GetAutoSnapshotsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetAutoSnapshotsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::PeerVpcRequest &, const Model::PeerVpcOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> PeerVpcResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetCostEstimateRequest &, const Model::GetCostEstimateOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetCostEstimateResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetInstanceSnapshotsRequest &, const Model::GetInstanceSnapshotsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetInstanceSnapshotsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetDistributionsRequest &, const Model::GetDistributionsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetDistributionsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetSubdomainsRequest &, const Model::GetSubdomainsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetSubdomainsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetDiskRequest &, const Model::GetDiskOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetDiskResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::AttachInstancesToLoadBalancerRequest &, const Model::AttachInstancesToLoadBalancerOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> AttachInstancesToLoadBalancerResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DetachCertificateFromDistributionRequest &, const Model::DetachCertificateFromDistributionOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DetachCertificateFromDistributionResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetInstanceSnapshotRequest &, const Model::GetInstanceSnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetInstanceSnapshotResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetInstanceAccessDetailsRequest &, const Model::GetInstanceAccessDetailsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetInstanceAccessDetailsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteContactMethodRequest &, const Model::DeleteContactMethodOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteContactMethodResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::UpdateContainerServiceRequest &, const Model::UpdateContainerServiceOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> UpdateContainerServiceResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateInstancesFromSnapshotRequest &, const Model::CreateInstancesFromSnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateInstancesFromSnapshotResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetContainerServiceMetricDataRequest &, const Model::GetContainerServiceMetricDataOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetContainerServiceMetricDataResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetContainerImagesRequest &, const Model::GetContainerImagesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetContainerImagesResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetRelationalDatabaseBundlesRequest &, const Model::GetRelationalDatabaseBundlesOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetRelationalDatabaseBundlesResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateContainerServiceDeploymentRequest &, const Model::CreateContainerServiceDeploymentOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateContainerServiceDeploymentResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::UpdateLoadBalancerAttributeRequest &, const Model::UpdateLoadBalancerAttributeOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> UpdateLoadBalancerAttributeResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateKeyPairRequest &, const Model::CreateKeyPairOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateKeyPairResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetOperationsRequest &, const Model::GetOperationsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetOperationsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CopySnapshotRequest &, const Model::CopySnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CopySnapshotResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::ReleaseStaticIpRequest &, const Model::ReleaseStaticIpOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> ReleaseStaticIpResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetDiskSnapshotsRequest &, const Model::GetDiskSnapshotsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetDiskSnapshotsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateBucketAccessKeyRequest &, const Model::CreateBucketAccessKeyOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateBucketAccessKeyResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetKeyPairRequest &, const Model::GetKeyPairOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetKeyPairResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DownloadDefaultKeyPairRequest &, const Model::DownloadDefaultKeyPairOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DownloadDefaultKeyPairResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetInstanceMetricDataRequest &, const Model::GetInstanceMetricDataOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetInstanceMetricDataResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteBucketAccessKeyRequest &, const Model::DeleteBucketAccessKeyOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteBucketAccessKeyResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetBucketsRequest &, const Model::GetBucketsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetBucketsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::UpdateDistributionRequest &, const Model::UpdateDistributionOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> UpdateDistributionResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteLoadBalancerTlsCertificateRequest &, const Model::DeleteLoadBalancerTlsCertificateOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteLoadBalancerTlsCertificateResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteKeyPairRequest &, const Model::DeleteKeyPairOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteKeyPairResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateCertificateRequest &, const Model::CreateCertificateOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateCertificateResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::SetResourceAccessForBucketRequest &, const Model::SetResourceAccessForBucketOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> SetResourceAccessForBucketResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetRegionsRequest &, const Model::GetRegionsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetRegionsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::DeleteAutoSnapshotRequest &, const Model::DeleteAutoSnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> DeleteAutoSnapshotResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetDiskSnapshotRequest &, const Model::GetDiskSnapshotOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetDiskSnapshotResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::CreateSubdomainRequest &, const Model::CreateSubdomainOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> CreateSubdomainResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetRelationalDatabaseParametersRequest &, const Model::GetRelationalDatabaseParametersOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetRelationalDatabaseParametersResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::ImportKeyPairRequest &, const Model::ImportKeyPairOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> ImportKeyPairResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetContactMethodsRequest &, const Model::GetContactMethodsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetContactMethodsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetDomainsRequest &, const Model::GetDomainsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetDomainsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetDistributionMetricDataRequest &, const Model::GetDistributionMetricDataOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetDistributionMetricDataResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::PutInstancePublicPortsRequest &, const Model::PutInstancePublicPortsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> PutInstancePublicPortsResponseReceivedHandler
std::function< void(const LightsailClient *, const Model::GetExportSnapshotRecordsRequest &, const Model::GetExportSnapshotRecordsOutcome &, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &)> GetExportSnapshotRecordsResponseReceivedHandler
std::basic_string< char, std::char_traits< char >, Aws::Allocator< char > > String