LightsailClient.h

 
#pragma once
#include <aws/lightsail/Lightsail_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/lightsail/LightsailServiceClientModel.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