AWS SDK for C++

AWS SDK for C++ Version 1.11.929

Loading...
Searching...
No Matches
LightsailClient.h
1
6#pragma once
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>
15
16namespace Aws {
17namespace Lightsail {
38class AWS_LIGHTSAIL_API LightsailClient : public Aws::Client::AWSJsonClient,
39 public Aws::Client::ClientWithAsyncTemplateMethods<LightsailClient>,
40 public LightsailPaginationBase<LightsailClient>,
41 public LightsailWaiter<LightsailClient> {
42 public:
44 static const char* GetServiceName();
45 static const char* GetAllocationTag();
46
47 typedef LightsailClientConfiguration ClientConfigurationType;
49
54 LightsailClient(const Aws::Lightsail::LightsailClientConfiguration& clientConfiguration = Aws::Lightsail::LightsailClientConfiguration(),
55 std::shared_ptr<LightsailEndpointProviderBase> endpointProvider = nullptr);
56
61 LightsailClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<LightsailEndpointProviderBase> endpointProvider = nullptr,
62 const Aws::Lightsail::LightsailClientConfiguration& clientConfiguration = Aws::Lightsail::LightsailClientConfiguration());
63
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());
71
72 /* Legacy constructors due deprecation */
78
83 LightsailClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
84
89 LightsailClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
90 const Aws::Client::ClientConfiguration& clientConfiguration);
91
92 /* End of legacy constructors due deprecation */
94
101
106 template <typename AllocateStaticIpRequestT = Model::AllocateStaticIpRequest>
107 Model::AllocateStaticIpOutcomeCallable AllocateStaticIpCallable(const AllocateStaticIpRequestT& request) const {
108 return SubmitCallable(&LightsailClient::AllocateStaticIp, request);
109 }
110
115 template <typename AllocateStaticIpRequestT = Model::AllocateStaticIpRequest>
116 void AllocateStaticIpAsync(const AllocateStaticIpRequestT& request, const AllocateStaticIpResponseReceivedHandler& handler,
117 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
118 return SubmitAsync(&LightsailClient::AllocateStaticIp, request, handler, context);
119 }
120
137
142 template <typename AttachCertificateToDistributionRequestT = Model::AttachCertificateToDistributionRequest>
144 const AttachCertificateToDistributionRequestT& request) const {
145 return SubmitCallable(&LightsailClient::AttachCertificateToDistribution, request);
146 }
147
152 template <typename AttachCertificateToDistributionRequestT = Model::AttachCertificateToDistributionRequest>
153 void AttachCertificateToDistributionAsync(const AttachCertificateToDistributionRequestT& request,
155 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
156 return SubmitAsync(&LightsailClient::AttachCertificateToDistribution, request, handler, context);
157 }
158
171
175 template <typename AttachDiskRequestT = Model::AttachDiskRequest>
176 Model::AttachDiskOutcomeCallable AttachDiskCallable(const AttachDiskRequestT& request) const {
177 return SubmitCallable(&LightsailClient::AttachDisk, request);
178 }
179
184 template <typename AttachDiskRequestT = Model::AttachDiskRequest>
185 void AttachDiskAsync(const AttachDiskRequestT& request, const AttachDiskResponseReceivedHandler& handler,
186 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
187 return SubmitAsync(&LightsailClient::AttachDisk, request, handler, context);
188 }
189
204
209 template <typename AttachInstancesToLoadBalancerRequestT = Model::AttachInstancesToLoadBalancerRequest>
211 const AttachInstancesToLoadBalancerRequestT& request) const {
212 return SubmitCallable(&LightsailClient::AttachInstancesToLoadBalancer, request);
213 }
214
219 template <typename AttachInstancesToLoadBalancerRequestT = Model::AttachInstancesToLoadBalancerRequest>
220 void AttachInstancesToLoadBalancerAsync(const AttachInstancesToLoadBalancerRequestT& request,
222 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
223 return SubmitAsync(&LightsailClient::AttachInstancesToLoadBalancer, request, handler, context);
224 }
225
244
249 template <typename AttachLoadBalancerTlsCertificateRequestT = Model::AttachLoadBalancerTlsCertificateRequest>
251 const AttachLoadBalancerTlsCertificateRequestT& request) const {
252 return SubmitCallable(&LightsailClient::AttachLoadBalancerTlsCertificate, request);
253 }
254
259 template <typename AttachLoadBalancerTlsCertificateRequestT = Model::AttachLoadBalancerTlsCertificateRequest>
260 void AttachLoadBalancerTlsCertificateAsync(const AttachLoadBalancerTlsCertificateRequestT& request,
262 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
263 return SubmitAsync(&LightsailClient::AttachLoadBalancerTlsCertificate, request, handler, context);
264 }
265
273
277 template <typename AttachStaticIpRequestT = Model::AttachStaticIpRequest>
278 Model::AttachStaticIpOutcomeCallable AttachStaticIpCallable(const AttachStaticIpRequestT& request) const {
279 return SubmitCallable(&LightsailClient::AttachStaticIp, request);
280 }
281
286 template <typename AttachStaticIpRequestT = Model::AttachStaticIpRequest>
287 void AttachStaticIpAsync(const AttachStaticIpRequestT& request, const AttachStaticIpResponseReceivedHandler& handler,
288 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
289 return SubmitAsync(&LightsailClient::AttachStaticIp, request, handler, context);
290 }
291
301 const Model::CheckSubdomainAvailabilityRequest& request) const;
302
307 template <typename CheckSubdomainAvailabilityRequestT = Model::CheckSubdomainAvailabilityRequest>
309 const CheckSubdomainAvailabilityRequestT& request) const {
310 return SubmitCallable(&LightsailClient::CheckSubdomainAvailability, request);
311 }
312
317 template <typename CheckSubdomainAvailabilityRequestT = Model::CheckSubdomainAvailabilityRequest>
318 void CheckSubdomainAvailabilityAsync(const CheckSubdomainAvailabilityRequestT& request,
320 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
321 return SubmitAsync(&LightsailClient::CheckSubdomainAvailability, request, handler, context);
322 }
323
335
340 template <typename CloseInstancePublicPortsRequestT = Model::CloseInstancePublicPortsRequest>
341 Model::CloseInstancePublicPortsOutcomeCallable CloseInstancePublicPortsCallable(const CloseInstancePublicPortsRequestT& request) const {
342 return SubmitCallable(&LightsailClient::CloseInstancePublicPorts, request);
343 }
344
349 template <typename CloseInstancePublicPortsRequestT = Model::CloseInstancePublicPortsRequest>
350 void CloseInstancePublicPortsAsync(const CloseInstancePublicPortsRequestT& request,
352 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
353 return SubmitAsync(&LightsailClient::CloseInstancePublicPorts, request, handler, context);
354 }
355
372
376 template <typename CopySnapshotRequestT = Model::CopySnapshotRequest>
377 Model::CopySnapshotOutcomeCallable CopySnapshotCallable(const CopySnapshotRequestT& request) const {
378 return SubmitCallable(&LightsailClient::CopySnapshot, request);
379 }
380
385 template <typename CopySnapshotRequestT = Model::CopySnapshotRequest>
386 void CopySnapshotAsync(const CopySnapshotRequestT& request, const CopySnapshotResponseReceivedHandler& handler,
387 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
388 return SubmitAsync(&LightsailClient::CopySnapshot, request, handler, context);
389 }
390
403
407 template <typename CreateBucketRequestT = Model::CreateBucketRequest>
408 Model::CreateBucketOutcomeCallable CreateBucketCallable(const CreateBucketRequestT& request) const {
409 return SubmitCallable(&LightsailClient::CreateBucket, request);
410 }
411
416 template <typename CreateBucketRequestT = Model::CreateBucketRequest>
417 void CreateBucketAsync(const CreateBucketRequestT& request, const CreateBucketResponseReceivedHandler& handler,
418 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
419 return SubmitAsync(&LightsailClient::CreateBucket, request, handler, context);
420 }
421
441
446 template <typename CreateBucketAccessKeyRequestT = Model::CreateBucketAccessKeyRequest>
447 Model::CreateBucketAccessKeyOutcomeCallable CreateBucketAccessKeyCallable(const CreateBucketAccessKeyRequestT& request) const {
448 return SubmitCallable(&LightsailClient::CreateBucketAccessKey, request);
449 }
450
455 template <typename CreateBucketAccessKeyRequestT = Model::CreateBucketAccessKeyRequest>
456 void CreateBucketAccessKeyAsync(const CreateBucketAccessKeyRequestT& request, const CreateBucketAccessKeyResponseReceivedHandler& handler,
457 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
458 return SubmitAsync(&LightsailClient::CreateBucketAccessKey, request, handler, context);
459 }
460
477
482 template <typename CreateCertificateRequestT = Model::CreateCertificateRequest>
483 Model::CreateCertificateOutcomeCallable CreateCertificateCallable(const CreateCertificateRequestT& request) const {
484 return SubmitCallable(&LightsailClient::CreateCertificate, request);
485 }
486
491 template <typename CreateCertificateRequestT = Model::CreateCertificateRequest>
492 void CreateCertificateAsync(const CreateCertificateRequestT& request, const CreateCertificateResponseReceivedHandler& handler,
493 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
494 return SubmitAsync(&LightsailClient::CreateCertificate, request, handler, context);
495 }
496
510
515 template <typename CreateCloudFormationStackRequestT = Model::CreateCloudFormationStackRequest>
517 const CreateCloudFormationStackRequestT& request) const {
518 return SubmitCallable(&LightsailClient::CreateCloudFormationStack, request);
519 }
520
525 template <typename CreateCloudFormationStackRequestT = Model::CreateCloudFormationStackRequest>
526 void CreateCloudFormationStackAsync(const CreateCloudFormationStackRequestT& request,
528 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
529 return SubmitAsync(&LightsailClient::CreateCloudFormationStack, request, handler, context);
530 }
531
549
554 template <typename CreateContactMethodRequestT = Model::CreateContactMethodRequest>
555 Model::CreateContactMethodOutcomeCallable CreateContactMethodCallable(const CreateContactMethodRequestT& request) const {
556 return SubmitCallable(&LightsailClient::CreateContactMethod, request);
557 }
558
563 template <typename CreateContactMethodRequestT = Model::CreateContactMethodRequest>
564 void CreateContactMethodAsync(const CreateContactMethodRequestT& request, const CreateContactMethodResponseReceivedHandler& handler,
565 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
566 return SubmitAsync(&LightsailClient::CreateContactMethod, request, handler, context);
567 }
568
580
585 template <typename CreateContainerServiceRequestT = Model::CreateContainerServiceRequest>
586 Model::CreateContainerServiceOutcomeCallable CreateContainerServiceCallable(const CreateContainerServiceRequestT& request) const {
587 return SubmitCallable(&LightsailClient::CreateContainerService, request);
588 }
589
594 template <typename CreateContainerServiceRequestT = Model::CreateContainerServiceRequest>
595 void CreateContainerServiceAsync(const CreateContainerServiceRequestT& request,
597 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
598 return SubmitAsync(&LightsailClient::CreateContainerService, request, handler, context);
599 }
600
619
624 template <typename CreateContainerServiceDeploymentRequestT = Model::CreateContainerServiceDeploymentRequest>
626 const CreateContainerServiceDeploymentRequestT& request) const {
627 return SubmitCallable(&LightsailClient::CreateContainerServiceDeployment, request);
628 }
629
634 template <typename CreateContainerServiceDeploymentRequestT = Model::CreateContainerServiceDeploymentRequest>
635 void CreateContainerServiceDeploymentAsync(const CreateContainerServiceDeploymentRequestT& request,
637 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
638 return SubmitAsync(&LightsailClient::CreateContainerServiceDeployment, request, handler, context);
639 }
640
666 const Model::CreateContainerServiceRegistryLoginRequest& request = {}) const;
667
672 template <typename CreateContainerServiceRegistryLoginRequestT = Model::CreateContainerServiceRegistryLoginRequest>
674 const CreateContainerServiceRegistryLoginRequestT& request = {}) const {
675 return SubmitCallable(&LightsailClient::CreateContainerServiceRegistryLogin, request);
676 }
677
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);
687 }
688
700
704 template <typename CreateDiskRequestT = Model::CreateDiskRequest>
705 Model::CreateDiskOutcomeCallable CreateDiskCallable(const CreateDiskRequestT& request) const {
706 return SubmitCallable(&LightsailClient::CreateDisk, request);
707 }
708
713 template <typename CreateDiskRequestT = Model::CreateDiskRequest>
714 void CreateDiskAsync(const CreateDiskRequestT& request, const CreateDiskResponseReceivedHandler& handler,
715 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
716 return SubmitAsync(&LightsailClient::CreateDisk, request, handler, context);
717 }
718
732
737 template <typename CreateDiskFromSnapshotRequestT = Model::CreateDiskFromSnapshotRequest>
738 Model::CreateDiskFromSnapshotOutcomeCallable CreateDiskFromSnapshotCallable(const CreateDiskFromSnapshotRequestT& request) const {
739 return SubmitCallable(&LightsailClient::CreateDiskFromSnapshot, request);
740 }
741
746 template <typename CreateDiskFromSnapshotRequestT = Model::CreateDiskFromSnapshotRequest>
747 void CreateDiskFromSnapshotAsync(const CreateDiskFromSnapshotRequestT& request,
749 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
750 return SubmitAsync(&LightsailClient::CreateDiskFromSnapshot, request, handler, context);
751 }
752
781
786 template <typename CreateDiskSnapshotRequestT = Model::CreateDiskSnapshotRequest>
787 Model::CreateDiskSnapshotOutcomeCallable CreateDiskSnapshotCallable(const CreateDiskSnapshotRequestT& request) const {
788 return SubmitCallable(&LightsailClient::CreateDiskSnapshot, request);
789 }
790
795 template <typename CreateDiskSnapshotRequestT = Model::CreateDiskSnapshotRequest>
796 void CreateDiskSnapshotAsync(const CreateDiskSnapshotRequestT& request, const CreateDiskSnapshotResponseReceivedHandler& handler,
797 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
798 return SubmitAsync(&LightsailClient::CreateDiskSnapshot, request, handler, context);
799 }
800
812
817 template <typename CreateDistributionRequestT = Model::CreateDistributionRequest>
818 Model::CreateDistributionOutcomeCallable CreateDistributionCallable(const CreateDistributionRequestT& request) const {
819 return SubmitCallable(&LightsailClient::CreateDistribution, request);
820 }
821
826 template <typename CreateDistributionRequestT = Model::CreateDistributionRequest>
827 void CreateDistributionAsync(const CreateDistributionRequestT& request, const CreateDistributionResponseReceivedHandler& handler,
828 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
829 return SubmitAsync(&LightsailClient::CreateDistribution, request, handler, context);
830 }
831
842
846 template <typename CreateDomainRequestT = Model::CreateDomainRequest>
847 Model::CreateDomainOutcomeCallable CreateDomainCallable(const CreateDomainRequestT& request) const {
848 return SubmitCallable(&LightsailClient::CreateDomain, request);
849 }
850
855 template <typename CreateDomainRequestT = Model::CreateDomainRequest>
856 void CreateDomainAsync(const CreateDomainRequestT& request, const CreateDomainResponseReceivedHandler& handler,
857 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
858 return SubmitAsync(&LightsailClient::CreateDomain, request, handler, context);
859 }
860
874
879 template <typename CreateDomainEntryRequestT = Model::CreateDomainEntryRequest>
880 Model::CreateDomainEntryOutcomeCallable CreateDomainEntryCallable(const CreateDomainEntryRequestT& request) const {
881 return SubmitCallable(&LightsailClient::CreateDomainEntry, request);
882 }
883
888 template <typename CreateDomainEntryRequestT = Model::CreateDomainEntryRequest>
889 void CreateDomainEntryAsync(const CreateDomainEntryRequestT& request, const CreateDomainEntryResponseReceivedHandler& handler,
890 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
891 return SubmitAsync(&LightsailClient::CreateDomainEntry, request, handler, context);
892 }
893
906
911 template <typename CreateGUISessionAccessDetailsRequestT = Model::CreateGUISessionAccessDetailsRequest>
913 const CreateGUISessionAccessDetailsRequestT& request) const {
914 return SubmitCallable(&LightsailClient::CreateGUISessionAccessDetails, request);
915 }
916
921 template <typename CreateGUISessionAccessDetailsRequestT = Model::CreateGUISessionAccessDetailsRequest>
922 void CreateGUISessionAccessDetailsAsync(const CreateGUISessionAccessDetailsRequestT& request,
924 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
925 return SubmitAsync(&LightsailClient::CreateGUISessionAccessDetails, request, handler, context);
926 }
927
939
944 template <typename CreateInstanceSnapshotRequestT = Model::CreateInstanceSnapshotRequest>
945 Model::CreateInstanceSnapshotOutcomeCallable CreateInstanceSnapshotCallable(const CreateInstanceSnapshotRequestT& request) const {
946 return SubmitCallable(&LightsailClient::CreateInstanceSnapshot, request);
947 }
948
953 template <typename CreateInstanceSnapshotRequestT = Model::CreateInstanceSnapshotRequest>
954 void CreateInstanceSnapshotAsync(const CreateInstanceSnapshotRequestT& request,
956 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
957 return SubmitAsync(&LightsailClient::CreateInstanceSnapshot, request, handler, context);
958 }
959
970
974 template <typename CreateInstancesRequestT = Model::CreateInstancesRequest>
975 Model::CreateInstancesOutcomeCallable CreateInstancesCallable(const CreateInstancesRequestT& request) const {
976 return SubmitCallable(&LightsailClient::CreateInstances, request);
977 }
978
983 template <typename CreateInstancesRequestT = Model::CreateInstancesRequest>
984 void CreateInstancesAsync(const CreateInstancesRequestT& request, const CreateInstancesResponseReceivedHandler& handler,
985 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
986 return SubmitAsync(&LightsailClient::CreateInstances, request, handler, context);
987 }
988
1001 const Model::CreateInstancesFromSnapshotRequest& request) const;
1002
1007 template <typename CreateInstancesFromSnapshotRequestT = Model::CreateInstancesFromSnapshotRequest>
1009 const CreateInstancesFromSnapshotRequestT& request) const {
1010 return SubmitCallable(&LightsailClient::CreateInstancesFromSnapshot, request);
1011 }
1012
1017 template <typename CreateInstancesFromSnapshotRequestT = Model::CreateInstancesFromSnapshotRequest>
1018 void CreateInstancesFromSnapshotAsync(const CreateInstancesFromSnapshotRequestT& request,
1020 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1021 return SubmitAsync(&LightsailClient::CreateInstancesFromSnapshot, request, handler, context);
1022 }
1023
1038
1042 template <typename CreateKeyPairRequestT = Model::CreateKeyPairRequest>
1043 Model::CreateKeyPairOutcomeCallable CreateKeyPairCallable(const CreateKeyPairRequestT& request) const {
1044 return SubmitCallable(&LightsailClient::CreateKeyPair, request);
1045 }
1046
1051 template <typename CreateKeyPairRequestT = Model::CreateKeyPairRequest>
1052 void CreateKeyPairAsync(const CreateKeyPairRequestT& request, const CreateKeyPairResponseReceivedHandler& handler,
1053 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1054 return SubmitAsync(&LightsailClient::CreateKeyPair, request, handler, context);
1055 }
1056
1073
1078 template <typename CreateLoadBalancerRequestT = Model::CreateLoadBalancerRequest>
1079 Model::CreateLoadBalancerOutcomeCallable CreateLoadBalancerCallable(const CreateLoadBalancerRequestT& request) const {
1080 return SubmitCallable(&LightsailClient::CreateLoadBalancer, request);
1081 }
1082
1087 template <typename CreateLoadBalancerRequestT = Model::CreateLoadBalancerRequest>
1088 void CreateLoadBalancerAsync(const CreateLoadBalancerRequestT& request, const CreateLoadBalancerResponseReceivedHandler& handler,
1089 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1090 return SubmitAsync(&LightsailClient::CreateLoadBalancer, request, handler, context);
1091 }
1092
1106
1111 template <typename CreateLoadBalancerTlsCertificateRequestT = Model::CreateLoadBalancerTlsCertificateRequest>
1113 const CreateLoadBalancerTlsCertificateRequestT& request) const {
1114 return SubmitCallable(&LightsailClient::CreateLoadBalancerTlsCertificate, request);
1115 }
1116
1121 template <typename CreateLoadBalancerTlsCertificateRequestT = Model::CreateLoadBalancerTlsCertificateRequest>
1122 void CreateLoadBalancerTlsCertificateAsync(const CreateLoadBalancerTlsCertificateRequestT& request,
1124 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1125 return SubmitAsync(&LightsailClient::CreateLoadBalancerTlsCertificate, request, handler, context);
1126 }
1127
1138
1143 template <typename CreateRelationalDatabaseRequestT = Model::CreateRelationalDatabaseRequest>
1144 Model::CreateRelationalDatabaseOutcomeCallable CreateRelationalDatabaseCallable(const CreateRelationalDatabaseRequestT& request) const {
1145 return SubmitCallable(&LightsailClient::CreateRelationalDatabase, request);
1146 }
1147
1152 template <typename CreateRelationalDatabaseRequestT = Model::CreateRelationalDatabaseRequest>
1153 void CreateRelationalDatabaseAsync(const CreateRelationalDatabaseRequestT& request,
1155 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1156 return SubmitAsync(&LightsailClient::CreateRelationalDatabase, request, handler, context);
1157 }
1158
1174
1179 template <typename CreateRelationalDatabaseFromSnapshotRequestT = Model::CreateRelationalDatabaseFromSnapshotRequest>
1181 const CreateRelationalDatabaseFromSnapshotRequestT& request) const {
1182 return SubmitCallable(&LightsailClient::CreateRelationalDatabaseFromSnapshot, request);
1183 }
1184
1189 template <typename CreateRelationalDatabaseFromSnapshotRequestT = Model::CreateRelationalDatabaseFromSnapshotRequest>
1190 void CreateRelationalDatabaseFromSnapshotAsync(const CreateRelationalDatabaseFromSnapshotRequestT& request,
1192 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1193 return SubmitAsync(&LightsailClient::CreateRelationalDatabaseFromSnapshot, request, handler, context);
1194 }
1195
1209
1214 template <typename CreateRelationalDatabaseSnapshotRequestT = Model::CreateRelationalDatabaseSnapshotRequest>
1216 const CreateRelationalDatabaseSnapshotRequestT& request) const {
1217 return SubmitCallable(&LightsailClient::CreateRelationalDatabaseSnapshot, request);
1218 }
1219
1224 template <typename CreateRelationalDatabaseSnapshotRequestT = Model::CreateRelationalDatabaseSnapshotRequest>
1225 void CreateRelationalDatabaseSnapshotAsync(const CreateRelationalDatabaseSnapshotRequestT& request,
1227 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1228 return SubmitAsync(&LightsailClient::CreateRelationalDatabaseSnapshot, request, handler, context);
1229 }
1230
1247
1251 template <typename CreateSubdomainRequestT = Model::CreateSubdomainRequest>
1252 Model::CreateSubdomainOutcomeCallable CreateSubdomainCallable(const CreateSubdomainRequestT& request) const {
1253 return SubmitCallable(&LightsailClient::CreateSubdomain, request);
1254 }
1255
1260 template <typename CreateSubdomainRequestT = Model::CreateSubdomainRequest>
1261 void CreateSubdomainAsync(const CreateSubdomainRequestT& request, const CreateSubdomainResponseReceivedHandler& handler,
1262 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1263 return SubmitAsync(&LightsailClient::CreateSubdomain, request, handler, context);
1264 }
1265
1277
1281 template <typename DeleteAlarmRequestT = Model::DeleteAlarmRequest>
1282 Model::DeleteAlarmOutcomeCallable DeleteAlarmCallable(const DeleteAlarmRequestT& request) const {
1283 return SubmitCallable(&LightsailClient::DeleteAlarm, request);
1284 }
1285
1290 template <typename DeleteAlarmRequestT = Model::DeleteAlarmRequest>
1291 void DeleteAlarmAsync(const DeleteAlarmRequestT& request, const DeleteAlarmResponseReceivedHandler& handler,
1292 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1293 return SubmitAsync(&LightsailClient::DeleteAlarm, request, handler, context);
1294 }
1295
1305
1310 template <typename DeleteAutoSnapshotRequestT = Model::DeleteAutoSnapshotRequest>
1311 Model::DeleteAutoSnapshotOutcomeCallable DeleteAutoSnapshotCallable(const DeleteAutoSnapshotRequestT& request) const {
1312 return SubmitCallable(&LightsailClient::DeleteAutoSnapshot, request);
1313 }
1314
1319 template <typename DeleteAutoSnapshotRequestT = Model::DeleteAutoSnapshotRequest>
1320 void DeleteAutoSnapshotAsync(const DeleteAutoSnapshotRequestT& request, const DeleteAutoSnapshotResponseReceivedHandler& handler,
1321 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1322 return SubmitAsync(&LightsailClient::DeleteAutoSnapshot, request, handler, context);
1323 }
1324
1333
1337 template <typename DeleteBucketRequestT = Model::DeleteBucketRequest>
1338 Model::DeleteBucketOutcomeCallable DeleteBucketCallable(const DeleteBucketRequestT& request) const {
1339 return SubmitCallable(&LightsailClient::DeleteBucket, request);
1340 }
1341
1346 template <typename DeleteBucketRequestT = Model::DeleteBucketRequest>
1347 void DeleteBucketAsync(const DeleteBucketRequestT& request, const DeleteBucketResponseReceivedHandler& handler,
1348 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1349 return SubmitAsync(&LightsailClient::DeleteBucket, request, handler, context);
1350 }
1351
1363
1368 template <typename DeleteBucketAccessKeyRequestT = Model::DeleteBucketAccessKeyRequest>
1369 Model::DeleteBucketAccessKeyOutcomeCallable DeleteBucketAccessKeyCallable(const DeleteBucketAccessKeyRequestT& request) const {
1370 return SubmitCallable(&LightsailClient::DeleteBucketAccessKey, request);
1371 }
1372
1377 template <typename DeleteBucketAccessKeyRequestT = Model::DeleteBucketAccessKeyRequest>
1378 void DeleteBucketAccessKeyAsync(const DeleteBucketAccessKeyRequestT& request, const DeleteBucketAccessKeyResponseReceivedHandler& handler,
1379 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1380 return SubmitAsync(&LightsailClient::DeleteBucketAccessKey, request, handler, context);
1381 }
1382
1393
1398 template <typename DeleteCertificateRequestT = Model::DeleteCertificateRequest>
1399 Model::DeleteCertificateOutcomeCallable DeleteCertificateCallable(const DeleteCertificateRequestT& request) const {
1400 return SubmitCallable(&LightsailClient::DeleteCertificate, request);
1401 }
1402
1407 template <typename DeleteCertificateRequestT = Model::DeleteCertificateRequest>
1408 void DeleteCertificateAsync(const DeleteCertificateRequestT& request, const DeleteCertificateResponseReceivedHandler& handler,
1409 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1410 return SubmitAsync(&LightsailClient::DeleteCertificate, request, handler, context);
1411 }
1412
1426
1431 template <typename DeleteContactMethodRequestT = Model::DeleteContactMethodRequest>
1432 Model::DeleteContactMethodOutcomeCallable DeleteContactMethodCallable(const DeleteContactMethodRequestT& request) const {
1433 return SubmitCallable(&LightsailClient::DeleteContactMethod, request);
1434 }
1435
1440 template <typename DeleteContactMethodRequestT = Model::DeleteContactMethodRequest>
1441 void DeleteContactMethodAsync(const DeleteContactMethodRequestT& request, const DeleteContactMethodResponseReceivedHandler& handler,
1442 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1443 return SubmitAsync(&LightsailClient::DeleteContactMethod, request, handler, context);
1444 }
1445
1453
1458 template <typename DeleteContainerImageRequestT = Model::DeleteContainerImageRequest>
1459 Model::DeleteContainerImageOutcomeCallable DeleteContainerImageCallable(const DeleteContainerImageRequestT& request) const {
1460 return SubmitCallable(&LightsailClient::DeleteContainerImage, request);
1461 }
1462
1467 template <typename DeleteContainerImageRequestT = Model::DeleteContainerImageRequest>
1468 void DeleteContainerImageAsync(const DeleteContainerImageRequestT& request, const DeleteContainerImageResponseReceivedHandler& handler,
1469 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1470 return SubmitAsync(&LightsailClient::DeleteContainerImage, request, handler, context);
1471 }
1472
1480
1485 template <typename DeleteContainerServiceRequestT = Model::DeleteContainerServiceRequest>
1486 Model::DeleteContainerServiceOutcomeCallable DeleteContainerServiceCallable(const DeleteContainerServiceRequestT& request) const {
1487 return SubmitCallable(&LightsailClient::DeleteContainerService, request);
1488 }
1489
1494 template <typename DeleteContainerServiceRequestT = Model::DeleteContainerServiceRequest>
1495 void DeleteContainerServiceAsync(const DeleteContainerServiceRequestT& request,
1497 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1498 return SubmitAsync(&LightsailClient::DeleteContainerService, request, handler, context);
1499 }
1500
1514
1518 template <typename DeleteDiskRequestT = Model::DeleteDiskRequest>
1519 Model::DeleteDiskOutcomeCallable DeleteDiskCallable(const DeleteDiskRequestT& request) const {
1520 return SubmitCallable(&LightsailClient::DeleteDisk, request);
1521 }
1522
1527 template <typename DeleteDiskRequestT = Model::DeleteDiskRequest>
1528 void DeleteDiskAsync(const DeleteDiskRequestT& request, const DeleteDiskResponseReceivedHandler& handler,
1529 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1530 return SubmitAsync(&LightsailClient::DeleteDisk, request, handler, context);
1531 }
1532
1549
1554 template <typename DeleteDiskSnapshotRequestT = Model::DeleteDiskSnapshotRequest>
1555 Model::DeleteDiskSnapshotOutcomeCallable DeleteDiskSnapshotCallable(const DeleteDiskSnapshotRequestT& request) const {
1556 return SubmitCallable(&LightsailClient::DeleteDiskSnapshot, request);
1557 }
1558
1563 template <typename DeleteDiskSnapshotRequestT = Model::DeleteDiskSnapshotRequest>
1564 void DeleteDiskSnapshotAsync(const DeleteDiskSnapshotRequestT& request, const DeleteDiskSnapshotResponseReceivedHandler& handler,
1565 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1566 return SubmitAsync(&LightsailClient::DeleteDiskSnapshot, request, handler, context);
1567 }
1568
1576
1581 template <typename DeleteDistributionRequestT = Model::DeleteDistributionRequest>
1582 Model::DeleteDistributionOutcomeCallable DeleteDistributionCallable(const DeleteDistributionRequestT& request = {}) const {
1583 return SubmitCallable(&LightsailClient::DeleteDistribution, request);
1584 }
1585
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);
1595 }
1596
1608
1612 template <typename DeleteDomainRequestT = Model::DeleteDomainRequest>
1613 Model::DeleteDomainOutcomeCallable DeleteDomainCallable(const DeleteDomainRequestT& request) const {
1614 return SubmitCallable(&LightsailClient::DeleteDomain, request);
1615 }
1616
1621 template <typename DeleteDomainRequestT = Model::DeleteDomainRequest>
1622 void DeleteDomainAsync(const DeleteDomainRequestT& request, const DeleteDomainResponseReceivedHandler& handler,
1623 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1624 return SubmitAsync(&LightsailClient::DeleteDomain, request, handler, context);
1625 }
1626
1638
1643 template <typename DeleteDomainEntryRequestT = Model::DeleteDomainEntryRequest>
1644 Model::DeleteDomainEntryOutcomeCallable DeleteDomainEntryCallable(const DeleteDomainEntryRequestT& request) const {
1645 return SubmitCallable(&LightsailClient::DeleteDomainEntry, request);
1646 }
1647
1652 template <typename DeleteDomainEntryRequestT = Model::DeleteDomainEntryRequest>
1653 void DeleteDomainEntryAsync(const DeleteDomainEntryRequestT& request, const DeleteDomainEntryResponseReceivedHandler& handler,
1654 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1655 return SubmitAsync(&LightsailClient::DeleteDomainEntry, request, handler, context);
1656 }
1657
1669
1673 template <typename DeleteInstanceRequestT = Model::DeleteInstanceRequest>
1674 Model::DeleteInstanceOutcomeCallable DeleteInstanceCallable(const DeleteInstanceRequestT& request) const {
1675 return SubmitCallable(&LightsailClient::DeleteInstance, request);
1676 }
1677
1682 template <typename DeleteInstanceRequestT = Model::DeleteInstanceRequest>
1683 void DeleteInstanceAsync(const DeleteInstanceRequestT& request, const DeleteInstanceResponseReceivedHandler& handler,
1684 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1685 return SubmitAsync(&LightsailClient::DeleteInstance, request, handler, context);
1686 }
1687
1700
1705 template <typename DeleteInstanceSnapshotRequestT = Model::DeleteInstanceSnapshotRequest>
1706 Model::DeleteInstanceSnapshotOutcomeCallable DeleteInstanceSnapshotCallable(const DeleteInstanceSnapshotRequestT& request) const {
1707 return SubmitCallable(&LightsailClient::DeleteInstanceSnapshot, request);
1708 }
1709
1714 template <typename DeleteInstanceSnapshotRequestT = Model::DeleteInstanceSnapshotRequest>
1715 void DeleteInstanceSnapshotAsync(const DeleteInstanceSnapshotRequestT& request,
1717 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1718 return SubmitAsync(&LightsailClient::DeleteInstanceSnapshot, request, handler, context);
1719 }
1720
1740
1744 template <typename DeleteKeyPairRequestT = Model::DeleteKeyPairRequest>
1745 Model::DeleteKeyPairOutcomeCallable DeleteKeyPairCallable(const DeleteKeyPairRequestT& request) const {
1746 return SubmitCallable(&LightsailClient::DeleteKeyPair, request);
1747 }
1748
1753 template <typename DeleteKeyPairRequestT = Model::DeleteKeyPairRequest>
1754 void DeleteKeyPairAsync(const DeleteKeyPairRequestT& request, const DeleteKeyPairResponseReceivedHandler& handler,
1755 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1756 return SubmitAsync(&LightsailClient::DeleteKeyPair, request, handler, context);
1757 }
1758
1774
1779 template <typename DeleteKnownHostKeysRequestT = Model::DeleteKnownHostKeysRequest>
1780 Model::DeleteKnownHostKeysOutcomeCallable DeleteKnownHostKeysCallable(const DeleteKnownHostKeysRequestT& request) const {
1781 return SubmitCallable(&LightsailClient::DeleteKnownHostKeys, request);
1782 }
1783
1788 template <typename DeleteKnownHostKeysRequestT = Model::DeleteKnownHostKeysRequest>
1789 void DeleteKnownHostKeysAsync(const DeleteKnownHostKeysRequestT& request, const DeleteKnownHostKeysResponseReceivedHandler& handler,
1790 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1791 return SubmitAsync(&LightsailClient::DeleteKnownHostKeys, request, handler, context);
1792 }
1793
1807
1812 template <typename DeleteLoadBalancerRequestT = Model::DeleteLoadBalancerRequest>
1813 Model::DeleteLoadBalancerOutcomeCallable DeleteLoadBalancerCallable(const DeleteLoadBalancerRequestT& request) const {
1814 return SubmitCallable(&LightsailClient::DeleteLoadBalancer, request);
1815 }
1816
1821 template <typename DeleteLoadBalancerRequestT = Model::DeleteLoadBalancerRequest>
1822 void DeleteLoadBalancerAsync(const DeleteLoadBalancerRequestT& request, const DeleteLoadBalancerResponseReceivedHandler& handler,
1823 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1824 return SubmitAsync(&LightsailClient::DeleteLoadBalancer, request, handler, context);
1825 }
1826
1839
1844 template <typename DeleteLoadBalancerTlsCertificateRequestT = Model::DeleteLoadBalancerTlsCertificateRequest>
1846 const DeleteLoadBalancerTlsCertificateRequestT& request) const {
1847 return SubmitCallable(&LightsailClient::DeleteLoadBalancerTlsCertificate, request);
1848 }
1849
1854 template <typename DeleteLoadBalancerTlsCertificateRequestT = Model::DeleteLoadBalancerTlsCertificateRequest>
1855 void DeleteLoadBalancerTlsCertificateAsync(const DeleteLoadBalancerTlsCertificateRequestT& request,
1857 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1858 return SubmitAsync(&LightsailClient::DeleteLoadBalancerTlsCertificate, request, handler, context);
1859 }
1860
1872
1877 template <typename DeleteRelationalDatabaseRequestT = Model::DeleteRelationalDatabaseRequest>
1878 Model::DeleteRelationalDatabaseOutcomeCallable DeleteRelationalDatabaseCallable(const DeleteRelationalDatabaseRequestT& request) const {
1879 return SubmitCallable(&LightsailClient::DeleteRelationalDatabase, request);
1880 }
1881
1886 template <typename DeleteRelationalDatabaseRequestT = Model::DeleteRelationalDatabaseRequest>
1887 void DeleteRelationalDatabaseAsync(const DeleteRelationalDatabaseRequestT& request,
1889 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1890 return SubmitAsync(&LightsailClient::DeleteRelationalDatabase, request, handler, context);
1891 }
1892
1905
1910 template <typename DeleteRelationalDatabaseSnapshotRequestT = Model::DeleteRelationalDatabaseSnapshotRequest>
1912 const DeleteRelationalDatabaseSnapshotRequestT& request) const {
1913 return SubmitCallable(&LightsailClient::DeleteRelationalDatabaseSnapshot, request);
1914 }
1915
1920 template <typename DeleteRelationalDatabaseSnapshotRequestT = Model::DeleteRelationalDatabaseSnapshotRequest>
1921 void DeleteRelationalDatabaseSnapshotAsync(const DeleteRelationalDatabaseSnapshotRequestT& request,
1923 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1924 return SubmitAsync(&LightsailClient::DeleteRelationalDatabaseSnapshot, request, handler, context);
1925 }
1926
1941
1945 template <typename DeleteSubdomainRequestT = Model::DeleteSubdomainRequest>
1946 Model::DeleteSubdomainOutcomeCallable DeleteSubdomainCallable(const DeleteSubdomainRequestT& request) const {
1947 return SubmitCallable(&LightsailClient::DeleteSubdomain, request);
1948 }
1949
1954 template <typename DeleteSubdomainRequestT = Model::DeleteSubdomainRequest>
1955 void DeleteSubdomainAsync(const DeleteSubdomainRequestT& request, const DeleteSubdomainResponseReceivedHandler& handler,
1956 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1957 return SubmitAsync(&LightsailClient::DeleteSubdomain, request, handler, context);
1958 }
1959
1970
1975 template <typename DetachCertificateFromDistributionRequestT = Model::DetachCertificateFromDistributionRequest>
1977 const DetachCertificateFromDistributionRequestT& request) const {
1978 return SubmitCallable(&LightsailClient::DetachCertificateFromDistribution, request);
1979 }
1980
1985 template <typename DetachCertificateFromDistributionRequestT = Model::DetachCertificateFromDistributionRequest>
1986 void DetachCertificateFromDistributionAsync(const DetachCertificateFromDistributionRequestT& request,
1988 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
1989 return SubmitAsync(&LightsailClient::DetachCertificateFromDistribution, request, handler, context);
1990 }
1991
2005
2009 template <typename DetachDiskRequestT = Model::DetachDiskRequest>
2010 Model::DetachDiskOutcomeCallable DetachDiskCallable(const DetachDiskRequestT& request) const {
2011 return SubmitCallable(&LightsailClient::DetachDisk, request);
2012 }
2013
2018 template <typename DetachDiskRequestT = Model::DetachDiskRequest>
2019 void DetachDiskAsync(const DetachDiskRequestT& request, const DetachDiskResponseReceivedHandler& handler,
2020 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
2021 return SubmitAsync(&LightsailClient::DetachDisk, request, handler, context);
2022 }
2023
2038
2043 template <typename DetachInstancesFromLoadBalancerRequestT = Model::DetachInstancesFromLoadBalancerRequest>
2045 const DetachInstancesFromLoadBalancerRequestT& request) const {
2046 return SubmitCallable(&LightsailClient::DetachInstancesFromLoadBalancer, request);
2047 }
2048
2053 template <typename DetachInstancesFromLoadBalancerRequestT = Model::DetachInstancesFromLoadBalancerRequest>
2054 void DetachInstancesFromLoadBalancerAsync(const DetachInstancesFromLoadBalancerRequestT& request,
2056 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
2057 return SubmitAsync(&LightsailClient::DetachInstancesFromLoadBalancer, request, handler, context);
2058 }
2059
2067
2071 template <typename DetachStaticIpRequestT = Model::DetachStaticIpRequest>
2072 Model::DetachStaticIpOutcomeCallable DetachStaticIpCallable(const DetachStaticIpRequestT& request) const {
2073 return SubmitCallable(&LightsailClient::DetachStaticIp, request);
2074 }
2075
2080 template <typename DetachStaticIpRequestT = Model::DetachStaticIpRequest>
2081 void DetachStaticIpAsync(const DetachStaticIpRequestT& request, const DetachStaticIpResponseReceivedHandler& handler,
2082 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
2083 return SubmitAsync(&LightsailClient::DetachStaticIp, request, handler, context);
2084 }
2085
2095
2099 template <typename DisableAddOnRequestT = Model::DisableAddOnRequest>
2100 Model::DisableAddOnOutcomeCallable DisableAddOnCallable(const DisableAddOnRequestT& request) const {
2101 return SubmitCallable(&LightsailClient::DisableAddOn, request);
2102 }
2103
2108 template <typename DisableAddOnRequestT = Model::DisableAddOnRequest>
2109 void DisableAddOnAsync(const DisableAddOnRequestT& request, const DisableAddOnResponseReceivedHandler& handler,
2110 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
2111 return SubmitAsync(&LightsailClient::DisableAddOn, request, handler, context);
2112 }
2113
2122
2127 template <typename DownloadDefaultKeyPairRequestT = Model::DownloadDefaultKeyPairRequest>
2128 Model::DownloadDefaultKeyPairOutcomeCallable DownloadDefaultKeyPairCallable(const DownloadDefaultKeyPairRequestT& request = {}) const {
2129 return SubmitCallable(&LightsailClient::DownloadDefaultKeyPair, request);
2130 }
2131
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);
2141 }
2142
2152
2156 template <typename EnableAddOnRequestT = Model::EnableAddOnRequest>
2157 Model::EnableAddOnOutcomeCallable EnableAddOnCallable(const EnableAddOnRequestT& request) const {
2158 return SubmitCallable(&LightsailClient::EnableAddOn, request);
2159 }
2160
2165 template <typename EnableAddOnRequestT = Model::EnableAddOnRequest>
2166 void EnableAddOnAsync(const EnableAddOnRequestT& request, const EnableAddOnResponseReceivedHandler& handler,
2167 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
2168 return SubmitAsync(&LightsailClient::EnableAddOn, request, handler, context);
2169 }
2170
2192
2196 template <typename ExportSnapshotRequestT = Model::ExportSnapshotRequest>
2197 Model::ExportSnapshotOutcomeCallable ExportSnapshotCallable(const ExportSnapshotRequestT& request) const {
2198 return SubmitCallable(&LightsailClient::ExportSnapshot, request);
2199 }
2200
2205 template <typename ExportSnapshotRequestT = Model::ExportSnapshotRequest>
2206 void ExportSnapshotAsync(const ExportSnapshotRequestT& request, const ExportSnapshotResponseReceivedHandler& handler,
2207 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
2208 return SubmitAsync(&LightsailClient::ExportSnapshot, request, handler, context);
2209 }
2210
2218
2222 template <typename GetActiveNamesRequestT = Model::GetActiveNamesRequest>
2223 Model::GetActiveNamesOutcomeCallable GetActiveNamesCallable(const GetActiveNamesRequestT& request = {}) const {
2224 return SubmitCallable(&LightsailClient::GetActiveNames, request);
2225 }
2226
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);
2236 }
2237
2252
2256 template <typename GetAlarmsRequestT = Model::GetAlarmsRequest>
2257 Model::GetAlarmsOutcomeCallable GetAlarmsCallable(const GetAlarmsRequestT& request = {}) const {
2258 return SubmitCallable(&LightsailClient::GetAlarms, request);
2259 }
2260
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);
2270 }
2271
2281
2286 template <typename GetAutoSnapshotsRequestT = Model::GetAutoSnapshotsRequest>
2287 Model::GetAutoSnapshotsOutcomeCallable GetAutoSnapshotsCallable(const GetAutoSnapshotsRequestT& request) const {
2288 return SubmitCallable(&LightsailClient::GetAutoSnapshots, request);
2289 }
2290
2295 template <typename GetAutoSnapshotsRequestT = Model::GetAutoSnapshotsRequest>
2296 void GetAutoSnapshotsAsync(const GetAutoSnapshotsRequestT& request, const GetAutoSnapshotsResponseReceivedHandler& handler,
2297 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
2298 return SubmitAsync(&LightsailClient::GetAutoSnapshots, request, handler, context);
2299 }
2300
2315
2319 template <typename GetBlueprintsRequestT = Model::GetBlueprintsRequest>
2320 Model::GetBlueprintsOutcomeCallable GetBlueprintsCallable(const GetBlueprintsRequestT& request = {}) const {
2321 return SubmitCallable(&LightsailClient::GetBlueprints, request);
2322 }
2323
2328 template <typename GetBlueprintsRequestT = Model::GetBlueprintsRequest>
2330 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
2331 const GetBlueprintsRequestT& request = {}) const {
2332 return SubmitAsync(&LightsailClient::GetBlueprints, request, handler, context);
2333 }
2334
2347
2352 template <typename GetBucketAccessKeysRequestT = Model::GetBucketAccessKeysRequest>
2353 Model::GetBucketAccessKeysOutcomeCallable GetBucketAccessKeysCallable(const GetBucketAccessKeysRequestT& request) const {
2354 return SubmitCallable(&LightsailClient::GetBucketAccessKeys, request);
2355 }
2356
2361 template <typename GetBucketAccessKeysRequestT = Model::GetBucketAccessKeysRequest>
2362 void GetBucketAccessKeysAsync(const GetBucketAccessKeysRequestT& request, const GetBucketAccessKeysResponseReceivedHandler& handler,
2363 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
2364 return SubmitAsync(&LightsailClient::GetBucketAccessKeys, request, handler, context);
2365 }
2366
2377
2382 template <typename GetBucketBundlesRequestT = Model::GetBucketBundlesRequest>
2383 Model::GetBucketBundlesOutcomeCallable GetBucketBundlesCallable(const GetBucketBundlesRequestT& request = {}) const {
2384 return SubmitCallable(&LightsailClient::GetBucketBundles, request);
2385 }
2386
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);
2396 }
2397
2408
2413 template <typename GetBucketMetricDataRequestT = Model::GetBucketMetricDataRequest>
2414 Model::GetBucketMetricDataOutcomeCallable GetBucketMetricDataCallable(const GetBucketMetricDataRequestT& request) const {
2415 return SubmitCallable(&LightsailClient::GetBucketMetricData, request);
2416 }
2417
2422 template <typename GetBucketMetricDataRequestT = Model::GetBucketMetricDataRequest>
2423 void GetBucketMetricDataAsync(const GetBucketMetricDataRequestT& request, const GetBucketMetricDataResponseReceivedHandler& handler,
2424 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
2425 return SubmitAsync(&LightsailClient::GetBucketMetricData, request, handler, context);
2426 }
2427
2440
2444 template <typename GetBucketsRequestT = Model::GetBucketsRequest>
2445 Model::GetBucketsOutcomeCallable GetBucketsCallable(const GetBucketsRequestT& request = {}) const {
2446 return SubmitCallable(&LightsailClient::GetBuckets, request);
2447 }
2448
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);
2458 }
2459
2471
2475 template <typename GetBundlesRequestT = Model::GetBundlesRequest>
2476 Model::GetBundlesOutcomeCallable GetBundlesCallable(const GetBundlesRequestT& request = {}) const {
2477 return SubmitCallable(&LightsailClient::GetBundles, request);
2478 }
2479
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);
2489 }
2490
2501
2505 template <typename GetCertificatesRequestT = Model::GetCertificatesRequest>
2506 Model::GetCertificatesOutcomeCallable GetCertificatesCallable(const GetCertificatesRequestT& request = {}) const {
2507 return SubmitCallable(&LightsailClient::GetCertificates, request);
2508 }
2509
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);
2519 }
2520
2530 const Model::GetCloudFormationStackRecordsRequest& request = {}) const;
2531
2536 template <typename GetCloudFormationStackRecordsRequestT = Model::GetCloudFormationStackRecordsRequest>
2538 const GetCloudFormationStackRecordsRequestT& request = {}) const {
2539 return SubmitCallable(&LightsailClient::GetCloudFormationStackRecords, request);
2540 }
2541
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);
2551 }
2552
2567
2572 template <typename GetContactMethodsRequestT = Model::GetContactMethodsRequest>
2573 Model::GetContactMethodsOutcomeCallable GetContactMethodsCallable(const GetContactMethodsRequestT& request = {}) const {
2574 return SubmitCallable(&LightsailClient::GetContactMethods, request);
2575 }
2576
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);
2586 }
2587
2596
2601 template <typename GetContainerAPIMetadataRequestT = Model::GetContainerAPIMetadataRequest>
2602 Model::GetContainerAPIMetadataOutcomeCallable GetContainerAPIMetadataCallable(const GetContainerAPIMetadataRequestT& request = {}) const {
2603 return SubmitCallable(&LightsailClient::GetContainerAPIMetadata, request);
2604 }
2605
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);
2615 }
2616
2628
2633 template <typename GetContainerImagesRequestT = Model::GetContainerImagesRequest>
2634 Model::GetContainerImagesOutcomeCallable GetContainerImagesCallable(const GetContainerImagesRequestT& request) const {
2635 return SubmitCallable(&LightsailClient::GetContainerImages, request);
2636 }
2637
2642 template <typename GetContainerImagesRequestT = Model::GetContainerImagesRequest>
2643 void GetContainerImagesAsync(const GetContainerImagesRequestT& request, const GetContainerImagesResponseReceivedHandler& handler,
2644 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
2645 return SubmitAsync(&LightsailClient::GetContainerImages, request, handler, context);
2646 }
2647
2662
2666 template <typename GetContainerLogRequestT = Model::GetContainerLogRequest>
2667 Model::GetContainerLogOutcomeCallable GetContainerLogCallable(const GetContainerLogRequestT& request) const {
2668 return SubmitCallable(&LightsailClient::GetContainerLog, request);
2669 }
2670
2675 template <typename GetContainerLogRequestT = Model::GetContainerLogRequest>
2676 void GetContainerLogAsync(const GetContainerLogRequestT& request, const GetContainerLogResponseReceivedHandler& handler,
2677 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
2678 return SubmitAsync(&LightsailClient::GetContainerLog, request, handler, context);
2679 }
2680
2696
2701 template <typename GetContainerServiceDeploymentsRequestT = Model::GetContainerServiceDeploymentsRequest>
2703 const GetContainerServiceDeploymentsRequestT& request) const {
2704 return SubmitCallable(&LightsailClient::GetContainerServiceDeployments, request);
2705 }
2706
2711 template <typename GetContainerServiceDeploymentsRequestT = Model::GetContainerServiceDeploymentsRequest>
2712 void GetContainerServiceDeploymentsAsync(const GetContainerServiceDeploymentsRequestT& request,
2714 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
2715 return SubmitAsync(&LightsailClient::GetContainerServiceDeployments, request, handler, context);
2716 }
2717
2727 const Model::GetContainerServiceMetricDataRequest& request) const;
2728
2733 template <typename GetContainerServiceMetricDataRequestT = Model::GetContainerServiceMetricDataRequest>
2735 const GetContainerServiceMetricDataRequestT& request) const {
2736 return SubmitCallable(&LightsailClient::GetContainerServiceMetricData, request);
2737 }
2738
2743 template <typename GetContainerServiceMetricDataRequestT = Model::GetContainerServiceMetricDataRequest>
2744 void GetContainerServiceMetricDataAsync(const GetContainerServiceMetricDataRequestT& request,
2746 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
2747 return SubmitAsync(&LightsailClient::GetContainerServiceMetricData, request, handler, context);
2748 }
2749
2759 const Model::GetContainerServicePowersRequest& request = {}) const;
2760
2765 template <typename GetContainerServicePowersRequestT = Model::GetContainerServicePowersRequest>
2767 const GetContainerServicePowersRequestT& request = {}) const {
2768 return SubmitCallable(&LightsailClient::GetContainerServicePowers, request);
2769 }
2770
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);
2780 }
2781
2789
2794 template <typename GetContainerServicesRequestT = Model::GetContainerServicesRequest>
2795 Model::GetContainerServicesOutcomeCallable GetContainerServicesCallable(const GetContainerServicesRequestT& request = {}) const {
2796 return SubmitCallable(&LightsailClient::GetContainerServices, request);
2797 }
2798
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);
2808 }
2809
2818
2822 template <typename GetCostEstimateRequestT = Model::GetCostEstimateRequest>
2823 Model::GetCostEstimateOutcomeCallable GetCostEstimateCallable(const GetCostEstimateRequestT& request) const {
2824 return SubmitCallable(&LightsailClient::GetCostEstimate, request);
2825 }
2826
2831 template <typename GetCostEstimateRequestT = Model::GetCostEstimateRequest>
2832 void GetCostEstimateAsync(const GetCostEstimateRequestT& request, const GetCostEstimateResponseReceivedHandler& handler,
2833 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
2834 return SubmitAsync(&LightsailClient::GetCostEstimate, request, handler, context);
2835 }
2836
2844
2848 template <typename GetDiskRequestT = Model::GetDiskRequest>
2849 Model::GetDiskOutcomeCallable GetDiskCallable(const GetDiskRequestT& request) const {
2850 return SubmitCallable(&LightsailClient::GetDisk, request);
2851 }
2852
2857 template <typename GetDiskRequestT = Model::GetDiskRequest>
2858 void GetDiskAsync(const GetDiskRequestT& request, const GetDiskResponseReceivedHandler& handler,
2859 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
2860 return SubmitAsync(&LightsailClient::GetDisk, request, handler, context);
2861 }
2862
2870
2874 template <typename GetDiskSnapshotRequestT = Model::GetDiskSnapshotRequest>
2875 Model::GetDiskSnapshotOutcomeCallable GetDiskSnapshotCallable(const GetDiskSnapshotRequestT& request) const {
2876 return SubmitCallable(&LightsailClient::GetDiskSnapshot, request);
2877 }
2878
2883 template <typename GetDiskSnapshotRequestT = Model::GetDiskSnapshotRequest>
2884 void GetDiskSnapshotAsync(const GetDiskSnapshotRequestT& request, const GetDiskSnapshotResponseReceivedHandler& handler,
2885 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
2886 return SubmitAsync(&LightsailClient::GetDiskSnapshot, request, handler, context);
2887 }
2888
2896
2901 template <typename GetDiskSnapshotsRequestT = Model::GetDiskSnapshotsRequest>
2902 Model::GetDiskSnapshotsOutcomeCallable GetDiskSnapshotsCallable(const GetDiskSnapshotsRequestT& request = {}) const {
2903 return SubmitCallable(&LightsailClient::GetDiskSnapshots, request);
2904 }
2905
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);
2915 }
2916
2923 virtual Model::GetDisksOutcome GetDisks(const Model::GetDisksRequest& request = {}) const;
2924
2928 template <typename GetDisksRequestT = Model::GetDisksRequest>
2929 Model::GetDisksOutcomeCallable GetDisksCallable(const GetDisksRequestT& request = {}) const {
2930 return SubmitCallable(&LightsailClient::GetDisks, request);
2931 }
2932
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);
2942 }
2943
2953
2958 template <typename GetDistributionBundlesRequestT = Model::GetDistributionBundlesRequest>
2959 Model::GetDistributionBundlesOutcomeCallable GetDistributionBundlesCallable(const GetDistributionBundlesRequestT& request = {}) const {
2960 return SubmitCallable(&LightsailClient::GetDistributionBundles, request);
2961 }
2962
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);
2972 }
2973
2982 const Model::GetDistributionLatestCacheResetRequest& request = {}) const;
2983
2988 template <typename GetDistributionLatestCacheResetRequestT = Model::GetDistributionLatestCacheResetRequest>
2990 const GetDistributionLatestCacheResetRequestT& request = {}) const {
2991 return SubmitCallable(&LightsailClient::GetDistributionLatestCacheReset, request);
2992 }
2993
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);
3003 }
3004
3015
3020 template <typename GetDistributionMetricDataRequestT = Model::GetDistributionMetricDataRequest>
3022 const GetDistributionMetricDataRequestT& request) const {
3023 return SubmitCallable(&LightsailClient::GetDistributionMetricData, request);
3024 }
3025
3030 template <typename GetDistributionMetricDataRequestT = Model::GetDistributionMetricDataRequest>
3031 void GetDistributionMetricDataAsync(const GetDistributionMetricDataRequestT& request,
3033 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
3034 return SubmitAsync(&LightsailClient::GetDistributionMetricData, request, handler, context);
3035 }
3036
3049
3054 template <typename GetDistributionsRequestT = Model::GetDistributionsRequest>
3055 Model::GetDistributionsOutcomeCallable GetDistributionsCallable(const GetDistributionsRequestT& request = {}) const {
3056 return SubmitCallable(&LightsailClient::GetDistributions, request);
3057 }
3058
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);
3068 }
3069
3077
3081 template <typename GetDomainRequestT = Model::GetDomainRequest>
3082 Model::GetDomainOutcomeCallable GetDomainCallable(const GetDomainRequestT& request) const {
3083 return SubmitCallable(&LightsailClient::GetDomain, request);
3084 }
3085
3090 template <typename GetDomainRequestT = Model::GetDomainRequest>
3091 void GetDomainAsync(const GetDomainRequestT& request, const GetDomainResponseReceivedHandler& handler,
3092 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
3093 return SubmitAsync(&LightsailClient::GetDomain, request, handler, context);
3094 }
3095
3103
3107 template <typename GetDomainsRequestT = Model::GetDomainsRequest>
3108 Model::GetDomainsOutcomeCallable GetDomainsCallable(const GetDomainsRequestT& request = {}) const {
3109 return SubmitCallable(&LightsailClient::GetDomains, request);
3110 }
3111
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);
3121 }
3122
3133
3138 template <typename GetExportSnapshotRecordsRequestT = Model::GetExportSnapshotRecordsRequest>
3140 const GetExportSnapshotRecordsRequestT& request = {}) const {
3141 return SubmitCallable(&LightsailClient::GetExportSnapshotRecords, request);
3142 }
3143
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);
3153 }
3154
3162
3166 template <typename GetInstanceRequestT = Model::GetInstanceRequest>
3167 Model::GetInstanceOutcomeCallable GetInstanceCallable(const GetInstanceRequestT& request) const {
3168 return SubmitCallable(&LightsailClient::GetInstance, request);
3169 }
3170
3175 template <typename GetInstanceRequestT = Model::GetInstanceRequest>
3176 void GetInstanceAsync(const GetInstanceRequestT& request, const GetInstanceResponseReceivedHandler& handler,
3177 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
3178 return SubmitAsync(&LightsailClient::GetInstance, request, handler, context);
3179 }
3180
3193
3198 template <typename GetInstanceAccessDetailsRequestT = Model::GetInstanceAccessDetailsRequest>
3199 Model::GetInstanceAccessDetailsOutcomeCallable GetInstanceAccessDetailsCallable(const GetInstanceAccessDetailsRequestT& request) const {
3200 return SubmitCallable(&LightsailClient::GetInstanceAccessDetails, request);
3201 }
3202
3207 template <typename GetInstanceAccessDetailsRequestT = Model::GetInstanceAccessDetailsRequest>
3208 void GetInstanceAccessDetailsAsync(const GetInstanceAccessDetailsRequestT& request,
3210 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
3211 return SubmitAsync(&LightsailClient::GetInstanceAccessDetails, request, handler, context);
3212 }
3213
3224
3229 template <typename GetInstanceMetricDataRequestT = Model::GetInstanceMetricDataRequest>
3230 Model::GetInstanceMetricDataOutcomeCallable GetInstanceMetricDataCallable(const GetInstanceMetricDataRequestT& request) const {
3231 return SubmitCallable(&LightsailClient::GetInstanceMetricData, request);
3232 }
3233
3238 template <typename GetInstanceMetricDataRequestT = Model::GetInstanceMetricDataRequest>
3239 void GetInstanceMetricDataAsync(const GetInstanceMetricDataRequestT& request, const GetInstanceMetricDataResponseReceivedHandler& handler,
3240 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
3241 return SubmitAsync(&LightsailClient::GetInstanceMetricData, request, handler, context);
3242 }
3243
3252
3257 template <typename GetInstancePortStatesRequestT = Model::GetInstancePortStatesRequest>
3258 Model::GetInstancePortStatesOutcomeCallable GetInstancePortStatesCallable(const GetInstancePortStatesRequestT& request) const {
3259 return SubmitCallable(&LightsailClient::GetInstancePortStates, request);
3260 }
3261
3266 template <typename GetInstancePortStatesRequestT = Model::GetInstancePortStatesRequest>
3267 void GetInstancePortStatesAsync(const GetInstancePortStatesRequestT& request, const GetInstancePortStatesResponseReceivedHandler& handler,
3268 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
3269 return SubmitAsync(&LightsailClient::GetInstancePortStates, request, handler, context);
3270 }
3271
3279
3284 template <typename GetInstanceSnapshotRequestT = Model::GetInstanceSnapshotRequest>
3285 Model::GetInstanceSnapshotOutcomeCallable GetInstanceSnapshotCallable(const GetInstanceSnapshotRequestT& request) const {
3286 return SubmitCallable(&LightsailClient::GetInstanceSnapshot, request);
3287 }
3288
3293 template <typename GetInstanceSnapshotRequestT = Model::GetInstanceSnapshotRequest>
3294 void GetInstanceSnapshotAsync(const GetInstanceSnapshotRequestT& request, const GetInstanceSnapshotResponseReceivedHandler& handler,
3295 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
3296 return SubmitAsync(&LightsailClient::GetInstanceSnapshot, request, handler, context);
3297 }
3298
3306
3311 template <typename GetInstanceSnapshotsRequestT = Model::GetInstanceSnapshotsRequest>
3312 Model::GetInstanceSnapshotsOutcomeCallable GetInstanceSnapshotsCallable(const GetInstanceSnapshotsRequestT& request = {}) const {
3313 return SubmitCallable(&LightsailClient::GetInstanceSnapshots, request);
3314 }
3315
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);
3325 }
3326
3334
3339 template <typename GetInstanceStateRequestT = Model::GetInstanceStateRequest>
3340 Model::GetInstanceStateOutcomeCallable GetInstanceStateCallable(const GetInstanceStateRequestT& request) const {
3341 return SubmitCallable(&LightsailClient::GetInstanceState, request);
3342 }
3343
3348 template <typename GetInstanceStateRequestT = Model::GetInstanceStateRequest>
3349 void GetInstanceStateAsync(const GetInstanceStateRequestT& request, const GetInstanceStateResponseReceivedHandler& handler,
3350 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
3351 return SubmitAsync(&LightsailClient::GetInstanceState, request, handler, context);
3352 }
3353
3361
3365 template <typename GetInstancesRequestT = Model::GetInstancesRequest>
3366 Model::GetInstancesOutcomeCallable GetInstancesCallable(const GetInstancesRequestT& request = {}) const {
3367 return SubmitCallable(&LightsailClient::GetInstances, request);
3368 }
3369
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);
3379 }
3380
3387
3391 template <typename GetKeyPairRequestT = Model::GetKeyPairRequest>
3392 Model::GetKeyPairOutcomeCallable GetKeyPairCallable(const GetKeyPairRequestT& request) const {
3393 return SubmitCallable(&LightsailClient::GetKeyPair, request);
3394 }
3395
3400 template <typename GetKeyPairRequestT = Model::GetKeyPairRequest>
3401 void GetKeyPairAsync(const GetKeyPairRequestT& request, const GetKeyPairResponseReceivedHandler& handler,
3402 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
3403 return SubmitAsync(&LightsailClient::GetKeyPair, request, handler, context);
3404 }
3405
3413
3417 template <typename GetKeyPairsRequestT = Model::GetKeyPairsRequest>
3418 Model::GetKeyPairsOutcomeCallable GetKeyPairsCallable(const GetKeyPairsRequestT& request = {}) const {
3419 return SubmitCallable(&LightsailClient::GetKeyPairs, request);
3420 }
3421
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);
3431 }
3432
3440
3444 template <typename GetLoadBalancerRequestT = Model::GetLoadBalancerRequest>
3445 Model::GetLoadBalancerOutcomeCallable GetLoadBalancerCallable(const GetLoadBalancerRequestT& request) const {
3446 return SubmitCallable(&LightsailClient::GetLoadBalancer, request);
3447 }
3448
3453 template <typename GetLoadBalancerRequestT = Model::GetLoadBalancerRequest>
3454 void GetLoadBalancerAsync(const GetLoadBalancerRequestT& request, const GetLoadBalancerResponseReceivedHandler& handler,
3455 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
3456 return SubmitAsync(&LightsailClient::GetLoadBalancer, request, handler, context);
3457 }
3458
3469
3474 template <typename GetLoadBalancerMetricDataRequestT = Model::GetLoadBalancerMetricDataRequest>
3476 const GetLoadBalancerMetricDataRequestT& request) const {
3477 return SubmitCallable(&LightsailClient::GetLoadBalancerMetricData, request);
3478 }
3479
3484 template <typename GetLoadBalancerMetricDataRequestT = Model::GetLoadBalancerMetricDataRequest>
3485 void GetLoadBalancerMetricDataAsync(const GetLoadBalancerMetricDataRequestT& request,
3487 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
3488 return SubmitAsync(&LightsailClient::GetLoadBalancerMetricData, request, handler, context);
3489 }
3490
3502
3507 template <typename GetLoadBalancerTlsCertificatesRequestT = Model::GetLoadBalancerTlsCertificatesRequest>
3509 const GetLoadBalancerTlsCertificatesRequestT& request) const {
3510 return SubmitCallable(&LightsailClient::GetLoadBalancerTlsCertificates, request);
3511 }
3512
3517 template <typename GetLoadBalancerTlsCertificatesRequestT = Model::GetLoadBalancerTlsCertificatesRequest>
3518 void GetLoadBalancerTlsCertificatesAsync(const GetLoadBalancerTlsCertificatesRequestT& request,
3520 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
3521 return SubmitAsync(&LightsailClient::GetLoadBalancerTlsCertificates, request, handler, context);
3522 }
3523
3535 const Model::GetLoadBalancerTlsPoliciesRequest& request = {}) const;
3536
3541 template <typename GetLoadBalancerTlsPoliciesRequestT = Model::GetLoadBalancerTlsPoliciesRequest>
3543 const GetLoadBalancerTlsPoliciesRequestT& request = {}) const {
3544 return SubmitCallable(&LightsailClient::GetLoadBalancerTlsPolicies, request);
3545 }
3546
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);
3556 }
3557
3565
3570 template <typename GetLoadBalancersRequestT = Model::GetLoadBalancersRequest>
3571 Model::GetLoadBalancersOutcomeCallable GetLoadBalancersCallable(const GetLoadBalancersRequestT& request = {}) const {
3572 return SubmitCallable(&LightsailClient::GetLoadBalancers, request);
3573 }
3574
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);
3584 }
3585
3594
3598 template <typename GetOperationRequestT = Model::GetOperationRequest>
3599 Model::GetOperationOutcomeCallable GetOperationCallable(const GetOperationRequestT& request) const {
3600 return SubmitCallable(&LightsailClient::GetOperation, request);
3601 }
3602
3607 template <typename GetOperationRequestT = Model::GetOperationRequest>
3608 void GetOperationAsync(const GetOperationRequestT& request, const GetOperationResponseReceivedHandler& handler,
3609 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
3610 return SubmitAsync(&LightsailClient::GetOperation, request, handler, context);
3611 }
3612
3623
3627 template <typename GetOperationsRequestT = Model::GetOperationsRequest>
3628 Model::GetOperationsOutcomeCallable GetOperationsCallable(const GetOperationsRequestT& request = {}) const {
3629 return SubmitCallable(&LightsailClient::GetOperations, request);
3630 }
3631
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);
3641 }
3642
3650
3655 template <typename GetOperationsForResourceRequestT = Model::GetOperationsForResourceRequest>
3656 Model::GetOperationsForResourceOutcomeCallable GetOperationsForResourceCallable(const GetOperationsForResourceRequestT& request) const {
3657 return SubmitCallable(&LightsailClient::GetOperationsForResource, request);
3658 }
3659
3664 template <typename GetOperationsForResourceRequestT = Model::GetOperationsForResourceRequest>
3665 void GetOperationsForResourceAsync(const GetOperationsForResourceRequestT& request,
3667 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
3668 return SubmitAsync(&LightsailClient::GetOperationsForResource, request, handler, context);
3669 }
3670
3680
3684 template <typename GetProfileRequestT = Model::GetProfileRequest>
3685 Model::GetProfileOutcomeCallable GetProfileCallable(const GetProfileRequestT& request = {}) const {
3686 return SubmitCallable(&LightsailClient::GetProfile, request);
3687 }
3688
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);
3698 }
3699
3708
3712 template <typename GetRegionsRequestT = Model::GetRegionsRequest>
3713 Model::GetRegionsOutcomeCallable GetRegionsCallable(const GetRegionsRequestT& request = {}) const {
3714 return SubmitCallable(&LightsailClient::GetRegions, request);
3715 }
3716
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);
3726 }
3727
3735
3740 template <typename GetRelationalDatabaseRequestT = Model::GetRelationalDatabaseRequest>
3741 Model::GetRelationalDatabaseOutcomeCallable GetRelationalDatabaseCallable(const GetRelationalDatabaseRequestT& request) const {
3742 return SubmitCallable(&LightsailClient::GetRelationalDatabase, request);
3743 }
3744
3749 template <typename GetRelationalDatabaseRequestT = Model::GetRelationalDatabaseRequest>
3750 void GetRelationalDatabaseAsync(const GetRelationalDatabaseRequestT& request, const GetRelationalDatabaseResponseReceivedHandler& handler,
3751 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
3752 return SubmitAsync(&LightsailClient::GetRelationalDatabase, request, handler, context);
3753 }
3754
3764 const Model::GetRelationalDatabaseBlueprintsRequest& request = {}) const;
3765
3770 template <typename GetRelationalDatabaseBlueprintsRequestT = Model::GetRelationalDatabaseBlueprintsRequest>
3772 const GetRelationalDatabaseBlueprintsRequestT& request = {}) const {
3773 return SubmitCallable(&LightsailClient::GetRelationalDatabaseBlueprints, request);
3774 }
3775
3780 template <typename GetRelationalDatabaseBlueprintsRequestT = Model::GetRelationalDatabaseBlueprintsRequest>
3782 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
3783 const GetRelationalDatabaseBlueprintsRequestT& request = {}) const {
3784 return SubmitAsync(&LightsailClient::GetRelationalDatabaseBlueprints, request, handler, context);
3785 }
3786
3796 const Model::GetRelationalDatabaseBundlesRequest& request = {}) const;
3797
3802 template <typename GetRelationalDatabaseBundlesRequestT = Model::GetRelationalDatabaseBundlesRequest>
3804 const GetRelationalDatabaseBundlesRequestT& request = {}) const {
3805 return SubmitCallable(&LightsailClient::GetRelationalDatabaseBundles, request);
3806 }
3807
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);
3817 }
3818
3826 const Model::GetRelationalDatabaseEventsRequest& request) const;
3827
3832 template <typename GetRelationalDatabaseEventsRequestT = Model::GetRelationalDatabaseEventsRequest>
3834 const GetRelationalDatabaseEventsRequestT& request) const {
3835 return SubmitCallable(&LightsailClient::GetRelationalDatabaseEvents, request);
3836 }
3837
3842 template <typename GetRelationalDatabaseEventsRequestT = Model::GetRelationalDatabaseEventsRequest>
3843 void GetRelationalDatabaseEventsAsync(const GetRelationalDatabaseEventsRequestT& request,
3845 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
3846 return SubmitAsync(&LightsailClient::GetRelationalDatabaseEvents, request, handler, context);
3847 }
3848
3857
3862 template <typename GetRelationalDatabaseLogEventsRequestT = Model::GetRelationalDatabaseLogEventsRequest>
3864 const GetRelationalDatabaseLogEventsRequestT& request) const {
3865 return SubmitCallable(&LightsailClient::GetRelationalDatabaseLogEvents, request);
3866 }
3867
3872 template <typename GetRelationalDatabaseLogEventsRequestT = Model::GetRelationalDatabaseLogEventsRequest>
3873 void GetRelationalDatabaseLogEventsAsync(const GetRelationalDatabaseLogEventsRequestT& request,
3875 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
3876 return SubmitAsync(&LightsailClient::GetRelationalDatabaseLogEvents, request, handler, context);
3877 }
3878
3887
3892 template <typename GetRelationalDatabaseLogStreamsRequestT = Model::GetRelationalDatabaseLogStreamsRequest>
3894 const GetRelationalDatabaseLogStreamsRequestT& request) const {
3895 return SubmitCallable(&LightsailClient::GetRelationalDatabaseLogStreams, request);
3896 }
3897
3902 template <typename GetRelationalDatabaseLogStreamsRequestT = Model::GetRelationalDatabaseLogStreamsRequest>
3903 void GetRelationalDatabaseLogStreamsAsync(const GetRelationalDatabaseLogStreamsRequestT& request,
3905 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
3906 return SubmitAsync(&LightsailClient::GetRelationalDatabaseLogStreams, request, handler, context);
3907 }
3908
3920
3925 template <typename GetRelationalDatabaseMasterUserPasswordRequestT = Model::GetRelationalDatabaseMasterUserPasswordRequest>
3927 const GetRelationalDatabaseMasterUserPasswordRequestT& request) const {
3928 return SubmitCallable(&LightsailClient::GetRelationalDatabaseMasterUserPassword, request);
3929 }
3930
3935 template <typename GetRelationalDatabaseMasterUserPasswordRequestT = Model::GetRelationalDatabaseMasterUserPasswordRequest>
3936 void GetRelationalDatabaseMasterUserPasswordAsync(const GetRelationalDatabaseMasterUserPasswordRequestT& request,
3938 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
3939 return SubmitAsync(&LightsailClient::GetRelationalDatabaseMasterUserPassword, request, handler, context);
3940 }
3941
3953
3958 template <typename GetRelationalDatabaseMetricDataRequestT = Model::GetRelationalDatabaseMetricDataRequest>
3960 const GetRelationalDatabaseMetricDataRequestT& request) const {
3961 return SubmitCallable(&LightsailClient::GetRelationalDatabaseMetricData, request);
3962 }
3963
3968 template <typename GetRelationalDatabaseMetricDataRequestT = Model::GetRelationalDatabaseMetricDataRequest>
3969 void GetRelationalDatabaseMetricDataAsync(const GetRelationalDatabaseMetricDataRequestT& request,
3971 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
3972 return SubmitAsync(&LightsailClient::GetRelationalDatabaseMetricData, request, handler, context);
3973 }
3974
3987
3992 template <typename GetRelationalDatabaseParametersRequestT = Model::GetRelationalDatabaseParametersRequest>
3994 const GetRelationalDatabaseParametersRequestT& request) const {
3995 return SubmitCallable(&LightsailClient::GetRelationalDatabaseParameters, request);
3996 }
3997
4002 template <typename GetRelationalDatabaseParametersRequestT = Model::GetRelationalDatabaseParametersRequest>
4003 void GetRelationalDatabaseParametersAsync(const GetRelationalDatabaseParametersRequestT& request,
4005 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4006 return SubmitAsync(&LightsailClient::GetRelationalDatabaseParameters, request, handler, context);
4007 }
4008
4016 const Model::GetRelationalDatabaseSnapshotRequest& request) const;
4017
4022 template <typename GetRelationalDatabaseSnapshotRequestT = Model::GetRelationalDatabaseSnapshotRequest>
4024 const GetRelationalDatabaseSnapshotRequestT& request) const {
4025 return SubmitCallable(&LightsailClient::GetRelationalDatabaseSnapshot, request);
4026 }
4027
4032 template <typename GetRelationalDatabaseSnapshotRequestT = Model::GetRelationalDatabaseSnapshotRequest>
4033 void GetRelationalDatabaseSnapshotAsync(const GetRelationalDatabaseSnapshotRequestT& request,
4035 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4036 return SubmitAsync(&LightsailClient::GetRelationalDatabaseSnapshot, request, handler, context);
4037 }
4038
4046 const Model::GetRelationalDatabaseSnapshotsRequest& request = {}) const;
4047
4052 template <typename GetRelationalDatabaseSnapshotsRequestT = Model::GetRelationalDatabaseSnapshotsRequest>
4054 const GetRelationalDatabaseSnapshotsRequestT& request = {}) const {
4055 return SubmitCallable(&LightsailClient::GetRelationalDatabaseSnapshots, request);
4056 }
4057
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);
4067 }
4068
4076
4081 template <typename GetRelationalDatabasesRequestT = Model::GetRelationalDatabasesRequest>
4082 Model::GetRelationalDatabasesOutcomeCallable GetRelationalDatabasesCallable(const GetRelationalDatabasesRequestT& request = {}) const {
4083 return SubmitCallable(&LightsailClient::GetRelationalDatabases, request);
4084 }
4085
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);
4095 }
4096
4105
4109 template <typename GetSetupHistoryRequestT = Model::GetSetupHistoryRequest>
4110 Model::GetSetupHistoryOutcomeCallable GetSetupHistoryCallable(const GetSetupHistoryRequestT& request) const {
4111 return SubmitCallable(&LightsailClient::GetSetupHistory, request);
4112 }
4113
4118 template <typename GetSetupHistoryRequestT = Model::GetSetupHistoryRequest>
4119 void GetSetupHistoryAsync(const GetSetupHistoryRequestT& request, const GetSetupHistoryResponseReceivedHandler& handler,
4120 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4121 return SubmitAsync(&LightsailClient::GetSetupHistory, request, handler, context);
4122 }
4123
4131
4135 template <typename GetStaticIpRequestT = Model::GetStaticIpRequest>
4136 Model::GetStaticIpOutcomeCallable GetStaticIpCallable(const GetStaticIpRequestT& request) const {
4137 return SubmitCallable(&LightsailClient::GetStaticIp, request);
4138 }
4139
4144 template <typename GetStaticIpRequestT = Model::GetStaticIpRequest>
4145 void GetStaticIpAsync(const GetStaticIpRequestT& request, const GetStaticIpResponseReceivedHandler& handler,
4146 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4147 return SubmitAsync(&LightsailClient::GetStaticIp, request, handler, context);
4148 }
4149
4157
4161 template <typename GetStaticIpsRequestT = Model::GetStaticIpsRequest>
4162 Model::GetStaticIpsOutcomeCallable GetStaticIpsCallable(const GetStaticIpsRequestT& request = {}) const {
4163 return SubmitCallable(&LightsailClient::GetStaticIps, request);
4164 }
4165
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);
4175 }
4176
4187
4191 template <typename GetSubdomainsRequestT = Model::GetSubdomainsRequest>
4192 Model::GetSubdomainsOutcomeCallable GetSubdomainsCallable(const GetSubdomainsRequestT& request = {}) const {
4193 return SubmitCallable(&LightsailClient::GetSubdomains, request);
4194 }
4195
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);
4205 }
4206
4214
4218 template <typename ImportKeyPairRequestT = Model::ImportKeyPairRequest>
4219 Model::ImportKeyPairOutcomeCallable ImportKeyPairCallable(const ImportKeyPairRequestT& request) const {
4220 return SubmitCallable(&LightsailClient::ImportKeyPair, request);
4221 }
4222
4227 template <typename ImportKeyPairRequestT = Model::ImportKeyPairRequest>
4228 void ImportKeyPairAsync(const ImportKeyPairRequestT& request, const ImportKeyPairResponseReceivedHandler& handler,
4229 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4230 return SubmitAsync(&LightsailClient::ImportKeyPair, request, handler, context);
4231 }
4232
4240
4244 template <typename IsVpcPeeredRequestT = Model::IsVpcPeeredRequest>
4245 Model::IsVpcPeeredOutcomeCallable IsVpcPeeredCallable(const IsVpcPeeredRequestT& request = {}) const {
4246 return SubmitCallable(&LightsailClient::IsVpcPeered, request);
4247 }
4248
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);
4258 }
4259
4272
4277 template <typename OpenInstancePublicPortsRequestT = Model::OpenInstancePublicPortsRequest>
4278 Model::OpenInstancePublicPortsOutcomeCallable OpenInstancePublicPortsCallable(const OpenInstancePublicPortsRequestT& request) const {
4279 return SubmitCallable(&LightsailClient::OpenInstancePublicPorts, request);
4280 }
4281
4286 template <typename OpenInstancePublicPortsRequestT = Model::OpenInstancePublicPortsRequest>
4287 void OpenInstancePublicPortsAsync(const OpenInstancePublicPortsRequestT& request,
4289 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4290 return SubmitAsync(&LightsailClient::OpenInstancePublicPorts, request, handler, context);
4291 }
4292
4299 virtual Model::PeerVpcOutcome PeerVpc(const Model::PeerVpcRequest& request = {}) const;
4300
4304 template <typename PeerVpcRequestT = Model::PeerVpcRequest>
4305 Model::PeerVpcOutcomeCallable PeerVpcCallable(const PeerVpcRequestT& request = {}) const {
4306 return SubmitCallable(&LightsailClient::PeerVpc, request);
4307 }
4308
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);
4318 }
4319
4341
4345 template <typename PutAlarmRequestT = Model::PutAlarmRequest>
4346 Model::PutAlarmOutcomeCallable PutAlarmCallable(const PutAlarmRequestT& request) const {
4347 return SubmitCallable(&LightsailClient::PutAlarm, request);
4348 }
4349
4354 template <typename PutAlarmRequestT = Model::PutAlarmRequest>
4355 void PutAlarmAsync(const PutAlarmRequestT& request, const PutAlarmResponseReceivedHandler& handler,
4356 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4357 return SubmitAsync(&LightsailClient::PutAlarm, request, handler, context);
4358 }
4359
4376
4381 template <typename PutInstancePublicPortsRequestT = Model::PutInstancePublicPortsRequest>
4382 Model::PutInstancePublicPortsOutcomeCallable PutInstancePublicPortsCallable(const PutInstancePublicPortsRequestT& request) const {
4383 return SubmitCallable(&LightsailClient::PutInstancePublicPorts, request);
4384 }
4385
4390 template <typename PutInstancePublicPortsRequestT = Model::PutInstancePublicPortsRequest>
4391 void PutInstancePublicPortsAsync(const PutInstancePublicPortsRequestT& request,
4393 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4394 return SubmitAsync(&LightsailClient::PutInstancePublicPorts, request, handler, context);
4395 }
4396
4408
4412 template <typename RebootInstanceRequestT = Model::RebootInstanceRequest>
4413 Model::RebootInstanceOutcomeCallable RebootInstanceCallable(const RebootInstanceRequestT& request) const {
4414 return SubmitCallable(&LightsailClient::RebootInstance, request);
4415 }
4416
4421 template <typename RebootInstanceRequestT = Model::RebootInstanceRequest>
4422 void RebootInstanceAsync(const RebootInstanceRequestT& request, const RebootInstanceResponseReceivedHandler& handler,
4423 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4424 return SubmitAsync(&LightsailClient::RebootInstance, request, handler, context);
4425 }
4426
4438
4443 template <typename RebootRelationalDatabaseRequestT = Model::RebootRelationalDatabaseRequest>
4444 Model::RebootRelationalDatabaseOutcomeCallable RebootRelationalDatabaseCallable(const RebootRelationalDatabaseRequestT& request) const {
4445 return SubmitCallable(&LightsailClient::RebootRelationalDatabase, request);
4446 }
4447
4452 template <typename RebootRelationalDatabaseRequestT = Model::RebootRelationalDatabaseRequest>
4453 void RebootRelationalDatabaseAsync(const RebootRelationalDatabaseRequestT& request,
4455 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4456 return SubmitAsync(&LightsailClient::RebootRelationalDatabase, request, handler, context);
4457 }
4458
4472
4477 template <typename RegisterContainerImageRequestT = Model::RegisterContainerImageRequest>
4478 Model::RegisterContainerImageOutcomeCallable RegisterContainerImageCallable(const RegisterContainerImageRequestT& request) const {
4479 return SubmitCallable(&LightsailClient::RegisterContainerImage, request);
4480 }
4481
4486 template <typename RegisterContainerImageRequestT = Model::RegisterContainerImageRequest>
4487 void RegisterContainerImageAsync(const RegisterContainerImageRequestT& request,
4489 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4490 return SubmitAsync(&LightsailClient::RegisterContainerImage, request, handler, context);
4491 }
4492
4499
4503 template <typename ReleaseStaticIpRequestT = Model::ReleaseStaticIpRequest>
4504 Model::ReleaseStaticIpOutcomeCallable ReleaseStaticIpCallable(const ReleaseStaticIpRequestT& request) const {
4505 return SubmitCallable(&LightsailClient::ReleaseStaticIp, request);
4506 }
4507
4512 template <typename ReleaseStaticIpRequestT = Model::ReleaseStaticIpRequest>
4513 void ReleaseStaticIpAsync(const ReleaseStaticIpRequestT& request, const ReleaseStaticIpResponseReceivedHandler& handler,
4514 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4515 return SubmitAsync(&LightsailClient::ReleaseStaticIp, request, handler, context);
4516 }
4517
4527
4532 template <typename ResetDistributionCacheRequestT = Model::ResetDistributionCacheRequest>
4533 Model::ResetDistributionCacheOutcomeCallable ResetDistributionCacheCallable(const ResetDistributionCacheRequestT& request = {}) const {
4534 return SubmitCallable(&LightsailClient::ResetDistributionCache, request);
4535 }
4536
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);
4546 }
4547
4567 const Model::SendContactMethodVerificationRequest& request) const;
4568
4573 template <typename SendContactMethodVerificationRequestT = Model::SendContactMethodVerificationRequest>
4575 const SendContactMethodVerificationRequestT& request) const {
4576 return SubmitCallable(&LightsailClient::SendContactMethodVerification, request);
4577 }
4578
4583 template <typename SendContactMethodVerificationRequestT = Model::SendContactMethodVerificationRequest>
4584 void SendContactMethodVerificationAsync(const SendContactMethodVerificationRequestT& request,
4586 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4587 return SubmitAsync(&LightsailClient::SendContactMethodVerification, request, handler, context);
4588 }
4589
4599
4604 template <typename SetIpAddressTypeRequestT = Model::SetIpAddressTypeRequest>
4605 Model::SetIpAddressTypeOutcomeCallable SetIpAddressTypeCallable(const SetIpAddressTypeRequestT& request) const {
4606 return SubmitCallable(&LightsailClient::SetIpAddressType, request);
4607 }
4608
4613 template <typename SetIpAddressTypeRequestT = Model::SetIpAddressTypeRequest>
4614 void SetIpAddressTypeAsync(const SetIpAddressTypeRequestT& request, const SetIpAddressTypeResponseReceivedHandler& handler,
4615 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4616 return SubmitAsync(&LightsailClient::SetIpAddressType, request, handler, context);
4617 }
4618
4627 const Model::SetResourceAccessForBucketRequest& request) const;
4628
4633 template <typename SetResourceAccessForBucketRequestT = Model::SetResourceAccessForBucketRequest>
4635 const SetResourceAccessForBucketRequestT& request) const {
4636 return SubmitCallable(&LightsailClient::SetResourceAccessForBucket, request);
4637 }
4638
4643 template <typename SetResourceAccessForBucketRequestT = Model::SetResourceAccessForBucketRequest>
4644 void SetResourceAccessForBucketAsync(const SetResourceAccessForBucketRequestT& request,
4646 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4647 return SubmitAsync(&LightsailClient::SetResourceAccessForBucket, request, handler, context);
4648 }
4649
4660
4665 template <typename SetupInstanceHttpsRequestT = Model::SetupInstanceHttpsRequest>
4666 Model::SetupInstanceHttpsOutcomeCallable SetupInstanceHttpsCallable(const SetupInstanceHttpsRequestT& request) const {
4667 return SubmitCallable(&LightsailClient::SetupInstanceHttps, request);
4668 }
4669
4674 template <typename SetupInstanceHttpsRequestT = Model::SetupInstanceHttpsRequest>
4675 void SetupInstanceHttpsAsync(const SetupInstanceHttpsRequestT& request, const SetupInstanceHttpsResponseReceivedHandler& handler,
4676 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4677 return SubmitAsync(&LightsailClient::SetupInstanceHttps, request, handler, context);
4678 }
4679
4689
4693 template <typename StartGUISessionRequestT = Model::StartGUISessionRequest>
4694 Model::StartGUISessionOutcomeCallable StartGUISessionCallable(const StartGUISessionRequestT& request) const {
4695 return SubmitCallable(&LightsailClient::StartGUISession, request);
4696 }
4697
4702 template <typename StartGUISessionRequestT = Model::StartGUISessionRequest>
4703 void StartGUISessionAsync(const StartGUISessionRequestT& request, const StartGUISessionResponseReceivedHandler& handler,
4704 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4705 return SubmitAsync(&LightsailClient::StartGUISession, request, handler, context);
4706 }
4707
4726
4730 template <typename StartInstanceRequestT = Model::StartInstanceRequest>
4731 Model::StartInstanceOutcomeCallable StartInstanceCallable(const StartInstanceRequestT& request) const {
4732 return SubmitCallable(&LightsailClient::StartInstance, request);
4733 }
4734
4739 template <typename StartInstanceRequestT = Model::StartInstanceRequest>
4740 void StartInstanceAsync(const StartInstanceRequestT& request, const StartInstanceResponseReceivedHandler& handler,
4741 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4742 return SubmitAsync(&LightsailClient::StartInstance, request, handler, context);
4743 }
4744
4757
4762 template <typename StartRelationalDatabaseRequestT = Model::StartRelationalDatabaseRequest>
4763 Model::StartRelationalDatabaseOutcomeCallable StartRelationalDatabaseCallable(const StartRelationalDatabaseRequestT& request) const {
4764 return SubmitCallable(&LightsailClient::StartRelationalDatabase, request);
4765 }
4766
4771 template <typename StartRelationalDatabaseRequestT = Model::StartRelationalDatabaseRequest>
4772 void StartRelationalDatabaseAsync(const StartRelationalDatabaseRequestT& request,
4774 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4775 return SubmitAsync(&LightsailClient::StartRelationalDatabase, request, handler, context);
4776 }
4777
4786
4790 template <typename StopGUISessionRequestT = Model::StopGUISessionRequest>
4791 Model::StopGUISessionOutcomeCallable StopGUISessionCallable(const StopGUISessionRequestT& request) const {
4792 return SubmitCallable(&LightsailClient::StopGUISession, request);
4793 }
4794
4799 template <typename StopGUISessionRequestT = Model::StopGUISessionRequest>
4800 void StopGUISessionAsync(const StopGUISessionRequestT& request, const StopGUISessionResponseReceivedHandler& handler,
4801 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4802 return SubmitAsync(&LightsailClient::StopGUISession, request, handler, context);
4803 }
4804
4822
4826 template <typename StopInstanceRequestT = Model::StopInstanceRequest>
4827 Model::StopInstanceOutcomeCallable StopInstanceCallable(const StopInstanceRequestT& request) const {
4828 return SubmitCallable(&LightsailClient::StopInstance, request);
4829 }
4830
4835 template <typename StopInstanceRequestT = Model::StopInstanceRequest>
4836 void StopInstanceAsync(const StopInstanceRequestT& request, const StopInstanceResponseReceivedHandler& handler,
4837 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4838 return SubmitAsync(&LightsailClient::StopInstance, request, handler, context);
4839 }
4840
4856
4861 template <typename StopRelationalDatabaseRequestT = Model::StopRelationalDatabaseRequest>
4862 Model::StopRelationalDatabaseOutcomeCallable StopRelationalDatabaseCallable(const StopRelationalDatabaseRequestT& request) const {
4863 return SubmitCallable(&LightsailClient::StopRelationalDatabase, request);
4864 }
4865
4870 template <typename StopRelationalDatabaseRequestT = Model::StopRelationalDatabaseRequest>
4871 void StopRelationalDatabaseAsync(const StopRelationalDatabaseRequestT& request,
4873 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4874 return SubmitAsync(&LightsailClient::StopRelationalDatabase, request, handler, context);
4875 }
4876
4893
4897 template <typename TagResourceRequestT = Model::TagResourceRequest>
4898 Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
4899 return SubmitCallable(&LightsailClient::TagResource, request);
4900 }
4901
4906 template <typename TagResourceRequestT = Model::TagResourceRequest>
4907 void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
4908 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4909 return SubmitAsync(&LightsailClient::TagResource, request, handler, context);
4910 }
4911
4926
4930 template <typename TestAlarmRequestT = Model::TestAlarmRequest>
4931 Model::TestAlarmOutcomeCallable TestAlarmCallable(const TestAlarmRequestT& request) const {
4932 return SubmitCallable(&LightsailClient::TestAlarm, request);
4933 }
4934
4939 template <typename TestAlarmRequestT = Model::TestAlarmRequest>
4940 void TestAlarmAsync(const TestAlarmRequestT& request, const TestAlarmResponseReceivedHandler& handler,
4941 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
4942 return SubmitAsync(&LightsailClient::TestAlarm, request, handler, context);
4943 }
4944
4952
4956 template <typename UnpeerVpcRequestT = Model::UnpeerVpcRequest>
4957 Model::UnpeerVpcOutcomeCallable UnpeerVpcCallable(const UnpeerVpcRequestT& request = {}) const {
4958 return SubmitCallable(&LightsailClient::UnpeerVpc, request);
4959 }
4960
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);
4970 }
4971
4984
4988 template <typename UntagResourceRequestT = Model::UntagResourceRequest>
4989 Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
4990 return SubmitCallable(&LightsailClient::UntagResource, request);
4991 }
4992
4997 template <typename UntagResourceRequestT = Model::UntagResourceRequest>
4998 void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
4999 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
5000 return SubmitAsync(&LightsailClient::UntagResource, request, handler, context);
5001 }
5002
5012
5016 template <typename UpdateBucketRequestT = Model::UpdateBucketRequest>
5017 Model::UpdateBucketOutcomeCallable UpdateBucketCallable(const UpdateBucketRequestT& request) const {
5018 return SubmitCallable(&LightsailClient::UpdateBucket, request);
5019 }
5020
5025 template <typename UpdateBucketRequestT = Model::UpdateBucketRequest>
5026 void UpdateBucketAsync(const UpdateBucketRequestT& request, const UpdateBucketResponseReceivedHandler& handler,
5027 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
5028 return SubmitAsync(&LightsailClient::UpdateBucket, request, handler, context);
5029 }
5030
5052
5057 template <typename UpdateBucketBundleRequestT = Model::UpdateBucketBundleRequest>
5058 Model::UpdateBucketBundleOutcomeCallable UpdateBucketBundleCallable(const UpdateBucketBundleRequestT& request) const {
5059 return SubmitCallable(&LightsailClient::UpdateBucketBundle, request);
5060 }
5061
5066 template <typename UpdateBucketBundleRequestT = Model::UpdateBucketBundleRequest>
5067 void UpdateBucketBundleAsync(const UpdateBucketBundleRequestT& request, const UpdateBucketBundleResponseReceivedHandler& handler,
5068 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
5069 return SubmitAsync(&LightsailClient::UpdateBucketBundle, request, handler, context);
5070 }
5071
5079
5084 template <typename UpdateContainerServiceRequestT = Model::UpdateContainerServiceRequest>
5085 Model::UpdateContainerServiceOutcomeCallable UpdateContainerServiceCallable(const UpdateContainerServiceRequestT& request) const {
5086 return SubmitCallable(&LightsailClient::UpdateContainerService, request);
5087 }
5088
5093 template <typename UpdateContainerServiceRequestT = Model::UpdateContainerServiceRequest>
5094 void UpdateContainerServiceAsync(const UpdateContainerServiceRequestT& request,
5096 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
5097 return SubmitAsync(&LightsailClient::UpdateContainerService, request, handler, context);
5098 }
5099
5108
5113 template <typename UpdateDistributionRequestT = Model::UpdateDistributionRequest>
5114 Model::UpdateDistributionOutcomeCallable UpdateDistributionCallable(const UpdateDistributionRequestT& request) const {
5115 return SubmitCallable(&LightsailClient::UpdateDistribution, request);
5116 }
5117
5122 template <typename UpdateDistributionRequestT = Model::UpdateDistributionRequest>
5123 void UpdateDistributionAsync(const UpdateDistributionRequestT& request, const UpdateDistributionResponseReceivedHandler& handler,
5124 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
5125 return SubmitAsync(&LightsailClient::UpdateDistribution, request, handler, context);
5126 }
5127
5143
5148 template <typename UpdateDistributionBundleRequestT = Model::UpdateDistributionBundleRequest>
5150 const UpdateDistributionBundleRequestT& request = {}) const {
5151 return SubmitCallable(&LightsailClient::UpdateDistributionBundle, request);
5152 }
5153
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);
5163 }
5164
5176
5181 template <typename UpdateDomainEntryRequestT = Model::UpdateDomainEntryRequest>
5182 Model::UpdateDomainEntryOutcomeCallable UpdateDomainEntryCallable(const UpdateDomainEntryRequestT& request) const {
5183 return SubmitCallable(&LightsailClient::UpdateDomainEntry, request);
5184 }
5185
5190 template <typename UpdateDomainEntryRequestT = Model::UpdateDomainEntryRequest>
5191 void UpdateDomainEntryAsync(const UpdateDomainEntryRequestT& request, const UpdateDomainEntryResponseReceivedHandler& handler,
5192 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
5193 return SubmitAsync(&LightsailClient::UpdateDomainEntry, request, handler, context);
5194 }
5195
5211 const Model::UpdateInstanceMetadataOptionsRequest& request) const;
5212
5217 template <typename UpdateInstanceMetadataOptionsRequestT = Model::UpdateInstanceMetadataOptionsRequest>
5219 const UpdateInstanceMetadataOptionsRequestT& request) const {
5220 return SubmitCallable(&LightsailClient::UpdateInstanceMetadataOptions, request);
5221 }
5222
5227 template <typename UpdateInstanceMetadataOptionsRequestT = Model::UpdateInstanceMetadataOptionsRequest>
5228 void UpdateInstanceMetadataOptionsAsync(const UpdateInstanceMetadataOptionsRequestT& request,
5230 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
5231 return SubmitAsync(&LightsailClient::UpdateInstanceMetadataOptions, request, handler, context);
5232 }
5233
5246 const Model::UpdateLoadBalancerAttributeRequest& request) const;
5247
5252 template <typename UpdateLoadBalancerAttributeRequestT = Model::UpdateLoadBalancerAttributeRequest>
5254 const UpdateLoadBalancerAttributeRequestT& request) const {
5255 return SubmitCallable(&LightsailClient::UpdateLoadBalancerAttribute, request);
5256 }
5257
5262 template <typename UpdateLoadBalancerAttributeRequestT = Model::UpdateLoadBalancerAttributeRequest>
5263 void UpdateLoadBalancerAttributeAsync(const UpdateLoadBalancerAttributeRequestT& request,
5265 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
5266 return SubmitAsync(&LightsailClient::UpdateLoadBalancerAttribute, request, handler, context);
5267 }
5268
5282
5287 template <typename UpdateRelationalDatabaseRequestT = Model::UpdateRelationalDatabaseRequest>
5288 Model::UpdateRelationalDatabaseOutcomeCallable UpdateRelationalDatabaseCallable(const UpdateRelationalDatabaseRequestT& request) const {
5289 return SubmitCallable(&LightsailClient::UpdateRelationalDatabase, request);
5290 }
5291
5296 template <typename UpdateRelationalDatabaseRequestT = Model::UpdateRelationalDatabaseRequest>
5297 void UpdateRelationalDatabaseAsync(const UpdateRelationalDatabaseRequestT& request,
5299 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
5300 return SubmitAsync(&LightsailClient::UpdateRelationalDatabase, request, handler, context);
5301 }
5302
5322
5327 template <typename UpdateRelationalDatabaseParametersRequestT = Model::UpdateRelationalDatabaseParametersRequest>
5329 const UpdateRelationalDatabaseParametersRequestT& request) const {
5330 return SubmitCallable(&LightsailClient::UpdateRelationalDatabaseParameters, request);
5331 }
5332
5337 template <typename UpdateRelationalDatabaseParametersRequestT = Model::UpdateRelationalDatabaseParametersRequest>
5338 void UpdateRelationalDatabaseParametersAsync(const UpdateRelationalDatabaseParametersRequestT& request,
5340 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
5341 return SubmitAsync(&LightsailClient::UpdateRelationalDatabaseParameters, request, handler, context);
5342 }
5343
5362 const Model::UpdateSubdomainAssociationRequest& request) const;
5363
5368 template <typename UpdateSubdomainAssociationRequestT = Model::UpdateSubdomainAssociationRequest>
5370 const UpdateSubdomainAssociationRequestT& request) const {
5371 return SubmitCallable(&LightsailClient::UpdateSubdomainAssociation, request);
5372 }
5373
5378 template <typename UpdateSubdomainAssociationRequestT = Model::UpdateSubdomainAssociationRequest>
5379 void UpdateSubdomainAssociationAsync(const UpdateSubdomainAssociationRequestT& request,
5381 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
5382 return SubmitAsync(&LightsailClient::UpdateSubdomainAssociation, request, handler, context);
5383 }
5384
5385 virtual void OverrideEndpoint(const Aws::String& endpoint);
5386 virtual std::shared_ptr<LightsailEndpointProviderBase>& accessEndpointProvider();
5387
5388 private:
5390 void init(const LightsailClientConfiguration& clientConfiguration);
5391
5393
5394 InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
5395
5396 LightsailClientConfiguration m_clientConfiguration;
5397 std::shared_ptr<LightsailEndpointProviderBase> m_endpointProvider;
5398};
5399
5400} // namespace Lightsail
5401} // namespace Aws
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
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