LightsailClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/lightsail/LightsailServiceClientModel.h>
#include <aws/lightsail/Lightsail_EXPORTS.h>
 
namespace Aws {
namespace Lightsail {
class AWS_LIGHTSAIL_API LightsailClient : public Aws::Client::AWSJsonClient,
                                          public Aws::Client::ClientWithAsyncTemplateMethods<LightsailClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef LightsailClientConfiguration ClientConfigurationType;
  typedef LightsailEndpointProvider EndpointProviderType;
 
  LightsailClient(const Aws::Lightsail::LightsailClientConfiguration& clientConfiguration = Aws::Lightsail::LightsailClientConfiguration(),
                  std::shared_ptr<LightsailEndpointProviderBase> endpointProvider = nullptr);
 
  LightsailClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<LightsailEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::Lightsail::LightsailClientConfiguration& clientConfiguration = Aws::Lightsail::LightsailClientConfiguration());
 
  LightsailClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<LightsailEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::Lightsail::LightsailClientConfiguration& clientConfiguration = Aws::Lightsail::LightsailClientConfiguration());
 
  /* Legacy constructors due deprecation */
  LightsailClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  LightsailClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  LightsailClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~LightsailClient();
 
  virtual Model::AllocateStaticIpOutcome AllocateStaticIp(const Model::AllocateStaticIpRequest& request) const;
 
  template <typename AllocateStaticIpRequestT = Model::AllocateStaticIpRequest>
  Model::AllocateStaticIpOutcomeCallable AllocateStaticIpCallable(const AllocateStaticIpRequestT& request) const {
    return SubmitCallable(&LightsailClient::AllocateStaticIp, request);
  }
 
  template <typename AllocateStaticIpRequestT = Model::AllocateStaticIpRequest>
  void AllocateStaticIpAsync(const AllocateStaticIpRequestT& request, const AllocateStaticIpResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::AllocateStaticIp, request, handler, context);
  }
 
  virtual Model::AttachCertificateToDistributionOutcome AttachCertificateToDistribution(
      const Model::AttachCertificateToDistributionRequest& request) const;
 
  template <typename AttachCertificateToDistributionRequestT = Model::AttachCertificateToDistributionRequest>
  Model::AttachCertificateToDistributionOutcomeCallable AttachCertificateToDistributionCallable(
      const AttachCertificateToDistributionRequestT& request) const {
    return SubmitCallable(&LightsailClient::AttachCertificateToDistribution, request);
  }
 
  template <typename AttachCertificateToDistributionRequestT = Model::AttachCertificateToDistributionRequest>
  void AttachCertificateToDistributionAsync(const AttachCertificateToDistributionRequestT& request,
                                            const AttachCertificateToDistributionResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::AttachCertificateToDistribution, request, handler, context);
  }
 
  virtual Model::AttachDiskOutcome AttachDisk(const Model::AttachDiskRequest& request) const;
 
  template <typename AttachDiskRequestT = Model::AttachDiskRequest>
  Model::AttachDiskOutcomeCallable AttachDiskCallable(const AttachDiskRequestT& request) const {
    return SubmitCallable(&LightsailClient::AttachDisk, request);
  }
 
  template <typename AttachDiskRequestT = Model::AttachDiskRequest>
  void AttachDiskAsync(const AttachDiskRequestT& request, const AttachDiskResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::AttachDisk, request, handler, context);
  }
 
  virtual Model::AttachInstancesToLoadBalancerOutcome AttachInstancesToLoadBalancer(
      const Model::AttachInstancesToLoadBalancerRequest& request) const;
 
  template <typename AttachInstancesToLoadBalancerRequestT = Model::AttachInstancesToLoadBalancerRequest>
  Model::AttachInstancesToLoadBalancerOutcomeCallable AttachInstancesToLoadBalancerCallable(
      const AttachInstancesToLoadBalancerRequestT& request) const {
    return SubmitCallable(&LightsailClient::AttachInstancesToLoadBalancer, request);
  }
 
  template <typename AttachInstancesToLoadBalancerRequestT = Model::AttachInstancesToLoadBalancerRequest>
  void AttachInstancesToLoadBalancerAsync(const AttachInstancesToLoadBalancerRequestT& request,
                                          const AttachInstancesToLoadBalancerResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::AttachInstancesToLoadBalancer, request, handler, context);
  }
 
  virtual Model::AttachLoadBalancerTlsCertificateOutcome AttachLoadBalancerTlsCertificate(
      const Model::AttachLoadBalancerTlsCertificateRequest& request) const;
 
  template <typename AttachLoadBalancerTlsCertificateRequestT = Model::AttachLoadBalancerTlsCertificateRequest>
  Model::AttachLoadBalancerTlsCertificateOutcomeCallable AttachLoadBalancerTlsCertificateCallable(
      const AttachLoadBalancerTlsCertificateRequestT& request) const {
    return SubmitCallable(&LightsailClient::AttachLoadBalancerTlsCertificate, request);
  }
 
  template <typename AttachLoadBalancerTlsCertificateRequestT = Model::AttachLoadBalancerTlsCertificateRequest>
  void AttachLoadBalancerTlsCertificateAsync(const AttachLoadBalancerTlsCertificateRequestT& request,
                                             const AttachLoadBalancerTlsCertificateResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::AttachLoadBalancerTlsCertificate, request, handler, context);
  }
 
  virtual Model::AttachStaticIpOutcome AttachStaticIp(const Model::AttachStaticIpRequest& request) const;
 
  template <typename AttachStaticIpRequestT = Model::AttachStaticIpRequest>
  Model::AttachStaticIpOutcomeCallable AttachStaticIpCallable(const AttachStaticIpRequestT& request) const {
    return SubmitCallable(&LightsailClient::AttachStaticIp, request);
  }
 
  template <typename AttachStaticIpRequestT = Model::AttachStaticIpRequest>
  void AttachStaticIpAsync(const AttachStaticIpRequestT& request, const AttachStaticIpResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::AttachStaticIp, request, handler, context);
  }
 
  virtual Model::CloseInstancePublicPortsOutcome CloseInstancePublicPorts(const Model::CloseInstancePublicPortsRequest& request) const;
 
  template <typename CloseInstancePublicPortsRequestT = Model::CloseInstancePublicPortsRequest>
  Model::CloseInstancePublicPortsOutcomeCallable CloseInstancePublicPortsCallable(const CloseInstancePublicPortsRequestT& request) const {
    return SubmitCallable(&LightsailClient::CloseInstancePublicPorts, request);
  }
 
  template <typename CloseInstancePublicPortsRequestT = Model::CloseInstancePublicPortsRequest>
  void CloseInstancePublicPortsAsync(const CloseInstancePublicPortsRequestT& request,
                                     const CloseInstancePublicPortsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CloseInstancePublicPorts, request, handler, context);
  }
 
  virtual Model::CopySnapshotOutcome CopySnapshot(const Model::CopySnapshotRequest& request) const;
 
  template <typename CopySnapshotRequestT = Model::CopySnapshotRequest>
  Model::CopySnapshotOutcomeCallable CopySnapshotCallable(const CopySnapshotRequestT& request) const {
    return SubmitCallable(&LightsailClient::CopySnapshot, request);
  }
 
  template <typename CopySnapshotRequestT = Model::CopySnapshotRequest>
  void CopySnapshotAsync(const CopySnapshotRequestT& request, const CopySnapshotResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CopySnapshot, request, handler, context);
  }
 
  virtual Model::CreateBucketOutcome CreateBucket(const Model::CreateBucketRequest& request) const;
 
  template <typename CreateBucketRequestT = Model::CreateBucketRequest>
  Model::CreateBucketOutcomeCallable CreateBucketCallable(const CreateBucketRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateBucket, request);
  }
 
  template <typename CreateBucketRequestT = Model::CreateBucketRequest>
  void CreateBucketAsync(const CreateBucketRequestT& request, const CreateBucketResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateBucket, request, handler, context);
  }
 
  virtual Model::CreateBucketAccessKeyOutcome CreateBucketAccessKey(const Model::CreateBucketAccessKeyRequest& request) const;
 
  template <typename CreateBucketAccessKeyRequestT = Model::CreateBucketAccessKeyRequest>
  Model::CreateBucketAccessKeyOutcomeCallable CreateBucketAccessKeyCallable(const CreateBucketAccessKeyRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateBucketAccessKey, request);
  }
 
  template <typename CreateBucketAccessKeyRequestT = Model::CreateBucketAccessKeyRequest>
  void CreateBucketAccessKeyAsync(const CreateBucketAccessKeyRequestT& request, const CreateBucketAccessKeyResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateBucketAccessKey, request, handler, context);
  }
 
  virtual Model::CreateCertificateOutcome CreateCertificate(const Model::CreateCertificateRequest& request) const;
 
  template <typename CreateCertificateRequestT = Model::CreateCertificateRequest>
  Model::CreateCertificateOutcomeCallable CreateCertificateCallable(const CreateCertificateRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateCertificate, request);
  }
 
  template <typename CreateCertificateRequestT = Model::CreateCertificateRequest>
  void CreateCertificateAsync(const CreateCertificateRequestT& request, const CreateCertificateResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateCertificate, request, handler, context);
  }
 
  virtual Model::CreateCloudFormationStackOutcome CreateCloudFormationStack(const Model::CreateCloudFormationStackRequest& request) const;
 
  template <typename CreateCloudFormationStackRequestT = Model::CreateCloudFormationStackRequest>
  Model::CreateCloudFormationStackOutcomeCallable CreateCloudFormationStackCallable(
      const CreateCloudFormationStackRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateCloudFormationStack, request);
  }
 
  template <typename CreateCloudFormationStackRequestT = Model::CreateCloudFormationStackRequest>
  void CreateCloudFormationStackAsync(const CreateCloudFormationStackRequestT& request,
                                      const CreateCloudFormationStackResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateCloudFormationStack, request, handler, context);
  }
 
  virtual Model::CreateContactMethodOutcome CreateContactMethod(const Model::CreateContactMethodRequest& request) const;
 
  template <typename CreateContactMethodRequestT = Model::CreateContactMethodRequest>
  Model::CreateContactMethodOutcomeCallable CreateContactMethodCallable(const CreateContactMethodRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateContactMethod, request);
  }
 
  template <typename CreateContactMethodRequestT = Model::CreateContactMethodRequest>
  void CreateContactMethodAsync(const CreateContactMethodRequestT& request, const CreateContactMethodResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateContactMethod, request, handler, context);
  }
 
  virtual Model::CreateContainerServiceOutcome CreateContainerService(const Model::CreateContainerServiceRequest& request) const;
 
  template <typename CreateContainerServiceRequestT = Model::CreateContainerServiceRequest>
  Model::CreateContainerServiceOutcomeCallable CreateContainerServiceCallable(const CreateContainerServiceRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateContainerService, request);
  }
 
  template <typename CreateContainerServiceRequestT = Model::CreateContainerServiceRequest>
  void CreateContainerServiceAsync(const CreateContainerServiceRequestT& request,
                                   const CreateContainerServiceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateContainerService, request, handler, context);
  }
 
  virtual Model::CreateContainerServiceDeploymentOutcome CreateContainerServiceDeployment(
      const Model::CreateContainerServiceDeploymentRequest& request) const;
 
  template <typename CreateContainerServiceDeploymentRequestT = Model::CreateContainerServiceDeploymentRequest>
  Model::CreateContainerServiceDeploymentOutcomeCallable CreateContainerServiceDeploymentCallable(
      const CreateContainerServiceDeploymentRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateContainerServiceDeployment, request);
  }
 
  template <typename CreateContainerServiceDeploymentRequestT = Model::CreateContainerServiceDeploymentRequest>
  void CreateContainerServiceDeploymentAsync(const CreateContainerServiceDeploymentRequestT& request,
                                             const CreateContainerServiceDeploymentResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateContainerServiceDeployment, request, handler, context);
  }
 
  virtual Model::CreateContainerServiceRegistryLoginOutcome CreateContainerServiceRegistryLogin(
      const Model::CreateContainerServiceRegistryLoginRequest& request = {}) const;
 
  template <typename CreateContainerServiceRegistryLoginRequestT = Model::CreateContainerServiceRegistryLoginRequest>
  Model::CreateContainerServiceRegistryLoginOutcomeCallable CreateContainerServiceRegistryLoginCallable(
      const CreateContainerServiceRegistryLoginRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::CreateContainerServiceRegistryLogin, request);
  }
 
  template <typename CreateContainerServiceRegistryLoginRequestT = Model::CreateContainerServiceRegistryLoginRequest>
  void CreateContainerServiceRegistryLoginAsync(const CreateContainerServiceRegistryLoginResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                const CreateContainerServiceRegistryLoginRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::CreateContainerServiceRegistryLogin, request, handler, context);
  }
 
  virtual Model::CreateDiskOutcome CreateDisk(const Model::CreateDiskRequest& request) const;
 
  template <typename CreateDiskRequestT = Model::CreateDiskRequest>
  Model::CreateDiskOutcomeCallable CreateDiskCallable(const CreateDiskRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateDisk, request);
  }
 
  template <typename CreateDiskRequestT = Model::CreateDiskRequest>
  void CreateDiskAsync(const CreateDiskRequestT& request, const CreateDiskResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateDisk, request, handler, context);
  }
 
  virtual Model::CreateDiskFromSnapshotOutcome CreateDiskFromSnapshot(const Model::CreateDiskFromSnapshotRequest& request) const;
 
  template <typename CreateDiskFromSnapshotRequestT = Model::CreateDiskFromSnapshotRequest>
  Model::CreateDiskFromSnapshotOutcomeCallable CreateDiskFromSnapshotCallable(const CreateDiskFromSnapshotRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateDiskFromSnapshot, request);
  }
 
  template <typename CreateDiskFromSnapshotRequestT = Model::CreateDiskFromSnapshotRequest>
  void CreateDiskFromSnapshotAsync(const CreateDiskFromSnapshotRequestT& request,
                                   const CreateDiskFromSnapshotResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateDiskFromSnapshot, request, handler, context);
  }
 
  virtual Model::CreateDiskSnapshotOutcome CreateDiskSnapshot(const Model::CreateDiskSnapshotRequest& request) const;
 
  template <typename CreateDiskSnapshotRequestT = Model::CreateDiskSnapshotRequest>
  Model::CreateDiskSnapshotOutcomeCallable CreateDiskSnapshotCallable(const CreateDiskSnapshotRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateDiskSnapshot, request);
  }
 
  template <typename CreateDiskSnapshotRequestT = Model::CreateDiskSnapshotRequest>
  void CreateDiskSnapshotAsync(const CreateDiskSnapshotRequestT& request, const CreateDiskSnapshotResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateDiskSnapshot, request, handler, context);
  }
 
  virtual Model::CreateDistributionOutcome CreateDistribution(const Model::CreateDistributionRequest& request) const;
 
  template <typename CreateDistributionRequestT = Model::CreateDistributionRequest>
  Model::CreateDistributionOutcomeCallable CreateDistributionCallable(const CreateDistributionRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateDistribution, request);
  }
 
  template <typename CreateDistributionRequestT = Model::CreateDistributionRequest>
  void CreateDistributionAsync(const CreateDistributionRequestT& request, const CreateDistributionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateDistribution, request, handler, context);
  }
 
  virtual Model::CreateDomainOutcome CreateDomain(const Model::CreateDomainRequest& request) const;
 
  template <typename CreateDomainRequestT = Model::CreateDomainRequest>
  Model::CreateDomainOutcomeCallable CreateDomainCallable(const CreateDomainRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateDomain, request);
  }
 
  template <typename CreateDomainRequestT = Model::CreateDomainRequest>
  void CreateDomainAsync(const CreateDomainRequestT& request, const CreateDomainResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateDomain, request, handler, context);
  }
 
  virtual Model::CreateDomainEntryOutcome CreateDomainEntry(const Model::CreateDomainEntryRequest& request) const;
 
  template <typename CreateDomainEntryRequestT = Model::CreateDomainEntryRequest>
  Model::CreateDomainEntryOutcomeCallable CreateDomainEntryCallable(const CreateDomainEntryRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateDomainEntry, request);
  }
 
  template <typename CreateDomainEntryRequestT = Model::CreateDomainEntryRequest>
  void CreateDomainEntryAsync(const CreateDomainEntryRequestT& request, const CreateDomainEntryResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateDomainEntry, request, handler, context);
  }
 
  virtual Model::CreateGUISessionAccessDetailsOutcome CreateGUISessionAccessDetails(
      const Model::CreateGUISessionAccessDetailsRequest& request) const;
 
  template <typename CreateGUISessionAccessDetailsRequestT = Model::CreateGUISessionAccessDetailsRequest>
  Model::CreateGUISessionAccessDetailsOutcomeCallable CreateGUISessionAccessDetailsCallable(
      const CreateGUISessionAccessDetailsRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateGUISessionAccessDetails, request);
  }
 
  template <typename CreateGUISessionAccessDetailsRequestT = Model::CreateGUISessionAccessDetailsRequest>
  void CreateGUISessionAccessDetailsAsync(const CreateGUISessionAccessDetailsRequestT& request,
                                          const CreateGUISessionAccessDetailsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateGUISessionAccessDetails, request, handler, context);
  }
 
  virtual Model::CreateInstanceSnapshotOutcome CreateInstanceSnapshot(const Model::CreateInstanceSnapshotRequest& request) const;
 
  template <typename CreateInstanceSnapshotRequestT = Model::CreateInstanceSnapshotRequest>
  Model::CreateInstanceSnapshotOutcomeCallable CreateInstanceSnapshotCallable(const CreateInstanceSnapshotRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateInstanceSnapshot, request);
  }
 
  template <typename CreateInstanceSnapshotRequestT = Model::CreateInstanceSnapshotRequest>
  void CreateInstanceSnapshotAsync(const CreateInstanceSnapshotRequestT& request,
                                   const CreateInstanceSnapshotResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateInstanceSnapshot, request, handler, context);
  }
 
  virtual Model::CreateInstancesOutcome CreateInstances(const Model::CreateInstancesRequest& request) const;
 
  template <typename CreateInstancesRequestT = Model::CreateInstancesRequest>
  Model::CreateInstancesOutcomeCallable CreateInstancesCallable(const CreateInstancesRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateInstances, request);
  }
 
  template <typename CreateInstancesRequestT = Model::CreateInstancesRequest>
  void CreateInstancesAsync(const CreateInstancesRequestT& request, const CreateInstancesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateInstances, request, handler, context);
  }
 
  virtual Model::CreateInstancesFromSnapshotOutcome CreateInstancesFromSnapshot(
      const Model::CreateInstancesFromSnapshotRequest& request) const;
 
  template <typename CreateInstancesFromSnapshotRequestT = Model::CreateInstancesFromSnapshotRequest>
  Model::CreateInstancesFromSnapshotOutcomeCallable CreateInstancesFromSnapshotCallable(
      const CreateInstancesFromSnapshotRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateInstancesFromSnapshot, request);
  }
 
  template <typename CreateInstancesFromSnapshotRequestT = Model::CreateInstancesFromSnapshotRequest>
  void CreateInstancesFromSnapshotAsync(const CreateInstancesFromSnapshotRequestT& request,
                                        const CreateInstancesFromSnapshotResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateInstancesFromSnapshot, request, handler, context);
  }
 
  virtual Model::CreateKeyPairOutcome CreateKeyPair(const Model::CreateKeyPairRequest& request) const;
 
  template <typename CreateKeyPairRequestT = Model::CreateKeyPairRequest>
  Model::CreateKeyPairOutcomeCallable CreateKeyPairCallable(const CreateKeyPairRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateKeyPair, request);
  }
 
  template <typename CreateKeyPairRequestT = Model::CreateKeyPairRequest>
  void CreateKeyPairAsync(const CreateKeyPairRequestT& request, const CreateKeyPairResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateKeyPair, request, handler, context);
  }
 
  virtual Model::CreateLoadBalancerOutcome CreateLoadBalancer(const Model::CreateLoadBalancerRequest& request) const;
 
  template <typename CreateLoadBalancerRequestT = Model::CreateLoadBalancerRequest>
  Model::CreateLoadBalancerOutcomeCallable CreateLoadBalancerCallable(const CreateLoadBalancerRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateLoadBalancer, request);
  }
 
  template <typename CreateLoadBalancerRequestT = Model::CreateLoadBalancerRequest>
  void CreateLoadBalancerAsync(const CreateLoadBalancerRequestT& request, const CreateLoadBalancerResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateLoadBalancer, request, handler, context);
  }
 
  virtual Model::CreateLoadBalancerTlsCertificateOutcome CreateLoadBalancerTlsCertificate(
      const Model::CreateLoadBalancerTlsCertificateRequest& request) const;
 
  template <typename CreateLoadBalancerTlsCertificateRequestT = Model::CreateLoadBalancerTlsCertificateRequest>
  Model::CreateLoadBalancerTlsCertificateOutcomeCallable CreateLoadBalancerTlsCertificateCallable(
      const CreateLoadBalancerTlsCertificateRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateLoadBalancerTlsCertificate, request);
  }
 
  template <typename CreateLoadBalancerTlsCertificateRequestT = Model::CreateLoadBalancerTlsCertificateRequest>
  void CreateLoadBalancerTlsCertificateAsync(const CreateLoadBalancerTlsCertificateRequestT& request,
                                             const CreateLoadBalancerTlsCertificateResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateLoadBalancerTlsCertificate, request, handler, context);
  }
 
  virtual Model::CreateRelationalDatabaseOutcome CreateRelationalDatabase(const Model::CreateRelationalDatabaseRequest& request) const;
 
  template <typename CreateRelationalDatabaseRequestT = Model::CreateRelationalDatabaseRequest>
  Model::CreateRelationalDatabaseOutcomeCallable CreateRelationalDatabaseCallable(const CreateRelationalDatabaseRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateRelationalDatabase, request);
  }
 
  template <typename CreateRelationalDatabaseRequestT = Model::CreateRelationalDatabaseRequest>
  void CreateRelationalDatabaseAsync(const CreateRelationalDatabaseRequestT& request,
                                     const CreateRelationalDatabaseResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateRelationalDatabase, request, handler, context);
  }
 
  virtual Model::CreateRelationalDatabaseFromSnapshotOutcome CreateRelationalDatabaseFromSnapshot(
      const Model::CreateRelationalDatabaseFromSnapshotRequest& request) const;
 
  template <typename CreateRelationalDatabaseFromSnapshotRequestT = Model::CreateRelationalDatabaseFromSnapshotRequest>
  Model::CreateRelationalDatabaseFromSnapshotOutcomeCallable CreateRelationalDatabaseFromSnapshotCallable(
      const CreateRelationalDatabaseFromSnapshotRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateRelationalDatabaseFromSnapshot, request);
  }
 
  template <typename CreateRelationalDatabaseFromSnapshotRequestT = Model::CreateRelationalDatabaseFromSnapshotRequest>
  void CreateRelationalDatabaseFromSnapshotAsync(const CreateRelationalDatabaseFromSnapshotRequestT& request,
                                                 const CreateRelationalDatabaseFromSnapshotResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateRelationalDatabaseFromSnapshot, request, handler, context);
  }
 
  virtual Model::CreateRelationalDatabaseSnapshotOutcome CreateRelationalDatabaseSnapshot(
      const Model::CreateRelationalDatabaseSnapshotRequest& request) const;
 
  template <typename CreateRelationalDatabaseSnapshotRequestT = Model::CreateRelationalDatabaseSnapshotRequest>
  Model::CreateRelationalDatabaseSnapshotOutcomeCallable CreateRelationalDatabaseSnapshotCallable(
      const CreateRelationalDatabaseSnapshotRequestT& request) const {
    return SubmitCallable(&LightsailClient::CreateRelationalDatabaseSnapshot, request);
  }
 
  template <typename CreateRelationalDatabaseSnapshotRequestT = Model::CreateRelationalDatabaseSnapshotRequest>
  void CreateRelationalDatabaseSnapshotAsync(const CreateRelationalDatabaseSnapshotRequestT& request,
                                             const CreateRelationalDatabaseSnapshotResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::CreateRelationalDatabaseSnapshot, request, handler, context);
  }
 
  virtual Model::DeleteAlarmOutcome DeleteAlarm(const Model::DeleteAlarmRequest& request) const;
 
  template <typename DeleteAlarmRequestT = Model::DeleteAlarmRequest>
  Model::DeleteAlarmOutcomeCallable DeleteAlarmCallable(const DeleteAlarmRequestT& request) const {
    return SubmitCallable(&LightsailClient::DeleteAlarm, request);
  }
 
  template <typename DeleteAlarmRequestT = Model::DeleteAlarmRequest>
  void DeleteAlarmAsync(const DeleteAlarmRequestT& request, const DeleteAlarmResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DeleteAlarm, request, handler, context);
  }
 
  virtual Model::DeleteAutoSnapshotOutcome DeleteAutoSnapshot(const Model::DeleteAutoSnapshotRequest& request) const;
 
  template <typename DeleteAutoSnapshotRequestT = Model::DeleteAutoSnapshotRequest>
  Model::DeleteAutoSnapshotOutcomeCallable DeleteAutoSnapshotCallable(const DeleteAutoSnapshotRequestT& request) const {
    return SubmitCallable(&LightsailClient::DeleteAutoSnapshot, request);
  }
 
  template <typename DeleteAutoSnapshotRequestT = Model::DeleteAutoSnapshotRequest>
  void DeleteAutoSnapshotAsync(const DeleteAutoSnapshotRequestT& request, const DeleteAutoSnapshotResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DeleteAutoSnapshot, request, handler, context);
  }
 
  virtual Model::DeleteBucketOutcome DeleteBucket(const Model::DeleteBucketRequest& request) const;
 
  template <typename DeleteBucketRequestT = Model::DeleteBucketRequest>
  Model::DeleteBucketOutcomeCallable DeleteBucketCallable(const DeleteBucketRequestT& request) const {
    return SubmitCallable(&LightsailClient::DeleteBucket, request);
  }
 
  template <typename DeleteBucketRequestT = Model::DeleteBucketRequest>
  void DeleteBucketAsync(const DeleteBucketRequestT& request, const DeleteBucketResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DeleteBucket, request, handler, context);
  }
 
  virtual Model::DeleteBucketAccessKeyOutcome DeleteBucketAccessKey(const Model::DeleteBucketAccessKeyRequest& request) const;
 
  template <typename DeleteBucketAccessKeyRequestT = Model::DeleteBucketAccessKeyRequest>
  Model::DeleteBucketAccessKeyOutcomeCallable DeleteBucketAccessKeyCallable(const DeleteBucketAccessKeyRequestT& request) const {
    return SubmitCallable(&LightsailClient::DeleteBucketAccessKey, request);
  }
 
  template <typename DeleteBucketAccessKeyRequestT = Model::DeleteBucketAccessKeyRequest>
  void DeleteBucketAccessKeyAsync(const DeleteBucketAccessKeyRequestT& request, const DeleteBucketAccessKeyResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DeleteBucketAccessKey, request, handler, context);
  }
 
  virtual Model::DeleteCertificateOutcome DeleteCertificate(const Model::DeleteCertificateRequest& request) const;
 
  template <typename DeleteCertificateRequestT = Model::DeleteCertificateRequest>
  Model::DeleteCertificateOutcomeCallable DeleteCertificateCallable(const DeleteCertificateRequestT& request) const {
    return SubmitCallable(&LightsailClient::DeleteCertificate, request);
  }
 
  template <typename DeleteCertificateRequestT = Model::DeleteCertificateRequest>
  void DeleteCertificateAsync(const DeleteCertificateRequestT& request, const DeleteCertificateResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DeleteCertificate, request, handler, context);
  }
 
  virtual Model::DeleteContactMethodOutcome DeleteContactMethod(const Model::DeleteContactMethodRequest& request) const;
 
  template <typename DeleteContactMethodRequestT = Model::DeleteContactMethodRequest>
  Model::DeleteContactMethodOutcomeCallable DeleteContactMethodCallable(const DeleteContactMethodRequestT& request) const {
    return SubmitCallable(&LightsailClient::DeleteContactMethod, request);
  }
 
  template <typename DeleteContactMethodRequestT = Model::DeleteContactMethodRequest>
  void DeleteContactMethodAsync(const DeleteContactMethodRequestT& request, const DeleteContactMethodResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DeleteContactMethod, request, handler, context);
  }
 
  virtual Model::DeleteContainerImageOutcome DeleteContainerImage(const Model::DeleteContainerImageRequest& request) const;
 
  template <typename DeleteContainerImageRequestT = Model::DeleteContainerImageRequest>
  Model::DeleteContainerImageOutcomeCallable DeleteContainerImageCallable(const DeleteContainerImageRequestT& request) const {
    return SubmitCallable(&LightsailClient::DeleteContainerImage, request);
  }
 
  template <typename DeleteContainerImageRequestT = Model::DeleteContainerImageRequest>
  void DeleteContainerImageAsync(const DeleteContainerImageRequestT& request, const DeleteContainerImageResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DeleteContainerImage, request, handler, context);
  }
 
  virtual Model::DeleteContainerServiceOutcome DeleteContainerService(const Model::DeleteContainerServiceRequest& request) const;
 
  template <typename DeleteContainerServiceRequestT = Model::DeleteContainerServiceRequest>
  Model::DeleteContainerServiceOutcomeCallable DeleteContainerServiceCallable(const DeleteContainerServiceRequestT& request) const {
    return SubmitCallable(&LightsailClient::DeleteContainerService, request);
  }
 
  template <typename DeleteContainerServiceRequestT = Model::DeleteContainerServiceRequest>
  void DeleteContainerServiceAsync(const DeleteContainerServiceRequestT& request,
                                   const DeleteContainerServiceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DeleteContainerService, request, handler, context);
  }
 
  virtual Model::DeleteDiskOutcome DeleteDisk(const Model::DeleteDiskRequest& request) const;
 
  template <typename DeleteDiskRequestT = Model::DeleteDiskRequest>
  Model::DeleteDiskOutcomeCallable DeleteDiskCallable(const DeleteDiskRequestT& request) const {
    return SubmitCallable(&LightsailClient::DeleteDisk, request);
  }
 
  template <typename DeleteDiskRequestT = Model::DeleteDiskRequest>
  void DeleteDiskAsync(const DeleteDiskRequestT& request, const DeleteDiskResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DeleteDisk, request, handler, context);
  }
 
  virtual Model::DeleteDiskSnapshotOutcome DeleteDiskSnapshot(const Model::DeleteDiskSnapshotRequest& request) const;
 
  template <typename DeleteDiskSnapshotRequestT = Model::DeleteDiskSnapshotRequest>
  Model::DeleteDiskSnapshotOutcomeCallable DeleteDiskSnapshotCallable(const DeleteDiskSnapshotRequestT& request) const {
    return SubmitCallable(&LightsailClient::DeleteDiskSnapshot, request);
  }
 
  template <typename DeleteDiskSnapshotRequestT = Model::DeleteDiskSnapshotRequest>
  void DeleteDiskSnapshotAsync(const DeleteDiskSnapshotRequestT& request, const DeleteDiskSnapshotResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DeleteDiskSnapshot, request, handler, context);
  }
 
  virtual Model::DeleteDistributionOutcome DeleteDistribution(const Model::DeleteDistributionRequest& request = {}) const;
 
  template <typename DeleteDistributionRequestT = Model::DeleteDistributionRequest>
  Model::DeleteDistributionOutcomeCallable DeleteDistributionCallable(const DeleteDistributionRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::DeleteDistribution, request);
  }
 
  template <typename DeleteDistributionRequestT = Model::DeleteDistributionRequest>
  void DeleteDistributionAsync(const DeleteDistributionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const DeleteDistributionRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::DeleteDistribution, request, handler, context);
  }
 
  virtual Model::DeleteDomainOutcome DeleteDomain(const Model::DeleteDomainRequest& request) const;
 
  template <typename DeleteDomainRequestT = Model::DeleteDomainRequest>
  Model::DeleteDomainOutcomeCallable DeleteDomainCallable(const DeleteDomainRequestT& request) const {
    return SubmitCallable(&LightsailClient::DeleteDomain, request);
  }
 
  template <typename DeleteDomainRequestT = Model::DeleteDomainRequest>
  void DeleteDomainAsync(const DeleteDomainRequestT& request, const DeleteDomainResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DeleteDomain, request, handler, context);
  }
 
  virtual Model::DeleteDomainEntryOutcome DeleteDomainEntry(const Model::DeleteDomainEntryRequest& request) const;
 
  template <typename DeleteDomainEntryRequestT = Model::DeleteDomainEntryRequest>
  Model::DeleteDomainEntryOutcomeCallable DeleteDomainEntryCallable(const DeleteDomainEntryRequestT& request) const {
    return SubmitCallable(&LightsailClient::DeleteDomainEntry, request);
  }
 
  template <typename DeleteDomainEntryRequestT = Model::DeleteDomainEntryRequest>
  void DeleteDomainEntryAsync(const DeleteDomainEntryRequestT& request, const DeleteDomainEntryResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DeleteDomainEntry, request, handler, context);
  }
 
  virtual Model::DeleteInstanceOutcome DeleteInstance(const Model::DeleteInstanceRequest& request) const;
 
  template <typename DeleteInstanceRequestT = Model::DeleteInstanceRequest>
  Model::DeleteInstanceOutcomeCallable DeleteInstanceCallable(const DeleteInstanceRequestT& request) const {
    return SubmitCallable(&LightsailClient::DeleteInstance, request);
  }
 
  template <typename DeleteInstanceRequestT = Model::DeleteInstanceRequest>
  void DeleteInstanceAsync(const DeleteInstanceRequestT& request, const DeleteInstanceResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DeleteInstance, request, handler, context);
  }
 
  virtual Model::DeleteInstanceSnapshotOutcome DeleteInstanceSnapshot(const Model::DeleteInstanceSnapshotRequest& request) const;
 
  template <typename DeleteInstanceSnapshotRequestT = Model::DeleteInstanceSnapshotRequest>
  Model::DeleteInstanceSnapshotOutcomeCallable DeleteInstanceSnapshotCallable(const DeleteInstanceSnapshotRequestT& request) const {
    return SubmitCallable(&LightsailClient::DeleteInstanceSnapshot, request);
  }
 
  template <typename DeleteInstanceSnapshotRequestT = Model::DeleteInstanceSnapshotRequest>
  void DeleteInstanceSnapshotAsync(const DeleteInstanceSnapshotRequestT& request,
                                   const DeleteInstanceSnapshotResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DeleteInstanceSnapshot, request, handler, context);
  }
 
  virtual Model::DeleteKeyPairOutcome DeleteKeyPair(const Model::DeleteKeyPairRequest& request) const;
 
  template <typename DeleteKeyPairRequestT = Model::DeleteKeyPairRequest>
  Model::DeleteKeyPairOutcomeCallable DeleteKeyPairCallable(const DeleteKeyPairRequestT& request) const {
    return SubmitCallable(&LightsailClient::DeleteKeyPair, request);
  }
 
  template <typename DeleteKeyPairRequestT = Model::DeleteKeyPairRequest>
  void DeleteKeyPairAsync(const DeleteKeyPairRequestT& request, const DeleteKeyPairResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DeleteKeyPair, request, handler, context);
  }
 
  virtual Model::DeleteKnownHostKeysOutcome DeleteKnownHostKeys(const Model::DeleteKnownHostKeysRequest& request) const;
 
  template <typename DeleteKnownHostKeysRequestT = Model::DeleteKnownHostKeysRequest>
  Model::DeleteKnownHostKeysOutcomeCallable DeleteKnownHostKeysCallable(const DeleteKnownHostKeysRequestT& request) const {
    return SubmitCallable(&LightsailClient::DeleteKnownHostKeys, request);
  }
 
  template <typename DeleteKnownHostKeysRequestT = Model::DeleteKnownHostKeysRequest>
  void DeleteKnownHostKeysAsync(const DeleteKnownHostKeysRequestT& request, const DeleteKnownHostKeysResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DeleteKnownHostKeys, request, handler, context);
  }
 
  virtual Model::DeleteLoadBalancerOutcome DeleteLoadBalancer(const Model::DeleteLoadBalancerRequest& request) const;
 
  template <typename DeleteLoadBalancerRequestT = Model::DeleteLoadBalancerRequest>
  Model::DeleteLoadBalancerOutcomeCallable DeleteLoadBalancerCallable(const DeleteLoadBalancerRequestT& request) const {
    return SubmitCallable(&LightsailClient::DeleteLoadBalancer, request);
  }
 
  template <typename DeleteLoadBalancerRequestT = Model::DeleteLoadBalancerRequest>
  void DeleteLoadBalancerAsync(const DeleteLoadBalancerRequestT& request, const DeleteLoadBalancerResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DeleteLoadBalancer, request, handler, context);
  }
 
  virtual Model::DeleteLoadBalancerTlsCertificateOutcome DeleteLoadBalancerTlsCertificate(
      const Model::DeleteLoadBalancerTlsCertificateRequest& request) const;
 
  template <typename DeleteLoadBalancerTlsCertificateRequestT = Model::DeleteLoadBalancerTlsCertificateRequest>
  Model::DeleteLoadBalancerTlsCertificateOutcomeCallable DeleteLoadBalancerTlsCertificateCallable(
      const DeleteLoadBalancerTlsCertificateRequestT& request) const {
    return SubmitCallable(&LightsailClient::DeleteLoadBalancerTlsCertificate, request);
  }
 
  template <typename DeleteLoadBalancerTlsCertificateRequestT = Model::DeleteLoadBalancerTlsCertificateRequest>
  void DeleteLoadBalancerTlsCertificateAsync(const DeleteLoadBalancerTlsCertificateRequestT& request,
                                             const DeleteLoadBalancerTlsCertificateResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DeleteLoadBalancerTlsCertificate, request, handler, context);
  }
 
  virtual Model::DeleteRelationalDatabaseOutcome DeleteRelationalDatabase(const Model::DeleteRelationalDatabaseRequest& request) const;
 
  template <typename DeleteRelationalDatabaseRequestT = Model::DeleteRelationalDatabaseRequest>
  Model::DeleteRelationalDatabaseOutcomeCallable DeleteRelationalDatabaseCallable(const DeleteRelationalDatabaseRequestT& request) const {
    return SubmitCallable(&LightsailClient::DeleteRelationalDatabase, request);
  }
 
  template <typename DeleteRelationalDatabaseRequestT = Model::DeleteRelationalDatabaseRequest>
  void DeleteRelationalDatabaseAsync(const DeleteRelationalDatabaseRequestT& request,
                                     const DeleteRelationalDatabaseResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DeleteRelationalDatabase, request, handler, context);
  }
 
  virtual Model::DeleteRelationalDatabaseSnapshotOutcome DeleteRelationalDatabaseSnapshot(
      const Model::DeleteRelationalDatabaseSnapshotRequest& request) const;
 
  template <typename DeleteRelationalDatabaseSnapshotRequestT = Model::DeleteRelationalDatabaseSnapshotRequest>
  Model::DeleteRelationalDatabaseSnapshotOutcomeCallable DeleteRelationalDatabaseSnapshotCallable(
      const DeleteRelationalDatabaseSnapshotRequestT& request) const {
    return SubmitCallable(&LightsailClient::DeleteRelationalDatabaseSnapshot, request);
  }
 
  template <typename DeleteRelationalDatabaseSnapshotRequestT = Model::DeleteRelationalDatabaseSnapshotRequest>
  void DeleteRelationalDatabaseSnapshotAsync(const DeleteRelationalDatabaseSnapshotRequestT& request,
                                             const DeleteRelationalDatabaseSnapshotResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DeleteRelationalDatabaseSnapshot, request, handler, context);
  }
 
  virtual Model::DetachCertificateFromDistributionOutcome DetachCertificateFromDistribution(
      const Model::DetachCertificateFromDistributionRequest& request) const;
 
  template <typename DetachCertificateFromDistributionRequestT = Model::DetachCertificateFromDistributionRequest>
  Model::DetachCertificateFromDistributionOutcomeCallable DetachCertificateFromDistributionCallable(
      const DetachCertificateFromDistributionRequestT& request) const {
    return SubmitCallable(&LightsailClient::DetachCertificateFromDistribution, request);
  }
 
  template <typename DetachCertificateFromDistributionRequestT = Model::DetachCertificateFromDistributionRequest>
  void DetachCertificateFromDistributionAsync(const DetachCertificateFromDistributionRequestT& request,
                                              const DetachCertificateFromDistributionResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DetachCertificateFromDistribution, request, handler, context);
  }
 
  virtual Model::DetachDiskOutcome DetachDisk(const Model::DetachDiskRequest& request) const;
 
  template <typename DetachDiskRequestT = Model::DetachDiskRequest>
  Model::DetachDiskOutcomeCallable DetachDiskCallable(const DetachDiskRequestT& request) const {
    return SubmitCallable(&LightsailClient::DetachDisk, request);
  }
 
  template <typename DetachDiskRequestT = Model::DetachDiskRequest>
  void DetachDiskAsync(const DetachDiskRequestT& request, const DetachDiskResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DetachDisk, request, handler, context);
  }
 
  virtual Model::DetachInstancesFromLoadBalancerOutcome DetachInstancesFromLoadBalancer(
      const Model::DetachInstancesFromLoadBalancerRequest& request) const;
 
  template <typename DetachInstancesFromLoadBalancerRequestT = Model::DetachInstancesFromLoadBalancerRequest>
  Model::DetachInstancesFromLoadBalancerOutcomeCallable DetachInstancesFromLoadBalancerCallable(
      const DetachInstancesFromLoadBalancerRequestT& request) const {
    return SubmitCallable(&LightsailClient::DetachInstancesFromLoadBalancer, request);
  }
 
  template <typename DetachInstancesFromLoadBalancerRequestT = Model::DetachInstancesFromLoadBalancerRequest>
  void DetachInstancesFromLoadBalancerAsync(const DetachInstancesFromLoadBalancerRequestT& request,
                                            const DetachInstancesFromLoadBalancerResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DetachInstancesFromLoadBalancer, request, handler, context);
  }
 
  virtual Model::DetachStaticIpOutcome DetachStaticIp(const Model::DetachStaticIpRequest& request) const;
 
  template <typename DetachStaticIpRequestT = Model::DetachStaticIpRequest>
  Model::DetachStaticIpOutcomeCallable DetachStaticIpCallable(const DetachStaticIpRequestT& request) const {
    return SubmitCallable(&LightsailClient::DetachStaticIp, request);
  }
 
  template <typename DetachStaticIpRequestT = Model::DetachStaticIpRequest>
  void DetachStaticIpAsync(const DetachStaticIpRequestT& request, const DetachStaticIpResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DetachStaticIp, request, handler, context);
  }
 
  virtual Model::DisableAddOnOutcome DisableAddOn(const Model::DisableAddOnRequest& request) const;
 
  template <typename DisableAddOnRequestT = Model::DisableAddOnRequest>
  Model::DisableAddOnOutcomeCallable DisableAddOnCallable(const DisableAddOnRequestT& request) const {
    return SubmitCallable(&LightsailClient::DisableAddOn, request);
  }
 
  template <typename DisableAddOnRequestT = Model::DisableAddOnRequest>
  void DisableAddOnAsync(const DisableAddOnRequestT& request, const DisableAddOnResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::DisableAddOn, request, handler, context);
  }
 
  virtual Model::DownloadDefaultKeyPairOutcome DownloadDefaultKeyPair(const Model::DownloadDefaultKeyPairRequest& request = {}) const;
 
  template <typename DownloadDefaultKeyPairRequestT = Model::DownloadDefaultKeyPairRequest>
  Model::DownloadDefaultKeyPairOutcomeCallable DownloadDefaultKeyPairCallable(const DownloadDefaultKeyPairRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::DownloadDefaultKeyPair, request);
  }
 
  template <typename DownloadDefaultKeyPairRequestT = Model::DownloadDefaultKeyPairRequest>
  void DownloadDefaultKeyPairAsync(const DownloadDefaultKeyPairResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const DownloadDefaultKeyPairRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::DownloadDefaultKeyPair, request, handler, context);
  }
 
  virtual Model::EnableAddOnOutcome EnableAddOn(const Model::EnableAddOnRequest& request) const;
 
  template <typename EnableAddOnRequestT = Model::EnableAddOnRequest>
  Model::EnableAddOnOutcomeCallable EnableAddOnCallable(const EnableAddOnRequestT& request) const {
    return SubmitCallable(&LightsailClient::EnableAddOn, request);
  }
 
  template <typename EnableAddOnRequestT = Model::EnableAddOnRequest>
  void EnableAddOnAsync(const EnableAddOnRequestT& request, const EnableAddOnResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::EnableAddOn, request, handler, context);
  }
 
  virtual Model::ExportSnapshotOutcome ExportSnapshot(const Model::ExportSnapshotRequest& request) const;
 
  template <typename ExportSnapshotRequestT = Model::ExportSnapshotRequest>
  Model::ExportSnapshotOutcomeCallable ExportSnapshotCallable(const ExportSnapshotRequestT& request) const {
    return SubmitCallable(&LightsailClient::ExportSnapshot, request);
  }
 
  template <typename ExportSnapshotRequestT = Model::ExportSnapshotRequest>
  void ExportSnapshotAsync(const ExportSnapshotRequestT& request, const ExportSnapshotResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::ExportSnapshot, request, handler, context);
  }
 
  virtual Model::GetActiveNamesOutcome GetActiveNames(const Model::GetActiveNamesRequest& request = {}) const;
 
  template <typename GetActiveNamesRequestT = Model::GetActiveNamesRequest>
  Model::GetActiveNamesOutcomeCallable GetActiveNamesCallable(const GetActiveNamesRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetActiveNames, request);
  }
 
  template <typename GetActiveNamesRequestT = Model::GetActiveNamesRequest>
  void GetActiveNamesAsync(const GetActiveNamesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const GetActiveNamesRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetActiveNames, request, handler, context);
  }
 
  virtual Model::GetAlarmsOutcome GetAlarms(const Model::GetAlarmsRequest& request = {}) const;
 
  template <typename GetAlarmsRequestT = Model::GetAlarmsRequest>
  Model::GetAlarmsOutcomeCallable GetAlarmsCallable(const GetAlarmsRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetAlarms, request);
  }
 
  template <typename GetAlarmsRequestT = Model::GetAlarmsRequest>
  void GetAlarmsAsync(const GetAlarmsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                      const GetAlarmsRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetAlarms, request, handler, context);
  }
 
  virtual Model::GetAutoSnapshotsOutcome GetAutoSnapshots(const Model::GetAutoSnapshotsRequest& request) const;
 
  template <typename GetAutoSnapshotsRequestT = Model::GetAutoSnapshotsRequest>
  Model::GetAutoSnapshotsOutcomeCallable GetAutoSnapshotsCallable(const GetAutoSnapshotsRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetAutoSnapshots, request);
  }
 
  template <typename GetAutoSnapshotsRequestT = Model::GetAutoSnapshotsRequest>
  void GetAutoSnapshotsAsync(const GetAutoSnapshotsRequestT& request, const GetAutoSnapshotsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetAutoSnapshots, request, handler, context);
  }
 
  virtual Model::GetBlueprintsOutcome GetBlueprints(const Model::GetBlueprintsRequest& request = {}) const;
 
  template <typename GetBlueprintsRequestT = Model::GetBlueprintsRequest>
  Model::GetBlueprintsOutcomeCallable GetBlueprintsCallable(const GetBlueprintsRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetBlueprints, request);
  }
 
  template <typename GetBlueprintsRequestT = Model::GetBlueprintsRequest>
  void GetBlueprintsAsync(const GetBlueprintsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const GetBlueprintsRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetBlueprints, request, handler, context);
  }
 
  virtual Model::GetBucketAccessKeysOutcome GetBucketAccessKeys(const Model::GetBucketAccessKeysRequest& request) const;
 
  template <typename GetBucketAccessKeysRequestT = Model::GetBucketAccessKeysRequest>
  Model::GetBucketAccessKeysOutcomeCallable GetBucketAccessKeysCallable(const GetBucketAccessKeysRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetBucketAccessKeys, request);
  }
 
  template <typename GetBucketAccessKeysRequestT = Model::GetBucketAccessKeysRequest>
  void GetBucketAccessKeysAsync(const GetBucketAccessKeysRequestT& request, const GetBucketAccessKeysResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetBucketAccessKeys, request, handler, context);
  }
 
  virtual Model::GetBucketBundlesOutcome GetBucketBundles(const Model::GetBucketBundlesRequest& request = {}) const;
 
  template <typename GetBucketBundlesRequestT = Model::GetBucketBundlesRequest>
  Model::GetBucketBundlesOutcomeCallable GetBucketBundlesCallable(const GetBucketBundlesRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetBucketBundles, request);
  }
 
  template <typename GetBucketBundlesRequestT = Model::GetBucketBundlesRequest>
  void GetBucketBundlesAsync(const GetBucketBundlesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const GetBucketBundlesRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetBucketBundles, request, handler, context);
  }
 
  virtual Model::GetBucketMetricDataOutcome GetBucketMetricData(const Model::GetBucketMetricDataRequest& request) const;
 
  template <typename GetBucketMetricDataRequestT = Model::GetBucketMetricDataRequest>
  Model::GetBucketMetricDataOutcomeCallable GetBucketMetricDataCallable(const GetBucketMetricDataRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetBucketMetricData, request);
  }
 
  template <typename GetBucketMetricDataRequestT = Model::GetBucketMetricDataRequest>
  void GetBucketMetricDataAsync(const GetBucketMetricDataRequestT& request, const GetBucketMetricDataResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetBucketMetricData, request, handler, context);
  }
 
  virtual Model::GetBucketsOutcome GetBuckets(const Model::GetBucketsRequest& request = {}) const;
 
  template <typename GetBucketsRequestT = Model::GetBucketsRequest>
  Model::GetBucketsOutcomeCallable GetBucketsCallable(const GetBucketsRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetBuckets, request);
  }
 
  template <typename GetBucketsRequestT = Model::GetBucketsRequest>
  void GetBucketsAsync(const GetBucketsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const GetBucketsRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetBuckets, request, handler, context);
  }
 
  virtual Model::GetBundlesOutcome GetBundles(const Model::GetBundlesRequest& request = {}) const;
 
  template <typename GetBundlesRequestT = Model::GetBundlesRequest>
  Model::GetBundlesOutcomeCallable GetBundlesCallable(const GetBundlesRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetBundles, request);
  }
 
  template <typename GetBundlesRequestT = Model::GetBundlesRequest>
  void GetBundlesAsync(const GetBundlesResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const GetBundlesRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetBundles, request, handler, context);
  }
 
  virtual Model::GetCertificatesOutcome GetCertificates(const Model::GetCertificatesRequest& request = {}) const;
 
  template <typename GetCertificatesRequestT = Model::GetCertificatesRequest>
  Model::GetCertificatesOutcomeCallable GetCertificatesCallable(const GetCertificatesRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetCertificates, request);
  }
 
  template <typename GetCertificatesRequestT = Model::GetCertificatesRequest>
  void GetCertificatesAsync(const GetCertificatesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const GetCertificatesRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetCertificates, request, handler, context);
  }
 
  virtual Model::GetCloudFormationStackRecordsOutcome GetCloudFormationStackRecords(
      const Model::GetCloudFormationStackRecordsRequest& request = {}) const;
 
  template <typename GetCloudFormationStackRecordsRequestT = Model::GetCloudFormationStackRecordsRequest>
  Model::GetCloudFormationStackRecordsOutcomeCallable GetCloudFormationStackRecordsCallable(
      const GetCloudFormationStackRecordsRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetCloudFormationStackRecords, request);
  }
 
  template <typename GetCloudFormationStackRecordsRequestT = Model::GetCloudFormationStackRecordsRequest>
  void GetCloudFormationStackRecordsAsync(const GetCloudFormationStackRecordsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const GetCloudFormationStackRecordsRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetCloudFormationStackRecords, request, handler, context);
  }
 
  virtual Model::GetContactMethodsOutcome GetContactMethods(const Model::GetContactMethodsRequest& request = {}) const;
 
  template <typename GetContactMethodsRequestT = Model::GetContactMethodsRequest>
  Model::GetContactMethodsOutcomeCallable GetContactMethodsCallable(const GetContactMethodsRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetContactMethods, request);
  }
 
  template <typename GetContactMethodsRequestT = Model::GetContactMethodsRequest>
  void GetContactMethodsAsync(const GetContactMethodsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const GetContactMethodsRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetContactMethods, request, handler, context);
  }
 
  virtual Model::GetContainerAPIMetadataOutcome GetContainerAPIMetadata(const Model::GetContainerAPIMetadataRequest& request = {}) const;
 
  template <typename GetContainerAPIMetadataRequestT = Model::GetContainerAPIMetadataRequest>
  Model::GetContainerAPIMetadataOutcomeCallable GetContainerAPIMetadataCallable(const GetContainerAPIMetadataRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetContainerAPIMetadata, request);
  }
 
  template <typename GetContainerAPIMetadataRequestT = Model::GetContainerAPIMetadataRequest>
  void GetContainerAPIMetadataAsync(const GetContainerAPIMetadataResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const GetContainerAPIMetadataRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetContainerAPIMetadata, request, handler, context);
  }
 
  virtual Model::GetContainerImagesOutcome GetContainerImages(const Model::GetContainerImagesRequest& request) const;
 
  template <typename GetContainerImagesRequestT = Model::GetContainerImagesRequest>
  Model::GetContainerImagesOutcomeCallable GetContainerImagesCallable(const GetContainerImagesRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetContainerImages, request);
  }
 
  template <typename GetContainerImagesRequestT = Model::GetContainerImagesRequest>
  void GetContainerImagesAsync(const GetContainerImagesRequestT& request, const GetContainerImagesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetContainerImages, request, handler, context);
  }
 
  virtual Model::GetContainerLogOutcome GetContainerLog(const Model::GetContainerLogRequest& request) const;
 
  template <typename GetContainerLogRequestT = Model::GetContainerLogRequest>
  Model::GetContainerLogOutcomeCallable GetContainerLogCallable(const GetContainerLogRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetContainerLog, request);
  }
 
  template <typename GetContainerLogRequestT = Model::GetContainerLogRequest>
  void GetContainerLogAsync(const GetContainerLogRequestT& request, const GetContainerLogResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetContainerLog, request, handler, context);
  }
 
  virtual Model::GetContainerServiceDeploymentsOutcome GetContainerServiceDeployments(
      const Model::GetContainerServiceDeploymentsRequest& request) const;
 
  template <typename GetContainerServiceDeploymentsRequestT = Model::GetContainerServiceDeploymentsRequest>
  Model::GetContainerServiceDeploymentsOutcomeCallable GetContainerServiceDeploymentsCallable(
      const GetContainerServiceDeploymentsRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetContainerServiceDeployments, request);
  }
 
  template <typename GetContainerServiceDeploymentsRequestT = Model::GetContainerServiceDeploymentsRequest>
  void GetContainerServiceDeploymentsAsync(const GetContainerServiceDeploymentsRequestT& request,
                                           const GetContainerServiceDeploymentsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetContainerServiceDeployments, request, handler, context);
  }
 
  virtual Model::GetContainerServiceMetricDataOutcome GetContainerServiceMetricData(
      const Model::GetContainerServiceMetricDataRequest& request) const;
 
  template <typename GetContainerServiceMetricDataRequestT = Model::GetContainerServiceMetricDataRequest>
  Model::GetContainerServiceMetricDataOutcomeCallable GetContainerServiceMetricDataCallable(
      const GetContainerServiceMetricDataRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetContainerServiceMetricData, request);
  }
 
  template <typename GetContainerServiceMetricDataRequestT = Model::GetContainerServiceMetricDataRequest>
  void GetContainerServiceMetricDataAsync(const GetContainerServiceMetricDataRequestT& request,
                                          const GetContainerServiceMetricDataResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetContainerServiceMetricData, request, handler, context);
  }
 
  virtual Model::GetContainerServicePowersOutcome GetContainerServicePowers(
      const Model::GetContainerServicePowersRequest& request = {}) const;
 
  template <typename GetContainerServicePowersRequestT = Model::GetContainerServicePowersRequest>
  Model::GetContainerServicePowersOutcomeCallable GetContainerServicePowersCallable(
      const GetContainerServicePowersRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetContainerServicePowers, request);
  }
 
  template <typename GetContainerServicePowersRequestT = Model::GetContainerServicePowersRequest>
  void GetContainerServicePowersAsync(const GetContainerServicePowersResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const GetContainerServicePowersRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetContainerServicePowers, request, handler, context);
  }
 
  virtual Model::GetContainerServicesOutcome GetContainerServices(const Model::GetContainerServicesRequest& request = {}) const;
 
  template <typename GetContainerServicesRequestT = Model::GetContainerServicesRequest>
  Model::GetContainerServicesOutcomeCallable GetContainerServicesCallable(const GetContainerServicesRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetContainerServices, request);
  }
 
  template <typename GetContainerServicesRequestT = Model::GetContainerServicesRequest>
  void GetContainerServicesAsync(const GetContainerServicesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const GetContainerServicesRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetContainerServices, request, handler, context);
  }
 
  virtual Model::GetCostEstimateOutcome GetCostEstimate(const Model::GetCostEstimateRequest& request) const;
 
  template <typename GetCostEstimateRequestT = Model::GetCostEstimateRequest>
  Model::GetCostEstimateOutcomeCallable GetCostEstimateCallable(const GetCostEstimateRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetCostEstimate, request);
  }
 
  template <typename GetCostEstimateRequestT = Model::GetCostEstimateRequest>
  void GetCostEstimateAsync(const GetCostEstimateRequestT& request, const GetCostEstimateResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetCostEstimate, request, handler, context);
  }
 
  virtual Model::GetDiskOutcome GetDisk(const Model::GetDiskRequest& request) const;
 
  template <typename GetDiskRequestT = Model::GetDiskRequest>
  Model::GetDiskOutcomeCallable GetDiskCallable(const GetDiskRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetDisk, request);
  }
 
  template <typename GetDiskRequestT = Model::GetDiskRequest>
  void GetDiskAsync(const GetDiskRequestT& request, const GetDiskResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetDisk, request, handler, context);
  }
 
  virtual Model::GetDiskSnapshotOutcome GetDiskSnapshot(const Model::GetDiskSnapshotRequest& request) const;
 
  template <typename GetDiskSnapshotRequestT = Model::GetDiskSnapshotRequest>
  Model::GetDiskSnapshotOutcomeCallable GetDiskSnapshotCallable(const GetDiskSnapshotRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetDiskSnapshot, request);
  }
 
  template <typename GetDiskSnapshotRequestT = Model::GetDiskSnapshotRequest>
  void GetDiskSnapshotAsync(const GetDiskSnapshotRequestT& request, const GetDiskSnapshotResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetDiskSnapshot, request, handler, context);
  }
 
  virtual Model::GetDiskSnapshotsOutcome GetDiskSnapshots(const Model::GetDiskSnapshotsRequest& request = {}) const;
 
  template <typename GetDiskSnapshotsRequestT = Model::GetDiskSnapshotsRequest>
  Model::GetDiskSnapshotsOutcomeCallable GetDiskSnapshotsCallable(const GetDiskSnapshotsRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetDiskSnapshots, request);
  }
 
  template <typename GetDiskSnapshotsRequestT = Model::GetDiskSnapshotsRequest>
  void GetDiskSnapshotsAsync(const GetDiskSnapshotsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const GetDiskSnapshotsRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetDiskSnapshots, request, handler, context);
  }
 
  virtual Model::GetDisksOutcome GetDisks(const Model::GetDisksRequest& request = {}) const;
 
  template <typename GetDisksRequestT = Model::GetDisksRequest>
  Model::GetDisksOutcomeCallable GetDisksCallable(const GetDisksRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetDisks, request);
  }
 
  template <typename GetDisksRequestT = Model::GetDisksRequest>
  void GetDisksAsync(const GetDisksResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                     const GetDisksRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetDisks, request, handler, context);
  }
 
  virtual Model::GetDistributionBundlesOutcome GetDistributionBundles(const Model::GetDistributionBundlesRequest& request = {}) const;
 
  template <typename GetDistributionBundlesRequestT = Model::GetDistributionBundlesRequest>
  Model::GetDistributionBundlesOutcomeCallable GetDistributionBundlesCallable(const GetDistributionBundlesRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetDistributionBundles, request);
  }
 
  template <typename GetDistributionBundlesRequestT = Model::GetDistributionBundlesRequest>
  void GetDistributionBundlesAsync(const GetDistributionBundlesResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const GetDistributionBundlesRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetDistributionBundles, request, handler, context);
  }
 
  virtual Model::GetDistributionLatestCacheResetOutcome GetDistributionLatestCacheReset(
      const Model::GetDistributionLatestCacheResetRequest& request = {}) const;
 
  template <typename GetDistributionLatestCacheResetRequestT = Model::GetDistributionLatestCacheResetRequest>
  Model::GetDistributionLatestCacheResetOutcomeCallable GetDistributionLatestCacheResetCallable(
      const GetDistributionLatestCacheResetRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetDistributionLatestCacheReset, request);
  }
 
  template <typename GetDistributionLatestCacheResetRequestT = Model::GetDistributionLatestCacheResetRequest>
  void GetDistributionLatestCacheResetAsync(const GetDistributionLatestCacheResetResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const GetDistributionLatestCacheResetRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetDistributionLatestCacheReset, request, handler, context);
  }
 
  virtual Model::GetDistributionMetricDataOutcome GetDistributionMetricData(const Model::GetDistributionMetricDataRequest& request) const;
 
  template <typename GetDistributionMetricDataRequestT = Model::GetDistributionMetricDataRequest>
  Model::GetDistributionMetricDataOutcomeCallable GetDistributionMetricDataCallable(
      const GetDistributionMetricDataRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetDistributionMetricData, request);
  }
 
  template <typename GetDistributionMetricDataRequestT = Model::GetDistributionMetricDataRequest>
  void GetDistributionMetricDataAsync(const GetDistributionMetricDataRequestT& request,
                                      const GetDistributionMetricDataResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetDistributionMetricData, request, handler, context);
  }
 
  virtual Model::GetDistributionsOutcome GetDistributions(const Model::GetDistributionsRequest& request = {}) const;
 
  template <typename GetDistributionsRequestT = Model::GetDistributionsRequest>
  Model::GetDistributionsOutcomeCallable GetDistributionsCallable(const GetDistributionsRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetDistributions, request);
  }
 
  template <typename GetDistributionsRequestT = Model::GetDistributionsRequest>
  void GetDistributionsAsync(const GetDistributionsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const GetDistributionsRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetDistributions, request, handler, context);
  }
 
  virtual Model::GetDomainOutcome GetDomain(const Model::GetDomainRequest& request) const;
 
  template <typename GetDomainRequestT = Model::GetDomainRequest>
  Model::GetDomainOutcomeCallable GetDomainCallable(const GetDomainRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetDomain, request);
  }
 
  template <typename GetDomainRequestT = Model::GetDomainRequest>
  void GetDomainAsync(const GetDomainRequestT& request, const GetDomainResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetDomain, request, handler, context);
  }
 
  virtual Model::GetDomainsOutcome GetDomains(const Model::GetDomainsRequest& request = {}) const;
 
  template <typename GetDomainsRequestT = Model::GetDomainsRequest>
  Model::GetDomainsOutcomeCallable GetDomainsCallable(const GetDomainsRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetDomains, request);
  }
 
  template <typename GetDomainsRequestT = Model::GetDomainsRequest>
  void GetDomainsAsync(const GetDomainsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const GetDomainsRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetDomains, request, handler, context);
  }
 
  virtual Model::GetExportSnapshotRecordsOutcome GetExportSnapshotRecords(const Model::GetExportSnapshotRecordsRequest& request = {}) const;
 
  template <typename GetExportSnapshotRecordsRequestT = Model::GetExportSnapshotRecordsRequest>
  Model::GetExportSnapshotRecordsOutcomeCallable GetExportSnapshotRecordsCallable(
      const GetExportSnapshotRecordsRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetExportSnapshotRecords, request);
  }
 
  template <typename GetExportSnapshotRecordsRequestT = Model::GetExportSnapshotRecordsRequest>
  void GetExportSnapshotRecordsAsync(const GetExportSnapshotRecordsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const GetExportSnapshotRecordsRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetExportSnapshotRecords, request, handler, context);
  }
 
  virtual Model::GetInstanceOutcome GetInstance(const Model::GetInstanceRequest& request) const;
 
  template <typename GetInstanceRequestT = Model::GetInstanceRequest>
  Model::GetInstanceOutcomeCallable GetInstanceCallable(const GetInstanceRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetInstance, request);
  }
 
  template <typename GetInstanceRequestT = Model::GetInstanceRequest>
  void GetInstanceAsync(const GetInstanceRequestT& request, const GetInstanceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetInstance, request, handler, context);
  }
 
  virtual Model::GetInstanceAccessDetailsOutcome GetInstanceAccessDetails(const Model::GetInstanceAccessDetailsRequest& request) const;
 
  template <typename GetInstanceAccessDetailsRequestT = Model::GetInstanceAccessDetailsRequest>
  Model::GetInstanceAccessDetailsOutcomeCallable GetInstanceAccessDetailsCallable(const GetInstanceAccessDetailsRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetInstanceAccessDetails, request);
  }
 
  template <typename GetInstanceAccessDetailsRequestT = Model::GetInstanceAccessDetailsRequest>
  void GetInstanceAccessDetailsAsync(const GetInstanceAccessDetailsRequestT& request,
                                     const GetInstanceAccessDetailsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetInstanceAccessDetails, request, handler, context);
  }
 
  virtual Model::GetInstanceMetricDataOutcome GetInstanceMetricData(const Model::GetInstanceMetricDataRequest& request) const;
 
  template <typename GetInstanceMetricDataRequestT = Model::GetInstanceMetricDataRequest>
  Model::GetInstanceMetricDataOutcomeCallable GetInstanceMetricDataCallable(const GetInstanceMetricDataRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetInstanceMetricData, request);
  }
 
  template <typename GetInstanceMetricDataRequestT = Model::GetInstanceMetricDataRequest>
  void GetInstanceMetricDataAsync(const GetInstanceMetricDataRequestT& request, const GetInstanceMetricDataResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetInstanceMetricData, request, handler, context);
  }
 
  virtual Model::GetInstancePortStatesOutcome GetInstancePortStates(const Model::GetInstancePortStatesRequest& request) const;
 
  template <typename GetInstancePortStatesRequestT = Model::GetInstancePortStatesRequest>
  Model::GetInstancePortStatesOutcomeCallable GetInstancePortStatesCallable(const GetInstancePortStatesRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetInstancePortStates, request);
  }
 
  template <typename GetInstancePortStatesRequestT = Model::GetInstancePortStatesRequest>
  void GetInstancePortStatesAsync(const GetInstancePortStatesRequestT& request, const GetInstancePortStatesResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetInstancePortStates, request, handler, context);
  }
 
  virtual Model::GetInstanceSnapshotOutcome GetInstanceSnapshot(const Model::GetInstanceSnapshotRequest& request) const;
 
  template <typename GetInstanceSnapshotRequestT = Model::GetInstanceSnapshotRequest>
  Model::GetInstanceSnapshotOutcomeCallable GetInstanceSnapshotCallable(const GetInstanceSnapshotRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetInstanceSnapshot, request);
  }
 
  template <typename GetInstanceSnapshotRequestT = Model::GetInstanceSnapshotRequest>
  void GetInstanceSnapshotAsync(const GetInstanceSnapshotRequestT& request, const GetInstanceSnapshotResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetInstanceSnapshot, request, handler, context);
  }
 
  virtual Model::GetInstanceSnapshotsOutcome GetInstanceSnapshots(const Model::GetInstanceSnapshotsRequest& request = {}) const;
 
  template <typename GetInstanceSnapshotsRequestT = Model::GetInstanceSnapshotsRequest>
  Model::GetInstanceSnapshotsOutcomeCallable GetInstanceSnapshotsCallable(const GetInstanceSnapshotsRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetInstanceSnapshots, request);
  }
 
  template <typename GetInstanceSnapshotsRequestT = Model::GetInstanceSnapshotsRequest>
  void GetInstanceSnapshotsAsync(const GetInstanceSnapshotsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const GetInstanceSnapshotsRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetInstanceSnapshots, request, handler, context);
  }
 
  virtual Model::GetInstanceStateOutcome GetInstanceState(const Model::GetInstanceStateRequest& request) const;
 
  template <typename GetInstanceStateRequestT = Model::GetInstanceStateRequest>
  Model::GetInstanceStateOutcomeCallable GetInstanceStateCallable(const GetInstanceStateRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetInstanceState, request);
  }
 
  template <typename GetInstanceStateRequestT = Model::GetInstanceStateRequest>
  void GetInstanceStateAsync(const GetInstanceStateRequestT& request, const GetInstanceStateResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetInstanceState, request, handler, context);
  }
 
  virtual Model::GetInstancesOutcome GetInstances(const Model::GetInstancesRequest& request = {}) const;
 
  template <typename GetInstancesRequestT = Model::GetInstancesRequest>
  Model::GetInstancesOutcomeCallable GetInstancesCallable(const GetInstancesRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetInstances, request);
  }
 
  template <typename GetInstancesRequestT = Model::GetInstancesRequest>
  void GetInstancesAsync(const GetInstancesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const GetInstancesRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetInstances, request, handler, context);
  }
 
  virtual Model::GetKeyPairOutcome GetKeyPair(const Model::GetKeyPairRequest& request) const;
 
  template <typename GetKeyPairRequestT = Model::GetKeyPairRequest>
  Model::GetKeyPairOutcomeCallable GetKeyPairCallable(const GetKeyPairRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetKeyPair, request);
  }
 
  template <typename GetKeyPairRequestT = Model::GetKeyPairRequest>
  void GetKeyPairAsync(const GetKeyPairRequestT& request, const GetKeyPairResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetKeyPair, request, handler, context);
  }
 
  virtual Model::GetKeyPairsOutcome GetKeyPairs(const Model::GetKeyPairsRequest& request = {}) const;
 
  template <typename GetKeyPairsRequestT = Model::GetKeyPairsRequest>
  Model::GetKeyPairsOutcomeCallable GetKeyPairsCallable(const GetKeyPairsRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetKeyPairs, request);
  }
 
  template <typename GetKeyPairsRequestT = Model::GetKeyPairsRequest>
  void GetKeyPairsAsync(const GetKeyPairsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const GetKeyPairsRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetKeyPairs, request, handler, context);
  }
 
  virtual Model::GetLoadBalancerOutcome GetLoadBalancer(const Model::GetLoadBalancerRequest& request) const;
 
  template <typename GetLoadBalancerRequestT = Model::GetLoadBalancerRequest>
  Model::GetLoadBalancerOutcomeCallable GetLoadBalancerCallable(const GetLoadBalancerRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetLoadBalancer, request);
  }
 
  template <typename GetLoadBalancerRequestT = Model::GetLoadBalancerRequest>
  void GetLoadBalancerAsync(const GetLoadBalancerRequestT& request, const GetLoadBalancerResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetLoadBalancer, request, handler, context);
  }
 
  virtual Model::GetLoadBalancerMetricDataOutcome GetLoadBalancerMetricData(const Model::GetLoadBalancerMetricDataRequest& request) const;
 
  template <typename GetLoadBalancerMetricDataRequestT = Model::GetLoadBalancerMetricDataRequest>
  Model::GetLoadBalancerMetricDataOutcomeCallable GetLoadBalancerMetricDataCallable(
      const GetLoadBalancerMetricDataRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetLoadBalancerMetricData, request);
  }
 
  template <typename GetLoadBalancerMetricDataRequestT = Model::GetLoadBalancerMetricDataRequest>
  void GetLoadBalancerMetricDataAsync(const GetLoadBalancerMetricDataRequestT& request,
                                      const GetLoadBalancerMetricDataResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetLoadBalancerMetricData, request, handler, context);
  }
 
  virtual Model::GetLoadBalancerTlsCertificatesOutcome GetLoadBalancerTlsCertificates(
      const Model::GetLoadBalancerTlsCertificatesRequest& request) const;
 
  template <typename GetLoadBalancerTlsCertificatesRequestT = Model::GetLoadBalancerTlsCertificatesRequest>
  Model::GetLoadBalancerTlsCertificatesOutcomeCallable GetLoadBalancerTlsCertificatesCallable(
      const GetLoadBalancerTlsCertificatesRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetLoadBalancerTlsCertificates, request);
  }
 
  template <typename GetLoadBalancerTlsCertificatesRequestT = Model::GetLoadBalancerTlsCertificatesRequest>
  void GetLoadBalancerTlsCertificatesAsync(const GetLoadBalancerTlsCertificatesRequestT& request,
                                           const GetLoadBalancerTlsCertificatesResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetLoadBalancerTlsCertificates, request, handler, context);
  }
 
  virtual Model::GetLoadBalancerTlsPoliciesOutcome GetLoadBalancerTlsPolicies(
      const Model::GetLoadBalancerTlsPoliciesRequest& request = {}) const;
 
  template <typename GetLoadBalancerTlsPoliciesRequestT = Model::GetLoadBalancerTlsPoliciesRequest>
  Model::GetLoadBalancerTlsPoliciesOutcomeCallable GetLoadBalancerTlsPoliciesCallable(
      const GetLoadBalancerTlsPoliciesRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetLoadBalancerTlsPolicies, request);
  }
 
  template <typename GetLoadBalancerTlsPoliciesRequestT = Model::GetLoadBalancerTlsPoliciesRequest>
  void GetLoadBalancerTlsPoliciesAsync(const GetLoadBalancerTlsPoliciesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const GetLoadBalancerTlsPoliciesRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetLoadBalancerTlsPolicies, request, handler, context);
  }
 
  virtual Model::GetLoadBalancersOutcome GetLoadBalancers(const Model::GetLoadBalancersRequest& request = {}) const;
 
  template <typename GetLoadBalancersRequestT = Model::GetLoadBalancersRequest>
  Model::GetLoadBalancersOutcomeCallable GetLoadBalancersCallable(const GetLoadBalancersRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetLoadBalancers, request);
  }
 
  template <typename GetLoadBalancersRequestT = Model::GetLoadBalancersRequest>
  void GetLoadBalancersAsync(const GetLoadBalancersResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const GetLoadBalancersRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetLoadBalancers, request, handler, context);
  }
 
  virtual Model::GetOperationOutcome GetOperation(const Model::GetOperationRequest& request) const;
 
  template <typename GetOperationRequestT = Model::GetOperationRequest>
  Model::GetOperationOutcomeCallable GetOperationCallable(const GetOperationRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetOperation, request);
  }
 
  template <typename GetOperationRequestT = Model::GetOperationRequest>
  void GetOperationAsync(const GetOperationRequestT& request, const GetOperationResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetOperation, request, handler, context);
  }
 
  virtual Model::GetOperationsOutcome GetOperations(const Model::GetOperationsRequest& request = {}) const;
 
  template <typename GetOperationsRequestT = Model::GetOperationsRequest>
  Model::GetOperationsOutcomeCallable GetOperationsCallable(const GetOperationsRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetOperations, request);
  }
 
  template <typename GetOperationsRequestT = Model::GetOperationsRequest>
  void GetOperationsAsync(const GetOperationsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const GetOperationsRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetOperations, request, handler, context);
  }
 
  virtual Model::GetOperationsForResourceOutcome GetOperationsForResource(const Model::GetOperationsForResourceRequest& request) const;
 
  template <typename GetOperationsForResourceRequestT = Model::GetOperationsForResourceRequest>
  Model::GetOperationsForResourceOutcomeCallable GetOperationsForResourceCallable(const GetOperationsForResourceRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetOperationsForResource, request);
  }
 
  template <typename GetOperationsForResourceRequestT = Model::GetOperationsForResourceRequest>
  void GetOperationsForResourceAsync(const GetOperationsForResourceRequestT& request,
                                     const GetOperationsForResourceResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetOperationsForResource, request, handler, context);
  }
 
  virtual Model::GetRegionsOutcome GetRegions(const Model::GetRegionsRequest& request = {}) const;
 
  template <typename GetRegionsRequestT = Model::GetRegionsRequest>
  Model::GetRegionsOutcomeCallable GetRegionsCallable(const GetRegionsRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetRegions, request);
  }
 
  template <typename GetRegionsRequestT = Model::GetRegionsRequest>
  void GetRegionsAsync(const GetRegionsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const GetRegionsRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetRegions, request, handler, context);
  }
 
  virtual Model::GetRelationalDatabaseOutcome GetRelationalDatabase(const Model::GetRelationalDatabaseRequest& request) const;
 
  template <typename GetRelationalDatabaseRequestT = Model::GetRelationalDatabaseRequest>
  Model::GetRelationalDatabaseOutcomeCallable GetRelationalDatabaseCallable(const GetRelationalDatabaseRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetRelationalDatabase, request);
  }
 
  template <typename GetRelationalDatabaseRequestT = Model::GetRelationalDatabaseRequest>
  void GetRelationalDatabaseAsync(const GetRelationalDatabaseRequestT& request, const GetRelationalDatabaseResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetRelationalDatabase, request, handler, context);
  }
 
  virtual Model::GetRelationalDatabaseBlueprintsOutcome GetRelationalDatabaseBlueprints(
      const Model::GetRelationalDatabaseBlueprintsRequest& request = {}) const;
 
  template <typename GetRelationalDatabaseBlueprintsRequestT = Model::GetRelationalDatabaseBlueprintsRequest>
  Model::GetRelationalDatabaseBlueprintsOutcomeCallable GetRelationalDatabaseBlueprintsCallable(
      const GetRelationalDatabaseBlueprintsRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetRelationalDatabaseBlueprints, request);
  }
 
  template <typename GetRelationalDatabaseBlueprintsRequestT = Model::GetRelationalDatabaseBlueprintsRequest>
  void GetRelationalDatabaseBlueprintsAsync(const GetRelationalDatabaseBlueprintsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                            const GetRelationalDatabaseBlueprintsRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetRelationalDatabaseBlueprints, request, handler, context);
  }
 
  virtual Model::GetRelationalDatabaseBundlesOutcome GetRelationalDatabaseBundles(
      const Model::GetRelationalDatabaseBundlesRequest& request = {}) const;
 
  template <typename GetRelationalDatabaseBundlesRequestT = Model::GetRelationalDatabaseBundlesRequest>
  Model::GetRelationalDatabaseBundlesOutcomeCallable GetRelationalDatabaseBundlesCallable(
      const GetRelationalDatabaseBundlesRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetRelationalDatabaseBundles, request);
  }
 
  template <typename GetRelationalDatabaseBundlesRequestT = Model::GetRelationalDatabaseBundlesRequest>
  void GetRelationalDatabaseBundlesAsync(const GetRelationalDatabaseBundlesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const GetRelationalDatabaseBundlesRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetRelationalDatabaseBundles, request, handler, context);
  }
 
  virtual Model::GetRelationalDatabaseEventsOutcome GetRelationalDatabaseEvents(
      const Model::GetRelationalDatabaseEventsRequest& request) const;
 
  template <typename GetRelationalDatabaseEventsRequestT = Model::GetRelationalDatabaseEventsRequest>
  Model::GetRelationalDatabaseEventsOutcomeCallable GetRelationalDatabaseEventsCallable(
      const GetRelationalDatabaseEventsRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetRelationalDatabaseEvents, request);
  }
 
  template <typename GetRelationalDatabaseEventsRequestT = Model::GetRelationalDatabaseEventsRequest>
  void GetRelationalDatabaseEventsAsync(const GetRelationalDatabaseEventsRequestT& request,
                                        const GetRelationalDatabaseEventsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetRelationalDatabaseEvents, request, handler, context);
  }
 
  virtual Model::GetRelationalDatabaseLogEventsOutcome GetRelationalDatabaseLogEvents(
      const Model::GetRelationalDatabaseLogEventsRequest& request) const;
 
  template <typename GetRelationalDatabaseLogEventsRequestT = Model::GetRelationalDatabaseLogEventsRequest>
  Model::GetRelationalDatabaseLogEventsOutcomeCallable GetRelationalDatabaseLogEventsCallable(
      const GetRelationalDatabaseLogEventsRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetRelationalDatabaseLogEvents, request);
  }
 
  template <typename GetRelationalDatabaseLogEventsRequestT = Model::GetRelationalDatabaseLogEventsRequest>
  void GetRelationalDatabaseLogEventsAsync(const GetRelationalDatabaseLogEventsRequestT& request,
                                           const GetRelationalDatabaseLogEventsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetRelationalDatabaseLogEvents, request, handler, context);
  }
 
  virtual Model::GetRelationalDatabaseLogStreamsOutcome GetRelationalDatabaseLogStreams(
      const Model::GetRelationalDatabaseLogStreamsRequest& request) const;
 
  template <typename GetRelationalDatabaseLogStreamsRequestT = Model::GetRelationalDatabaseLogStreamsRequest>
  Model::GetRelationalDatabaseLogStreamsOutcomeCallable GetRelationalDatabaseLogStreamsCallable(
      const GetRelationalDatabaseLogStreamsRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetRelationalDatabaseLogStreams, request);
  }
 
  template <typename GetRelationalDatabaseLogStreamsRequestT = Model::GetRelationalDatabaseLogStreamsRequest>
  void GetRelationalDatabaseLogStreamsAsync(const GetRelationalDatabaseLogStreamsRequestT& request,
                                            const GetRelationalDatabaseLogStreamsResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetRelationalDatabaseLogStreams, request, handler, context);
  }
 
  virtual Model::GetRelationalDatabaseMasterUserPasswordOutcome GetRelationalDatabaseMasterUserPassword(
      const Model::GetRelationalDatabaseMasterUserPasswordRequest& request) const;
 
  template <typename GetRelationalDatabaseMasterUserPasswordRequestT = Model::GetRelationalDatabaseMasterUserPasswordRequest>
  Model::GetRelationalDatabaseMasterUserPasswordOutcomeCallable GetRelationalDatabaseMasterUserPasswordCallable(
      const GetRelationalDatabaseMasterUserPasswordRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetRelationalDatabaseMasterUserPassword, request);
  }
 
  template <typename GetRelationalDatabaseMasterUserPasswordRequestT = Model::GetRelationalDatabaseMasterUserPasswordRequest>
  void GetRelationalDatabaseMasterUserPasswordAsync(const GetRelationalDatabaseMasterUserPasswordRequestT& request,
                                                    const GetRelationalDatabaseMasterUserPasswordResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetRelationalDatabaseMasterUserPassword, request, handler, context);
  }
 
  virtual Model::GetRelationalDatabaseMetricDataOutcome GetRelationalDatabaseMetricData(
      const Model::GetRelationalDatabaseMetricDataRequest& request) const;
 
  template <typename GetRelationalDatabaseMetricDataRequestT = Model::GetRelationalDatabaseMetricDataRequest>
  Model::GetRelationalDatabaseMetricDataOutcomeCallable GetRelationalDatabaseMetricDataCallable(
      const GetRelationalDatabaseMetricDataRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetRelationalDatabaseMetricData, request);
  }
 
  template <typename GetRelationalDatabaseMetricDataRequestT = Model::GetRelationalDatabaseMetricDataRequest>
  void GetRelationalDatabaseMetricDataAsync(const GetRelationalDatabaseMetricDataRequestT& request,
                                            const GetRelationalDatabaseMetricDataResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetRelationalDatabaseMetricData, request, handler, context);
  }
 
  virtual Model::GetRelationalDatabaseParametersOutcome GetRelationalDatabaseParameters(
      const Model::GetRelationalDatabaseParametersRequest& request) const;
 
  template <typename GetRelationalDatabaseParametersRequestT = Model::GetRelationalDatabaseParametersRequest>
  Model::GetRelationalDatabaseParametersOutcomeCallable GetRelationalDatabaseParametersCallable(
      const GetRelationalDatabaseParametersRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetRelationalDatabaseParameters, request);
  }
 
  template <typename GetRelationalDatabaseParametersRequestT = Model::GetRelationalDatabaseParametersRequest>
  void GetRelationalDatabaseParametersAsync(const GetRelationalDatabaseParametersRequestT& request,
                                            const GetRelationalDatabaseParametersResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetRelationalDatabaseParameters, request, handler, context);
  }
 
  virtual Model::GetRelationalDatabaseSnapshotOutcome GetRelationalDatabaseSnapshot(
      const Model::GetRelationalDatabaseSnapshotRequest& request) const;
 
  template <typename GetRelationalDatabaseSnapshotRequestT = Model::GetRelationalDatabaseSnapshotRequest>
  Model::GetRelationalDatabaseSnapshotOutcomeCallable GetRelationalDatabaseSnapshotCallable(
      const GetRelationalDatabaseSnapshotRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetRelationalDatabaseSnapshot, request);
  }
 
  template <typename GetRelationalDatabaseSnapshotRequestT = Model::GetRelationalDatabaseSnapshotRequest>
  void GetRelationalDatabaseSnapshotAsync(const GetRelationalDatabaseSnapshotRequestT& request,
                                          const GetRelationalDatabaseSnapshotResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetRelationalDatabaseSnapshot, request, handler, context);
  }
 
  virtual Model::GetRelationalDatabaseSnapshotsOutcome GetRelationalDatabaseSnapshots(
      const Model::GetRelationalDatabaseSnapshotsRequest& request = {}) const;
 
  template <typename GetRelationalDatabaseSnapshotsRequestT = Model::GetRelationalDatabaseSnapshotsRequest>
  Model::GetRelationalDatabaseSnapshotsOutcomeCallable GetRelationalDatabaseSnapshotsCallable(
      const GetRelationalDatabaseSnapshotsRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetRelationalDatabaseSnapshots, request);
  }
 
  template <typename GetRelationalDatabaseSnapshotsRequestT = Model::GetRelationalDatabaseSnapshotsRequest>
  void GetRelationalDatabaseSnapshotsAsync(const GetRelationalDatabaseSnapshotsResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const GetRelationalDatabaseSnapshotsRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetRelationalDatabaseSnapshots, request, handler, context);
  }
 
  virtual Model::GetRelationalDatabasesOutcome GetRelationalDatabases(const Model::GetRelationalDatabasesRequest& request = {}) const;
 
  template <typename GetRelationalDatabasesRequestT = Model::GetRelationalDatabasesRequest>
  Model::GetRelationalDatabasesOutcomeCallable GetRelationalDatabasesCallable(const GetRelationalDatabasesRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetRelationalDatabases, request);
  }
 
  template <typename GetRelationalDatabasesRequestT = Model::GetRelationalDatabasesRequest>
  void GetRelationalDatabasesAsync(const GetRelationalDatabasesResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const GetRelationalDatabasesRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetRelationalDatabases, request, handler, context);
  }
 
  virtual Model::GetSetupHistoryOutcome GetSetupHistory(const Model::GetSetupHistoryRequest& request) const;
 
  template <typename GetSetupHistoryRequestT = Model::GetSetupHistoryRequest>
  Model::GetSetupHistoryOutcomeCallable GetSetupHistoryCallable(const GetSetupHistoryRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetSetupHistory, request);
  }
 
  template <typename GetSetupHistoryRequestT = Model::GetSetupHistoryRequest>
  void GetSetupHistoryAsync(const GetSetupHistoryRequestT& request, const GetSetupHistoryResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetSetupHistory, request, handler, context);
  }
 
  virtual Model::GetStaticIpOutcome GetStaticIp(const Model::GetStaticIpRequest& request) const;
 
  template <typename GetStaticIpRequestT = Model::GetStaticIpRequest>
  Model::GetStaticIpOutcomeCallable GetStaticIpCallable(const GetStaticIpRequestT& request) const {
    return SubmitCallable(&LightsailClient::GetStaticIp, request);
  }
 
  template <typename GetStaticIpRequestT = Model::GetStaticIpRequest>
  void GetStaticIpAsync(const GetStaticIpRequestT& request, const GetStaticIpResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::GetStaticIp, request, handler, context);
  }
 
  virtual Model::GetStaticIpsOutcome GetStaticIps(const Model::GetStaticIpsRequest& request = {}) const;
 
  template <typename GetStaticIpsRequestT = Model::GetStaticIpsRequest>
  Model::GetStaticIpsOutcomeCallable GetStaticIpsCallable(const GetStaticIpsRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::GetStaticIps, request);
  }
 
  template <typename GetStaticIpsRequestT = Model::GetStaticIpsRequest>
  void GetStaticIpsAsync(const GetStaticIpsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const GetStaticIpsRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::GetStaticIps, request, handler, context);
  }
 
  virtual Model::ImportKeyPairOutcome ImportKeyPair(const Model::ImportKeyPairRequest& request) const;
 
  template <typename ImportKeyPairRequestT = Model::ImportKeyPairRequest>
  Model::ImportKeyPairOutcomeCallable ImportKeyPairCallable(const ImportKeyPairRequestT& request) const {
    return SubmitCallable(&LightsailClient::ImportKeyPair, request);
  }
 
  template <typename ImportKeyPairRequestT = Model::ImportKeyPairRequest>
  void ImportKeyPairAsync(const ImportKeyPairRequestT& request, const ImportKeyPairResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::ImportKeyPair, request, handler, context);
  }
 
  virtual Model::IsVpcPeeredOutcome IsVpcPeered(const Model::IsVpcPeeredRequest& request = {}) const;
 
  template <typename IsVpcPeeredRequestT = Model::IsVpcPeeredRequest>
  Model::IsVpcPeeredOutcomeCallable IsVpcPeeredCallable(const IsVpcPeeredRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::IsVpcPeered, request);
  }
 
  template <typename IsVpcPeeredRequestT = Model::IsVpcPeeredRequest>
  void IsVpcPeeredAsync(const IsVpcPeeredResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const IsVpcPeeredRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::IsVpcPeered, request, handler, context);
  }
 
  virtual Model::OpenInstancePublicPortsOutcome OpenInstancePublicPorts(const Model::OpenInstancePublicPortsRequest& request) const;
 
  template <typename OpenInstancePublicPortsRequestT = Model::OpenInstancePublicPortsRequest>
  Model::OpenInstancePublicPortsOutcomeCallable OpenInstancePublicPortsCallable(const OpenInstancePublicPortsRequestT& request) const {
    return SubmitCallable(&LightsailClient::OpenInstancePublicPorts, request);
  }
 
  template <typename OpenInstancePublicPortsRequestT = Model::OpenInstancePublicPortsRequest>
  void OpenInstancePublicPortsAsync(const OpenInstancePublicPortsRequestT& request,
                                    const OpenInstancePublicPortsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::OpenInstancePublicPorts, request, handler, context);
  }
 
  virtual Model::PeerVpcOutcome PeerVpc(const Model::PeerVpcRequest& request = {}) const;
 
  template <typename PeerVpcRequestT = Model::PeerVpcRequest>
  Model::PeerVpcOutcomeCallable PeerVpcCallable(const PeerVpcRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::PeerVpc, request);
  }
 
  template <typename PeerVpcRequestT = Model::PeerVpcRequest>
  void PeerVpcAsync(const PeerVpcResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                    const PeerVpcRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::PeerVpc, request, handler, context);
  }
 
  virtual Model::PutAlarmOutcome PutAlarm(const Model::PutAlarmRequest& request) const;
 
  template <typename PutAlarmRequestT = Model::PutAlarmRequest>
  Model::PutAlarmOutcomeCallable PutAlarmCallable(const PutAlarmRequestT& request) const {
    return SubmitCallable(&LightsailClient::PutAlarm, request);
  }
 
  template <typename PutAlarmRequestT = Model::PutAlarmRequest>
  void PutAlarmAsync(const PutAlarmRequestT& request, const PutAlarmResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::PutAlarm, request, handler, context);
  }
 
  virtual Model::PutInstancePublicPortsOutcome PutInstancePublicPorts(const Model::PutInstancePublicPortsRequest& request) const;
 
  template <typename PutInstancePublicPortsRequestT = Model::PutInstancePublicPortsRequest>
  Model::PutInstancePublicPortsOutcomeCallable PutInstancePublicPortsCallable(const PutInstancePublicPortsRequestT& request) const {
    return SubmitCallable(&LightsailClient::PutInstancePublicPorts, request);
  }
 
  template <typename PutInstancePublicPortsRequestT = Model::PutInstancePublicPortsRequest>
  void PutInstancePublicPortsAsync(const PutInstancePublicPortsRequestT& request,
                                   const PutInstancePublicPortsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::PutInstancePublicPorts, request, handler, context);
  }
 
  virtual Model::RebootInstanceOutcome RebootInstance(const Model::RebootInstanceRequest& request) const;
 
  template <typename RebootInstanceRequestT = Model::RebootInstanceRequest>
  Model::RebootInstanceOutcomeCallable RebootInstanceCallable(const RebootInstanceRequestT& request) const {
    return SubmitCallable(&LightsailClient::RebootInstance, request);
  }
 
  template <typename RebootInstanceRequestT = Model::RebootInstanceRequest>
  void RebootInstanceAsync(const RebootInstanceRequestT& request, const RebootInstanceResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::RebootInstance, request, handler, context);
  }
 
  virtual Model::RebootRelationalDatabaseOutcome RebootRelationalDatabase(const Model::RebootRelationalDatabaseRequest& request) const;
 
  template <typename RebootRelationalDatabaseRequestT = Model::RebootRelationalDatabaseRequest>
  Model::RebootRelationalDatabaseOutcomeCallable RebootRelationalDatabaseCallable(const RebootRelationalDatabaseRequestT& request) const {
    return SubmitCallable(&LightsailClient::RebootRelationalDatabase, request);
  }
 
  template <typename RebootRelationalDatabaseRequestT = Model::RebootRelationalDatabaseRequest>
  void RebootRelationalDatabaseAsync(const RebootRelationalDatabaseRequestT& request,
                                     const RebootRelationalDatabaseResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::RebootRelationalDatabase, request, handler, context);
  }
 
  virtual Model::RegisterContainerImageOutcome RegisterContainerImage(const Model::RegisterContainerImageRequest& request) const;
 
  template <typename RegisterContainerImageRequestT = Model::RegisterContainerImageRequest>
  Model::RegisterContainerImageOutcomeCallable RegisterContainerImageCallable(const RegisterContainerImageRequestT& request) const {
    return SubmitCallable(&LightsailClient::RegisterContainerImage, request);
  }
 
  template <typename RegisterContainerImageRequestT = Model::RegisterContainerImageRequest>
  void RegisterContainerImageAsync(const RegisterContainerImageRequestT& request,
                                   const RegisterContainerImageResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::RegisterContainerImage, request, handler, context);
  }
 
  virtual Model::ReleaseStaticIpOutcome ReleaseStaticIp(const Model::ReleaseStaticIpRequest& request) const;
 
  template <typename ReleaseStaticIpRequestT = Model::ReleaseStaticIpRequest>
  Model::ReleaseStaticIpOutcomeCallable ReleaseStaticIpCallable(const ReleaseStaticIpRequestT& request) const {
    return SubmitCallable(&LightsailClient::ReleaseStaticIp, request);
  }
 
  template <typename ReleaseStaticIpRequestT = Model::ReleaseStaticIpRequest>
  void ReleaseStaticIpAsync(const ReleaseStaticIpRequestT& request, const ReleaseStaticIpResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::ReleaseStaticIp, request, handler, context);
  }
 
  virtual Model::ResetDistributionCacheOutcome ResetDistributionCache(const Model::ResetDistributionCacheRequest& request = {}) const;
 
  template <typename ResetDistributionCacheRequestT = Model::ResetDistributionCacheRequest>
  Model::ResetDistributionCacheOutcomeCallable ResetDistributionCacheCallable(const ResetDistributionCacheRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::ResetDistributionCache, request);
  }
 
  template <typename ResetDistributionCacheRequestT = Model::ResetDistributionCacheRequest>
  void ResetDistributionCacheAsync(const ResetDistributionCacheResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ResetDistributionCacheRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::ResetDistributionCache, request, handler, context);
  }
 
  virtual Model::SendContactMethodVerificationOutcome SendContactMethodVerification(
      const Model::SendContactMethodVerificationRequest& request) const;
 
  template <typename SendContactMethodVerificationRequestT = Model::SendContactMethodVerificationRequest>
  Model::SendContactMethodVerificationOutcomeCallable SendContactMethodVerificationCallable(
      const SendContactMethodVerificationRequestT& request) const {
    return SubmitCallable(&LightsailClient::SendContactMethodVerification, request);
  }
 
  template <typename SendContactMethodVerificationRequestT = Model::SendContactMethodVerificationRequest>
  void SendContactMethodVerificationAsync(const SendContactMethodVerificationRequestT& request,
                                          const SendContactMethodVerificationResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::SendContactMethodVerification, request, handler, context);
  }
 
  virtual Model::SetIpAddressTypeOutcome SetIpAddressType(const Model::SetIpAddressTypeRequest& request) const;
 
  template <typename SetIpAddressTypeRequestT = Model::SetIpAddressTypeRequest>
  Model::SetIpAddressTypeOutcomeCallable SetIpAddressTypeCallable(const SetIpAddressTypeRequestT& request) const {
    return SubmitCallable(&LightsailClient::SetIpAddressType, request);
  }
 
  template <typename SetIpAddressTypeRequestT = Model::SetIpAddressTypeRequest>
  void SetIpAddressTypeAsync(const SetIpAddressTypeRequestT& request, const SetIpAddressTypeResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::SetIpAddressType, request, handler, context);
  }
 
  virtual Model::SetResourceAccessForBucketOutcome SetResourceAccessForBucket(
      const Model::SetResourceAccessForBucketRequest& request) const;
 
  template <typename SetResourceAccessForBucketRequestT = Model::SetResourceAccessForBucketRequest>
  Model::SetResourceAccessForBucketOutcomeCallable SetResourceAccessForBucketCallable(
      const SetResourceAccessForBucketRequestT& request) const {
    return SubmitCallable(&LightsailClient::SetResourceAccessForBucket, request);
  }
 
  template <typename SetResourceAccessForBucketRequestT = Model::SetResourceAccessForBucketRequest>
  void SetResourceAccessForBucketAsync(const SetResourceAccessForBucketRequestT& request,
                                       const SetResourceAccessForBucketResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::SetResourceAccessForBucket, request, handler, context);
  }
 
  virtual Model::SetupInstanceHttpsOutcome SetupInstanceHttps(const Model::SetupInstanceHttpsRequest& request) const;
 
  template <typename SetupInstanceHttpsRequestT = Model::SetupInstanceHttpsRequest>
  Model::SetupInstanceHttpsOutcomeCallable SetupInstanceHttpsCallable(const SetupInstanceHttpsRequestT& request) const {
    return SubmitCallable(&LightsailClient::SetupInstanceHttps, request);
  }
 
  template <typename SetupInstanceHttpsRequestT = Model::SetupInstanceHttpsRequest>
  void SetupInstanceHttpsAsync(const SetupInstanceHttpsRequestT& request, const SetupInstanceHttpsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::SetupInstanceHttps, request, handler, context);
  }
 
  virtual Model::StartGUISessionOutcome StartGUISession(const Model::StartGUISessionRequest& request) const;
 
  template <typename StartGUISessionRequestT = Model::StartGUISessionRequest>
  Model::StartGUISessionOutcomeCallable StartGUISessionCallable(const StartGUISessionRequestT& request) const {
    return SubmitCallable(&LightsailClient::StartGUISession, request);
  }
 
  template <typename StartGUISessionRequestT = Model::StartGUISessionRequest>
  void StartGUISessionAsync(const StartGUISessionRequestT& request, const StartGUISessionResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::StartGUISession, request, handler, context);
  }
 
  virtual Model::StartInstanceOutcome StartInstance(const Model::StartInstanceRequest& request) const;
 
  template <typename StartInstanceRequestT = Model::StartInstanceRequest>
  Model::StartInstanceOutcomeCallable StartInstanceCallable(const StartInstanceRequestT& request) const {
    return SubmitCallable(&LightsailClient::StartInstance, request);
  }
 
  template <typename StartInstanceRequestT = Model::StartInstanceRequest>
  void StartInstanceAsync(const StartInstanceRequestT& request, const StartInstanceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::StartInstance, request, handler, context);
  }
 
  virtual Model::StartRelationalDatabaseOutcome StartRelationalDatabase(const Model::StartRelationalDatabaseRequest& request) const;
 
  template <typename StartRelationalDatabaseRequestT = Model::StartRelationalDatabaseRequest>
  Model::StartRelationalDatabaseOutcomeCallable StartRelationalDatabaseCallable(const StartRelationalDatabaseRequestT& request) const {
    return SubmitCallable(&LightsailClient::StartRelationalDatabase, request);
  }
 
  template <typename StartRelationalDatabaseRequestT = Model::StartRelationalDatabaseRequest>
  void StartRelationalDatabaseAsync(const StartRelationalDatabaseRequestT& request,
                                    const StartRelationalDatabaseResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::StartRelationalDatabase, request, handler, context);
  }
 
  virtual Model::StopGUISessionOutcome StopGUISession(const Model::StopGUISessionRequest& request) const;
 
  template <typename StopGUISessionRequestT = Model::StopGUISessionRequest>
  Model::StopGUISessionOutcomeCallable StopGUISessionCallable(const StopGUISessionRequestT& request) const {
    return SubmitCallable(&LightsailClient::StopGUISession, request);
  }
 
  template <typename StopGUISessionRequestT = Model::StopGUISessionRequest>
  void StopGUISessionAsync(const StopGUISessionRequestT& request, const StopGUISessionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::StopGUISession, request, handler, context);
  }
 
  virtual Model::StopInstanceOutcome StopInstance(const Model::StopInstanceRequest& request) const;
 
  template <typename StopInstanceRequestT = Model::StopInstanceRequest>
  Model::StopInstanceOutcomeCallable StopInstanceCallable(const StopInstanceRequestT& request) const {
    return SubmitCallable(&LightsailClient::StopInstance, request);
  }
 
  template <typename StopInstanceRequestT = Model::StopInstanceRequest>
  void StopInstanceAsync(const StopInstanceRequestT& request, const StopInstanceResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::StopInstance, request, handler, context);
  }
 
  virtual Model::StopRelationalDatabaseOutcome StopRelationalDatabase(const Model::StopRelationalDatabaseRequest& request) const;
 
  template <typename StopRelationalDatabaseRequestT = Model::StopRelationalDatabaseRequest>
  Model::StopRelationalDatabaseOutcomeCallable StopRelationalDatabaseCallable(const StopRelationalDatabaseRequestT& request) const {
    return SubmitCallable(&LightsailClient::StopRelationalDatabase, request);
  }
 
  template <typename StopRelationalDatabaseRequestT = Model::StopRelationalDatabaseRequest>
  void StopRelationalDatabaseAsync(const StopRelationalDatabaseRequestT& request,
                                   const StopRelationalDatabaseResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::StopRelationalDatabase, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&LightsailClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::TagResource, request, handler, context);
  }
 
  virtual Model::TestAlarmOutcome TestAlarm(const Model::TestAlarmRequest& request) const;
 
  template <typename TestAlarmRequestT = Model::TestAlarmRequest>
  Model::TestAlarmOutcomeCallable TestAlarmCallable(const TestAlarmRequestT& request) const {
    return SubmitCallable(&LightsailClient::TestAlarm, request);
  }
 
  template <typename TestAlarmRequestT = Model::TestAlarmRequest>
  void TestAlarmAsync(const TestAlarmRequestT& request, const TestAlarmResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::TestAlarm, request, handler, context);
  }
 
  virtual Model::UnpeerVpcOutcome UnpeerVpc(const Model::UnpeerVpcRequest& request = {}) const;
 
  template <typename UnpeerVpcRequestT = Model::UnpeerVpcRequest>
  Model::UnpeerVpcOutcomeCallable UnpeerVpcCallable(const UnpeerVpcRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::UnpeerVpc, request);
  }
 
  template <typename UnpeerVpcRequestT = Model::UnpeerVpcRequest>
  void UnpeerVpcAsync(const UnpeerVpcResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                      const UnpeerVpcRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::UnpeerVpc, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&LightsailClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateBucketOutcome UpdateBucket(const Model::UpdateBucketRequest& request) const;
 
  template <typename UpdateBucketRequestT = Model::UpdateBucketRequest>
  Model::UpdateBucketOutcomeCallable UpdateBucketCallable(const UpdateBucketRequestT& request) const {
    return SubmitCallable(&LightsailClient::UpdateBucket, request);
  }
 
  template <typename UpdateBucketRequestT = Model::UpdateBucketRequest>
  void UpdateBucketAsync(const UpdateBucketRequestT& request, const UpdateBucketResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::UpdateBucket, request, handler, context);
  }
 
  virtual Model::UpdateBucketBundleOutcome UpdateBucketBundle(const Model::UpdateBucketBundleRequest& request) const;
 
  template <typename UpdateBucketBundleRequestT = Model::UpdateBucketBundleRequest>
  Model::UpdateBucketBundleOutcomeCallable UpdateBucketBundleCallable(const UpdateBucketBundleRequestT& request) const {
    return SubmitCallable(&LightsailClient::UpdateBucketBundle, request);
  }
 
  template <typename UpdateBucketBundleRequestT = Model::UpdateBucketBundleRequest>
  void UpdateBucketBundleAsync(const UpdateBucketBundleRequestT& request, const UpdateBucketBundleResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::UpdateBucketBundle, request, handler, context);
  }
 
  virtual Model::UpdateContainerServiceOutcome UpdateContainerService(const Model::UpdateContainerServiceRequest& request) const;
 
  template <typename UpdateContainerServiceRequestT = Model::UpdateContainerServiceRequest>
  Model::UpdateContainerServiceOutcomeCallable UpdateContainerServiceCallable(const UpdateContainerServiceRequestT& request) const {
    return SubmitCallable(&LightsailClient::UpdateContainerService, request);
  }
 
  template <typename UpdateContainerServiceRequestT = Model::UpdateContainerServiceRequest>
  void UpdateContainerServiceAsync(const UpdateContainerServiceRequestT& request,
                                   const UpdateContainerServiceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::UpdateContainerService, request, handler, context);
  }
 
  virtual Model::UpdateDistributionOutcome UpdateDistribution(const Model::UpdateDistributionRequest& request) const;
 
  template <typename UpdateDistributionRequestT = Model::UpdateDistributionRequest>
  Model::UpdateDistributionOutcomeCallable UpdateDistributionCallable(const UpdateDistributionRequestT& request) const {
    return SubmitCallable(&LightsailClient::UpdateDistribution, request);
  }
 
  template <typename UpdateDistributionRequestT = Model::UpdateDistributionRequest>
  void UpdateDistributionAsync(const UpdateDistributionRequestT& request, const UpdateDistributionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::UpdateDistribution, request, handler, context);
  }
 
  virtual Model::UpdateDistributionBundleOutcome UpdateDistributionBundle(const Model::UpdateDistributionBundleRequest& request = {}) const;
 
  template <typename UpdateDistributionBundleRequestT = Model::UpdateDistributionBundleRequest>
  Model::UpdateDistributionBundleOutcomeCallable UpdateDistributionBundleCallable(
      const UpdateDistributionBundleRequestT& request = {}) const {
    return SubmitCallable(&LightsailClient::UpdateDistributionBundle, request);
  }
 
  template <typename UpdateDistributionBundleRequestT = Model::UpdateDistributionBundleRequest>
  void UpdateDistributionBundleAsync(const UpdateDistributionBundleResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const UpdateDistributionBundleRequestT& request = {}) const {
    return SubmitAsync(&LightsailClient::UpdateDistributionBundle, request, handler, context);
  }
 
  virtual Model::UpdateDomainEntryOutcome UpdateDomainEntry(const Model::UpdateDomainEntryRequest& request) const;
 
  template <typename UpdateDomainEntryRequestT = Model::UpdateDomainEntryRequest>
  Model::UpdateDomainEntryOutcomeCallable UpdateDomainEntryCallable(const UpdateDomainEntryRequestT& request) const {
    return SubmitCallable(&LightsailClient::UpdateDomainEntry, request);
  }
 
  template <typename UpdateDomainEntryRequestT = Model::UpdateDomainEntryRequest>
  void UpdateDomainEntryAsync(const UpdateDomainEntryRequestT& request, const UpdateDomainEntryResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::UpdateDomainEntry, request, handler, context);
  }
 
  virtual Model::UpdateInstanceMetadataOptionsOutcome UpdateInstanceMetadataOptions(
      const Model::UpdateInstanceMetadataOptionsRequest& request) const;
 
  template <typename UpdateInstanceMetadataOptionsRequestT = Model::UpdateInstanceMetadataOptionsRequest>
  Model::UpdateInstanceMetadataOptionsOutcomeCallable UpdateInstanceMetadataOptionsCallable(
      const UpdateInstanceMetadataOptionsRequestT& request) const {
    return SubmitCallable(&LightsailClient::UpdateInstanceMetadataOptions, request);
  }
 
  template <typename UpdateInstanceMetadataOptionsRequestT = Model::UpdateInstanceMetadataOptionsRequest>
  void UpdateInstanceMetadataOptionsAsync(const UpdateInstanceMetadataOptionsRequestT& request,
                                          const UpdateInstanceMetadataOptionsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::UpdateInstanceMetadataOptions, request, handler, context);
  }
 
  virtual Model::UpdateLoadBalancerAttributeOutcome UpdateLoadBalancerAttribute(
      const Model::UpdateLoadBalancerAttributeRequest& request) const;
 
  template <typename UpdateLoadBalancerAttributeRequestT = Model::UpdateLoadBalancerAttributeRequest>
  Model::UpdateLoadBalancerAttributeOutcomeCallable UpdateLoadBalancerAttributeCallable(
      const UpdateLoadBalancerAttributeRequestT& request) const {
    return SubmitCallable(&LightsailClient::UpdateLoadBalancerAttribute, request);
  }
 
  template <typename UpdateLoadBalancerAttributeRequestT = Model::UpdateLoadBalancerAttributeRequest>
  void UpdateLoadBalancerAttributeAsync(const UpdateLoadBalancerAttributeRequestT& request,
                                        const UpdateLoadBalancerAttributeResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::UpdateLoadBalancerAttribute, request, handler, context);
  }
 
  virtual Model::UpdateRelationalDatabaseOutcome UpdateRelationalDatabase(const Model::UpdateRelationalDatabaseRequest& request) const;
 
  template <typename UpdateRelationalDatabaseRequestT = Model::UpdateRelationalDatabaseRequest>
  Model::UpdateRelationalDatabaseOutcomeCallable UpdateRelationalDatabaseCallable(const UpdateRelationalDatabaseRequestT& request) const {
    return SubmitCallable(&LightsailClient::UpdateRelationalDatabase, request);
  }
 
  template <typename UpdateRelationalDatabaseRequestT = Model::UpdateRelationalDatabaseRequest>
  void UpdateRelationalDatabaseAsync(const UpdateRelationalDatabaseRequestT& request,
                                     const UpdateRelationalDatabaseResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::UpdateRelationalDatabase, request, handler, context);
  }
 
  virtual Model::UpdateRelationalDatabaseParametersOutcome UpdateRelationalDatabaseParameters(
      const Model::UpdateRelationalDatabaseParametersRequest& request) const;
 
  template <typename UpdateRelationalDatabaseParametersRequestT = Model::UpdateRelationalDatabaseParametersRequest>
  Model::UpdateRelationalDatabaseParametersOutcomeCallable UpdateRelationalDatabaseParametersCallable(
      const UpdateRelationalDatabaseParametersRequestT& request) const {
    return SubmitCallable(&LightsailClient::UpdateRelationalDatabaseParameters, request);
  }
 
  template <typename UpdateRelationalDatabaseParametersRequestT = Model::UpdateRelationalDatabaseParametersRequest>
  void UpdateRelationalDatabaseParametersAsync(const UpdateRelationalDatabaseParametersRequestT& request,
                                               const UpdateRelationalDatabaseParametersResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LightsailClient::UpdateRelationalDatabaseParameters, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<LightsailEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<LightsailClient>;
  void init(const LightsailClientConfiguration& clientConfiguration);
 
  LightsailClientConfiguration m_clientConfiguration;
  std::shared_ptr<LightsailEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Lightsail
}  // namespace Aws